language
stringclasses 1
value | owner
stringlengths 2
15
| repo
stringlengths 2
21
| sha
stringlengths 45
45
| message
stringlengths 7
36.3k
| path
stringlengths 1
199
| patch
stringlengths 15
102k
| is_multipart
bool 2
classes |
|---|---|---|---|---|---|---|---|
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/-internals/runtime/lib/compare.ts | @@ -1,5 +1,6 @@
import { typeOf } from './type-of';
import Comparable from './mixins/comparable';
+import { assert } from '@ember/debug';
const TYPE_ORDER = {
undefined: 0,
@@ -15,6 +16,8 @@ const TYPE_ORDER = {
date: 10,
};
+type Compare = -1 | 0 | 1;
+
//
// the spaceship operator
//
@@ -32,9 +35,10 @@ const TYPE_ORDER = {
// | `._ `. \
// `._________`-. `. `.___
// SSt `------'`
-function spaceship(a, b) {
+function spaceship(a: number, b: number): Compare {
let diff = a - b;
- return (diff > 0) - (diff < 0);
+ // SAFETY: It will be one of the known values
+ return (Number(diff > 0) - Number(diff < 0)) as Compare;
}
/**
@@ -87,20 +91,21 @@ function spaceship(a, b) {
@return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
@public
*/
-export default function compare(v, w) {
+export default function compare(v: unknown, w: unknown): Compare {
if (v === w) {
return 0;
}
let type1 = typeOf(v);
let type2 = typeOf(w);
- if (type1 === 'instance' && Comparable.detect(v) && v.constructor.compare) {
+ if (type1 === 'instance' && isComparable(v) && v.constructor.compare) {
return v.constructor.compare(v, w);
}
- if (type2 === 'instance' && Comparable.detect(w) && w.constructor.compare) {
- return w.constructor.compare(w, v) * -1;
+ if (type2 === 'instance' && isComparable(w) && w.constructor.compare) {
+ // SAFETY: Multiplying by a negative just changes the sign
+ return (w.constructor.compare(w, v) * -1) as Compare;
}
let res = spaceship(TYPE_ORDER[type1], TYPE_ORDER[type2]);
@@ -112,13 +117,17 @@ export default function compare(v, w) {
// types are equal - so we have to check values now
switch (type1) {
case 'boolean':
+ assert('both are boolean', typeof v === 'boolean' && typeof w === 'boolean');
+ return spaceship(Number(v), Number(w));
case 'number':
+ assert('both are numbers', typeof v === 'number' && typeof w === 'number');
return spaceship(v, w);
-
case 'string':
+ assert('both are strings', typeof v === 'string' && typeof w === 'string');
return spaceship(v.localeCompare(w), 0);
case 'array': {
+ assert('both are arrays', Array.isArray(v) && Array.isArray(w));
let vLen = v.length;
let wLen = w.length;
let len = Math.min(vLen, wLen);
@@ -135,15 +144,24 @@ export default function compare(v, w) {
return spaceship(vLen, wLen);
}
case 'instance':
- if (Comparable.detect(v)) {
+ if (isComparable(v) && v.compare) {
return v.compare(v, w);
}
return 0;
case 'date':
+ assert('both are dates', v instanceof Date && w instanceof Date);
return spaceship(v.getTime(), w.getTime());
default:
return 0;
}
}
+
+interface ComparableConstructor {
+ constructor: Comparable;
+}
+
+function isComparable(value: unknown): value is Comparable & ComparableConstructor {
+ return Comparable.detect(value);
+} | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/-internals/runtime/lib/copy.d.ts | @@ -1,3 +0,0 @@
-declare function copy<T>(obj: T, deep: true): T;
-declare function copy(obj: any, deep?: boolean): any;
-export default copy; | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/-internals/runtime/lib/is-equal.ts | @@ -47,9 +47,9 @@
@return {Boolean}
@public
*/
-export default function isEqual(a, b) {
- if (a && typeof a.isEqual === 'function') {
- return a.isEqual(b);
+export default function isEqual(a: unknown, b: unknown): boolean {
+ if (a && typeof (a as IsEqual).isEqual === 'function') {
+ return (a as IsEqual).isEqual(b);
}
if (a instanceof Date && b instanceof Date) {
@@ -58,3 +58,7 @@ export default function isEqual(a, b) {
return a === b;
}
+
+interface IsEqual {
+ isEqual(val: unknown): boolean;
+} | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/-internals/runtime/lib/mixins/action_handler.d.ts | @@ -1,3 +1,3 @@
-import Mixin from '../../types/mixin';
+import { Mixin } from '@ember/-internals/metal';
export default class ActionHandler extends Mixin {} | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/-internals/runtime/lib/mixins/comparable.d.ts | @@ -0,0 +1,8 @@
+import { Mixin } from '@ember/-internals/metal';
+
+interface Comparable {
+ compare: ((a: unknown, b: unknown) => -1 | 0 | 1) | null;
+}
+declare const Comparable: Mixin;
+
+export default Comparable; | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/-internals/runtime/lib/mixins/evented.d.ts | @@ -1,4 +1,4 @@
-import Mixin from '../../types/mixin';
+import { Mixin } from '@ember/-internals/metal';
/**
* This mixin allows for Ember objects to subscribe to and emit events. | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/-internals/runtime/lib/type-of.ts | @@ -1,9 +1,25 @@
import CoreObject from './system/core_object';
+type TypeName =
+ | 'undefined'
+ | 'null'
+ | 'string'
+ | 'number'
+ | 'boolean'
+ | 'function'
+ | 'array'
+ | 'regexp'
+ | 'date'
+ | 'filelist'
+ | 'class'
+ | 'instance'
+ | 'error'
+ | 'object';
+
// ........................................
// TYPING & ARRAY MESSAGING
//
-const TYPE_MAP = {
+const TYPE_MAP: Record<string, TypeName> = {
'[object Boolean]': 'boolean',
'[object Number]': 'number',
'[object String]': 'string',
@@ -14,7 +30,7 @@ const TYPE_MAP = {
'[object RegExp]': 'regexp',
'[object Object]': 'object',
'[object FileList]': 'filelist',
-};
+} as const;
const { toString } = Object.prototype;
@@ -82,7 +98,7 @@ const { toString } = Object.prototype;
@public
@static
*/
-export function typeOf(item) {
+export function typeOf(item: unknown): TypeName {
if (item === null) {
return 'null';
} | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/-internals/runtime/types/mixin.d.ts | @@ -1,3 +0,0 @@
-import { Mixin } from '../../metal/lib/mixin';
-
-export default Mixin; | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/utils/type-tests/compare.test.ts | @@ -0,0 +1,8 @@
+import { compare } from '@ember/utils';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(compare('hello', 'hello')).toEqualTypeOf<-1 | 0 | 1>(); // 0
+compare('abc', 'dfg'); // -1
+compare(2, 1); // 1
+compare('hello', 50); // 1
+compare(50, 'hello'); // -1 | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/utils/type-tests/is-blank.test.ts | @@ -0,0 +1,17 @@
+import { isBlank } from '@ember/utils';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(isBlank(null)).toEqualTypeOf<boolean>(); // true
+
+isBlank(undefined); // true
+isBlank(''); // true
+isBlank([]); // true
+isBlank('\n\t'); // true
+isBlank(' '); // true
+isBlank({}); // false
+isBlank('\n\t Hello'); // false
+isBlank('Hello world'); // false
+isBlank([1, 2, 3]); // false
+
+// @ts-expect-error requires an argument
+isBlank(); | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/utils/type-tests/is-empty.test.ts | @@ -0,0 +1,19 @@
+import { isEmpty } from '@ember/utils';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(isEmpty(null)).toEqualTypeOf<boolean>(); // true
+
+isEmpty(undefined); // true
+isEmpty(''); // true
+isEmpty([]); // true
+isEmpty({ size: 0 }); // true
+isEmpty({}); // false
+isEmpty('Adam Hawkins'); // false
+isEmpty([0, 1, 2]); // false
+isEmpty('\n\t'); // false
+isEmpty(' '); // false
+isEmpty({ size: 1 }); // false
+isEmpty({ size: () => 0 }); // false
+
+// @ts-expect-error requires an argument
+isEmpty(); | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/utils/type-tests/is-equal.test.ts | @@ -0,0 +1,21 @@
+import { isEqual } from '@ember/utils';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(isEqual('hello', 'hello')).toEqualTypeOf<boolean>(); // true
+
+isEqual(1, 2); // false
+
+class Person {
+ constructor(public ssn: string) {}
+
+ isEqual(other: Person) {
+ return this.ssn == other.ssn;
+ }
+}
+
+let personA = new Person('123-45-6789');
+let personB = new Person('123-45-6789');
+
+isEqual(personA, personB); // true
+
+isEqual([4, 2], [4, 2]); // false | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/utils/type-tests/is-none.test.ts | @@ -0,0 +1,17 @@
+import { isNone } from '@ember/utils';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(isNone(null)).toEqualTypeOf<boolean>(); // true
+isNone(undefined); // true
+isNone(''); // false
+isNone([]); // false
+isNone(function () {}); // false
+
+// It functions as a type guard
+let foo: unknown;
+if (isNone(foo)) {
+ expectTypeOf(foo).toEqualTypeOf<null | undefined>();
+}
+
+// @ts-expect-error argument is required
+isNone(); // true | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/utils/type-tests/is-present.test.ts | @@ -0,0 +1,28 @@
+import { isPresent } from '@ember/utils';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(isPresent(null)).toEqualTypeOf<boolean>(); // false
+
+isPresent(undefined); // false
+isPresent(''); // false
+isPresent(' '); // false
+isPresent('\n\t'); // false
+isPresent([]); // false
+isPresent({ length: 0 }); // false
+isPresent(false); // true
+isPresent(true); // true
+isPresent('string'); // true
+isPresent(0); // true
+isPresent(function () {}); // true
+isPresent({}); // true
+isPresent('\n\t Hello'); // true
+isPresent([1, 2, 3]); // true
+
+// It functions as a type guard
+let foo: string | null | undefined;
+if (isPresent(foo)) {
+ expectTypeOf(foo).toEqualTypeOf<string>();
+}
+
+// @ts-expect-error it requires an argument
+isPresent(); // false | true |
Other | emberjs | ember.js | 420a01fe1864a5e8d447ac714a3cfb9aff012a49.json | Improve @ember/utils and add type tests | packages/@ember/utils/type-tests/type-of.test.ts | @@ -0,0 +1,44 @@
+/* eslint-disable no-new-wrappers */
+
+import { typeOf } from '@ember/utils';
+import { A } from '@ember/array';
+import EmberObject from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(typeOf(null)).toEqualTypeOf<
+ | 'undefined'
+ | 'null'
+ | 'string'
+ | 'number'
+ | 'boolean'
+ | 'function'
+ | 'array'
+ | 'regexp'
+ | 'date'
+ | 'filelist'
+ | 'class'
+ | 'instance'
+ | 'error'
+ | 'object'
+>();
+
+typeOf(undefined); // 'undefined'
+typeOf('michael'); // 'string'
+typeOf(new String('michael')); // 'string'
+typeOf(101); // 'number'
+typeOf(new Number(101)); // 'number'
+typeOf(true); // 'boolean'
+typeOf(new Boolean(true)); // 'boolean'
+typeOf(A); // 'function'
+typeOf(A()); // 'array'
+typeOf([1, 2, 90]); // 'array'
+typeOf(/abc/); // 'regexp'
+typeOf(new Date()); // 'date'
+typeOf((({} as Event).target as HTMLInputElement).files); // 'filelist'
+typeOf(EmberObject.extend()); // 'class'
+typeOf(EmberObject.create()); // 'instance'
+typeOf(new Error('teamocil')); // 'error'
+typeOf({ a: 'b' }); // 'object'
+
+// @ts-expect-error it requires an argument
+typeOf(); | true |
Other | emberjs | ember.js | 3ea0f394fd644d579a4c0f04d97d6ce7d9dd0310.json | Add type tests for @ember/destroyable | packages/@ember/destroyable/type-tests/assert-destroyables-destroyed.test.ts | @@ -0,0 +1,6 @@
+import { assertDestroyablesDestroyed } from '@ember/destroyable';
+import { expectTypeOf } from 'expect-type';
+
+if (assertDestroyablesDestroyed) {
+ expectTypeOf(assertDestroyablesDestroyed()).toEqualTypeOf<void>();
+} | true |
Other | emberjs | ember.js | 3ea0f394fd644d579a4c0f04d97d6ce7d9dd0310.json | Add type tests for @ember/destroyable | packages/@ember/destroyable/type-tests/associate-destroyable-child.test.ts | @@ -0,0 +1,16 @@
+import { associateDestroyableChild } from '@ember/destroyable';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {}
+class Bar {}
+
+let foo = new Foo();
+let bar = new Bar();
+
+expectTypeOf(associateDestroyableChild(foo, bar)).toEqualTypeOf<Bar>();
+// @ts-expect-error number is not destroyable
+associateDestroyableChild(1, bar);
+// @ts-expect-error number is not destroyable
+associateDestroyableChild(foo, 1);
+// @ts-expect-error two values required
+associateDestroyableChild(foo); | true |
Other | emberjs | ember.js | 3ea0f394fd644d579a4c0f04d97d6ce7d9dd0310.json | Add type tests for @ember/destroyable | packages/@ember/destroyable/type-tests/destroy.test.ts | @@ -0,0 +1,15 @@
+import { destroy, registerDestructor } from '@ember/destroyable';
+import { expectTypeOf } from 'expect-type';
+
+let obj = {};
+
+registerDestructor(obj, () => {
+ /* Will get called when destroyed */
+});
+
+expectTypeOf(destroy(obj)).toEqualTypeOf<void>();
+
+// @ts-expect-error not destroyable
+destroy(1);
+// @ts-expect-error requires arg
+destroy(); | true |
Other | emberjs | ember.js | 3ea0f394fd644d579a4c0f04d97d6ce7d9dd0310.json | Add type tests for @ember/destroyable | packages/@ember/destroyable/type-tests/enable-destroy-tracking.test.ts | @@ -0,0 +1,6 @@
+import { enableDestroyableTracking } from '@ember/destroyable';
+import { expectTypeOf } from 'expect-type';
+
+if (enableDestroyableTracking) {
+ expectTypeOf(enableDestroyableTracking()).toEqualTypeOf<void>();
+} | true |
Other | emberjs | ember.js | 3ea0f394fd644d579a4c0f04d97d6ce7d9dd0310.json | Add type tests for @ember/destroyable | packages/@ember/destroyable/type-tests/is-destroyed.test.ts | @@ -0,0 +1,16 @@
+import { destroy, isDestroyed } from '@ember/destroyable';
+import { expectTypeOf } from 'expect-type';
+
+let obj = {};
+
+expectTypeOf(isDestroyed(obj)).toEqualTypeOf<boolean>(); // false
+destroy(obj);
+
+// ...sometime later, after scheduled destruction
+
+expectTypeOf(isDestroyed(obj)).toEqualTypeOf<boolean>(); // true
+
+// @ts-expect-error requires a destroyable value
+isDestroyed(1);
+// @ts-expect-error requires a value
+isDestroyed(); | true |
Other | emberjs | ember.js | 3ea0f394fd644d579a4c0f04d97d6ce7d9dd0310.json | Add type tests for @ember/destroyable | packages/@ember/destroyable/type-tests/is-destroying.test.ts | @@ -0,0 +1,19 @@
+import { destroy, isDestroying, isDestroyed } from '@ember/destroyable';
+import { expectTypeOf } from 'expect-type';
+
+let obj = {};
+
+expectTypeOf(isDestroying(obj)).toEqualTypeOf<boolean>(); // false
+
+destroy(obj);
+
+isDestroying(obj); // true
+
+// ...sometime later, after scheduled destruction
+isDestroyed(obj); // true
+isDestroying(obj); // true
+
+// @ts-expect-error requires a destroyable value
+isDestroying(1);
+// @ts-expect-error requires a value
+isDestroying(); | true |
Other | emberjs | ember.js | 3ea0f394fd644d579a4c0f04d97d6ce7d9dd0310.json | Add type tests for @ember/destroyable | packages/@ember/destroyable/type-tests/register-destructor.test.ts | @@ -0,0 +1,27 @@
+import { destroy, registerDestructor } from '@ember/destroyable';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {}
+let obj = new Foo();
+
+expectTypeOf(
+ registerDestructor(obj, () => {
+ /* Will get called when destroyed */
+ })
+).toEqualTypeOf<(destroyable: {}) => void>();
+
+registerDestructor(obj, (_obj: Foo) => {});
+
+destroy(obj);
+
+// @ts-expect-error not destroyable
+registerDestructor(1, () => {});
+
+// @ts-expect-error requires object
+registerDestructor(() => {});
+
+// @ts-expect-error requires callback
+registerDestructor(obj);
+
+// @ts-expect-error invalid callback
+registerDestructor(obj, (blah: number) => {}); | true |
Other | emberjs | ember.js | 3ea0f394fd644d579a4c0f04d97d6ce7d9dd0310.json | Add type tests for @ember/destroyable | packages/@ember/destroyable/type-tests/unregister-destructor.test.ts | @@ -0,0 +1,30 @@
+import { registerDestructor, unregisterDestructor } from '@ember/destroyable';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {
+ type: 'foo' = 'foo';
+}
+let obj = new Foo();
+
+let destructor = registerDestructor(obj, () => {
+ /* Will get called when destroyed */
+});
+
+expectTypeOf(unregisterDestructor(obj, destructor)).toEqualTypeOf<void>();
+
+// @ts-expect-error invalid destructor
+unregisterDestructor(obj, 1);
+
+// @ts-expect-error requires destructor
+unregisterDestructor(obj);
+
+// @ts-expect-error requires object
+unregisterDestructor(destructor);
+
+class Bar {
+ type: 'blah' = 'blah';
+}
+let obj2 = new Bar();
+
+// @ts-expect-error destroyable type mismatch
+unregisterDestructor(obj2, destructor); | true |
Other | emberjs | ember.js | 96cc5d57439b60731ed5a191d52f61294eb64a4a.json | Add type tests for @ember/canary-features | packages/@ember/canary-features/type-tests/index.test.ts | @@ -0,0 +1,8 @@
+import { DEFAULT_FEATURES, FEATURES, isEnabled } from '@ember/canary-features';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(DEFAULT_FEATURES).toMatchTypeOf<Record<string, boolean | null>>();
+
+expectTypeOf(FEATURES).toMatchTypeOf<Record<string, boolean | null>>();
+
+expectTypeOf(isEnabled('foo')).toMatchTypeOf<boolean>(); | false |
Other | emberjs | ember.js | d1989091294eff20d3c7c618393dbc1e4d92de5a.json | Add type test for @ember/polyfills | packages/@ember/polyfills/type-tests/assign.test.ts | @@ -0,0 +1,14 @@
+import { assign } from '@ember/polyfills';
+import { expectTypeOf } from 'expect-type';
+
+// NOTE: Actual types could be better, but this is deprecated.
+
+let a = { first: 'Yehuda' };
+let b = { last: 'Katz' };
+let c = { company: 'Other Company' };
+let d = { company: 'Tilde Inc.' };
+expectTypeOf(assign(a, b, c, d)).toEqualTypeOf<{
+ first: string;
+ last: string;
+ company: string;
+}>(); | false |
Other | emberjs | ember.js | d0371027994e0203c1072d0f258cc169830aa0b2.json | Improve BootOptions types and add more type-tests | packages/@ember/application/instance.d.ts | @@ -1,22 +1,13 @@
import EngineInstance from '@ember/engine/instance';
-export class BootOptions {
- isBrowser: boolean;
- shouldRender: boolean;
- document: Document | null;
- rootElement: string | Element | null;
- location: string | null;
-
- constructor(options?: {
- isBrowser?: boolean;
- shouldRender?: boolean;
- document?: Document;
- rootElement?: string | Element;
- location?: string;
- isInteractive?: boolean;
- });
-
- toEnvironment(): Record<string, unknown>;
+export interface BootOptions {
+ isBrowser?: boolean;
+ shouldRender?: boolean;
+ document?: Document | null;
+ rootElement?: string | Element | null;
+ location?: string | null;
+ // Private?
+ isInteractive?: boolean;
}
export default class ApplicationInstance extends EngineInstance {} | true |
Other | emberjs | ember.js | d0371027994e0203c1072d0f258cc169830aa0b2.json | Improve BootOptions types and add more type-tests | packages/@ember/application/instance.js | @@ -335,12 +335,12 @@ class BootOptions {
@default auto-detected
@private
*/
- this.isInteractive = environment.hasDOM; // This default is overridable below
+ this.isInteractive = Boolean(environment.hasDOM); // This default is overridable below
/**
@property _renderMode
@type string
- @default false
+ @default undefined
@private
*/
this._renderMode = options._renderMode;
@@ -372,7 +372,7 @@ class BootOptions {
if (options.isBrowser !== undefined) {
this.isBrowser = Boolean(options.isBrowser);
} else {
- this.isBrowser = environment.hasDOM;
+ this.isBrowser = Boolean(environment.hasDOM);
}
if (!this.isBrowser) { | true |
Other | emberjs | ember.js | d0371027994e0203c1072d0f258cc169830aa0b2.json | Improve BootOptions types and add more type-tests | packages/@ember/application/lib/application.d.ts | @@ -13,5 +13,5 @@ export default class Application extends Engine {
boot(): void;
ready(): void;
reset(): void;
- visit(url: string, options: BootOptions): Promise<ApplicationInstance>;
+ visit(url: string, options?: BootOptions): Promise<ApplicationInstance>;
} | true |
Other | emberjs | ember.js | d0371027994e0203c1072d0f258cc169830aa0b2.json | Improve BootOptions types and add more type-tests | packages/@ember/application/type-tests/index.test.ts | @@ -1,6 +1,6 @@
import { EventDispatcher } from '@ember/-internals/views';
import Application, { getOwner, setOwner } from '@ember/application';
-import ApplicationInstance, { BootOptions } from '@ember/application/instance';
+import ApplicationInstance from '@ember/application/instance';
import { Owner } from '@ember/-internals/owner';
import { expectTypeOf } from 'expect-type';
@@ -29,7 +29,29 @@ expectTypeOf(app.advanceReadiness()).toEqualTypeOf<void>();
expectTypeOf(app.boot()).toEqualTypeOf<void>();
expectTypeOf(app.ready()).toEqualTypeOf<void>();
expectTypeOf(app.reset()).toEqualTypeOf<void>();
-expectTypeOf(app.visit('/my-app', new BootOptions())).toEqualTypeOf<Promise<ApplicationInstance>>();
+
+let bootOptions = {
+ isBrowser: true,
+ shouldRender: false,
+ document: window.document,
+ rootElement: '#ember-application',
+ location: 'history',
+};
+
+app.visit('/my-app', bootOptions);
+
+app.visit('/my-app', { isBrowser: true });
+
+// @ts-expect-error Incorrect type
+app.visit('/my-app', { isBrowser: 1 });
+// @ts-expect-error Incorrect type
+app.visit('/my-app', { shouldRender: 1 });
+// @ts-expect-error Incorrect type
+app.visit('/my-app', { document: window });
+// @ts-expect-error Incorrect type
+app.visit('/my-app', { rootElement: 1 });
+// @ts-expect-error Incorrect type
+app.visit('/my-app', { location: 1 });
class App2 extends Application {
// @ts-expect-error Doesn't allow number | true |
Other | emberjs | ember.js | d0371027994e0203c1072d0f258cc169830aa0b2.json | Improve BootOptions types and add more type-tests | packages/@ember/application/type-tests/instance.test.ts | @@ -34,35 +34,25 @@ instance.hasRegistration();
expectTypeOf(instance.boot()).toEqualTypeOf<void>();
-const bootOptions = new BootOptions({
+const bootOptions: BootOptions = {
isBrowser: true,
shouldRender: false,
document: window.document,
rootElement: '#ember-application',
location: 'history',
-});
-
-expectTypeOf(bootOptions.isBrowser).toEqualTypeOf<boolean>();
-expectTypeOf(bootOptions.shouldRender).toEqualTypeOf<boolean>();
-expectTypeOf(bootOptions.document).toEqualTypeOf<Document | null>();
-expectTypeOf(bootOptions.rootElement).toEqualTypeOf<string | Element | null>();
-expectTypeOf(bootOptions.location).toEqualTypeOf<string | null>();
-
-new BootOptions({
- // @ts-expect-error Incorrect type
- isBrowser: 1,
- // @ts-expect-error Incorrect type
- shouldRender: 1,
- // @ts-expect-error Incorrect type
- document: window,
- // @ts-expect-error Incorrect type
- rootElement: 1,
- // @ts-expect-error Incorrect type
- location: 1,
-});
-
-new BootOptions({
- rootElement: window.document.createElement('div'),
-});
-
-new BootOptions();
+};
+
+instance.boot(bootOptions);
+
+instance.boot({ isBrowser: true });
+
+// @ts-expect-error Incorrect type
+instance.boot({ isBrowser: 1 });
+// @ts-expect-error Incorrect type
+instance.boot({ shouldRender: 1 });
+// @ts-expect-error Incorrect type
+instance.boot({ document: window });
+// @ts-expect-error Incorrect type
+instance.boot({ rootElement: 1 });
+// @ts-expect-error Incorrect type
+instance.boot({ location: 1 }); | true |
Other | emberjs | ember.js | d0371027994e0203c1072d0f258cc169830aa0b2.json | Improve BootOptions types and add more type-tests | packages/@ember/engine/type-tests/instance.test.ts | @@ -0,0 +1,38 @@
+import { Owner } from '@ember/-internals/owner';
+import EngineInstance from '@ember/engine/instance';
+import EmberObject from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf<EngineInstance>().toMatchTypeOf<EmberObject>();
+expectTypeOf<EngineInstance>().toMatchTypeOf<Owner>();
+
+// Good enough for tests
+let owner = {} as Owner;
+let instance = new EngineInstance(owner);
+
+expectTypeOf(instance.boot()).toEqualTypeOf<void>();
+
+expectTypeOf(instance.boot()).toEqualTypeOf<void>();
+
+let bootOptions = {
+ isBrowser: true,
+ shouldRender: false,
+ document: window.document,
+ rootElement: '#ember-application',
+ location: 'history',
+};
+
+instance.boot(bootOptions);
+
+instance.boot({ isBrowser: true });
+
+// @ts-expect-error Incorrect type
+instance.boot({ isBrowser: 1 });
+// @ts-expect-error Incorrect type
+instance.boot({ shouldRender: 1 });
+// @ts-expect-error Incorrect type
+instance.boot({ document: window });
+// @ts-expect-error Incorrect type
+instance.boot({ rootElement: 1 });
+// @ts-expect-error Incorrect type
+instance.boot({ location: 1 }); | true |
Other | emberjs | ember.js | b97e01a685c316ab4bb80fd71ac0cefda8d1d1ea.json | Fix failing tests | packages/@ember/application/type-tests/index.test.ts | @@ -5,6 +5,8 @@ import { Owner } from '@ember/-internals/owner';
import { expectTypeOf } from 'expect-type';
+let owner = {} as Owner;
+
class App extends Application {
rootElement = '#ember-application';
customEvents = {
@@ -16,7 +18,7 @@ class App extends Application {
}
}
-const app = new App();
+const app = new App(owner);
// You shouldn't really be setting this, so let's at least check that we can read it
expectTypeOf(app.eventDispatcher).toEqualTypeOf<EventDispatcher>();
@@ -34,7 +36,7 @@ class App2 extends Application {
rootElement = 1;
}
-new App2();
+new App2(owner);
expectTypeOf(getOwner('foo')).toEqualTypeOf<Owner | undefined>();
| true |
Other | emberjs | ember.js | b97e01a685c316ab4bb80fd71ac0cefda8d1d1ea.json | Fix failing tests | packages/@ember/application/type-tests/instance.test.ts | @@ -1,11 +1,15 @@
+import { Owner } from '@ember/-internals/owner';
import Application from '@ember/application';
import ApplicationInstance, { BootOptions } from '@ember/application/instance';
import EngineInstance from '@ember/engine/instance';
import EmberObject from '@ember/object';
import { expectTypeOf } from 'expect-type';
-const app = new Application();
+// Good enough for tests
+let owner = {} as Owner;
+
+const app = new Application(owner);
const instance = app.buildInstance();
expectTypeOf(instance).toEqualTypeOf<ApplicationInstance>(); | true |
Other | emberjs | ember.js | b97e01a685c316ab4bb80fd71ac0cefda8d1d1ea.json | Fix failing tests | packages/@ember/engine/type-tests/index.test.ts | @@ -1,15 +1,18 @@
import { TypeOptions } from '@ember/-internals/container/lib/registry';
-import { Factory } from '@ember/-internals/owner';
+import { Factory, Owner } from '@ember/-internals/owner';
import Namespace from '@ember/application/namespace';
import Engine from '@ember/engine';
import EngineInstance from '@ember/engine/instance';
import EmberObject from '@ember/object';
import { expectTypeOf } from 'expect-type';
+// Good enough for tests
+let owner = {} as Owner;
+
class Foo extends EmberObject {}
class Bar {}
-let engine = new Engine();
+let engine = new Engine(owner);
expectTypeOf(engine).toMatchTypeOf<Namespace>();
| true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/container/lib/container.ts | @@ -1,4 +1,4 @@
-import { Factory, Owner, setOwner } from '@ember/-internals/owner';
+import { Factory, FactoryClass, Owner, setOwner } from '@ember/-internals/owner';
import { dictionary, symbol } from '@ember/-internals/utils';
import { assert } from '@ember/debug';
import { DEBUG } from '@glimmer/env';
@@ -143,7 +143,7 @@ export default class Container {
@param {String} [options.source] The fullname of the request source (used for local lookup)
@return {any}
*/
- lookup<T>(fullName: string, options?: TypeOptions): T | undefined {
+ lookup(fullName: string, options?: TypeOptions): unknown {
if (this.isDestroyed) {
throw new Error(`Cannot call \`.lookup\` after the owner has been destroyed`);
}
@@ -208,15 +208,17 @@ export default class Container {
@param {String} fullName
@return {any}
*/
- factoryFor<T, C>(fullName: string): Factory<T, C> | undefined {
+ factoryFor(fullName: string): Factory<unknown> | undefined {
if (this.isDestroyed) {
throw new Error(`Cannot call \`.factoryFor\` after the owner has been destroyed`);
}
let normalizedName = this.registry.normalize(fullName);
assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName));
- return factoryFor<T, C>(this, normalizedName, fullName) as Factory<T, C> | undefined;
+ // TODO: This needs to return a Factory to be compatible with Owner.
+ // We should correctly the types so that this cast is not necessary.
+ return factoryFor(this, normalizedName, fullName) as Factory<unknown>;
}
}
@@ -275,14 +277,18 @@ function lookup(container: Container, fullName: string, options: TypeOptions = {
return instantiateFactory(container, normalizedName, fullName, options);
}
-function factoryFor<T, C>(container: Container, normalizedName: string, fullName: string) {
+function factoryFor(
+ container: Container,
+ normalizedName: string,
+ fullName: string
+): FactoryManager<unknown> | undefined {
let cached = container.factoryManagerCache[normalizedName];
if (cached !== undefined) {
return cached;
}
- let factory = container.registry.resolve(normalizedName) as DebugFactory<T, C> | undefined;
+ let factory = container.registry.resolve(normalizedName) as DebugFactory<unknown> | undefined;
if (factory === undefined) {
return;
@@ -440,7 +446,8 @@ export interface LazyInjection {
specifier: string;
}
-declare interface DebugFactory<T, C> extends Factory<T, C> {
+declare interface DebugFactory<T, C extends FactoryClass | object = FactoryClass>
+ extends Factory<T, C> {
_onLookup?: (fullName: string) => void;
_initFactory?: (factoryManager: FactoryManager<T, C>) => void;
_lazyInjections(): { [key: string]: LazyInjection };
@@ -456,7 +463,7 @@ export function setFactoryFor(obj: any, factory: FactoryManager<any, any>): void
obj[INIT_FACTORY] = factory;
}
-export class FactoryManager<T, C> {
+export class FactoryManager<T, C extends FactoryClass | object = FactoryClass> {
readonly container: Container;
readonly owner: Owner | null;
readonly class: Factory<T, C> & DebugFactory<T, C>; | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/container/lib/registry.ts | @@ -182,7 +182,7 @@ export default class Registry implements IRegistry {
@param {Function} factory
@param {Object} options
*/
- register<T, C>(fullName: string, factory: Factory<T, C>, options: TypeOptions = {}): void {
+ register(fullName: string, factory: Factory<unknown>, options: TypeOptions = {}): void {
assert('fullName must be a proper full name', this.isValidFullName(fullName));
assert(`Attempting to register an unknown factory: '${fullName}'`, factory !== undefined);
| true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/glimmer/lib/component-managers/curly.ts | @@ -133,7 +133,7 @@ export default class CurlyComponentManager
if (layout === undefined) {
if (layoutName !== undefined) {
- let _factory = owner.lookup<TemplateFactory>(`template:${layoutName}`);
+ let _factory = owner.lookup(`template:${layoutName}`) as TemplateFactory;
assert(`Layout \`${layoutName}\` not found!`, _factory !== undefined);
factory = _factory;
} else { | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/glimmer/lib/component.ts | @@ -710,8 +710,8 @@ const Component = CoreView.extend(
let owner = getOwner(this);
assert('Component is unexpectedly missing an owner', owner);
- if (owner.lookup<Environment>('-environment:main')!.isInteractive) {
- this.__dispatcher = owner.lookup<EventDispatcher>('event_dispatcher:main');
+ if ((owner.lookup('-environment:main') as Environment)!.isInteractive) {
+ this.__dispatcher = owner.lookup('event_dispatcher:main') as EventDispatcher;
} else {
// In FastBoot we have no EventDispatcher. Set to null to not try again to look it up.
this.__dispatcher = null; | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/glimmer/lib/modifiers/action.ts | @@ -265,7 +265,7 @@ class ActionModifierManager implements InternalModifierManager<ActionState, obje
}
ensureEventSetup(actionState: ActionState): void {
- let dispatcher = actionState.owner.lookup<EventDispatcher>('event_dispatcher:main');
+ let dispatcher = actionState.owner.lookup('event_dispatcher:main') as EventDispatcher;
dispatcher?.setupHandlerForEmberEvent(actionState.eventName);
}
| true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/glimmer/lib/resolver.ts | @@ -1,7 +1,7 @@
import { privatize as P } from '@ember/-internals/container';
import { TypeOptions } from '@ember/-internals/container/lib/registry';
import { ENV } from '@ember/-internals/environment';
-import { Factory, FactoryClass, Owner } from '@ember/-internals/owner';
+import { Factory, Owner } from '@ember/-internals/owner';
import { assert } from '@ember/debug';
import { _instrumentStart } from '@ember/instrumentation';
import { DEBUG } from '@glimmer/env';
@@ -57,24 +57,24 @@ function instrumentationPayload(name: string) {
return { object: `component:${name}` };
}
-function componentFor(name: string, owner: Owner): Option<Factory<{}, {}>> {
+function componentFor(name: string, owner: Owner): Option<Factory<unknown>> {
let fullName = `component:${name}`;
return owner.factoryFor(fullName) || null;
}
function layoutFor(name: string, owner: Owner, options?: TypeOptions): Option<Template> {
let templateFullName = `template:components/${name}`;
- return owner.lookup(templateFullName, options) || null;
+ return (owner.lookup(templateFullName, options) as Template) || null;
}
type LookupResult =
| {
- component: Factory<{}, {}>;
+ component: Factory<unknown>;
layout: TemplateFactory;
}
| {
- component: Factory<{}, {}>;
+ component: Factory<unknown>;
layout: null;
}
| {
@@ -173,10 +173,9 @@ export default class ResolverImpl implements RuntimeResolver<Owner>, CompileTime
return helper;
}
- const factory = owner.factoryFor<
- SimpleHelper | HelperInstance,
- HelperFactory<SimpleHelper | HelperInstance>
- >(`helper:${name}`);
+ const factory = owner.factoryFor(`helper:${name}`) as
+ | Factory<SimpleHelper, HelperFactory<SimpleHelper>>
+ | Factory<HelperInstance, HelperFactory<HelperInstance>>;
if (factory === undefined) {
return null;
@@ -221,7 +220,7 @@ export default class ResolverImpl implements RuntimeResolver<Owner>, CompileTime
return builtin;
}
- let modifier = owner.factoryFor<unknown, FactoryClass>(`modifier:${name}`);
+ let modifier = owner.factoryFor(`modifier:${name}`);
if (modifier === undefined) {
return null; | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts | @@ -670,7 +670,7 @@ if (ENV._DEBUG_RENDER_TREE) {
]);
runTask(() => {
- let controller = instance!.lookup<Controller>('controller:application')!;
+ let controller = (instance!.lookup('controller:application') as Controller)!;
controller.set('message', 'World');
});
@@ -716,7 +716,7 @@ if (ENV._DEBUG_RENDER_TREE) {
]);
runTask(() => {
- let controller = instance!.lookup<Controller>('controller:application')!;
+ let controller = (instance!.lookup('controller:application') as Controller)!;
controller.set('message', undefined);
});
| true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/owner/index.ts | @@ -24,9 +24,9 @@ export interface EngineInstanceOptions {
import EngineInstance from '@ember/engine/instance';
import { TypeOptions } from '../container/lib/registry';
export interface Owner {
- lookup<T>(fullName: string, options?: TypeOptions): T | undefined;
- factoryFor<T, C>(fullName: string): Factory<T, C> | undefined;
- register<T, C>(fullName: string, factory: Factory<T, C>, options?: TypeOptions): void;
+ lookup(fullName: string, options?: TypeOptions): unknown;
+ factoryFor(fullName: string): Factory<unknown> | undefined;
+ register(fullName: string, factory: Factory<unknown>, options?: TypeOptions): void;
hasRegistration(name: string): boolean;
/** @internal */ | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/routing/lib/location/auto_location.ts | @@ -182,7 +182,7 @@ export default class AutoLocation extends EmberObject implements EmberLocation {
let owner = getOwner(this);
assert('AutoLocation is unexpectedly missing an owner', owner);
- let concrete = owner.lookup<EmberLocation>(`location:${implementation}`);
+ let concrete = owner.lookup(`location:${implementation}`) as EmberLocation;
assert(`Could not find location '${implementation}'.`, concrete !== undefined);
set(concrete, 'rootURL', rootURL); | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/routing/lib/system/generate_controller.ts | @@ -16,7 +16,7 @@ import { DEBUG } from '@glimmer/env';
*/
export function generateControllerFactory(owner: Owner, controllerName: string): Factory<{}> {
- let Factory = owner.factoryFor<any, any>('controller:basic')!.class;
+ let Factory = (owner.factoryFor('controller:basic') as Factory<any, any>).class;
Factory = Factory.extend({
toString() {
@@ -44,7 +44,7 @@ export default function generateController(owner: Owner, controllerName: string)
generateControllerFactory(owner, controllerName);
let fullName = `controller:${controllerName}`;
- let instance = owner.lookup<Controller>(fullName)!;
+ let instance = (owner.lookup(fullName) as Controller)!;
if (DEBUG) {
if (get(instance, 'namespace.LOG_ACTIVE_GENERATION')) { | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/routing/lib/system/route.ts | @@ -278,8 +278,8 @@ class Route<T = unknown>
super(owner);
if (owner) {
- let router = owner.lookup<EmberRouter>('router:main');
- let bucketCache = owner.lookup<BucketCache>(P`-bucket-cache:main`);
+ let router = owner.lookup('router:main') as EmberRouter;
+ let bucketCache = owner.lookup(P`-bucket-cache:main`) as BucketCache;
assert(
'ROUTER BUG: Expected route injections to be defined on the route. This is an internal bug, please open an issue on Github if you see this message!',
@@ -658,7 +658,7 @@ class Route<T = unknown>
paramsFor(name: string): Record<string, unknown> {
let owner = getOwner(this);
assert('Route is unexpectedly missing an owner', owner);
- let route = owner.lookup<Route>(`route:${name}`);
+ let route = owner.lookup(`route:${name}`) as Route;
if (route === undefined) {
return {};
@@ -1587,13 +1587,13 @@ class Route<T = unknown>
controllerFor(name: string, _skipAssert = false): Controller | undefined {
let owner = getOwner(this);
assert('Route is unexpectedly missing an owner', owner);
- let route = owner.lookup<Route>(`route:${name}`);
+ let route = owner.lookup(`route:${name}`) as Route;
if (route && route.controllerName) {
name = route.controllerName;
}
- let controller = owner.lookup<Controller>(`controller:${name}`);
+ let controller = owner.lookup(`controller:${name}`) as Controller;
// NOTE: We're specifically checking that skipAssert is true, because according
// to the old API the second parameter was model. We do not want people who
@@ -1693,7 +1693,7 @@ class Route<T = unknown>
name = _name;
}
- let route = owner.lookup<Route>(`route:${name}`);
+ let route = owner.lookup(`route:${name}`) as Route;
// If we are mid-transition, we want to try and look up
// resolved parent contexts on the current transitionEvent.
if (transition !== undefined && transition !== null) {
@@ -1874,7 +1874,7 @@ class Route<T = unknown>
let controllerName = this.controllerName || this.routeName;
let owner = getOwner(this);
assert('Route is unexpectedly missing an owner', owner);
- let controller = owner.lookup<Controller>(`controller:${controllerName}`);
+ let controller = owner.lookup(`controller:${controllerName}`) as Controller;
let queryParameterConfiguraton = get(this, 'queryParams');
let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
@@ -2127,16 +2127,18 @@ function buildRenderOptions(
if (controller === undefined) {
if (isDefaultRender) {
- controller = route.controllerName || owner.lookup<Controller>(`controller:${name}`);
+ controller = route.controllerName || (owner.lookup(`controller:${name}`) as Controller);
} else {
controller =
- owner.lookup<Controller>(`controller:${name}`) || route.controllerName || route.routeName;
+ (owner.lookup(`controller:${name}`) as Controller) ||
+ route.controllerName ||
+ route.routeName;
}
}
if (typeof controller === 'string') {
let controllerName = controller;
- controller = owner.lookup<Controller>(`controller:${controllerName}`);
+ controller = owner.lookup(`controller:${controllerName}`) as Controller;
assert(
`You passed \`controller: '${controllerName}'\` into the \`render\` method, but no such controller could be found.`,
isDefaultRender || controller !== undefined
@@ -2149,7 +2151,7 @@ function buildRenderOptions(
(controller! as any).set('model', model);
}
- let template = owner.lookup<TemplateFactory>(`template:${templateName}`);
+ let template = owner.lookup(`template:${templateName}`) as TemplateFactory;
assert(
`Could not find "${templateName}" template, view, or component.`,
isDefaultRender || template !== undefined | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/routing/lib/system/router.ts | @@ -1,7 +1,7 @@
import { privatize as P } from '@ember/-internals/container';
import { OutletState as GlimmerOutletState, OutletView } from '@ember/-internals/glimmer';
import { computed, get, set } from '@ember/-internals/metal';
-import { FactoryClass, getOwner, Owner } from '@ember/-internals/owner';
+import { Factory, FactoryClass, getOwner, Owner } from '@ember/-internals/owner';
import { BucketCache } from '@ember/-internals/routing';
import RouterService from '@ember/-internals/routing/lib/services/router';
import { A as emberA, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
@@ -312,11 +312,11 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
this._resetQueuedQueryParameterChanges();
this.namespace = owner.lookup('application:main');
- let bucketCache: BucketCache | undefined = owner.lookup(P`-bucket-cache:main`);
+ let bucketCache = owner.lookup(P`-bucket-cache:main`) as BucketCache | undefined;
assert('BUG: BucketCache should always be present', bucketCache !== undefined);
this._bucketCache = bucketCache;
- let routerService: RouterService<R> | undefined = owner.lookup('service:router');
+ let routerService = owner.lookup('service:router') as RouterService<R> | undefined;
assert('BUG: RouterService should always be present', routerService !== undefined);
this._routerService = routerService;
}
@@ -345,7 +345,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
assert('Route is unexpectedly missing an owner', routeOwner);
- let route = routeOwner.lookup<R>(fullRouteName);
+ let route = routeOwner.lookup(fullRouteName) as R;
if (seen[name]) {
assert('seen routes should exist', route);
@@ -357,7 +357,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
if (!route) {
let DefaultRoute: any = routeOwner.factoryFor('route:basic')!.class;
routeOwner.register(fullRouteName, DefaultRoute.extend());
- route = routeOwner.lookup(fullRouteName);
+ route = routeOwner.lookup(fullRouteName) as R;
if (DEBUG) {
if (router.namespace.LOG_ACTIVE_GENERATION) {
@@ -642,7 +642,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
if (!this._toplevelView) {
let owner = getOwner(this);
assert('Router is unexpectedly missing an owner', owner);
- let OutletView = owner.factoryFor<OutletView, FactoryClass>('view:-outlet')!;
+ let OutletView = owner.factoryFor('view:-outlet') as Factory<OutletView, FactoryClass>;
let application = owner.lookup('application:main');
let environment = owner.lookup('-environment:main');
let template = owner.lookup('template:-outlet');
@@ -866,7 +866,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
assert('Router is unexpectedly missing an owner', owner);
if ('string' === typeof location) {
- let resolvedLocation = owner.lookup<IEmberLocation>(`location:${location}`);
+ let resolvedLocation = owner.lookup(`location:${location}`) as IEmberLocation;
if (location === 'auto') {
deprecate(
@@ -1788,7 +1788,7 @@ function updatePaths(router: EmberRouter) {
let owner = getOwner(router);
assert('Router is unexpectedly missing an owner', owner);
- let appController = owner.lookup<Controller>('controller:application');
+ let appController = owner.lookup('controller:application') as Controller;
if (!appController) {
// appController might not exist when top-level loading/error | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/-internals/views/lib/system/utils.ts | @@ -44,7 +44,7 @@ interface View {
@param {Object} owner
*/
export function getRootViews(owner: Owner): View[] {
- let registry = owner.lookup<Dict<View>>('-view-registry:main')!;
+ let registry = owner.lookup('-view-registry:main') as Dict<View>;
let rootViews: View[] = [];
@@ -120,7 +120,7 @@ const CHILD_VIEW_IDS: WeakMap<View, Set<string>> = new WeakMap();
export function getChildViews(view: View): View[] {
let owner = getOwner(view);
assert('View is unexpectedly missing an owner', owner);
- let registry = owner.lookup<Dict<View>>('-view-registry:main')!;
+ let registry = owner.lookup('-view-registry:main') as Dict<View>;
return collectChildViews(view, registry);
}
| true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/application/type-tests/instance.test.ts | @@ -19,10 +19,10 @@ expectTypeOf(
instance.register('service:store-singleton', Store, { singleton: true, instantiate: true })
).toEqualTypeOf<void>();
-expectTypeOf(instance.lookup<Store>('service:store')).toEqualTypeOf<Store | undefined>();
+expectTypeOf(instance.lookup('service:store')).toEqualTypeOf<unknown>();
expectTypeOf(
- instance.lookup<Store>('service:store', { singleton: true, instantiate: true })
-).toEqualTypeOf<Store | undefined>();
+ instance.lookup('service:store', { singleton: true, instantiate: true })
+).toEqualTypeOf<unknown>();
expectTypeOf(instance.hasRegistration('service:store')).toEqualTypeOf<boolean>();
// @ts-expect-error requires name | true |
Other | emberjs | ember.js | d4c40f1d66cbdea276ec7db4f61a025619b12b79.json | Resolve unsafe owner methods | packages/@ember/debug/lib/capture-render-tree.ts | @@ -20,7 +20,7 @@ import { expect } from '@glimmer/util';
@since 3.14.0
*/
export default function captureRenderTree(app: Owner): CapturedRenderNode[] {
- let renderer = expect(app.lookup<Renderer>('renderer:-dom'), `BUG: owner is missing renderer`);
+ let renderer = expect(app.lookup('renderer:-dom') as Renderer, `BUG: owner is missing renderer`);
return renderer.debugRenderTree.capture();
} | true |
Other | emberjs | ember.js | b1047ad3e7a4fb0f3c8a5203e8ec983f97c21f91.json | lint: Fix lint error | node-tests/blueprints/mixin-test.js | @@ -5,7 +5,6 @@ const setupTestHooks = blueprintHelpers.setupTestHooks;
const emberNew = blueprintHelpers.emberNew;
const emberGenerateDestroy = blueprintHelpers.emberGenerateDestroy;
const setupPodConfig = blueprintHelpers.setupPodConfig;
-const EOL = require('os').EOL;
const chai = require('ember-cli-blueprint-test-helpers/chai');
const expect = chai.expect; | false |
Other | emberjs | ember.js | db7c537fb7b2e30d28287dce74856322bc45bbf0.json | Fix types for canInvoke | packages/@ember/-internals/utils/lib/invoke.ts | @@ -16,8 +16,8 @@
@return {Boolean}
@private
*/
-export function canInvoke(obj: any | null | undefined, methodName: string): obj is Function {
- return obj !== null && obj !== undefined && typeof obj[methodName] === 'function';
+export function canInvoke(obj: unknown, methodName: string): boolean {
+ return obj != null && typeof (obj as Record<string, unknown>)[methodName] === 'function';
}
/** | false |
Other | emberjs | ember.js | e1d249355bb29586d3ff69863c6ab5637b9d7017.json | Update router_js types | package.json | @@ -140,7 +140,7 @@
"rollup-plugin-commonjs": "^9.3.4",
"rollup-plugin-node-resolve": "^4.2.4",
"route-recognizer": "^0.3.4",
- "router_js": "^8.0.1",
+ "router_js": "^8.0.2",
"rsvp": "^4.8.5",
"serve-static": "^1.14.1",
"simple-dom": "^1.4.0", | true |
Other | emberjs | ember.js | e1d249355bb29586d3ff69863c6ab5637b9d7017.json | Update router_js types | packages/@ember/-internals/routing/lib/system/route.ts | @@ -29,7 +29,6 @@ import { DEBUG } from '@glimmer/env';
import { Template, TemplateFactory } from '@glimmer/interfaces';
import {
InternalRouteInfo,
- IModel,
ModelFor,
PARAMS_SYMBOL,
Route as IRoute,
@@ -87,7 +86,7 @@ const RENDER = (symbol('render') as unknown) as string;
@since 1.0.0
@public
*/
-interface Route<T extends IModel = {}> extends IRoute<T> {
+interface Route<T = unknown> extends IRoute<T> {
/**
The `willTransition` action is fired at the beginning of any
attempted transition with a `Transition` object as the sole
@@ -258,7 +257,7 @@ interface Route<T extends IModel = {}> extends IRoute<T> {
error?(error: Error, transition: Transition): boolean | void;
}
-class Route<T extends IModel = {}>
+class Route<T = unknown>
extends EmberObject.extend(ActionHandler, Evented)
implements IRoute, Evented {
static isRouteFactory = true; | true |
Other | emberjs | ember.js | e1d249355bb29586d3ff69863c6ab5637b9d7017.json | Update router_js types | yarn.lock | @@ -8612,10 +8612,10 @@ route-recognizer@^0.3.4:
resolved "https://registry.yarnpkg.com/route-recognizer/-/route-recognizer-0.3.4.tgz#39ab1ffbce1c59e6d2bdca416f0932611e4f3ca3"
integrity "sha1-Oasf+84cWebSvcpBbwkyYR5PPKM= sha512-2+MhsfPhvauN1O8KaXpXAOfR/fwe8dnUXVM+xw7yt40lJRfPVQxV6yryZm0cgRvAj5fMF/mdRZbL2ptwbs5i2g=="
-router_js@^8.0.1:
- version "8.0.1"
- resolved "https://registry.yarnpkg.com/router_js/-/router_js-8.0.1.tgz#26e197ac0e7be04e9b7850e7755f81fa737c5568"
- integrity sha512-61q9s2hLFHh8bCl/sTDoAOf0B+7lnTzG1tYjK8W32vg0iwUC2hXMo+2ymLFBfdvdDtD4RdknMVh9scyy9zbElg==
+router_js@^8.0.2:
+ version "8.0.2"
+ resolved "https://registry.yarnpkg.com/router_js/-/router_js-8.0.2.tgz#ea0e011ac050d41cae896e3bd18c542456bec910"
+ integrity sha512-l0RUYT61Z7xtmTrEJh4pP6Y4TvFfp6OdCWAV0i+3wQZpAZOnX/OQR8wsbyPRjM3iJIddCJYkX3ayySKMfCzdGw==
dependencies:
"@glimmer/env" "^0.1.7"
| true |
Other | emberjs | ember.js | 2ef2be9950885f1c39248525e98b9db7c3854cf0.json | Remove code related to named outlets | packages/@ember/-internals/glimmer/lib/syntax/outlet.ts | @@ -6,7 +6,6 @@ import {
childRefFromParts,
createComputeRef,
createDebugAliasRef,
- createPrimitiveRef,
Reference,
valueForRef,
} from '@glimmer/reference';
@@ -38,32 +37,22 @@ import { OutletState } from '../utils/outlet';
Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
@method outlet
- @param {String} [name]
@for Ember.Templates.helpers
@public
*/
export const outletHelper = internalHelper(
- (args: CapturedArguments, owner?: Owner, scope?: DynamicScope) => {
+ (_args: CapturedArguments, owner?: Owner, scope?: DynamicScope) => {
assert('Expected owner to be present, {{outlet}} requires an owner', owner);
assert(
'Expected dynamic scope to be present. You may have attempted to use the {{outlet}} keyword dynamically. This keyword cannot be used dynamically.',
scope
);
- let nameRef: Reference<string>;
-
- if (args.positional.length === 0) {
- nameRef = createPrimitiveRef('main');
- } else {
- let maybeNameRef = args.positional[0];
- assert('Expected at least one positional arg', maybeNameRef);
- nameRef = maybeNameRef;
- }
let outletRef = createComputeRef(() => {
let state = valueForRef(scope.get('outletState') as Reference<OutletState | undefined>);
let outlets = state !== undefined ? state.outlets : undefined;
- return outlets !== undefined ? outlets[valueForRef(nameRef)] : undefined;
+ return outlets !== undefined ? outlets.main : undefined;
});
let lastState: OutletDefinitionState | null = null; | false |
Other | emberjs | ember.js | 1e56cc828415bd0bfcccb35f431daa12467129aa.json | Add v4.3.0-beta.1 to CHANGELOG
(cherry picked from commit 30d54b8e69d9bf5ad78e9b442c3946c47d8c78b2) | CHANGELOG.md | @@ -1,5 +1,9 @@
# Ember Changelog
+### v4.3.0-beta.1 (February 7, 2022)
+
+No public API changes or bugfixes.
+
### v4.2.0 (February 7, 2022)
- [#19878](https://github.com/emberjs/ember.js/pull/19878) [BUGFIX] Allow class-based helpers to work in strict-mode. | false |
Other | emberjs | ember.js | ea486c5e693346373886dcd08496085268ad1e1d.json | Add 4.2.0 to CHANGELOG
(cherry picked from commit 693ce77994e0c826988ee0370831cd2dc3237d8b) | CHANGELOG.md | @@ -1,8 +1,8 @@
# Ember Changelog
-### v4.2.0-beta.1 (December 28, 2021)
+### v4.2.0 (February 7, 2022)
-- [#19878](https://github.com/emberjs/ember.js/pull/19772) [BUGFIX] Allow class-based helpers to work in strict-mode.
+- [#19878](https://github.com/emberjs/ember.js/pull/19878) [BUGFIX] Allow class-based helpers to work in strict-mode.
### v4.1.0 (December 28, 2021)
| false |
Other | emberjs | ember.js | 4afbe9103a2a2fee6518ad80c91f8cf80122fc37.json | adjust failing assertions | packages/@ember/-internals/container/tests/container_test.js | @@ -608,7 +608,7 @@ moduleFor(
assert.throws(() => {
container.lookup('service:foo');
- }, /Can not call `.lookup` after the owner has been destroyed/);
+ }, /Cannot call `.lookup` after the owner has been destroyed/);
}
[`@test assert when calling factoryFor after destroy on a container`](assert) {
@@ -626,7 +626,7 @@ moduleFor(
assert.throws(() => {
container.factoryFor('service:foo');
- }, /Can not call `.factoryFor` after the owner has been destroyed/);
+ }, /Cannot call `.factoryFor` after the owner has been destroyed/);
}
// this is skipped until templates and the glimmer environment do not require `OWNER` to be
@@ -690,7 +690,7 @@ moduleFor(
assert.throws(() => {
Factory.create();
- }, /Can not create new instances after the owner has been destroyed \(you attempted to create service:other\)/);
+ }, /Cannot create new instances after the owner has been destroyed \(you attempted to create service:other\)/);
}
}
); | false |
Other | emberjs | ember.js | 839eed2ab13d26cb349dc3c5e898c7c142acd65f.json | Fix typo in error messages
Cannot is one word | packages/@ember/-internals/container/lib/container.ts | @@ -145,7 +145,7 @@ export default class Container {
*/
lookup(fullName: string, options: LookupOptions): any {
if (this.isDestroyed) {
- throw new Error(`Can not call \`.lookup\` after the owner has been destroyed`);
+ throw new Error(`Cannot call \`.lookup\` after the owner has been destroyed`);
}
assert('fullName must be a proper full name', this.registry.isValidFullName(fullName));
return lookup(this, this.registry.normalize(fullName), options);
@@ -212,7 +212,7 @@ export default class Container {
*/
factoryFor<T, C>(fullName: string): Factory<T, C> | undefined {
if (this.isDestroyed) {
- throw new Error(`Can not call \`.factoryFor\` after the owner has been destroyed`);
+ throw new Error(`Cannot call \`.factoryFor\` after the owner has been destroyed`);
}
let normalizedName = this.registry.normalize(fullName);
@@ -500,7 +500,7 @@ export class FactoryManager<T, C> {
if (container.isDestroyed) {
throw new Error(
- `Can not create new instances after the owner has been destroyed (you attempted to create ${this.fullName})`
+ `Cannot create new instances after the owner has been destroyed (you attempted to create ${this.fullName})`
);
}
| false |
Other | emberjs | ember.js | 1320f55a753739584a64a521cc0483f8277e7f7e.json | Improve routing docs | packages/@ember/-internals/routing/lib/services/router.ts | @@ -79,8 +79,6 @@ class RouterService extends Service.extend(Evented) {
Transition the application into another route. The route may
be either a single route or route path:
- See [transitionTo](/ember/release/classes/Route/methods/transitionTo?anchor=transitionTo) for more info.
-
Calling `transitionTo` from the Router service will cause default query parameter values to be included in the URL.
This behavior is different from calling `transitionTo` on a route or `transitionToRoute` on a controller.
See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
@@ -151,8 +149,6 @@ class RouterService extends Service.extend(Evented) {
This is most commonly used to manage redirects in a way that does not cause confusing additions
to the user's browsing history.
- See [replaceWith](/ember/release/classes/Route/methods/replaceWith?anchor=replaceWith) for more info.
-
Calling `replaceWith` from the Router service will cause default query parameter values to be included in the URL.
This behavior is different from calling `replaceWith` on a route.
See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info. | true |
Other | emberjs | ember.js | 1320f55a753739584a64a521cc0483f8277e7f7e.json | Improve routing docs | packages/@ember/-internals/routing/lib/system/router.ts | @@ -669,8 +669,6 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
Transition the application into another route. The route may
be either a single route or route path:
- See [transitionTo](/ember/release/classes/Route/methods/transitionTo?anchor=transitionTo) for more info.
-
@method transitionTo
@param {String} [name] the name of the route or a URL
@param {...Object} models the model(s) or identifier(s) to be used while
@@ -712,6 +710,23 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
}
}
+ /**
+ Similar to `transitionTo`, but instead of adding the destination to the browser's URL history,
+ it replaces the entry for the current route.
+ When the user clicks the "back" button in the browser, there will be fewer steps.
+ This is most commonly used to manage redirects in a way that does not cause confusing additions
+ to the user's browsing history.
+
+ @method replaceWith
+ @param {String} [name] the name of the route or a URL
+ @param {...Object} models the model(s) or identifier(s) to be used while
+ transitioning to the route.
+ @param {Object} [options] optional hash with a queryParams property
+ containing a mapping of query parameters
+ @return {Transition} the transition object associated with this
+ attempted transition
+ @public
+ */
replaceWith(...args: RouteArgs): Transition {
return this.transitionTo(...args).method('replace');
} | true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/computed.test.ts | @@ -22,7 +22,7 @@ class Foo {
declare badFullName: string;
// NOTE: This works, but is not recommended.
- @computed('firstName', 'lastName', function () {
+ @computed('firstName', 'lastName', function (this: Foo) {
return `${this.firstName} ${this.lastName}`;
})
declare altFullName: string; | true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/define-property.test.ts | @@ -1,6 +1,6 @@
import { defineProperty } from '@ember/object';
-let contact = {};
+const contact = {};
// ES5 compatible mode
defineProperty(contact, 'firstName', { | true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/ember-object.test.ts | @@ -57,7 +57,7 @@ expectTypeOf(p.toggleProperty('age')).toEqualTypeOf<boolean>();
expectTypeOf(p.cacheFor('age')).toEqualTypeOf<unknown>();
// get is not preferred for TS and only returns unknown
-let getPropertiesResult = p.getProperties('firstName', 'lastName', 'invalid');
+const getPropertiesResult = p.getProperties('firstName', 'lastName', 'invalid');
expectTypeOf(getPropertiesResult).toEqualTypeOf<{
firstName: unknown;
lastName: unknown;
@@ -69,7 +69,7 @@ getPropertiesResult.unknown;
expectTypeOf(p.set('firstName', 'Joe')).toEqualTypeOf<string>();
expectTypeOf(p.set('invalid', 1)).toEqualTypeOf<number>();
-let setPropertiesResult = p.setProperties({ firstName: 'Joe', invalid: 1 });
+const setPropertiesResult = p.setProperties({ firstName: 'Joe', invalid: 1 });
expectTypeOf(setPropertiesResult).toEqualTypeOf<{
firstName: string;
invalid: number;
@@ -105,8 +105,10 @@ class MyComponent extends EmberObject {
constructor() {
super();
this.addObserver('foo', this, 'fooDidChange');
+
this.addObserver('foo', this, this.fooDidChange);
this.removeObserver('foo', this, 'fooDidChange');
+
this.removeObserver('foo', this, this.fooDidChange);
const lambda = () => {
this.fooDidChange(this, 'foo'); | true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/evented/on.test.ts | @@ -9,7 +9,7 @@ class Job {
});
}
-let job = new Job();
+const job = new Job();
sendEvent(job, 'completed'); // Logs 'Job completed!'
| true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/events/index.test.ts | @@ -26,9 +26,12 @@ class MyClass extends EmberObject {
super();
addListener(this, 'willDestroy', this, 'willDestroyListener');
addListener(this, 'willDestroy', this, 'willDestroyListener', true);
+
addListener(this, 'willDestroy', this, this.willDestroyListener);
+
addListener(this, 'willDestroy', this, this.willDestroyListener, true);
removeListener(this, 'willDestroy', this, 'willDestroyListener');
+
removeListener(this, 'willDestroy', this, this.willDestroyListener);
}
| true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/get-properties.test.ts | @@ -2,7 +2,7 @@ import { getProperties } from '@ember/object';
import { expectTypeOf } from 'expect-type';
-let foo = { baz: 1 };
+const foo = { baz: 1 };
// We can't correctly infer CP types so just return unknown
expectTypeOf(getProperties(foo, 'baz', 'missing')).toEqualTypeOf<{ | true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/get.test.ts | @@ -2,7 +2,7 @@ import { get } from '@ember/object';
import { expectTypeOf } from 'expect-type';
-let foo = { baz: 1 };
+const foo = { baz: 1 };
// We can infer basic types
expectTypeOf(get(foo, 'baz')).toEqualTypeOf<number>(); | true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/mixin/index.test.ts | @@ -2,7 +2,7 @@ import { expectTypeOf } from 'expect-type';
import Mixin from '@ember/object/mixin';
-let newMixin = Mixin.create({
+const newMixin = Mixin.create({
foo: 'bar',
});
| true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/observer.test.ts | @@ -2,8 +2,9 @@ import { observer } from '@ember/object';
import { expectTypeOf } from 'expect-type';
-let definition = {
+const definition = {
dependentKeys: ['value1', 'value2', 'value3'],
+
fn: () => {},
sync: true,
};
@@ -22,7 +23,7 @@ class Foo {
extraKeysObserver = observer('extraKey', definition);
}
-let foo = new Foo();
+const foo = new Foo();
expectTypeOf(foo.valueObserver).toEqualTypeOf<() => void>();
expectTypeOf(foo.definitionObserver).toEqualTypeOf<() => void>(); | true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/observers/index.test.ts | @@ -5,8 +5,10 @@ class MyComponent {
constructor() {
addObserver(this, 'foo', this, 'fooDidChange');
+
addObserver(this, 'foo', this, this.fooDidChange);
removeObserver(this, 'foo', this, 'fooDidChange');
+
removeObserver(this, 'foo', this, this.fooDidChange);
const lambda = () => {
this.fooDidChange(this, 'foo'); | true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/set-properties.test.ts | @@ -2,7 +2,7 @@ import { setProperties } from '@ember/object';
import { expectTypeOf } from 'expect-type';
-let foo = { baz: 1 };
+const foo = { baz: 1 };
expectTypeOf(setProperties(foo, { baz: 2, missing: true })).toEqualTypeOf<{
baz: number; | true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/set.test.ts | @@ -2,7 +2,7 @@ import { set } from '@ember/object';
import { expectTypeOf } from 'expect-type';
-let foo = { baz: 1 };
+const foo = { baz: 1 };
expectTypeOf(set(foo, 'baz', 2)).toEqualTypeOf<number>();
| true |
Other | emberjs | ember.js | 251d3eb21f07888b431dc1fb814eab7a6b55636c.json | Resolve some warnings in tests | packages/@ember/object/type-tests/try-set.test.ts | @@ -1,9 +1,9 @@
import { trySet } from '@ember/object';
import { expectTypeOf } from 'expect-type';
-let obj = { name: 'Zoey' };
+const obj = { name: 'Zoey' };
-let result = trySet(obj, 'contacts.twitter', '@emberjs');
+const result = trySet(obj, 'contacts.twitter', '@emberjs');
expectTypeOf(result).toEqualTypeOf<string | undefined>();
// @ts-expect-error requires a value | true |
Other | emberjs | ember.js | 95df93d670fd2efffc17087563862dc57d274095.json | Resolve warnings in @ember/object/computed.d.ts | packages/@ember/object/computed.d.ts | @@ -18,7 +18,7 @@ export function deprecatingAlias(
export function empty(dependentKey: string): PropertyDecorator;
-export function equal(dependentKey: string, value: any): PropertyDecorator;
+export function equal(dependentKey: string, value: unknown): PropertyDecorator;
export function filter(
dependentKey: string,
@@ -30,7 +30,11 @@ export function filter(
callback: (value: unknown, index: number, array: unknown[]) => boolean
): PropertyDecorator;
-export function filterBy(dependentKey: string, propertyKey: string, value?: any): PropertyDecorator;
+export function filterBy(
+ dependentKey: string,
+ propertyKey: string,
+ value?: unknown
+): PropertyDecorator;
export function gt(dependentKey: string, value: number): PropertyDecorator;
| false |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/browser-environment/lib/has-dom.ts | @@ -1,7 +1,7 @@
// check if window exists and actually is the global
export default typeof self === 'object' &&
self !== null &&
- (self as Window['self']).Object === Object &&
+ self.Object === Object &&
typeof Window !== 'undefined' &&
self.constructor === Window &&
typeof document === 'object' && | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/glimmer/lib/component-managers/curly.ts | @@ -434,7 +434,7 @@ export default class CurlyComponentManager
if (args !== null && !validateTag(argsTag, argsRevision)) {
beginTrackFrame();
- let props = processComponentArgs(args!);
+ let props = processComponentArgs(args);
argsTag = bucket.argsTag = endTrackFrame();
bucket.argsRevision = valueForTag(argsTag); | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/glimmer/lib/component-managers/mount.ts | @@ -154,7 +154,7 @@ class MountManager
let { controller, modelRef } = bucket;
if (modelRef !== undefined) {
- controller.set('model', valueForRef(modelRef!));
+ controller.set('model', valueForRef(modelRef));
}
}
} | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/glimmer/lib/component.ts | @@ -787,7 +787,7 @@ const Component = CoreView.extend(
_element !== null
);
- let element = _element!;
+ let element = _element;
let isSVG = element.namespaceURI === Namespace.SVG;
let { type, normalized } = normalizeProperty(element, name);
| true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/glimmer/lib/helpers/action.ts | @@ -410,7 +410,7 @@ function makeClosureAction(
if (typeofAction === 'string') {
self = target;
- fn = target.actions! && target.actions![action as string];
+ fn = (target.actions && target.actions[action as string])!;
assert(`An action named '${action}' was not found in ${target}`, Boolean(fn));
} else if (typeofAction === 'function') { | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/glimmer/lib/resolver.ts | @@ -252,7 +252,7 @@ export default class ResolverImpl implements RuntimeResolver<Owner>, CompileTime
let key: object;
if (pair.component === null) {
- key = template = pair.layout!(owner);
+ key = template = pair.layout(owner);
} else {
key = pair.component;
} | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/glimmer/lib/syntax/mount.ts | @@ -87,7 +87,7 @@ export const mountHelper = internalHelper(
assert(
`You used \`{{mount '${name}'}}\`, but the engine '${name}' can not be found.`,
- (owner as Owner).hasRegistration(`engine:${name}`)
+ owner.hasRegistration(`engine:${name}`)
);
lastName = name; | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/glimmer/lib/utils/bindings.ts | @@ -116,7 +116,7 @@ export function createSimpleClassNameBindingRef(inner: Reference, path?: string)
path !== undefined
);
- return dasherizedPath || (dasherizedPath = dasherize(path!));
+ return dasherizedPath || (dasherizedPath = dasherize(path));
} else if (value || value === 0) {
return String(value);
} else { | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/glimmer/lib/utils/to-bool.ts | @@ -6,7 +6,7 @@ import { consumeTag } from '@glimmer/validator';
export default function toBool(predicate: unknown): boolean {
if (isProxy(predicate)) {
- consumeTag(tagForProperty(predicate as object, 'content'));
+ consumeTag(tagForProperty(predicate, 'content'));
return Boolean(get(predicate, 'isTruthy'));
} else if (isArray(predicate)) { | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts | @@ -28,7 +28,7 @@ interface CapturedBounds {
}
function compileTemplate(templateSource: string, options: Partial<EmberPrecompileOptions>) {
- return compile(templateSource, options) as any;
+ return compile(templateSource, options);
}
type Expected<T> = T | ((actual: T) => boolean); | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/meta/lib/meta.ts | @@ -383,7 +383,7 @@ export class Meta {
): void {
let listeners = this.writableListeners();
- let i = indexOfListener(listeners, event, target, method!);
+ let i = indexOfListener(listeners, event, target, method);
// remove if found listener was inherited
if (i !== -1 && i < this._inheritedEnd) { | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/metal/lib/computed.ts | @@ -344,7 +344,7 @@ export class ComputedProperty extends ComputedDescriptor {
(typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function')
);
- let { get, set } = propertyDesc!;
+ let { get, set } = propertyDesc;
if (get !== undefined) {
this._getter = get as ComputedPropertyGetterFunction;
@@ -414,7 +414,7 @@ export class ComputedProperty extends ComputedDescriptor {
});
if (_dependentKeys !== undefined) {
- updateTag(propertyTag!, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta));
+ updateTag(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta));
if (DEBUG) {
ALLOW_CYCLES!.set(propertyTag, true);
@@ -427,7 +427,7 @@ export class ComputedProperty extends ComputedDescriptor {
finishLazyChains(meta, keyName, ret);
}
- consumeTag(propertyTag!);
+ consumeTag(propertyTag);
// Add the tag of the returned value if it is an array, since arrays
// should always cause updates if they are consumed and then changed
@@ -573,15 +573,15 @@ class AutoComputedProperty extends ComputedProperty {
ret = _getter!.call(obj, keyName);
});
- updateTag(propertyTag!, tag);
+ updateTag(propertyTag, tag);
meta.setValueFor(keyName, ret);
meta.setRevisionFor(keyName, valueForTag(propertyTag));
finishLazyChains(meta, keyName, ret);
}
- consumeTag(propertyTag!);
+ consumeTag(propertyTag);
// Add the tag of the returned value if it is an array, since arrays
// should always cause updates if they are consumed and then changed | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/metal/lib/events.ts | @@ -133,7 +133,7 @@ export function sendEvent(
for (let i = actions.length - 3; i >= 0; i -= 3) {
// looping in reverse for once listeners
- let target = actions[i] as any | null;
+ let target = actions[i];
let method = actions[i + 1] as string | Function;
let once = actions[i + 2] as boolean;
| true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/metal/lib/mixin.ts | @@ -814,9 +814,9 @@ export function observer<T extends (...args: any[]) => any>(
dependentKeys = args as string[];
sync = !ENV._DEFAULT_ASYNC_OBSERVERS;
} else {
- func = (funcOrDef as ObserverDefinition<T>).fn;
- dependentKeys = (funcOrDef as ObserverDefinition<T>).dependentKeys;
- sync = (funcOrDef as ObserverDefinition<T>).sync;
+ func = funcOrDef.fn;
+ dependentKeys = funcOrDef.dependentKeys;
+ sync = funcOrDef.sync;
}
assert('observer called without a function', typeof func === 'function');
@@ -831,7 +831,7 @@ export function observer<T extends (...args: any[]) => any>(
let paths: string[] = [];
for (let i = 0; i < dependentKeys.length; ++i) {
- expandProperties(dependentKeys[i] as string, (path: string) => paths.push(path));
+ expandProperties(dependentKeys[i], (path: string) => paths.push(path));
}
setObservers(func as Function, { | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/metal/lib/namespace_search.ts | @@ -153,7 +153,7 @@ function tryIsNamespace(lookup: { [k: string]: any }, prop: string): Namespace |
let obj = lookup[prop];
return (
((obj !== null && typeof obj === 'object') || typeof obj === 'function') &&
- (obj as any).isNamespace &&
+ obj.isNamespace &&
obj
);
} catch (e) { | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/metal/lib/properties.ts | @@ -72,7 +72,7 @@ export function defineProperty(
}
if (isClassicDecorator(desc)) {
- defineDecorator(obj, keyName, desc!, meta);
+ defineDecorator(obj, keyName, desc, meta);
} else if (desc === null || desc === undefined) {
defineValue(obj, keyName, data, wasDescriptor, true);
} else {
@@ -91,9 +91,9 @@ export function defineDecorator(obj: object, keyName: string, desc: Decorator, m
let propertyDesc;
if (DEBUG) {
- propertyDesc = desc!(obj, keyName, undefined, meta, true);
+ propertyDesc = desc(obj, keyName, undefined, meta, true);
} else {
- propertyDesc = desc!(obj, keyName, undefined, meta);
+ propertyDesc = desc(obj, keyName, undefined, meta);
}
Object.defineProperty(obj, keyName, propertyDesc as PropertyDescriptor); | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/routing/lib/services/router.ts | @@ -1,4 +1,4 @@
-import { getOwner, Owner } from '@ember/-internals/owner';
+import { getOwner } from '@ember/-internals/owner';
import { Evented } from '@ember/-internals/runtime';
import { symbol } from '@ember/-internals/utils';
import { EMBER_ROUTING_ROUTER_SERVICE_REFRESH } from '@ember/canary-features';
@@ -58,7 +58,7 @@ export default class RouterService extends Service {
if (router !== undefined) {
return router;
}
- const owner = getOwner(this) as Owner;
+ const owner = getOwner(this);
router = owner.lookup('router:main') as EmberRouter;
return (this[ROUTER] = router);
} | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/routing/lib/services/routing.ts | @@ -2,7 +2,7 @@
@module ember
*/
-import { getOwner, Owner } from '@ember/-internals/owner';
+import { getOwner } from '@ember/-internals/owner';
import { symbol } from '@ember/-internals/utils';
import { readOnly } from '@ember/object/computed';
import Service from '@ember/service';
@@ -27,7 +27,7 @@ export default class RoutingService extends Service {
if (router !== undefined) {
return router;
}
- const owner = getOwner(this) as Owner;
+ const owner = getOwner(this);
router = owner.lookup('router:main') as EmberRouter;
router.setupRouter();
return (this[ROUTER] = router); | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/routing/lib/system/dsl.ts | @@ -77,7 +77,7 @@ export default class DSLImpl implements DSL {
} else if (isCallback(_callback)) {
assert('Unexpected arguments', arguments.length === 3);
assert('Unexpected arguments', isOptions(_options));
- options = _options as RouteOptions;
+ options = _options;
callback = _callback;
} else {
options = _options || {}; | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/routing/lib/system/generate_controller.ts | @@ -16,7 +16,7 @@ import { DEBUG } from '@glimmer/env';
*/
export function generateControllerFactory(owner: Owner, controllerName: string): Factory<{}> {
- let Factory = owner.factoryFor<any, any>('controller:basic')!.class!;
+ let Factory = owner.factoryFor<any, any>('controller:basic')!.class;
Factory = Factory.extend({
toString() { | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/routing/lib/system/route.ts | @@ -456,7 +456,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) implements IRoute
let state = transition ? transition[STATE_SYMBOL] : this._router._routerMicrolib.state;
let fullName = route.fullRouteName;
- let params = Object.assign({}, state!.params[fullName!]);
+ let params = Object.assign({}, state!.params[fullName]);
let queryParams = getQueryParamsFor(route, state!);
return Object.keys(queryParams).reduce((params, key) => { | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/routing/lib/system/router.ts | @@ -596,7 +596,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
for (let i = 0; i < routeInfos.length; i++) {
let route = routeInfos[i].route!;
- let connections = ROUTE_CONNECTIONS.get(route!);
+ let connections = ROUTE_CONNECTIONS.get(route);
let ownState: OutletState;
if (connections.length === 0) {
ownState = representEmptyRoute(liveRoutes, defaultParentState, route);
@@ -675,7 +675,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
`A transition was attempted from '${this.currentRouteName}' to '${args[0]}' but the application instance has already been destroyed.`,
!this.isDestroying && !this.isDestroyed
);
- return this._doURLTransition('transitionTo', args[0] as string);
+ return this._doURLTransition('transitionTo', args[0]);
}
let { routeName, models, queryParams } = extractRouteArgs(args);
assert( | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/utils/lib/mandatory-setter.ts | @@ -32,7 +32,6 @@ if (DEBUG) {
let MANDATORY_SETTERS: WeakMap<
object,
- // @ts-ignore
{ [key: string | symbol]: PropertyDescriptorWithMeta }
> = new WeakMap();
@@ -45,7 +44,7 @@ if (DEBUG) {
return;
}
- SEEN_TAGS!.add(tag);
+ SEEN_TAGS.add(tag);
if (Array.isArray(obj) && isElementKey(keyName)) {
return; | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/-internals/views/lib/system/utils.ts | @@ -229,7 +229,7 @@ export const elMatches: typeof Element.prototype.matches | undefined =
export function matches(el: Element, selector: string): boolean {
assert('cannot call `matches` in fastboot mode', elMatches !== undefined);
- return elMatches!.call(el, selector);
+ return elMatches.call(el, selector);
}
export function contains(a: Node, b: Node): boolean { | true |
Other | emberjs | ember.js | ce44b6ab241c85ab6e7454af6c9ad2ed86485406.json | Resolve some eslint warnings | packages/@ember/object/compat.ts | @@ -153,7 +153,7 @@ export function dependentKeyCompat(
(typeof desc.get === 'function' || typeof desc.set === 'function')
);
- return wrapGetterSetter(target, key, desc!);
+ return wrapGetterSetter(target, key, desc);
};
setClassicDecorator(decorator); | true |