ember-source 6.12.0 → 7.0.0-beta.1

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

@@ -0,0 +1,267 @@
+import { i as isObject } from '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import { consumeTag, validateTag, tagFor, valueForTag, combine } from '../../@glimmer/validator/index.js';
+import { g as get, n as objectAt, a as tagForProperty } from '../../shared-chunks/observers-R1ZklwWy.js';
+import { P as PROPERTY_DID_CHANGE } from '../../shared-chunks/namespace_search-Aog9nySA.js';
+import { a as alias } from '../../shared-chunks/alias-BkT-0B1G.js';
+import { r as replace, a as arrayContentWillChange, b as arrayContentDidChange, c as addArrayObserver, d as removeArrayObserver } from '../../shared-chunks/array-EwekEvId.js';
+import EmberObject from '../object/index.js';
+import { MutableArray } from './index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import { s as setCustomTagFor } from '../../shared-chunks/args-proxy-Dl0A0YWI.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+
+/**
+@module @ember/array/proxy
+*/
+
+const ARRAY_OBSERVER_MAPPING = {
+  willChange: '_arrangedContentArrayWillChange',
+  didChange: '_arrangedContentArrayDidChange'
+};
+function customTagForArrayProxy(proxy, key) {
+  if (key === '[]') {
+    proxy._revalidate();
+    return proxy._arrTag;
+  } else if (key === 'length') {
+    proxy._revalidate();
+    return proxy._lengthTag;
+  }
+  return tagFor(proxy, key);
+}
+
+/**
+  An ArrayProxy wraps any other object that implements `Array` and/or
+  `MutableArray,` forwarding all requests. This makes it very useful for
+  a number of binding use cases or other cases where being able to swap
+  out the underlying array is useful.
+
+  A simple example of usage:
+
+  ```javascript
+  import { A } from '@ember/array';
+  import ArrayProxy from '@ember/array/proxy';
+
+  let pets = ['dog', 'cat', 'fish'];
+  let ap = ArrayProxy.create({ content: A(pets) });
+
+  ap.get('firstObject');                        // 'dog'
+  ap.set('content', ['amoeba', 'paramecium']);
+  ap.get('firstObject');                        // 'amoeba'
+  ```
+
+  This class can also be useful as a layer to transform the contents of
+  an array, as they are accessed. This can be done by overriding
+  `objectAtContent`:
+
+  ```javascript
+  import { A } from '@ember/array';
+  import ArrayProxy from '@ember/array/proxy';
+
+  let pets = ['dog', 'cat', 'fish'];
+  let ap = ArrayProxy.create({
+      content: A(pets),
+      objectAtContent: function(idx) {
+          return this.get('content').objectAt(idx).toUpperCase();
+      }
+  });
+
+  ap.get('firstObject'); // . 'DOG'
+  ```
+
+  When overriding this class, it is important to place the call to
+  `_super` *after* setting `content` so the internal observers have
+  a chance to fire properly:
+
+  ```javascript
+  import { A } from '@ember/array';
+  import ArrayProxy from '@ember/array/proxy';
+
+  export default ArrayProxy.extend({
+    init() {
+      this.set('content', A(['dog', 'cat', 'fish']));
+      this._super(...arguments);
+    }
+  });
+  ```
+
+  @class ArrayProxy
+  @extends EmberObject
+  @uses MutableArray
+  @public
+*/
+
+class ArrayProxy extends EmberObject {
+  /*
+    `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 */
+  _objectsDirtyIndex = 0;
+  /** @internal */
+  _objects = null;
+
+  /** @internal */
+  _lengthDirty = true;
+  /** @internal */
+  _length = 0;
+
+  /** @internal */
+  _arrangedContent = null;
+  /** @internal */
+  _arrangedContentIsUpdating = false;
+  /** @internal */
+  _arrangedContentTag = null;
+  /** @internal */
+  _arrangedContentRevision = null;
+  /** @internal */
+  _lengthTag = null;
+  /** @internal */
+  _arrTag = null;
+  init(props) {
+    super.init(props);
+    setCustomTagFor(this, customTagForArrayProxy);
+  }
+  [PROPERTY_DID_CHANGE]() {
+    this._revalidate();
+  }
+  willDestroy() {
+    this._removeArrangedContentArrayObserver();
+  }
+  objectAtContent(idx) {
+    let arrangedContent = get(this, '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) {
+    this.replaceContent(idx, amt, objects);
+  }
+  replaceContent(idx, amt, objects) {
+    let content = get(this, '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;
+    }
+    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) {
+      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) {
+      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, {
+  arrangedContent: alias('content')
+});
+
+export { ArrayProxy as default };

package/dist/prod/packages/@ember/canary-features/index.js

@@ -0,0 +1,67 @@
+import { ENV } from '../-internals/environment/index.js';
+
+/**
+  Set `EmberENV.FEATURES` in your application's `config/environment.js` file
+  to enable canary features in your application.
+
+  See the [feature flag guide](https://guides.emberjs.com/release/configuring-ember/feature-flags/)
+  for more details.
+
+  @module @ember/canary-features
+  @public
+*/
+
+const DEFAULT_FEATURES = {
+  // FLAG_NAME: true/false
+};
+
+/**
+  The hash of enabled Canary features. Add to this, any canary features
+  before creating your application.
+
+  @class FEATURES
+  @static
+  @since 1.1.0
+  @public
+*/
+const FEATURES = Object.assign(DEFAULT_FEATURES, ENV.FEATURES);
+
+/**
+  Determine whether the specified `feature` is enabled. Used by Ember's
+  build tools to exclude experimental features from beta/stable builds.
+
+  You can define the following configuration options:
+
+  * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
+    enabled/disabled.
+
+  @method isEnabled
+  @param {String} feature The feature to check
+  @return {Boolean}
+  @since 1.1.0
+  @public
+*/
+function isEnabled(feature) {
+  let value = FEATURES[feature];
+  if (value === true || value === false) {
+    return value;
+  } else if (ENV.ENABLE_OPTIONAL_FEATURES) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// Uncomment the below when features are present:
+
+// function featureValue(value: null | boolean) {
+//   if (ENV.ENABLE_OPTIONAL_FEATURES && value === null) {
+//     return true;
+//   }
+
+//   return value;
+// }
+//
+// export const FLAG_NAME = featureValue(FEATURES.FLAG_NAME);
+
+export { DEFAULT_FEATURES, FEATURES, isEnabled };

package/dist/prod/packages/@ember/component/helper.js

@@ -0,0 +1,12 @@
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/index-CSVCFS_p.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+export { H as default, h as helper } from '../../shared-chunks/index-DZLHQAlb.js';
+import '../-internals/container/index.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import '../../shared-chunks/on-CrTl7JQU.js';
+import '../../shared-chunks/constants-b-2IVErl.js';
+import '../runloop/index.js';

package/dist/prod/packages/@ember/component/index.js

@@ -0,0 +1,32 @@
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { setComponentManager as setComponentManager$1 } from '../../@glimmer/manager/index.js';
+export { componentCapabilities as capabilities } from '../../@glimmer/manager/index.js';
+export { g as getComponentTemplate, s as setComponentTemplate } from '../../shared-chunks/template-Dc_cBOoX.js';
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../shared-chunks/index-CSVCFS_p.js';
+export { I as Input, T as Textarea, C as default } from '../../shared-chunks/index-DZLHQAlb.js';
+import '../-internals/container/index.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import '../../shared-chunks/on-CrTl7JQU.js';
+import '../../shared-chunks/constants-b-2IVErl.js';
+import '../runloop/index.js';
+
+/**
+   Associate a class with a component manager (an object that is responsible for
+   coordinating the lifecycle events that occurs when invoking, rendering and
+   re-rendering a component).
+
+   @method setComponentManager
+   @param {Function} factory a function to create the owner for an object
+   @param {Object} obj the object to associate with the componetn manager
+   @return {Object} the same object passed in
+   @public
+  */
+function setComponentManager(manager, obj) {
+  return setComponentManager$1(manager, obj);
+}
+
+export { setComponentManager };

package/dist/prod/packages/@ember/component/template-only.js

@@ -0,0 +1,39 @@
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import { w as templateOnlyComponent } from '../../shared-chunks/on-CrTl7JQU.js';
+import '../../shared-chunks/constants-b-2IVErl.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+
+/**
+  @module @ember/component/template-only
+  @public
+*/
+
+
+/**
+ * Template-only components have no backing class instance, so `this` in their
+ * templates is null. This means that you can only reference passed in arguments
+ * (e.g. `{{@arg}}`).
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+/**
+ * A convenience alias for {@link TemplateOnlyComponent}
+ */
+
+// NOTES:
+//
+// 1. The generic here is for a *signature: a way to hang information for tools
+//    like Glint which can provide typey checking for component templates using
+//    information supplied via this generic. While it may appear useless on this
+//    class definition and extension, it is used by external tools and should
+//    not be removed.
+// 2. SAFETY: this cast is *throwing away* information that is not part of the
+//    public API and replacing it with something which has the same calling
+//    contract, but much less information (since we do not want to expose the
+//    internal APIs like `moduleName` etc.).
+// prettier-ignore
+const templateOnly = templateOnlyComponent;
+
+export { templateOnly as default };

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

@@ -0,0 +1,177 @@
+import { getOwner } from '../-internals/owner/index.js';
+import '../object/index.js';
+import { FrameworkObject } from '../object/-internals.js';
+import { c as computed } from '../../shared-chunks/namespace_search-Aog9nySA.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { g as get } from '../../shared-chunks/observers-R1ZklwWy.js';
+import { i as inject$1 } from '../../shared-chunks/injected_property-DL3vQoFA.js';
+import Mixin from '../object/mixin.js';
+import '../-internals/runtime/lib/mixins/registry_proxy.js';
+import '../-internals/runtime/lib/mixins/container_proxy.js';
+import '../-internals/runtime/lib/mixins/comparable.js';
+import ActionHandler from '../-internals/runtime/lib/mixins/action_handler.js';
+import '../-internals/runtime/lib/mixins/-proxy.js';
+import '../enumerable/mutable.js';
+import '../-internals/runtime/lib/mixins/target_action_support.js';
+import '../-internals/runtime/lib/ext/rsvp.js';
+
+const MODEL = Symbol('MODEL');
+
+/**
+@module @ember/controller
+*/
+
+/**
+  @class ControllerMixin
+  @namespace Ember
+  @uses Ember.ActionHandler
+  @private
+*/
+
+const ControllerMixin = Mixin.create(ActionHandler, {
+  /* ducktype as a controller */
+  isController: true,
+  concatenatedProperties: ['queryParams'],
+  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');
+    }
+  },
+  model: computed({
+    get() {
+      return this[MODEL];
+    },
+    set(_key, value) {
+      return this[MODEL] = value;
+    }
+  }),
+  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,
+  // set by route
+
+  /**
+   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);
+  }
+});
+
+// NOTE: This doesn't actually extend EmberObject.
+/**
+  @class Controller
+  @extends EmberObject
+  @uses Ember.ControllerMixin
+  @public
+*/
+
+class Controller extends FrameworkObject.extend(ControllerMixin) {}
+
+/**
+  Creates a property that lazily looks up another controller in the container.
+  Can only be used when defining another controller.
+
+  Example:
+
+  ```app/controllers/post.js
+  import Controller, {
+    inject as controller
+  } from '@ember/controller';
+
+  export default class PostController extends Controller {
+    @controller posts;
+  }
+  ```
+
+  Classic Class Example:
+
+  ```app/controllers/post.js
+  import Controller, {
+    inject as controller
+  } from '@ember/controller';
+
+  export default Controller.extend({
+    posts: controller()
+  });
+  ```
+
+  This example will create a `posts` property on the `post` controller that
+  looks up the `posts` controller in the container, making it easy to reference
+  other controllers.
+
+  @method inject
+  @static
+  @for @ember/controller
+  @since 1.10.0
+  @param {String} name (optional) name of the controller to inject, defaults to
+         the property's name
+  @return {ComputedDecorator} injection decorator instance
+  @public
+*/
+
+function inject(...args) {
+  return inject$1('controller', ...args);
+}
+
+/**
+  A type registry for Ember `Controller`s. Meant to be declaration-merged so string
+  lookups resolve to the correct type.
+
+  Blueprints should include such a declaration merge for TypeScript:
+
+  ```ts
+  import Controller from '@ember/controller';
+
+  export default class ExampleController extends Controller {
+  // ...
+  }
+
+  declare module '@ember/controller' {
+    export interface Registry {
+      example: ExampleController;
+    }
+  }
+  ```
+
+  Then `@inject` can check that the service is registered correctly, and APIs
+  like `owner.lookup('controller:example')` can return `ExampleController`.
+*/
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+export { ControllerMixin, Controller as default, inject };