ember-source 4.4.0-alpha.2 → 4.4.0-alpha.5

package/dist/packages/@ember/runloop/type-tests.ts/bind.test.js

@@ -0,0 +1,59 @@
+import { bind } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(bind((_foo, _bar, _baz) => {
+  return 1;
+})).toEqualTypeOf();
+expectTypeOf(bind((_foo, _bar, _baz) => {
+  return 1;
+}, 1)).toEqualTypeOf();
+expectTypeOf(bind((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true)).toEqualTypeOf();
+expectTypeOf(bind((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'baz')).toEqualTypeOf();
+expectTypeOf(bind((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, undefined)).toEqualTypeOf();
+bind(_foo => {
+  return 1; // @ts-expect-error invalid argument
+}, 'string'); // With target and function
+
+expectTypeOf(bind(foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+})).toEqualTypeOf();
+expectTypeOf(bind(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1)).toEqualTypeOf();
+expectTypeOf(bind(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true)).toEqualTypeOf();
+expectTypeOf(bind(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'baz')).toEqualTypeOf();
+expectTypeOf(bind(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, undefined)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+bind(foo, function (_foo) {
+  return 1;
+}, 'string'); // With function string reference
+
+expectTypeOf(bind(foo, 'test')).toEqualTypeOf();
+expectTypeOf(bind(foo, 'test', 1)).toEqualTypeOf();
+expectTypeOf(bind(foo, 'test', 1, true)).toEqualTypeOf();
+expectTypeOf(bind(foo, 'test', 1, true, 'baz')).toEqualTypeOf();
+expectTypeOf(bind(foo, 'test', 1, true, undefined)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+bind(foo, 'test', 'string');

package/dist/packages/@ember/runloop/type-tests.ts/cancel.test.js

@@ -0,0 +1,5 @@
+import { cancel, next } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type';
+let runNext = next(null, () => {// will not be executed
+});
+expectTypeOf(cancel(runNext)).toEqualTypeOf();

package/dist/packages/@ember/runloop/type-tests.ts/debounce.test.js

@@ -0,0 +1,77 @@
+import { debounce } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type'; // From Docs
+
+function whoRan() {// Do stuff
+}
+
+let myContext = {
+  name: 'debounce',
+
+  test(_foo, _baz) {}
+
+};
+debounce(myContext, whoRan, 150); // less than 150ms passes
+
+debounce(myContext, whoRan, 150);
+debounce(myContext, whoRan, 150, true); // console logs 'debounce ran.' one time immediately.
+// 100ms passes
+
+debounce(myContext, whoRan, 150, true); // 150ms passes and nothing else is logged to the console and
+// the debouncee is no longer being watched
+
+debounce(myContext, whoRan, 150, true); // console logs 'debounce ran.' one time immediately.
+// 150ms passes and nothing else is logged to the console and
+// the debouncee is no longer being watched
+// Method only
+
+expectTypeOf(debounce((_foo, _baz) => {}, 1, undefined, 1)).toEqualTypeOf(); // @ts-expect-error Requires wait
+
+debounce((_foo, _baz) => {}, 1, true); // @ts-expect-error Requires all args
+
+debounce((_foo, _baz) => {}, 1, 1); // Can set immediate
+
+debounce((_foo, _baz) => {}, 1, true, 1, true); // With target
+
+debounce(myContext, function (_foo, _baz) {
+  expectTypeOf(this).toEqualTypeOf(myContext);
+}, 1, true, 1, true); // With key
+
+debounce(myContext, 'test', 1, true, 1, true); // @ts-expect-error invalid key
+
+debounce(myContext, 'invalid');
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(debounce((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, undefined, 1)).toEqualTypeOf();
+expectTypeOf(debounce((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'string', 1)).toEqualTypeOf();
+debounce(_foo => {
+  return 1; // @ts-expect-error invalid argument
+}, 'string'); // With target and function
+
+expectTypeOf(debounce(foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+}, 1, true, undefined, 1)).toEqualTypeOf();
+expectTypeOf(debounce(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'string', 1)).toEqualTypeOf(); // @ts-expect-error invalid args
+
+debounce(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, 'string', true, 1); // With function string reference
+
+expectTypeOf(debounce(foo, 'test', 1, true, 'string', 1)).toEqualTypeOf();
+expectTypeOf(debounce(foo, 'test', 1, true, undefined, 1)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+debounce(foo, 'test', 'string');

package/dist/packages/@ember/runloop/type-tests.ts/join.test.js

@@ -0,0 +1,38 @@
+import { join } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(join((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true)).toEqualTypeOf();
+expectTypeOf(join((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf();
+join(_foo => {
+  return 1; // @ts-expect-error invalid argument
+}, 'string'); // With target and function
+
+expectTypeOf(join(foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+}, 1, true)).toEqualTypeOf();
+expectTypeOf(join(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+join(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, 'string'); // With function string reference
+
+expectTypeOf(join(foo, 'test', 1, true)).toEqualTypeOf();
+expectTypeOf(join(foo, 'test', 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+join(foo, 'test', 'string');

package/dist/packages/@ember/runloop/type-tests.ts/later.test.js

@@ -0,0 +1,38 @@
+import { later } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(later((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, undefined, 1)).toEqualTypeOf();
+expectTypeOf(later((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'string', 1)).toEqualTypeOf();
+later(_foo => {
+  return 1; // @ts-expect-error invalid argument
+}, 'string'); // With target and function
+
+expectTypeOf(later(foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+}, 1, true, undefined, 1)).toEqualTypeOf();
+expectTypeOf(later(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'string', 1)).toEqualTypeOf(); // @ts-expect-error invalid args
+
+later(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, 'string', true, 1); // With function string reference
+
+expectTypeOf(later(foo, 'test', 1, true, 'string', 1)).toEqualTypeOf();
+expectTypeOf(later(foo, 'test', 1, true, undefined, 1)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+later(foo, 'test', 'string');

package/dist/packages/@ember/runloop/type-tests.ts/next.test.js

@@ -0,0 +1,38 @@
+import { next } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(next((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, undefined)).toEqualTypeOf();
+expectTypeOf(next((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf();
+next(_foo => {
+  return 1; // @ts-expect-error invalid argument
+}, 'string'); // With target and function
+
+expectTypeOf(next(foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+}, 1, true)).toEqualTypeOf();
+expectTypeOf(next(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+next(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, 'string', true); // With function string reference
+
+expectTypeOf(next(foo, 'test', 1, true, 'string')).toEqualTypeOf();
+expectTypeOf(next(foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+next(foo, 'test', 'string');

package/dist/packages/@ember/runloop/type-tests.ts/once.test.js

@@ -0,0 +1,38 @@
+import { once } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(once((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, undefined)).toEqualTypeOf();
+expectTypeOf(once((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf();
+once(_foo => {
+  return 1; // @ts-expect-error invalid argument
+}, 'string'); // With target and function
+
+expectTypeOf(once(foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+}, 1, true)).toEqualTypeOf();
+expectTypeOf(once(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+once(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, 'string', true); // With function string reference
+
+expectTypeOf(once(foo, 'test', 1, true, 'string')).toEqualTypeOf();
+expectTypeOf(once(foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+once(foo, 'test', 'string');

package/dist/packages/@ember/runloop/type-tests.ts/run.test.js

@@ -0,0 +1,38 @@
+import { run } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(run((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, undefined)).toEqualTypeOf();
+expectTypeOf(run((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf();
+run(_foo => {
+  return 1; // @ts-expect-error invalid argument
+}, 'string'); // With target and function
+
+expectTypeOf(run(foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+}, 1, true)).toEqualTypeOf();
+expectTypeOf(run(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+run(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, 'string', true); // With function string reference
+
+expectTypeOf(run(foo, 'test', 1, true, 'string')).toEqualTypeOf();
+expectTypeOf(run(foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+run(foo, 'test', 'string');

package/dist/packages/@ember/runloop/type-tests.ts/schedule-once.test.js

@@ -0,0 +1,39 @@
+import { scheduleOnce } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(scheduleOnce('my-queue', (_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, undefined)).toEqualTypeOf();
+expectTypeOf(scheduleOnce('my-queue', (_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf();
+scheduleOnce('my-queue', _foo => {
+  return 1;
+}, // @ts-expect-error invalid argument
+'string'); // With target and function
+
+expectTypeOf(scheduleOnce('my-queue', foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+}, 1, true)).toEqualTypeOf();
+expectTypeOf(scheduleOnce('my-queue', foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+scheduleOnce('my-queue', foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, 'string', true); // With function string reference
+
+expectTypeOf(scheduleOnce('my-queue', foo, 'test', 1, true, 'string')).toEqualTypeOf();
+expectTypeOf(scheduleOnce('my-queue', foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+scheduleOnce('my-queue', foo, 'test', 'string');

package/dist/packages/@ember/runloop/type-tests.ts/schedule.test.js

@@ -0,0 +1,39 @@
+import { schedule } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type';
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(schedule('my-queue', (_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, undefined)).toEqualTypeOf();
+expectTypeOf(schedule('my-queue', (_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf();
+schedule('my-queue', _foo => {
+  return 1;
+}, // @ts-expect-error invalid argument
+'string'); // With target and function
+
+expectTypeOf(schedule('my-queue', foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+}, 1, true)).toEqualTypeOf();
+expectTypeOf(schedule('my-queue', foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'string')).toEqualTypeOf(); // @ts-expect-error invalid args
+
+schedule('my-queue', foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, 'string', true); // With function string reference
+
+expectTypeOf(schedule('my-queue', foo, 'test', 1, true, 'string')).toEqualTypeOf();
+expectTypeOf(schedule('my-queue', foo, 'test', 1, true)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+schedule('my-queue', foo, 'test', 'string');

package/dist/packages/@ember/runloop/type-tests.ts/throttle.test.js

@@ -0,0 +1,77 @@
+import { throttle } from '@ember/runloop';
+import { expectTypeOf } from 'expect-type'; // From Docs
+
+function whoRan() {// Do stuff
+}
+
+let myContext = {
+  name: 'throttle',
+
+  test(_foo, _baz) {}
+
+};
+throttle(myContext, whoRan, 150); // less than 150ms passes
+
+throttle(myContext, whoRan, 150);
+throttle(myContext, whoRan, 150, true); // console logs 'throttle ran.' one time immediately.
+// 100ms passes
+
+throttle(myContext, whoRan, 150, true); // 150ms passes and nothing else is logged to the console and
+// the throttlee is no longer being watched
+
+throttle(myContext, whoRan, 150, true); // console logs 'throttle ran.' one time immediately.
+// 150ms passes and nothing else is logged to the console and
+// the throttlee is no longer being watched
+// Method only
+
+expectTypeOf(throttle((_foo, _baz) => {}, 1, undefined, 1)).toEqualTypeOf(); // Wait is optional
+
+throttle((_foo, _baz) => {}, 1, true); // @ts-expect-error Requires all args
+
+throttle((_foo, _baz) => {}, 1, 1); // Can set immediate
+
+throttle((_foo, _baz) => {}, 1, true, 1, true); // With target
+
+throttle(myContext, function (_foo, _baz) {
+  expectTypeOf(this).toEqualTypeOf(myContext);
+}, 1, true, 1, true); // With key
+
+throttle(myContext, 'test', 1, true, 1, true); // @ts-expect-error invalid key
+
+throttle(myContext, 'invalid');
+
+class Foo {
+  test(_foo, _bar, _baz) {
+    return 1;
+  }
+
+}
+
+let foo = new Foo(); // With only function
+
+expectTypeOf(throttle((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, undefined, 1)).toEqualTypeOf();
+expectTypeOf(throttle((_foo, _bar, _baz) => {
+  return 1;
+}, 1, true, 'string', 1)).toEqualTypeOf();
+throttle(_foo => {
+  return 1; // @ts-expect-error invalid argument
+}, 'string'); // With target and function
+
+expectTypeOf(throttle(foo, function (_foo, _bar, _baz) {
+  expectTypeOf(this).toEqualTypeOf();
+  return 1;
+}, 1, true, undefined, 1)).toEqualTypeOf();
+expectTypeOf(throttle(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, true, 'string', 1)).toEqualTypeOf(); // @ts-expect-error invalid args
+
+throttle(foo, function (_foo, _bar, _baz) {
+  return 1;
+}, 1, 'string', true, 1); // With function string reference
+
+expectTypeOf(throttle(foo, 'test', 1, true, 'string', 1)).toEqualTypeOf();
+expectTypeOf(throttle(foo, 'test', 1, true, undefined, 1)).toEqualTypeOf(); // @ts-expect-error Invalid args
+
+throttle(foo, 'test', 'string');

package/dist/packages/ember/index.js

@@ -325,6 +325,7 @@ const deprecateImportFromString = function (name, message = `Importing ${name} f
     id: 'ember-string.htmlsafe-ishtmlsafe',
     for: 'ember-source',
     since: {
+      available: '3.25',
       enabled: '3.25'
     },
     until: '4.0.0',

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "4.4.0-alpha.2";
+export default "4.4.0-alpha.5";