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

package/dist/packages/@ember/array/mutable.js

@@ -1 +1 @@
-export { MutableArray as default } from '@ember/-internals/runtime';
+export { MutableArray as default } from '@ember/array';

package/dist/packages/@ember/array/proxy.js

@@ -1 +1,307 @@
-export { ArrayProxy as default } from '@ember/-internals/runtime';
+/**
+@module @ember/array/proxy
+*/
+import { objectAt, alias, PROPERTY_DID_CHANGE, addArrayObserver, removeArrayObserver, replace, arrayContentDidChange, arrayContentWillChange, tagForProperty } from '@ember/-internals/metal';
+import { get } from '@ember/object';
+import { isObject } from '@ember/-internals/utils';
+import EmberObject from '@ember/object';
+import EmberArray from '@ember/array';
+import MutableArray from '@ember/array/mutable';
+import { assert } from '@ember/debug';
+import { setCustomTagFor } from '@glimmer/manager';
+import { combine, consumeTag, validateTag, valueForTag, tagFor } from '@glimmer/validator';
+
+function isMutable(obj) {
+  return Array.isArray(obj) || typeof obj.replace === 'function';
+}
+
+const ARRAY_OBSERVER_MAPPING = {
+  willChange: '_arrangedContentArrayWillChange',
+  didChange: '_arrangedContentArrayDidChange'
+};
+
+function customTagForArrayProxy(proxy, key) {
+  assert('[BUG] Expected a proxy', proxy instanceof ArrayProxy);
+
+  if (key === '[]') {
+    proxy._revalidate();
+
+    return proxy._arrTag;
+  } else if (key === 'length') {
+    proxy._revalidate();
+
+    return proxy._lengthTag;
+  }
+
+  return tagFor(proxy, key);
+}
+
+class ArrayProxy extends EmberObject {
+  constructor() {
+    super(...arguments);
+    /*
+      `this._objectsDirtyIndex` determines which indexes in the `this._objects`
+      cache are dirty.
+             If `this._objectsDirtyIndex === -1` then no indexes are dirty.
+      Otherwise, an index `i` is dirty if `i >= this._objectsDirtyIndex`.
+             Calling `objectAt` with a dirty index will cause the `this._objects`
+      cache to be recomputed.
+    */
+
+    /** @internal */
+
+    this._objectsDirtyIndex = 0;
+    /** @internal */
+
+    this._objects = null;
+    /** @internal */
+
+    this._lengthDirty = true;
+    /** @internal */
+
+    this._length = 0;
+    /** @internal */
+
+    this._arrangedContent = null;
+    /** @internal */
+
+    this._arrangedContentIsUpdating = false;
+    /** @internal */
+
+    this._arrangedContentTag = null;
+    /** @internal */
+
+    this._arrangedContentRevision = null;
+    /** @internal */
+
+    this._lengthTag = null;
+    /** @internal */
+
+    this._arrTag = null;
+  }
+
+  init(props) {
+    super.init(props);
+    setCustomTagFor(this, customTagForArrayProxy);
+  }
+
+  [PROPERTY_DID_CHANGE]() {
+    this._revalidate();
+  }
+
+  willDestroy() {
+    this._removeArrangedContentArrayObserver();
+  }
+  /**
+    Should actually retrieve the object at the specified index from the
+    content. You can override this method in subclasses to transform the
+    content item to something new.
+       This method will only be called if content is non-`null`.
+       @method objectAtContent
+    @param {Number} idx The index to retrieve.
+    @return {Object} the value or undefined if none found
+    @public
+  */
+
+
+  objectAtContent(idx) {
+    let arrangedContent = get(this, 'arrangedContent');
+    assert('[BUG] Called objectAtContent without content', arrangedContent);
+    return objectAt(arrangedContent, idx);
+  } // See additional docs for `replace` from `MutableArray`:
+  // https://api.emberjs.com/ember/release/classes/MutableArray/methods/replace?anchor=replace
+
+
+  replace(idx, amt, objects) {
+    assert('Mutating an arranged ArrayProxy is not allowed', get(this, 'arrangedContent') === get(this, 'content'));
+    this.replaceContent(idx, amt, objects);
+  }
+  /**
+    Should actually replace the specified objects on the content array.
+    You can override this method in subclasses to transform the content item
+    into something new.
+       This method will only be called if content is non-`null`.
+       @method replaceContent
+    @param {Number} idx The starting index
+    @param {Number} amt The number of items to remove from the content.
+    @param {Array} objects Optional array of objects to insert.
+    @return {void}
+    @public
+  */
+
+
+  replaceContent(idx, amt, objects) {
+    let content = get(this, 'content');
+    assert('[BUG] Called replaceContent without content', content);
+    assert('Mutating a non-mutable array is not allowed', isMutable(content));
+    replace(content, idx, amt, objects);
+  } // Overriding objectAt is not supported.
+
+
+  objectAt(idx) {
+    this._revalidate();
+
+    if (this._objects === null) {
+      this._objects = [];
+    }
+
+    if (this._objectsDirtyIndex !== -1 && idx >= this._objectsDirtyIndex) {
+      let arrangedContent = get(this, 'arrangedContent');
+
+      if (arrangedContent) {
+        let length = this._objects.length = get(arrangedContent, 'length');
+
+        for (let i = this._objectsDirtyIndex; i < length; i++) {
+          // SAFETY: This is expected to only ever return an instance of T. In other words, there should
+          // be no gaps in the array. Unfortunately, we can't actually assert for it since T could include
+          // any types, including null or undefined.
+          this._objects[i] = this.objectAtContent(i);
+        }
+      } else {
+        this._objects.length = 0;
+      }
+
+      this._objectsDirtyIndex = -1;
+    }
+
+    return this._objects[idx];
+  } // Overriding length is not supported.
+
+
+  get length() {
+    this._revalidate();
+
+    if (this._lengthDirty) {
+      let arrangedContent = get(this, 'arrangedContent');
+      this._length = arrangedContent ? get(arrangedContent, 'length') : 0;
+      this._lengthDirty = false;
+    }
+
+    assert('[BUG] _lengthTag is not set', this._lengthTag);
+    consumeTag(this._lengthTag);
+    return this._length;
+  }
+
+  set length(value) {
+    let length = this.length;
+    let removedCount = length - value;
+    let added;
+
+    if (removedCount === 0) {
+      return;
+    } else if (removedCount < 0) {
+      added = new Array(-removedCount);
+      removedCount = 0;
+    }
+
+    let content = get(this, 'content');
+
+    if (content) {
+      assert('Mutating a non-mutable array is not allowed', isMutable(content));
+      replace(content, value, removedCount, added);
+
+      this._invalidate();
+    }
+  }
+
+  _updateArrangedContentArray(arrangedContent) {
+    let oldLength = this._objects === null ? 0 : this._objects.length;
+    let newLength = arrangedContent ? get(arrangedContent, 'length') : 0;
+
+    this._removeArrangedContentArrayObserver();
+
+    arrayContentWillChange(this, 0, oldLength, newLength);
+
+    this._invalidate();
+
+    arrayContentDidChange(this, 0, oldLength, newLength, false);
+
+    this._addArrangedContentArrayObserver(arrangedContent);
+  }
+
+  _addArrangedContentArrayObserver(arrangedContent) {
+    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 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;
+    }
+  }
+
+  _removeArrangedContentArrayObserver() {
+    if (this._arrangedContent) {
+      removeArrayObserver(this._arrangedContent, this, ARRAY_OBSERVER_MAPPING);
+    }
+  }
+
+  _arrangedContentArrayWillChange() {}
+
+  _arrangedContentArrayDidChange(_proxy, idx, removedCnt, addedCnt) {
+    arrayContentWillChange(this, idx, removedCnt, addedCnt);
+    let dirtyIndex = idx;
+
+    if (dirtyIndex < 0) {
+      let length = get(this._arrangedContent, 'length');
+      dirtyIndex += length + removedCnt - addedCnt;
+    }
+
+    if (this._objectsDirtyIndex === -1 || this._objectsDirtyIndex > dirtyIndex) {
+      this._objectsDirtyIndex = dirtyIndex;
+    }
+
+    this._lengthDirty = true;
+    arrayContentDidChange(this, idx, removedCnt, addedCnt, false);
+  }
+
+  _invalidate() {
+    this._objectsDirtyIndex = 0;
+    this._lengthDirty = true;
+  }
+
+  _revalidate() {
+    if (this._arrangedContentIsUpdating === true) return;
+
+    if (this._arrangedContentTag === null || !validateTag(this._arrangedContentTag, this._arrangedContentRevision)) {
+      let arrangedContent = this.get('arrangedContent');
+
+      if (this._arrangedContentTag === null) {
+        // This is the first time the proxy has been setup, only add the observer
+        // don't trigger any events
+        this._addArrangedContentArrayObserver(arrangedContent);
+      } else {
+        this._arrangedContentIsUpdating = true;
+
+        this._updateArrangedContentArray(arrangedContent);
+
+        this._arrangedContentIsUpdating = false;
+      }
+
+      let arrangedContentTag = this._arrangedContentTag = tagFor(this, 'arrangedContent');
+      this._arrangedContentRevision = valueForTag(this._arrangedContentTag);
+
+      if (isObject(arrangedContent)) {
+        this._lengthTag = combine([arrangedContentTag, tagForProperty(arrangedContent, 'length')]);
+        this._arrTag = combine([arrangedContentTag, tagForProperty(arrangedContent, '[]')]);
+      } else {
+        this._lengthTag = this._arrTag = arrangedContentTag;
+      }
+    }
+  }
+
+}
+
+ArrayProxy.reopen(MutableArray, {
+  /**
+    The array that the proxy pretends to be. In the default `ArrayProxy`
+    implementation, this and `content` are the same. Subclasses of `ArrayProxy`
+    can override this property to provide things like sorting and filtering.
+       @property arrangedContent
+    @public
+  */
+  arrangedContent: alias('content')
+});
+export default ArrayProxy;

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: null,
-  EMBER_IMPROVED_INSTRUMENTATION: null,
+  EMBER_LIBRARIES_ISREGISTERED: false,
+  EMBER_IMPROVED_INSTRUMENTATION: false,
   EMBER_UNIQUE_ID_HELPER: true,
   EMBER_DEFAULT_HELPER_MANAGER: true
 };

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

@@ -1,10 +1,267 @@
-import { FrameworkObject } from '@ember/-internals/runtime';
+import { getOwner } from '@ember/-internals/owner'; // This is imported from -internals to avoid circularity
+
+import { computed, get } from '@ember/object';
+import { FrameworkObject } from '@ember/object/-internals';
 import { inject as metalInject } from '@ember/-internals/metal';
-import ControllerMixin from './lib/controller_mixin';
+import Mixin from '@ember/object/mixin';
+import { deprecateTransitionMethods, prefixRouteNameArg } from '@ember/routing/-internals';
+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,
+  concatenatedProperties: ['queryParams'],
+
+  /**
+    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,
+
+  init() {
+    this._super(...arguments);
+
+    let owner = getOwner(this);
+
+    if (owner) {
+      this.namespace = owner.lookup('application:main');
+      this.target = owner.lookup('router:main');
+    }
+  },
+
+  /**
+    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;
+    }
+
+  }),
+
+  /**
+    Defines which query parameters the controller accepts.
+    If you give the names `['category','page']` it will bind
+    the values of these query parameters to the variables
+    `this.category` and `this.page`.
+       By default, query parameters are parsed as strings. This
+    may cause unexpected behavior if a query parameter is used with `toggleProperty`,
+    because the initial value set for `param=false` will be the string `"false"`, which is truthy.
+       To avoid this, you may specify that the query parameter should be parsed as a boolean
+    by using the following verbose form with a `type` property:
+    ```javascript
+      queryParams: [{
+        category: {
+          type: 'boolean'
+        }
+      }]
+    ```
+    Available values for the `type` parameter are `'boolean'`, `'number'`, `'array'`, and `'string'`.
+    If query param type is not specified, it will default to `'string'`.
+       @for Ember.ControllerMixin
+    @property queryParams
+    @public
+  */
+  queryParams: null,
+
+  /**
+   This property is updated to various different callback functions depending on
+   the current "state" of the backing route. It is used by
+   `Controller.prototype._qpChanged`.
+      The methods backing each state can be found in the `Route.prototype._qp` computed
+   property return value (the `.states` property). The current values are listed here for
+   the sanity of future travelers:
+      * `inactive` - This state is used when this controller instance is not part of the active
+     route hierarchy. Set in `Route.prototype._reset` (a `router.js` microlib hook) and
+     `Route.prototype.actions.finalizeQueryParamChange`.
+   * `active` - This state is used when this controller instance is part of the active
+     route hierarchy. Set in `Route.prototype.actions.finalizeQueryParamChange`.
+   * `allowOverrides` - This state is used in `Route.prototype.setup` (`route.js` microlib hook).
+       @method _qpDelegate
+    @private
+  */
+  _qpDelegate: null,
+
+  /**
+   During `Route#setup` observers are created to invoke this method
+   when any of the query params declared in `Controller#queryParams` property
+   are changed.
+      When invoked this method uses the currently active query param update delegate
+   (see `Controller.prototype._qpDelegate` for details) and invokes it with
+   the QP key/value being changed.
+       @method _qpChanged
+    @private
+  */
+  _qpChanged(controller, _prop) {
+    let dotIndex = _prop.indexOf('.[]');
+
+    let prop = dotIndex === -1 ? _prop : _prop.slice(0, dotIndex);
+    let delegate = controller._qpDelegate;
+    let value = get(controller, prop);
+    delegate(prop, value);
+  },
+
+  /**
+    Transition the application into another route. The route may
+    be either a single route or route path:
+       ```javascript
+    aController.transitionToRoute('blogPosts');
+    aController.transitionToRoute('blogPosts.recentEntries');
+    ```
+       Optionally supply a model for the route in question. The model
+    will be serialized into the URL using the `serialize` hook of
+    the route:
+       ```javascript
+    aController.transitionToRoute('blogPost', aPost);
+    ```
+       If a literal is passed (such as a number or a string), it will
+    be treated as an identifier instead. In this case, the `model`
+    hook of the route will be triggered:
+       ```javascript
+    aController.transitionToRoute('blogPost', 1);
+    ```
+       Multiple models will be applied last to first recursively up the
+    route tree.
+       ```app/router.js
+    Router.map(function() {
+      this.route('blogPost', { path: ':blogPostId' }, function() {
+        this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
+      });
+    });
+    ```
+       ```javascript
+    aController.transitionToRoute('blogComment', aPost, aComment);
+    aController.transitionToRoute('blogComment', 1, 13);
+    ```
+       It is also possible to pass a URL (a string that starts with a
+    `/`).
+       ```javascript
+    aController.transitionToRoute('/');
+    aController.transitionToRoute('/blog/post/1/comment/13');
+    aController.transitionToRoute('/blog/posts?sort=title');
+    ```
+       An options hash with a `queryParams` property may be provided as
+    the final argument to add query parameters to the destination URL.
+       ```javascript
+    aController.transitionToRoute('blogPost', 1, {
+      queryParams: { showComments: 'true' }
+    });
+       // if you just want to transition the query parameters without changing the route
+    aController.transitionToRoute({ queryParams: { sort: 'date' } });
+    ```
+       See also [replaceRoute](/ember/release/classes/Ember.ControllerMixin/methods/replaceRoute?anchor=replaceRoute).
+       @for Ember.ControllerMixin
+    @method transitionToRoute
+    @deprecated Use transitionTo from the Router service instead.
+    @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
+  */
+  transitionToRoute(...args) {
+    var _a;
+
+    deprecateTransitionMethods('controller', 'transitionToRoute'); // target may be either another controller or a router
+
+    let target = get(this, 'target'); // SAFETY: We can't actually assert that this is a full Controller or Router since some tests
+    // mock out an object that only has the single method. Since this is deprecated, I think it's
+    // ok to be a little less than proper here.
+
+    let method = (_a = target.transitionToRoute) !== null && _a !== void 0 ? _a : target.transitionTo;
+    return method.apply(target, prefixRouteNameArg(this, args));
+  },
+
+  /**
+    Transition into another route while replacing the current URL, if possible.
+    This will replace the current history entry instead of adding a new one.
+    Beside that, it is identical to `transitionToRoute` in all other respects.
+       ```javascript
+    aController.replaceRoute('blogPosts');
+    aController.replaceRoute('blogPosts.recentEntries');
+    ```
+       Optionally supply a model for the route in question. The model
+    will be serialized into the URL using the `serialize` hook of
+    the route:
+       ```javascript
+    aController.replaceRoute('blogPost', aPost);
+    ```
+       If a literal is passed (such as a number or a string), it will
+    be treated as an identifier instead. In this case, the `model`
+    hook of the route will be triggered:
+       ```javascript
+    aController.replaceRoute('blogPost', 1);
+    ```
+       Multiple models will be applied last to first recursively up the
+    route tree.
+       ```app/router.js
+    Router.map(function() {
+      this.route('blogPost', { path: ':blogPostId' }, function() {
+        this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
+      });
+    });
+    ```
+       ```
+    aController.replaceRoute('blogComment', aPost, aComment);
+    aController.replaceRoute('blogComment', 1, 13);
+    ```
+       It is also possible to pass a URL (a string that starts with a
+    `/`).
+       ```javascript
+    aController.replaceRoute('/');
+    aController.replaceRoute('/blog/post/1/comment/13');
+    ```
+       @for Ember.ControllerMixin
+    @method replaceRoute
+    @deprecated Use replaceWith from the Router service instead.
+    @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
+  */
+  replaceRoute(...args) {
+    var _a;
+
+    deprecateTransitionMethods('controller', 'replaceRoute'); // target may be either another controller or a router
+
+    let target = get(this, 'target'); // SAFETY: We can't actually assert that this is a full Controller or Router since some tests
+    // mock out an object that only has the single method. Since this is deprecated, I think it's
+    // ok to be a little less than proper here.
+
+    let method = (_a = target.replaceRoute) !== null && _a !== void 0 ? _a : target.replaceWith;
+    return method.apply(target, prefixRouteNameArg(this, args));
+  }
+
+});
 
 class Controller extends FrameworkObject.extend(ControllerMixin) {}
 
 export function inject(...args) {
   return metalInject('controller', ...args);
 }
-export default Controller;
+export { Controller as default, ControllerMixin };

package/dist/packages/@ember/debug/container-debug-adapter.js

@@ -1 +1,99 @@
-export { ContainerDebugAdapter as default } from '@ember/-internals/extension-support';
+import { classify, dasherize } from '@ember/string';
+import EmberObject from '@ember/object';
+import { A as emberA } from '@ember/array';
+import { typeOf } from '@ember/utils';
+import { getOwner } from '@ember/-internals/owner';
+import Namespace from '@ember/application/namespace';
+/**
+@module @ember/debug/container-debug-adapter
+*/
+
+/**
+  The `ContainerDebugAdapter` helps the container and resolver interface
+  with tools that debug Ember such as the
+  [Ember Inspector](https://github.com/emberjs/ember-inspector)
+  for Chrome and Firefox.
+
+  This class can be extended by a custom resolver implementer
+  to override some of the methods with library-specific code.
+
+  The methods likely to be overridden are:
+
+  * `canCatalogEntriesByType`
+  * `catalogEntriesByType`
+
+  The adapter will need to be registered
+  in the application's container as `container-debug-adapter:main`.
+
+  Example:
+
+  ```javascript
+  Application.initializer({
+    name: "containerDebugAdapter",
+
+    initialize(application) {
+      application.register('container-debug-adapter:main', require('app/container-debug-adapter'));
+    }
+  });
+  ```
+
+  @class ContainerDebugAdapter
+  @extends EmberObject
+  @since 1.5.0
+  @public
+*/
+
+export default class ContainerDebugAdapter extends EmberObject {
+  constructor(owner) {
+    super(owner);
+    this.resolver = getOwner(this).lookup('resolver-for-debugging:main');
+  }
+  /**
+    Returns true if it is possible to catalog a list of available
+    classes in the resolver for a given type.
+       @method canCatalogEntriesByType
+    @param {String} type The type. e.g. "model", "controller", "route".
+    @return {boolean} whether a list is available for this type.
+    @public
+  */
+
+
+  canCatalogEntriesByType(type) {
+    if (type === 'model' || type === 'template') {
+      return false;
+    }
+
+    return true;
+  }
+  /**
+    Returns the available classes a given type.
+       @method catalogEntriesByType
+    @param {String} type The type. e.g. "model", "controller", "route".
+    @return {Array} An array of strings.
+    @public
+  */
+
+
+  catalogEntriesByType(type) {
+    let namespaces = emberA(Namespace.NAMESPACES);
+    let types = emberA();
+    let typeSuffixRegex = new RegExp(`${classify(type)}$`);
+    namespaces.forEach(namespace => {
+      for (let key in namespace) {
+        if (!Object.prototype.hasOwnProperty.call(namespace, key)) {
+          continue;
+        }
+
+        if (typeSuffixRegex.test(key)) {
+          let klass = namespace[key];
+
+          if (typeOf(klass) === 'class') {
+            types.push(dasherize(key.replace(typeSuffixRegex, '')));
+          }
+        }
+      }
+    });
+    return types;
+  }
+
+}