ember-source 7.1.0-alpha.4 → 7.1.0-beta.1

package/dist/prod/packages/shared-chunks/{namespace_search-Dcdalhj6.js → computed-DjCIU_ht.js}

@@ -1,11 +1,10 @@
-import { peekMeta, meta } from '../@ember/-internals/meta/lib/meta.js';
-import './super-Cm_a_cLQ.js';
-import { context } from '../@ember/-internals/environment/index.js';
+import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import { d as descriptorForProperty, a as isClassicDecorator, c as ComputedDescriptor, i as isElementDescriptor, m as makeComputedDecorator, b as descriptorForDecorator } from './decorator-9ikVwsjY.js';
+import { c as revalidateObservers, d as flushSyncObservers, e as resumeObserverDeactivation, s as suspendedObserverDeactivation, b as addObserver, g as setObserverSuspended } from './observers-CDkeR0nI.js';
 import inspect from '../@ember/debug/lib/inspect.js';
-import { tagMetaFor, tagFor, validateTag, untrack, updateTag as UPDATE_TAG, valueForTag, consumeTag, ALLOW_CYCLES, track } from '../@glimmer/validator/index.js';
-import { w as flushSyncObservers, x as resumeObserverDeactivation, v as markObjectAsDirty, y as suspendedObserverDeactivation, z as getChainTagsForKeys, l as finishLazyChains, c as addObserver, B as setObserverSuspended, d as revalidateObservers } from './observers-tZ2aOzr4.js';
-import { c as ComputedDescriptor, i as isElementDescriptor, m as makeComputedDecorator, b as descriptorForDecorator, d as descriptorForProperty, a as isClassicDecorator } from './decorator-BdDDBUd2.js';
-import { s as setName, g as getName } from './name-C68GLLO3.js';
+import { v as validateTag, u as untrack, U as UPDATE_TAG, d as valueForTag, a as consumeTag, A as ALLOW_CYCLES, t as track } from './cache-BIlOoPA7.js';
+import { a as tagMetaFor, t as tagFor } from './meta-B9mldqPL.js';
+import { m as markObjectAsDirty, b as getChainTagsForKeys, f as finishLazyChains } from './chain-tags-C9rFtQ_x.js';
 
 /**
 @module @ember/object
@@ -70,6 +69,107 @@ function dive(prefix, pattern, start, callback) {
   }
 }
 
+/**
+@module @ember/object
+*/
+
+
+/**
+  NOTE: This is a low-level method used by other parts of the API. You almost
+  never want to call this method directly. Instead you should use
+  `mixin()` to define new properties.
+
+  Defines a property on an object. This method works much like the ES5
+  `Object.defineProperty()` method except that it can also accept computed
+  properties and other special descriptors.
+
+  Normally this method takes only three parameters. However if you pass an
+  instance of `Descriptor` as the third param then you can pass an
+  optional value as the fourth parameter. This is often more efficient than
+  creating new descriptor hashes for each property.
+
+  ## Examples
+
+  ```javascript
+  import { defineProperty, computed } from '@ember/object';
+
+  // ES5 compatible mode
+  defineProperty(contact, 'firstName', {
+    writable: true,
+    configurable: false,
+    enumerable: true,
+    value: 'Charles'
+  });
+
+  // define a simple property
+  defineProperty(contact, 'lastName', undefined, 'Jolley');
+
+  // define a computed property
+  defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
+    return this.firstName+' '+this.lastName;
+  }));
+  ```
+
+  @public
+  @method defineProperty
+  @static
+  @for @ember/object
+  @param {Object} obj the object to define this property on. This may be a prototype.
+  @param {String} keyName the name of the property
+  @param {Descriptor} [desc] an instance of `Descriptor` (typically a
+    computed property) or an ES5 descriptor.
+    You must provide this or `data` but not both.
+  @param {*} [data] something other than a descriptor, that will
+    become the explicit value of this property.
+*/
+function defineProperty(obj, keyName, desc, data, _meta) {
+  let meta$1 = _meta === undefined ? meta(obj) : _meta;
+  let previousDesc = descriptorForProperty(obj, keyName, meta$1);
+  let wasDescriptor = previousDesc !== undefined;
+  if (wasDescriptor) {
+    previousDesc.teardown(obj, keyName, meta$1);
+  }
+  if (isClassicDecorator(desc)) {
+    defineDecorator(obj, keyName, desc, meta$1);
+  } else if (desc === null || desc === undefined) {
+    defineValue(obj, keyName, data, wasDescriptor, true);
+  } else {
+    // fallback to ES5
+    Object.defineProperty(obj, keyName, desc);
+  }
+
+  // if key is being watched, override chains that
+  // were initialized with the prototype
+  if (!meta$1.isPrototypeMeta(obj)) {
+    revalidateObservers(obj);
+  }
+}
+function defineDecorator(obj, keyName, desc, meta) {
+  let propertyDesc;
+  {
+    propertyDesc = desc(obj, keyName, undefined, meta);
+  }
+  Object.defineProperty(obj, keyName, propertyDesc);
+
+  // pass the decorator function forward for backwards compat
+  return desc;
+}
+function defineValue(obj, keyName, value, wasDescriptor, enumerable = true) {
+  if (wasDescriptor === true || enumerable === false) {
+    Object.defineProperty(obj, keyName, {
+      configurable: true,
+      enumerable,
+      writable: true,
+      value
+    });
+  } else {
+    {
+      obj[keyName] = value;
+    }
+  }
+  return value;
+}
+
 /**
  @module ember
  @private
@@ -836,235 +936,4 @@ function isComputed(obj, key) {
   return Boolean(descriptorForProperty(obj, key));
 }
 
-/**
-@module @ember/object
-*/
-
-
-/**
-  NOTE: This is a low-level method used by other parts of the API. You almost
-  never want to call this method directly. Instead you should use
-  `mixin()` to define new properties.
-
-  Defines a property on an object. This method works much like the ES5
-  `Object.defineProperty()` method except that it can also accept computed
-  properties and other special descriptors.
-
-  Normally this method takes only three parameters. However if you pass an
-  instance of `Descriptor` as the third param then you can pass an
-  optional value as the fourth parameter. This is often more efficient than
-  creating new descriptor hashes for each property.
-
-  ## Examples
-
-  ```javascript
-  import { defineProperty, computed } from '@ember/object';
-
-  // ES5 compatible mode
-  defineProperty(contact, 'firstName', {
-    writable: true,
-    configurable: false,
-    enumerable: true,
-    value: 'Charles'
-  });
-
-  // define a simple property
-  defineProperty(contact, 'lastName', undefined, 'Jolley');
-
-  // define a computed property
-  defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
-    return this.firstName+' '+this.lastName;
-  }));
-  ```
-
-  @public
-  @method defineProperty
-  @static
-  @for @ember/object
-  @param {Object} obj the object to define this property on. This may be a prototype.
-  @param {String} keyName the name of the property
-  @param {Descriptor} [desc] an instance of `Descriptor` (typically a
-    computed property) or an ES5 descriptor.
-    You must provide this or `data` but not both.
-  @param {*} [data] something other than a descriptor, that will
-    become the explicit value of this property.
-*/
-function defineProperty(obj, keyName, desc, data, _meta) {
-  let meta$1 = _meta === undefined ? meta(obj) : _meta;
-  let previousDesc = descriptorForProperty(obj, keyName, meta$1);
-  let wasDescriptor = previousDesc !== undefined;
-  if (wasDescriptor) {
-    previousDesc.teardown(obj, keyName, meta$1);
-  }
-  if (isClassicDecorator(desc)) {
-    defineDecorator(obj, keyName, desc, meta$1);
-  } else if (desc === null || desc === undefined) {
-    defineValue(obj, keyName, data, wasDescriptor, true);
-  } else {
-    // fallback to ES5
-    Object.defineProperty(obj, keyName, desc);
-  }
-
-  // if key is being watched, override chains that
-  // were initialized with the prototype
-  if (!meta$1.isPrototypeMeta(obj)) {
-    revalidateObservers(obj);
-  }
-}
-function defineDecorator(obj, keyName, desc, meta) {
-  let propertyDesc;
-  {
-    propertyDesc = desc(obj, keyName, undefined, meta);
-  }
-  Object.defineProperty(obj, keyName, propertyDesc);
-
-  // pass the decorator function forward for backwards compat
-  return desc;
-}
-function defineValue(obj, keyName, value, wasDescriptor, enumerable = true) {
-  if (wasDescriptor === true || enumerable === false) {
-    Object.defineProperty(obj, keyName, {
-      configurable: true,
-      enumerable,
-      writable: true,
-      value
-    });
-  } else {
-    {
-      obj[keyName] = value;
-    }
-  }
-  return value;
-}
-
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-let searchDisabled = false;
-const flags = {
-  _set: 0,
-  _unprocessedNamespaces: false,
-  get unprocessedNamespaces() {
-    return this._unprocessedNamespaces;
-  },
-  set unprocessedNamespaces(v) {
-    this._set++;
-    this._unprocessedNamespaces = v;
-  }
-};
-let unprocessedMixins = false;
-const NAMESPACES = [];
-const NAMESPACES_BY_ID = Object.create(null);
-function addNamespace(namespace) {
-  flags.unprocessedNamespaces = true;
-  NAMESPACES.push(namespace);
-}
-function removeNamespace(namespace) {
-  let name = getName(namespace);
-  delete NAMESPACES_BY_ID[name];
-  NAMESPACES.splice(NAMESPACES.indexOf(namespace), 1);
-  if (name in context.lookup && namespace === context.lookup[name]) {
-    context.lookup[name] = undefined;
-  }
-}
-function findNamespaces() {
-  if (!flags.unprocessedNamespaces) {
-    return;
-  }
-  let lookup = context.lookup;
-  let keys = Object.keys(lookup);
-  for (let key of keys) {
-    // Only process entities that start with uppercase A-Z
-    if (!isUppercase(key.charCodeAt(0))) {
-      continue;
-    }
-    let obj = tryIsNamespace(lookup, key);
-    if (obj) {
-      setName(obj, key);
-    }
-  }
-}
-function findNamespace(name) {
-  if (!searchDisabled) {
-    processAllNamespaces();
-  }
-  return NAMESPACES_BY_ID[name];
-}
-function processNamespace(namespace) {
-  _processNamespace([namespace.toString()], namespace, new Set());
-}
-function processAllNamespaces() {
-  let unprocessedNamespaces = flags.unprocessedNamespaces;
-  if (unprocessedNamespaces) {
-    findNamespaces();
-    flags.unprocessedNamespaces = false;
-  }
-  if (unprocessedNamespaces || unprocessedMixins) {
-    let namespaces = NAMESPACES;
-    for (let namespace of namespaces) {
-      processNamespace(namespace);
-    }
-    unprocessedMixins = false;
-  }
-}
-function isSearchDisabled() {
-  return searchDisabled;
-}
-function setSearchDisabled(flag) {
-  searchDisabled = Boolean(flag);
-}
-function setUnprocessedMixins() {
-  unprocessedMixins = true;
-}
-function _processNamespace(paths, root, seen) {
-  let idx = paths.length;
-  let id = paths.join('.');
-  NAMESPACES_BY_ID[id] = root;
-  setName(root, id);
-
-  // Loop over all of the keys in the namespace, looking for classes
-  for (let key in root) {
-    if (!hasOwnProperty.call(root, key)) {
-      continue;
-    }
-    let obj = root[key];
-
-    // If we are processing the `Ember` namespace, for example, the
-    // `paths` will start with `["Ember"]`. Every iteration through
-    // the loop will update the **second** element of this list with
-    // the key, so processing `Ember.View` will make the Array
-    // `['Ember', 'View']`.
-    paths[idx] = key;
-
-    // If we have found an unprocessed class
-    if (obj && getName(obj) === void 0) {
-      // Replace the class' `toString` with the dot-separated path
-      setName(obj, paths.join('.'));
-      // Support nested namespaces
-    } else if (obj && isNamespace(obj)) {
-      // Skip aliased namespaces
-      if (seen.has(obj)) {
-        continue;
-      }
-      seen.add(obj);
-      // Process the child namespace
-      _processNamespace(paths, obj, seen);
-    }
-  }
-  paths.length = idx; // cut out last item
-}
-function isNamespace(obj) {
-  return obj != null && typeof obj === 'object' && obj.isNamespace;
-}
-function isUppercase(code) {
-  return code >= 65 && code <= 90 // A
-; // Z
-}
-function tryIsNamespace(lookup, prop) {
-  try {
-    let obj = lookup[prop];
-    return (obj !== null && typeof obj === 'object' || typeof obj === 'function') && obj.isNamespace && obj;
-  } catch (_e) {
-    // continue
-  }
-}
-
-export { ComputedProperty as C, NAMESPACES as N, PROPERTY_DID_CHANGE as P, endPropertyChanges as a, beginPropertyChanges as b, computed as c, defineProperty as d, expandProperties as e, defineValue as f, defineDecorator as g, NAMESPACES_BY_ID as h, findNamespace as i, addNamespace as j, findNamespaces as k, processNamespace as l, autoComputed as m, notifyPropertyChange as n, changeProperties as o, processAllNamespaces as p, isComputed as q, removeNamespace as r, setUnprocessedMixins as s, isSearchDisabled as t, setSearchDisabled as u };
+export { ComputedProperty as C, PROPERTY_DID_CHANGE as P, endPropertyChanges as a, beginPropertyChanges as b, computed as c, defineProperty as d, expandProperties as e, changeProperties as f, defineValue as g, defineDecorator as h, autoComputed as i, isComputed as j, notifyPropertyChange as n };

package/dist/prod/packages/shared-chunks/container-BYOnjnwz.js

@@ -0,0 +1,315 @@
+import { setOwner } from '../@ember/-internals/owner/index.js';
+import { m as makeDictionary } from './dictionary-gc5gpyOG.js';
+
+/**
+ A container used to instantiate and cache objects.
+
+ Every `Container` must be associated with a `Registry`, which is referenced
+ to determine the factory and options that should be used to instantiate
+ objects.
+
+ The public API for `Container` is still in flux and should not be considered
+ stable.
+
+ @private
+ @class Container
+ */
+class Container {
+  static _leakTracking;
+  owner;
+  registry;
+  cache;
+  factoryManagerCache;
+  validationCache;
+  isDestroyed;
+  isDestroying;
+  constructor(registry, options = {}) {
+    this.registry = registry;
+    this.owner = options.owner || null;
+    this.cache = makeDictionary(options.cache || null);
+    this.factoryManagerCache = makeDictionary(options.factoryManagerCache || null);
+    this.isDestroyed = false;
+    this.isDestroying = false;
+  }
+
+  /**
+   @private
+   @property registry
+   @type Registry
+   @since 1.11.0
+   */
+
+  /**
+   @private
+   @property cache
+   @type InheritingDict
+   */
+
+  /**
+   @private
+   @property validationCache
+   @type InheritingDict
+   */
+
+  /**
+   Given a fullName return a corresponding instance.
+    The default behavior is for lookup to return a singleton instance.
+   The singleton is scoped to the container, allowing multiple containers
+   to all have their own locally scoped singletons.
+    ```javascript
+   let registry = new Registry();
+   let container = registry.container();
+    registry.register('api:twitter', Twitter);
+    let twitter = container.lookup('api:twitter');
+    twitter instanceof Twitter; // => true
+    // by default the container will return singletons
+   let twitter2 = container.lookup('api:twitter');
+   twitter2 instanceof Twitter; // => true
+    twitter === twitter2; //=> true
+   ```
+    If singletons are not wanted, an optional flag can be provided at lookup.
+    ```javascript
+   let registry = new Registry();
+   let container = registry.container();
+    registry.register('api:twitter', Twitter);
+    let twitter = container.lookup('api:twitter', { singleton: false });
+   let twitter2 = container.lookup('api:twitter', { singleton: false });
+    twitter === twitter2; //=> false
+   ```
+    @private
+   @method lookup
+   @param {String} fullName
+   @param {RegisterOptions} [options]
+   @return {any}
+   */
+  lookup(fullName, options) {
+    if (this.isDestroyed) {
+      throw new Error(`Cannot call \`.lookup('${fullName}')\` after the owner has been destroyed`);
+    }
+    return lookup(this, this.registry.normalize(fullName), options);
+  }
+
+  /**
+   A depth first traversal, destroying the container, its descendant containers and all
+   their managed objects.
+    @private
+   @method destroy
+   */
+  destroy() {
+    this.isDestroying = true;
+    destroyDestroyables(this);
+  }
+  finalizeDestroy() {
+    resetCache(this);
+    this.isDestroyed = true;
+  }
+
+  /**
+   Clear either the entire cache or just the cache for a particular key.
+    @private
+   @method reset
+   @param {String} fullName optional key to reset; if missing, resets everything
+  */
+  reset(fullName) {
+    if (this.isDestroyed) return;
+    if (fullName === undefined) {
+      destroyDestroyables(this);
+      resetCache(this);
+    } else {
+      resetMember(this, this.registry.normalize(fullName));
+    }
+  }
+
+  /**
+   Returns an object that can be used to provide an owner to a
+   manually created instance.
+    @private
+   @method ownerInjection
+   @returns { Object }
+  */
+  ownerInjection() {
+    let injection = {};
+    setOwner(injection, this.owner);
+    return injection;
+  }
+
+  /**
+   Given a fullName, return the corresponding factory. The consumer of the factory
+   is responsible for the destruction of any factory instances, as there is no
+   way for the container to ensure instances are destroyed when it itself is
+   destroyed.
+    @public
+   @method factoryFor
+   @param {String} fullName
+   @return {any}
+   */
+  factoryFor(fullName) {
+    if (this.isDestroyed) {
+      throw new Error(`Cannot call \`.factoryFor('${fullName}')\` after the owner has been destroyed`);
+    }
+    let normalizedName = this.registry.normalize(fullName);
+    return factoryFor(this, normalizedName, fullName);
+  }
+}
+function isSingleton(container, fullName) {
+  return container.registry.getOption(fullName, 'singleton') !== false;
+}
+function isInstantiatable(container, fullName) {
+  return container.registry.getOption(fullName, 'instantiate') !== false;
+}
+function lookup(container, fullName, options = {}) {
+  let normalizedName = fullName;
+  if (options.singleton === true || options.singleton === undefined && isSingleton(container, fullName)) {
+    let cached = container.cache[normalizedName];
+    if (cached !== undefined) {
+      return cached;
+    }
+  }
+  return instantiateFactory(container, normalizedName, fullName, options);
+}
+function factoryFor(container, normalizedName, fullName) {
+  let cached = container.factoryManagerCache[normalizedName];
+  if (cached !== undefined) {
+    return cached;
+  }
+  let factory = container.registry.resolve(normalizedName);
+  if (factory === undefined) {
+    return;
+  }
+  let manager = new InternalFactoryManager(container, factory, fullName, normalizedName);
+  container.factoryManagerCache[normalizedName] = manager;
+  return manager;
+}
+function isSingletonClass(container, fullName, {
+  instantiate,
+  singleton
+}) {
+  return singleton !== false && !instantiate && isSingleton(container, fullName) && !isInstantiatable(container, fullName);
+}
+function isSingletonInstance(container, fullName, {
+  instantiate,
+  singleton
+}) {
+  return singleton !== false && instantiate !== false && (singleton === true || isSingleton(container, fullName)) && isInstantiatable(container, fullName);
+}
+function isFactoryClass(container, fullname, {
+  instantiate,
+  singleton
+}) {
+  return instantiate === false && (singleton === false || !isSingleton(container, fullname)) && !isInstantiatable(container, fullname);
+}
+function isFactoryInstance(container, fullName, {
+  instantiate,
+  singleton
+}) {
+  return instantiate !== false && (singleton === false || !isSingleton(container, fullName)) && isInstantiatable(container, fullName);
+}
+function instantiateFactory(container, normalizedName, fullName, options) {
+  let factoryManager = factoryFor(container, normalizedName, fullName);
+  if (factoryManager === undefined) {
+    return;
+  }
+
+  // SomeClass { singleton: true, instantiate: true } | { singleton: true } | { instantiate: true } | {}
+  // By default majority of objects fall into this case
+  if (isSingletonInstance(container, fullName, options)) {
+    let instance = container.cache[normalizedName] = factoryManager.create();
+
+    // if this lookup happened _during_ destruction (emits a deprecation, but
+    // is still possible) ensure that it gets destroyed
+    if (container.isDestroying) {
+      if (typeof instance.destroy === 'function') {
+        instance.destroy();
+      }
+    }
+    return instance;
+  }
+
+  // SomeClass { singleton: false, instantiate: true }
+  if (isFactoryInstance(container, fullName, options)) {
+    return factoryManager.create();
+  }
+
+  // SomeClass { singleton: true, instantiate: false } | { instantiate: false } | { singleton: false, instantiation: false }
+  if (isSingletonClass(container, fullName, options) || isFactoryClass(container, fullName, options)) {
+    return factoryManager.class;
+  }
+  throw new Error('Could not create factory');
+}
+function destroyDestroyables(container) {
+  let cache = container.cache;
+  let keys = Object.keys(cache);
+  for (let key of keys) {
+    let value = cache[key];
+    if (value.destroy) {
+      value.destroy();
+    }
+  }
+}
+function resetCache(container) {
+  container.cache = makeDictionary(null);
+  container.factoryManagerCache = makeDictionary(null);
+}
+function resetMember(container, fullName) {
+  let member = container.cache[fullName];
+  delete container.factoryManagerCache[fullName];
+  if (member) {
+    delete container.cache[fullName];
+    if (member.destroy) {
+      member.destroy();
+    }
+  }
+}
+const INIT_FACTORY = Symbol('INIT_FACTORY');
+function getFactoryFor(obj) {
+  // SAFETY: since we know `obj` is an `object`, we also know we can safely ask
+  // whether a key is set on it.
+  return obj[INIT_FACTORY];
+}
+function setFactoryFor(obj, factory) {
+  // SAFETY: since we know `obj` is an `object`, we also know we can safely set
+  // a key it safely at this location. (The only way this could be blocked is if
+  // someone has gone out of their way to use `Object.defineProperty()` with our
+  // internal-only symbol and made it `writable: false`.)
+  obj[INIT_FACTORY] = factory;
+}
+class InternalFactoryManager {
+  container;
+  owner;
+  class;
+  fullName;
+  normalizedName;
+  madeToString;
+  injections;
+  constructor(container, factory, fullName, normalizedName) {
+    this.container = container;
+    this.owner = container.owner;
+    this.class = factory;
+    this.fullName = fullName;
+    this.normalizedName = normalizedName;
+    this.madeToString = undefined;
+    this.injections = undefined;
+  }
+  toString() {
+    if (this.madeToString === undefined) {
+      this.madeToString = this.container.registry.makeToString(this.class, this.fullName);
+    }
+    return this.madeToString;
+  }
+  create(options) {
+    let {
+      container
+    } = this;
+    if (container.isDestroyed) {
+      throw new Error(`Cannot create new instances after the owner has been destroyed (you attempted to create ${this.fullName})`);
+    }
+    let props = options ? {
+      ...options
+    } : {};
+    setOwner(props, container.owner);
+    setFactoryFor(props, this);
+    return this.class.create(props);
+  }
+}
+
+export { Container as C, INIT_FACTORY as I, getFactoryFor as g, setFactoryFor as s };