ember-source 4.8.0-alpha.5 → 4.8.0-beta.2

package/dist/packages/@ember/controller/lib/controller_mixin.js

@@ -1,42 +0,0 @@
-import { Mixin, computed } from '@ember/-internals/metal';
-import { ActionHandler } from '@ember/-internals/runtime';
-import { symbol } from '@ember/-internals/utils';
-const MODEL = symbol('MODEL');
-const ControllerMixin = Mixin.create(ActionHandler, {
-  /* ducktype as a controller */
-  isController: true,
-
-  /**
-    The object to which actions from the view should be sent.
-       For example, when a Handlebars template uses the `{{action}}` helper,
-    it will attempt to send the action to the view's controller's `target`.
-       By default, the value of the target property is set to the router, and
-    is injected when a controller is instantiated. This injection is applied
-    as part of the application's initialization process. In most cases the
-    `target` property will automatically be set to the logical consumer of
-    actions for the controller.
-       @property target
-    @default null
-    @public
-  */
-  target: null,
-  store: null,
-
-  /**
-    The controller's current model. When retrieving or modifying a controller's
-    model, this property should be used instead of the `content` property.
-       @property model
-    @public
-  */
-  model: computed({
-    get() {
-      return this[MODEL];
-    },
-
-    set(_key, value) {
-      return this[MODEL] = value;
-    }
-
-  })
-});
-export default ControllerMixin;

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

@@ -1,5 +0,0 @@
-import { begin, end } from '@ember/runloop';
-import { expectTypeOf } from 'expect-type';
-expectTypeOf(begin()).toEqualTypeOf(); // code to be executed within a RunLoop
-
-expectTypeOf(end()).toEqualTypeOf();

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

@@ -1,59 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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');