ember-source 4.5.0-beta.1 → 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/canary-features/index.js

@@ -11,8 +11,8 @@ import { ENV } from '@ember/-internals/environment';
 */
 
 export const DEFAULT_FEATURES = {
-  EMBER_LIBRARIES_ISREGISTERED: false,
-  EMBER_IMPROVED_INSTRUMENTATION: false,
+  EMBER_LIBRARIES_ISREGISTERED: null,
+  EMBER_IMPROVED_INSTRUMENTATION: null,
   EMBER_UNIQUE_ID_HELPER: true,
   EMBER_DEFAULT_HELPER_MANAGER: true
 };

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

@@ -2,31 +2,20 @@ import { Mixin, computed } from '@ember/-internals/metal';
 import { ActionHandler } from '@ember/-internals/runtime';
 import { symbol } from '@ember/-internals/utils';
 const MODEL = symbol('MODEL');
-/**
-@module ember
-*/
-
-/**
-  @class ControllerMixin
-  @namespace Ember
-  @uses Ember.ActionHandler
-  @private
-*/
-
-export default Mixin.create(ActionHandler, {
+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,
+       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
+       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
+       @property target
     @default null
     @public
   */
@@ -36,7 +25,7 @@ export default Mixin.create(ActionHandler, {
   /**
     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
+       @property model
     @public
   */
   model: computed({
@@ -44,9 +33,10 @@ export default Mixin.create(ActionHandler, {
       return this[MODEL];
     },
 
-    set(key, value) {
+    set(_key, value) {
       return this[MODEL] = value;
     }
 
   })
-});
+});
+export default ControllerMixin;

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/computed_macros.js

@@ -11,8 +11,7 @@ function expandPropertiesToArray(predicateName, properties) {
     expandedProperties.push(entry);
   }
 
-  for (let i = 0; i < properties.length; i++) {
-    let property = properties[i];
+  for (let property of properties) {
     assert(`Dependent keys passed to \`${predicateName}\` computed macro can't have spaces.`, property.indexOf(' ') < 0);
     expandProperties(property, extractProperty);
   }
@@ -21,19 +20,22 @@ function expandPropertiesToArray(predicateName, properties) {
 }
 
 function generateComputedWithPredicate(name, predicate) {
-  return (...properties) => {
+  return (dependentKey, ...additionalDependentKeys) => {
+    let properties = [dependentKey, ...additionalDependentKeys];
     assert(`You attempted to use @${name} as a decorator directly, but it requires at least one dependent key parameter`, !isElementDescriptor(properties));
     let dependentKeys = expandPropertiesToArray(name, properties);
     let computedFunc = computed(...dependentKeys, function () {
       let lastIdx = dependentKeys.length - 1;
 
       for (let i = 0; i < lastIdx; i++) {
+        // SAFETY: `i` is derived from the length of `dependentKeys`
         let value = get(this, dependentKeys[i]);
 
         if (!predicate(value)) {
           return value;
         }
-      }
+      } // SAFETY: `lastIdx` is derived from the length of `dependentKeys`
+
 
       return get(this, dependentKeys[lastIdx]);
     });