ember-source 4.6.0-alpha.2 → 4.6.0-alpha.3

package/dist/packages/@ember/-internals/runtime/lib/system/array_proxy.js

@@ -4,7 +4,7 @@
 import { get, objectAt, alias, PROPERTY_DID_CHANGE, addArrayObserver, removeArrayObserver, replace, arrayContentDidChange, arrayContentWillChange, tagForProperty } from '@ember/-internals/metal';
 import { isObject } from '@ember/-internals/utils';
 import EmberObject from './object';
-import { isArray, MutableArray } from '../mixins/array';
+import EmberArray, { MutableArray } from '../mixins/array';
 import { assert } from '@ember/debug';
 import { setCustomTagFor } from '@glimmer/manager';
 import { combine, consumeTag, validateTag, valueForTag, tagFor } from '@glimmer/validator';
@@ -122,7 +122,7 @@ class ArrayProxy extends EmberObject {
        @method replaceContent
     @param {Number} idx The starting index
     @param {Number} amt The number of items to remove from the content.
-    @param {EmberArray} objects Optional array of objects to insert.
+    @param {Array} objects Optional array of objects to insert.
     @return {void}
     @public
   */
@@ -130,9 +130,9 @@ class ArrayProxy extends EmberObject {
 
   replaceContent(idx, amt, objects) {
     let content = get(this, 'content');
-    assert('[BUG] Called objectAtContent without content', content);
+    assert('[BUG] Called replaceContent without content', content);
     assert('Mutating a non-mutable array is not allowed', isMutable(content));
-    content.replace(idx, amt, objects);
+    replace(content, idx, amt, objects);
   } // Overriding objectAt is not supported.
 
 
@@ -221,7 +221,10 @@ class ArrayProxy extends EmberObject {
     if (arrangedContent && !arrangedContent.isDestroyed) {
       // @ts-expect-error This check is still good for ensuring correctness
       assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
-      assert(`ArrayProxy expects an Array or ArrayProxy, but you passed ${typeof arrangedContent}`, isArray(arrangedContent) || arrangedContent.isDestroyed);
+      assert(`ArrayProxy expects a native Array, EmberArray, or ArrayProxy, but you passed ${typeof arrangedContent}`, function (arr) {
+        return Array.isArray(arr) || EmberArray.detect(arr);
+      }(arrangedContent));
+      assert('ArrayProxy expected its contents to not be destroyed', !arrangedContent.isDestroyed);
       addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING);
       this._arrangedContent = arrangedContent;
     }

package/dist/packages/@ember/application/lib/application.js

@@ -13,7 +13,7 @@ import { RSVP } from '@ember/-internals/runtime';
 import { EventDispatcher } from '@ember/-internals/views';
 import { Route, Router, HashLocation, HistoryLocation, AutoLocation, NoneLocation, BucketCache } from '@ember/-internals/routing';
 import ApplicationInstance from '../instance';
-import Engine from '@ember/engine';
+import Engine, { buildInitializerMethod } from '@ember/engine';
 import { privatize as P } from '@ember/-internals/container';
 import { setupApplicationRegistry } from '@ember/-internals/glimmer';
 import { RouterService } from '@ember/-internals/routing';
@@ -841,6 +841,9 @@ class Application extends Engine {
 
 }
 
+Application.initializer = buildInitializerMethod('initializers', 'initializer');
+Application.instanceInitializer = buildInitializerMethod('instanceInitializers', 'instance initializer');
+
 function commonSetupRegistry(registry) {
   registry.register('router:main', Router);
   registry.register('-view-registry:main', {

package/dist/packages/@ember/engine/index.js

@@ -420,8 +420,10 @@ function resolverFor(namespace) {
   };
   return ResolverClass.create(props);
 }
+/** @internal */
 
-function buildInitializerMethod(bucketName, humanName) {
+
+export function buildInitializerMethod(bucketName, humanName) {
   return function (initializer) {
     // If this is the first initializer being added to a subclass, we are going to reopen the class
     // to make sure we have a new `initializers` object, which extends from the parent class' using

package/dist/packages/@ember/object/index.js

@@ -117,8 +117,12 @@ export { notifyPropertyChange, defineProperty, get, set, getProperties, setPrope
 
 const BINDINGS_MAP = new WeakMap();
 
+function hasProto(obj) {
+  return obj != null && obj.constructor !== undefined && typeof obj.constructor.proto === 'function';
+}
+
 function setupAction(target, key, actionFn) {
-  if (target.constructor !== undefined && typeof target.constructor.proto === 'function') {
+  if (hasProto(target)) {
     target.constructor.proto();
   }
 
@@ -128,6 +132,7 @@ function setupAction(target, key, actionFn) {
     target.actions = parentActions ? Object.assign({}, parentActions) : {};
   }
 
+  assert("[BUG] Somehow the target doesn't have actions!", target.actions != null);
   target.actions[key] = actionFn;
   return {
     get() {
@@ -151,13 +156,13 @@ function setupAction(target, key, actionFn) {
   };
 }
 
-export function action(target, key, desc) {
+export function action(...args) {
   let actionFn;
 
-  if (!isElementDescriptor([target, key, desc])) {
-    actionFn = target;
+  if (!isElementDescriptor(args)) {
+    actionFn = args[0];
 
-    let decorator = function (target, key, desc, meta, isClassicDecorator) {
+    let decorator = function (target, key, _desc, _meta, isClassicDecorator) {
       assert('The @action decorator may only be passed a method when used in classic classes. You should decorate methods directly in native classes', isClassicDecorator);
       assert('The action() decorator must be passed a method when used in classic classes', typeof actionFn === 'function');
       return setupAction(target, key, actionFn);
@@ -167,8 +172,11 @@ export function action(target, key, desc) {
     return decorator;
   }
 
-  actionFn = desc.value;
-  assert('The @action decorator must be applied to methods when used in native classes', typeof actionFn === 'function');
+  let [target, key, desc] = args;
+  actionFn = desc === null || desc === void 0 ? void 0 : desc.value;
+  assert('The @action decorator must be applied to methods when used in native classes', typeof actionFn === 'function'); // SAFETY: TS types are weird with decorators. This should work.
+
   return setupAction(target, key, actionFn);
-}
+} // SAFETY: TS types are weird with decorators. This should work.
+
 setClassicDecorator(action);

package/dist/packages/@ember/object/lib/computed/reduce_computed_macros.js

@@ -626,7 +626,7 @@ export function setDiff(setAProperty, setBProperty) {
     }
 
     if (!isNativeOrEmberArray(setB)) {
-      return emberA(setA);
+      return setA;
     }
 
     return setA.filter(x => setB.indexOf(x) === -1);

package/dist/packages/@ember/test/adapter.js

@@ -1,2 +1,2 @@
-import { Test } from 'ember-testing';
-export default Test.Adapter;
+import { Adapter } from 'ember-testing';
+export default Adapter;

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "4.6.0-alpha.2";
+export default "4.6.0-alpha.3";

package/dist/packages/ember-testing/lib/adapters/adapter.js

@@ -1,29 +1,17 @@
 import { Object as EmberObject } from '@ember/-internals/runtime';
-/**
- @module @ember/test
-*/
-
-/**
-  The primary purpose of this class is to create hooks that can be implemented
-  by an adapter for various test frameworks.
-
-  @class TestAdapter
-  @public
-*/
-
-export default EmberObject.extend({
+const Adapter = EmberObject.extend({
   /**
     This callback will be called whenever an async operation is about to start.
-     Override this to call your framework's methods that handle async
+       Override this to call your framework's methods that handle async
     operations.
-     @public
+       @public
     @method asyncStart
   */
   asyncStart() {},
 
   /**
     This callback will be called whenever an async operation has completed.
-     @public
+       @public
     @method asyncEnd
   */
   asyncEnd() {},
@@ -32,13 +20,13 @@ export default EmberObject.extend({
     Override this method with your testing framework's false assertion.
     This function is called whenever an exception occurs causing the testing
     promise to fail.
-     QUnit example:
-     ```javascript
+       QUnit example:
+       ```javascript
       exception: function(error) {
         ok(false, error);
       };
     ```
-     @public
+       @public
     @method exception
     @param {String} error The exception to be raised.
   */
@@ -46,4 +34,5 @@ export default EmberObject.extend({
     throw error;
   }
 
-});
+});
+export default Adapter;

package/dist/packages/ember-testing/lib/adapters/qunit.js

@@ -1,27 +1,18 @@
 /* globals QUnit */
 import { inspect } from '@ember/-internals/utils';
 import Adapter from './adapter';
-/**
-   @module ember
-*/
 
-/**
-  This class implements the methods defined by TestAdapter for the
-  QUnit testing framework.
+function isVeryOldQunit(obj) {
+  return obj != null && typeof obj.stop === 'function';
+}
 
-  @class QUnitAdapter
-  @namespace Ember.Test
-  @extends TestAdapter
-  @public
-*/
-
-export default Adapter.extend({
+const QUnitAdapter = Adapter.extend({
   init() {
     this.doneCallbacks = [];
   },
 
   asyncStart() {
-    if (typeof QUnit.stop === 'function') {
+    if (isVeryOldQunit(QUnit)) {
       // very old QUnit version
       // eslint-disable-next-line qunit/no-qunit-stop
       QUnit.stop();
@@ -34,7 +25,7 @@ export default Adapter.extend({
     // checking for QUnit.stop here (even though we _need_ QUnit.start) because
     // QUnit.start() still exists in QUnit 2.x (it just throws an error when calling
     // inside a test context)
-    if (typeof QUnit.stop === 'function') {
+    if (isVeryOldQunit(QUnit)) {
       QUnit.start();
     } else {
       let done = this.doneCallbacks.pop(); // This can be null if asyncStart() was called outside of a test
@@ -49,4 +40,5 @@ export default Adapter.extend({
     QUnit.config.current.assert.ok(false, inspect(error));
   }
 
-});
+});
+export default QUnitAdapter;

package/dist/packages/ember-testing/lib/ext/application.js

@@ -5,13 +5,14 @@ import TestPromise, { resolve, getLastPromise } from '../test/promise';
 import run from '../test/run';
 import { invokeInjectHelpersCallbacks } from '../test/on_inject_helpers';
 import { asyncStart, asyncEnd } from '../test/adapter';
+import { assert } from '@ember/debug';
 EmberApplication.reopen({
   /**
    This property contains the testing helpers for the current application. These
    are created once you call `injectTestHelpers` on your `Application`
    instance. The included helpers are also available on the `window` object by
    default, but can be used from this object on the individual application also.
-     @property testHelpers
+       @property testHelpers
     @type {Object}
     @default {}
     @public
@@ -21,9 +22,9 @@ EmberApplication.reopen({
   /**
    This property will contain the original methods that were registered
    on the `helperContainer` before `injectTestHelpers` is called.
-    When `removeTestHelpers` is called, these methods are restored to the
+      When `removeTestHelpers` is called, these methods are restored to the
    `helperContainer`.
-     @property originalMethods
+       @property originalMethods
     @type {Object}
     @default {}
     @private
@@ -35,7 +36,7 @@ EmberApplication.reopen({
   This property indicates whether or not this application is currently in
   testing mode. This is set when `setupForTesting` is called on the current
   application.
-   @property testing
+     @property testing
   @type {Boolean}
   @default false
   @since 1.3.0
@@ -50,11 +51,11 @@ EmberApplication.reopen({
     (preventing both accidental leaking of state between tests and interference
     with your testing framework). `setupForTesting` should only be called after
     setting a custom `router` class (for example `App.Router = Router.extend(`).
-     Example:
-     ```
+       Example:
+       ```
     App.setupForTesting();
     ```
-     @method setupForTesting
+       @method setupForTesting
     @public
   */
   setupForTesting() {
@@ -68,7 +69,7 @@ EmberApplication.reopen({
   /**
     This will be used as the container to inject the test helpers into. By
     default the helpers are injected into `window`.
-     @property helperContainer
+       @property helperContainer
     @type {Object} The object to be used for test helpers.
     @default window
     @since 1.2.0
@@ -82,13 +83,13 @@ EmberApplication.reopen({
     to `window`. If a function of the same name has already been defined it will be cached
     (so that it can be reset if the helper is removed with `unregisterHelper` or
     `removeTestHelpers`).
-     Any callbacks registered with `onInjectHelpers` will be called once the
+       Any callbacks registered with `onInjectHelpers` will be called once the
     helpers have been injected.
-     Example:
+       Example:
     ```
     App.injectTestHelpers();
     ```
-     @method injectTestHelpers
+       @method injectTestHelpers
     @public
   */
   injectTestHelpers(helperContainer) {
@@ -109,8 +110,11 @@ EmberApplication.reopen({
     this.testHelpers = {};
 
     for (let name in helpers) {
-      this.originalMethods[name] = this.helperContainer[name];
-      this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
+      // SAFETY: It is safe to access a property on an object
+      this.originalMethods[name] = this.helperContainer[name]; // SAFETY: It is not quite as safe to do this, but it _seems_ to be ok.
+
+      this.testHelpers[name] = this.helperContainer[name] = helper(this, name); // SAFETY: We checked that it exists
+
       protoWrap(TestPromise.prototype, name, helper(this, name), helpers[name].meta.wait);
     }
 
@@ -120,11 +124,11 @@ EmberApplication.reopen({
   /**
     This removes all helpers that have been registered, and resets and functions
     that were overridden by the helpers.
-     Example:
-     ```javascript
+       Example:
+       ```javascript
     App.removeTestHelpers();
     ```
-     @public
+       @public
     @method removeTestHelpers
   */
   removeTestHelpers() {
@@ -133,7 +137,8 @@ EmberApplication.reopen({
     }
 
     for (let name in helpers) {
-      this.helperContainer[name] = this.originalMethods[name];
+      this.helperContainer[name] = this.originalMethods[name]; // SAFETY: This is a weird thing, but it's not technically unsafe here.
+
       delete TestPromise.prototype[name];
       delete this.testHelpers[name];
       delete this.originalMethods[name];
@@ -145,10 +150,12 @@ EmberApplication.reopen({
 // of helper chaining
 
 function protoWrap(proto, name, callback, isAsync) {
+  // SAFETY: This isn't entirely safe, but it _seems_ to be ok.
   proto[name] = function (...args) {
     if (isAsync) {
       return callback.apply(this, args);
     } else {
+      // SAFETY: This is not actually safe.
       return this.then(function () {
         return callback.apply(this, args);
       });
@@ -157,8 +164,10 @@ function protoWrap(proto, name, callback, isAsync) {
 }
 
 function helper(app, name) {
-  let fn = helpers[name].method;
-  let meta = helpers[name].meta;
+  let helper = helpers[name];
+  assert(`[BUG] Missing helper: ${name}`, helper);
+  let fn = helper.method;
+  let meta = helper.meta;
 
   if (!meta.wait) {
     return (...args) => fn.apply(app, [app, ...args]);

package/dist/packages/ember-testing/lib/helpers/and_then.js

@@ -1,3 +1,6 @@
+import { assert } from '@ember/debug';
 export default function andThen(app, callback) {
-  return app.testHelpers.wait(callback(app));
+  let wait = app.testHelpers['wait'];
+  assert('[BUG] Missing wait helper', wait);
+  return wait(callback(app));
 }

package/dist/packages/ember-testing/lib/helpers/current_path.js

@@ -2,6 +2,8 @@
 @module ember
 */
 import { get } from '@ember/-internals/metal';
+import { RoutingService } from '@ember/-internals/routing';
+import { assert } from '@ember/debug';
 /**
   Returns the current path.
 
@@ -22,7 +24,10 @@ click('#some-link-id').then(validateURL);
 */
 
 export default function currentPath(app) {
+  assert('[BUG] app.__container__ is not set', app.__container__);
+
   let routingService = app.__container__.lookup('service:-routing');
 
+  assert('[BUG] service:-routing is not a RoutingService', routingService instanceof RoutingService);
   return get(routingService, 'currentPath');
 }

package/dist/packages/ember-testing/lib/helpers/current_route_name.js

@@ -2,6 +2,8 @@
 @module ember
 */
 import { get } from '@ember/-internals/metal';
+import { RoutingService } from '@ember/-internals/routing';
+import { assert } from '@ember/debug';
 /**
   Returns the currently active route name.
 
@@ -21,7 +23,10 @@ visit('/some/path').then(validateRouteName)
 */
 
 export default function currentRouteName(app) {
+  assert('[BUG] app.__container__ is not set', app.__container__);
+
   let routingService = app.__container__.lookup('service:-routing');
 
+  assert('[BUG] service:-routing is not a RoutingService', routingService instanceof RoutingService);
   return get(routingService, 'currentRouteName');
 }

package/dist/packages/ember-testing/lib/helpers/current_url.js

@@ -2,6 +2,8 @@
 @module ember
 */
 import { get } from '@ember/-internals/metal';
+import { assert } from '@ember/debug';
+import Router from '@ember/routing/router';
 /**
   Returns the current URL.
 
@@ -22,7 +24,12 @@ click('#some-link-id').then(validateURL);
 */
 
 export default function currentURL(app) {
+  assert('[BUG] app.__container__ is not set', app.__container__);
+
   let router = app.__container__.lookup('router:main');
 
-  return get(router, 'location').getURL();
+  assert('[BUG] router:main is not a Router', router instanceof Router);
+  let location = get(router, 'location');
+  assert('[BUG] location is still a string', typeof location !== 'string');
+  return location.getURL();
 }

package/dist/packages/ember-testing/lib/helpers/visit.js

@@ -1,3 +1,5 @@
+import { assert } from '@ember/debug';
+import Router from '@ember/routing/router';
 import { run } from '@ember/runloop';
 /**
   Loads a route, sets up any controllers, and renders any templates associated
@@ -19,18 +21,24 @@ import { run } from '@ember/runloop';
 */
 
 export default function visit(app, url) {
-  let router = app.__container__.lookup('router:main');
+  assert('[BUG] Missing container', app.__container__);
 
+  const router = app.__container__.lookup('router:main');
+
+  assert('[BUG] router:main is not a Router', router instanceof Router);
   let shouldHandleURL = false;
   app.boot().then(() => {
+    assert('[BUG] router.location is still a string', typeof router.location !== 'string');
     router.location.setURL(url);
 
     if (shouldHandleURL) {
+      assert("[BUG] __deprecatedInstance__ isn't set", app.__deprecatedInstance__);
       run(app.__deprecatedInstance__, 'handleURL', url);
     }
   });
 
   if (app._readinessDeferrals > 0) {
+    // SAFETY: This should be safe, though it is odd.
     router.initialURL = url;
     run(app, 'advanceReadiness');
     delete router.initialURL;
@@ -38,5 +46,7 @@ export default function visit(app, url) {
     shouldHandleURL = true;
   }
 
-  return app.testHelpers.wait();
+  let wait = app.testHelpers['wait'];
+  assert('[BUG] missing wait helper', wait);
+  return wait();
 }

package/dist/packages/ember-testing/lib/helpers/wait.js

@@ -5,6 +5,8 @@ import { checkWaiters } from '../test/waiters';
 import { RSVP } from '@ember/-internals/runtime';
 import { _getCurrentRunLoop, _hasScheduledTimers, run } from '@ember/runloop';
 import { pendingRequests } from '../test/pending_requests';
+import { assert } from '@ember/debug';
+import Router from '@ember/routing/router';
 /**
   Causes the run loop to process any pending events. This is used to ensure that
   any async operations from other helpers (or your assertions) have been processed.
@@ -38,8 +40,11 @@ import { pendingRequests } from '../test/pending_requests';
 
 export default function wait(app, value) {
   return new RSVP.Promise(function (resolve) {
-    let router = app.__container__.lookup('router:main'); // Every 10ms, poll for the async thing to have finished
+    assert('[BUG] Missing container', app.__container__);
 
+    const router = app.__container__.lookup('router:main');
+
+    assert('[BUG] Expected router:main to be a subclass of Ember Router', router instanceof Router); // Every 10ms, poll for the async thing to have finished
 
     let watcher = setInterval(() => {
       // 1. If the router is loading, keep polling

package/dist/packages/ember-testing/lib/initializers.js

@@ -1,8 +1,8 @@
 import { onLoad } from '@ember/application';
 let name = 'deferReadiness in `testing` mode';
-onLoad('Ember.Application', function (Application) {
-  if (!Application.initializers[name]) {
-    Application.initializer({
+onLoad('Ember.Application', function (ApplicationClass) {
+  if (!ApplicationClass.initializers[name]) {
+    ApplicationClass.initializer({
       name: name,
 
       initialize(application) {

package/dist/packages/ember-testing/lib/test/adapter.js

@@ -24,6 +24,7 @@ export function asyncEnd() {
 }
 
 function adapterDispatch(error) {
-  adapter.exception(error);
+  adapter.exception(error); // @ts-expect-error Normally unreachable
+
   console.error(error.stack); // eslint-disable-line no-console
 }

package/dist/packages/ember-testing/lib/test/helpers.js

@@ -124,6 +124,8 @@ export function registerAsyncHelper(name, helperMethod) {
 */
 
 export function unregisterHelper(name) {
-  delete helpers[name];
+  delete helpers[name]; // SAFETY: This isn't necessarily a safe thing to do, but in terms of the immediate types here
+  // it won't error.
+
   delete TestPromise.prototype[name];
 }

package/dist/packages/ember-testing/lib/test/on_inject_helpers.js

@@ -31,7 +31,7 @@ export function onInjectHelpers(callback) {
   callbacks.push(callback);
 }
 export function invokeInjectHelpersCallbacks(app) {
-  for (let i = 0; i < callbacks.length; i++) {
-    callbacks[i](app);
+  for (let callback of callbacks) {
+    callback(app);
   }
 }

package/dist/packages/ember-testing/lib/test/promise.js

@@ -1,15 +1,15 @@
 import { RSVP } from '@ember/-internals/runtime';
 import run from './run';
-let lastPromise;
+let lastPromise = null;
 export default class TestPromise extends RSVP.Promise {
-  constructor() {
-    super(...arguments);
+  constructor(executor, label) {
+    super(executor, label);
     lastPromise = this;
   }
 
-  then(_onFulfillment, ...args) {
-    let onFulfillment = typeof _onFulfillment === 'function' ? result => isolate(_onFulfillment, result) : undefined;
-    return super.then(onFulfillment, ...args);
+  then(onFulfilled, onRejected, label) {
+    let normalizedOnFulfilled = typeof onFulfilled === 'function' ? result => isolate(onFulfilled, result) : undefined;
+    return super.then(normalizedOnFulfilled, onRejected, label);
   }
 
 }
@@ -55,10 +55,10 @@ export function getLastPromise() {
 // 2. Invoke method
 // 3. Return the last promise created during method
 
-function isolate(onFulfillment, result) {
+function isolate(onFulfilled, result) {
   // Reset lastPromise for nested helpers
   lastPromise = null;
-  let value = onFulfillment(result);
+  let value = onFulfilled(result);
   let promise = lastPromise;
   lastPromise = null; // If the method returned a promise
   // return that promise. If not,