Cleanup use of deprecated barrel file in type-tests

Author: ef4

type-tests/@ember/object-test/proxy.ts

@@ -1,8 +1,8 @@
-import Ember from 'ember';
+import EmberObject, { set, computed } from '@ember/object';
 import ObjectProxy from '@ember/object/proxy';
 import { expectTypeOf } from 'expect-type';
 
-declare class X extends Ember.Object {
+declare class X extends EmberObject {
   foo: string;
   bar: number;
 }
@@ -74,21 +74,21 @@ book.setProperties({ title: 1 });
 book.setProperties({ altTitle: 1 });
 book.setProperties({ invalid: true });
 
-class Person extends Ember.Object {
+class Person extends EmberObject {
   firstName = 'Peter';
 
   lastName = 'Wagenet';
 
-  @Ember.computed('firstName', 'lastName')
+  @computed('firstName', 'lastName')
   get fullName() {
     return `${this.firstName} ${this.lastName}`;
   }
 
   set fullName(value: string) {
     const [firstName, lastName] = value.split(' ');
 
-    Ember.set(this, 'firstName', firstName ?? '');
-    Ember.set(this, 'lastName', lastName ?? '');
+    set(this, 'firstName', firstName ?? '');
+    set(this, 'lastName', lastName ?? '');
   }
 }
 

type-tests/ember/application.ts

@@ -1,7 +1,7 @@
+import Application from '@ember/application';
 import EmberObject from '@ember/object';
-import Ember from 'ember';
 
-const BaseApp = Ember.Application.extend({
+const BaseApp = Application.extend({
   modulePrefix: 'my-app',
 });
 

type-tests/ember/array-proxy.ts

@@ -1,27 +1,28 @@
 import type Array from '@ember/array';
-import Ember from 'ember';
+import { A } from '@ember/array';
+import ArrayProxy from '@ember/array/proxy';
 import { expectTypeOf } from 'expect-type';
 
 const pets = ['dog', 'cat', 'fish'];
-const proxy = Ember.ArrayProxy.create({ content: Ember.A(pets) });
+const proxy = ArrayProxy.create({ content: A(pets) });
 
 proxy.get('firstObject'); // 'dog'
-proxy.set('content', Ember.A(['amoeba', 'paramecium']));
+proxy.set('content', A(['amoeba', 'paramecium']));
 proxy.get('firstObject'); // 'amoeba'
 
-const overridden = Ember.ArrayProxy.create({
-  content: Ember.A(pets),
-  objectAtContent(this: Ember.ArrayProxy<string>, idx: number): string | undefined {
+const overridden = ArrayProxy.create({
+  content: A(pets),
+  objectAtContent(this: ArrayProxy<string>, idx: number): string | undefined {
     return (this.get('content') as Array<string>).objectAt(idx)?.toUpperCase();
   },
 });
 
 overridden.get('firstObject'); // 'DOG'
 
-class MyNewProxy<T> extends Ember.ArrayProxy<T> {
+class MyNewProxy<T> extends ArrayProxy<T> {
   isNew = true;
 }
 
-const x = MyNewProxy.create({ content: Ember.A([1, 2, 3]) }) as MyNewProxy<number>;
+const x = MyNewProxy.create({ content: A([1, 2, 3]) }) as MyNewProxy<number>;
 expectTypeOf(x.get('firstObject')).toEqualTypeOf<number | undefined>();
 expectTypeOf(x.isNew).toBeBoolean();

type-tests/ember/array.ts

@@ -1,12 +1,13 @@
-import Ember from 'ember';
+import { A, NativeArray } from '@ember/array';
+import EmberObject from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
-class Person extends Ember.Object {
+class Person extends EmberObject {
   name = '';
   isHappy = false;
 }
 
-const people = Ember.A([
+const people = A([
   Person.create({ name: 'Yehuda', isHappy: true }),
   Person.create({ name: 'Majd', isHappy: false }),
 ]);
@@ -23,17 +24,17 @@ expectTypeOf(people.objectAt(0)).toEqualTypeOf<Person | undefined>();
 expectTypeOf(people.objectsAt([1, 2, 3])).toEqualTypeOf<Array<Person | undefined>>();
 
 expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<Person[]>();
-expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<Ember.NativeArray<Person>>();
+expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<NativeArray<Person>>();
 expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<Person[]>();
-expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<Ember.NativeArray<Person>>();
+expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<NativeArray<Person>>();
 expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatchTypeOf<Person[]>();
 expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatchTypeOf<Person[]>();
 
 expectTypeOf(people.get('[]')).toEqualTypeOf<typeof people>();
 expectTypeOf(people.get('[]').get('firstObject')).toEqualTypeOf<Person | undefined>();
 
-expectTypeOf(people.mapBy('isHappy')).toEqualTypeOf<Ember.NativeArray<boolean>>();
-expectTypeOf(people.mapBy('name.length')).toEqualTypeOf<Ember.NativeArray<unknown>>();
+expectTypeOf(people.mapBy('isHappy')).toEqualTypeOf<NativeArray<boolean>>();
+expectTypeOf(people.mapBy('name.length')).toEqualTypeOf<NativeArray<unknown>>();
 
 const last = people.get('lastObject');
 expectTypeOf(last).toEqualTypeOf<Person | undefined>();
@@ -46,7 +47,7 @@ if (first) {
   expectTypeOf(first.get('isHappy')).toBeBoolean();
 }
 
-const letters: Ember.NativeArray<string> = Ember.A(['a', 'b', 'c']);
+const letters: NativeArray<string> = A(['a', 'b', 'c']);
 const codes = letters.map((item, index, array) => {
   expectTypeOf(item).toBeString();
   expectTypeOf(index).toBeNumber();
@@ -56,11 +57,11 @@ const codes = letters.map((item, index, array) => {
 expectTypeOf(codes).toEqualTypeOf<number[]>();
 
 const value = '1,2,3';
-const filters = Ember.A(value.split(','));
+const filters = A(value.split(','));
 filters.push('4');
 filters.sort();
 
-const multiSortArr = Ember.A([
+const multiSortArr = A([
   { k: 'a', v: 'z' },
   { k: 'a', v: 'y' },
   { k: 'b', v: 'c' },

type-tests/ember/component.ts

@@ -1,22 +1,23 @@
-import Ember from 'ember';
+import Component from '@ember/component';
+import EmberObject, { computed, get } from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
-Ember.Component.extend({
+Component.extend({
   layout: 'my-layout',
 });
 
-const MyComponent = Ember.Component.extend();
-expectTypeOf(Ember.get(MyComponent, 'positionalParams')).toEqualTypeOf<string | string[]>();
+const MyComponent = Component.extend();
+expectTypeOf(get(MyComponent, 'positionalParams')).toEqualTypeOf<string | string[]>();
 
-const component1 = Ember.Component.extend({
+const component1 = Component.extend({
   actions: {
     hello(name: string) {
       console.log('Hello', name);
     },
   },
 });
 
-class AnotherComponent extends Ember.Component {
+class AnotherComponent extends Component {
   name = '';
 
   hello(name: string) {
@@ -25,93 +26,93 @@ class AnotherComponent extends Ember.Component {
   }
 }
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'em',
 });
 
-Ember.Component.extend({
+Component.extend({
   classNames: ['my-class', 'my-other-class'],
 });
 
-class Bindings extends Ember.Component {
+class Bindings extends Component {
   classNameBindings = ['propertyA', 'propertyB'];
   propertyA = 'from-a';
 
-  @Ember.computed()
+  @computed()
   get propertyB() {
     if (!this.get('propertyA')) {
       return 'from-b';
     }
   }
 }
 
-Ember.Component.extend({
+Component.extend({
   classNameBindings: ['hovered'],
   hovered: true,
 });
 
-class Message extends Ember.Object {
+class Message extends EmberObject {
   empty = false;
 }
 
-Ember.Component.extend({
+Component.extend({
   classNameBindings: ['messages.empty'],
   messages: Message.create({
     empty: true,
   }),
 });
 
-Ember.Component.extend({
+Component.extend({
   classNameBindings: ['isEnabled:enabled:disabled'],
   isEnabled: true,
 });
 
-Ember.Component.extend({
+Component.extend({
   classNameBindings: ['isEnabled::disabled'],
   isEnabled: true,
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'a',
   attributeBindings: ['href'],
   href: 'http://google.com',
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'a',
   attributeBindings: ['url:href'],
   url: 'http://google.com',
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'use',
   attributeBindings: ['xlinkHref:xlink:href'],
   xlinkHref: '#triangle',
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'input',
   attributeBindings: ['disabled'],
   disabled: false,
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'input',
   attributeBindings: ['disabled'],
-  disabled: Ember.computed(() => {
+  disabled: computed(() => {
     return someLogic();
   }),
 });
 
 declare function someLogic(): boolean;
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'form',
   attributeBindings: ['novalidate'],
   novalidate: null,
 });
 
-Ember.Component.extend({
+Component.extend({
   click(event: object) {
     // will be called when an instance's
     // rendered element is clicked

type-tests/ember/computed.ts

@@ -1,34 +1,34 @@
-import Ember from 'ember';
+import EmberObject, { computed } from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
 function customMacro(message: string) {
-  return Ember.computed(() => {
+  return computed(() => {
     return [message, message];
   });
 }
 
-class Person extends Ember.Object {
+class Person extends EmberObject {
   firstName = '';
   lastName = '';
   age = 0;
 
   // Equivalent to a per-instance `defineProperty` call.
-  @Ember.computed()
+  @computed()
   get noArgs() {
     return 'test';
   }
 
-  @Ember.computed('firstName', 'lastName')
+  @computed('firstName', 'lastName')
   get fullName(): string {
     return `${this.get('firstName')} ${this.get('lastName')}`;
   }
 
-  @(Ember.computed('fullName').readOnly())
+  @(computed('fullName').readOnly())
   get fullNameReadonly() {
     return this.get('fullName');
   }
 
-  @Ember.computed('firstName', 'lastName')
+  @computed('firstName', 'lastName')
   get fullNameWritable(): string {
     return this.get('fullName');
   }
@@ -39,7 +39,7 @@ class Person extends Ember.Object {
     this.set('lastName', last);
   }
 
-  @(Ember.computed().meta({ foo: 'bar' }).readOnly())
+  @(computed().meta({ foo: 'bar' }).readOnly())
   get combinators() {
     return this.get('firstName');
   }
@@ -92,8 +92,8 @@ expectTypeOf(person3.get('firstName')).toEqualTypeOf<string>();
 expectTypeOf(person3.get('fullName')).toEqualTypeOf<string>();
 
 const person4 = Person.extend({
-  firstName: Ember.computed(() => 'Fred'),
-  fullName: Ember.computed(() => 'Fred Smith'),
+  firstName: computed(() => 'Fred'),
+  fullName: computed(() => 'Fred Smith'),
 }).create();
 
 expectTypeOf(person4.get('firstName')).toEqualTypeOf<string>();

type-tests/ember/controller.ts

@@ -1,6 +1,6 @@
-import Ember from 'ember';
+import Controller from "@ember/controller";
 
-class MyController extends Ember.Controller {
+class MyController extends Controller {
   queryParams = ['category'];
   category = null;
   isExpanded = false;

type-tests/ember/core-object.ts

@@ -1,21 +1,19 @@
-import Ember from 'ember';
+import CoreObject from '@ember/object/core';
 import { expectTypeOf } from 'expect-type';
 
-const { CoreObject } = Ember;
-
 /** Newable tests */
 const co1 = new CoreObject();
 
 expectTypeOf(co1.isDestroyed).toBeBoolean();
 expectTypeOf(co1.isDestroying).toBeBoolean();
-expectTypeOf(co1.destroy()).toEqualTypeOf<Ember.CoreObject>();
+expectTypeOf(co1.destroy()).toEqualTypeOf<CoreObject>();
 expectTypeOf(co1.toString()).toBeString();
 
 /** .create tests */
 const co2 = CoreObject.create();
 expectTypeOf(co2.isDestroyed).toBeBoolean();
 expectTypeOf(co2.isDestroying).toBeBoolean();
-expectTypeOf(co2.destroy()).toEqualTypeOf<Ember.CoreObject>();
+expectTypeOf(co2.destroy()).toEqualTypeOf<CoreObject>();
 expectTypeOf(co2.toString()).toBeString();
 
 /** .create tests w/ initial instance data passed in */