ember-source 7.1.0-alpha.3 → 7.1.0-alpha.5

package/dist/dev/packages/shared-chunks/container-BzzHmCNj.js

@@ -0,0 +1,404 @@
+import { setOwner } from '../@ember/-internals/owner/index.js';
+import { m as makeDictionary } from './dictionary-gc5gpyOG.js';
+import '../@ember/debug/index.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+// node exposes this. I'm not pulling in the whole @types/node because it
+// doesn't work with isolatedModules
+
+let leakTracking;
+let containers;
+{
+  // requires v8
+  // chrome --js-flags="--allow-natives-syntax --expose-gc"
+  // node --allow-natives-syntax --expose-gc
+  try {
+    if (typeof gc === 'function') {
+      leakTracking = (() => {
+        // avoid syntax errors when --allow-natives-syntax not present
+        let GetWeakSetValues = new Function('weakSet', 'return %GetWeakSetValues(weakSet, 0)');
+        containers = new WeakSet();
+        return {
+          hasContainers() {
+            gc();
+            return GetWeakSetValues(containers).length > 0;
+          },
+          reset() {
+            let values = GetWeakSetValues(containers);
+            for (let i = 0; i < values.length; i++) {
+              containers.delete(values[i]);
+            }
+          }
+        };
+      })();
+    }
+  } catch (_e) {
+    // ignore
+  }
+}
+/**
+ 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;
+    {
+      this.validationCache = makeDictionary(options.validationCache || null);
+      if (containers !== undefined) {
+        containers.add(this);
+      }
+    }
+  }
+
+  /**
+   @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`);
+    }
+    (!(this.registry.isValidFullName(fullName)) && assert('fullName must be a proper full name', this.registry.isValidFullName(fullName)));
+    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);
+    (!(this.registry.isValidFullName(normalizedName)) && assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName)));
+    return factoryFor(this, normalizedName, fullName);
+  }
+}
+{
+  Container._leakTracking = leakTracking;
+}
+
+/*
+ * Wrap a factory manager in a proxy which will not permit properties to be
+ * set on the manager.
+ */
+function wrapManagerInDeprecationProxy(manager) {
+  let validator = {
+    set(_obj, prop) {
+      throw new Error(`You attempted to set "${String(prop)}" on a factory manager created by container#factoryFor. A factory manager is a read-only construct.`);
+    }
+  };
+
+  // Note:
+  // We have to proxy access to the manager here so that private property
+  // access doesn't cause the above errors to occur.
+  let m = manager;
+  let proxiedManager = {
+    class: m.class,
+    create(props) {
+      return m.create(props);
+    }
+  };
+  return new Proxy(proxiedManager, validator);
+}
+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;
+  }
+  if (factory && typeof factory._onLookup === 'function') {
+    factory._onLookup(fullName);
+  }
+  let manager = new InternalFactoryManager(container, factory, fullName, normalizedName);
+  {
+    manager = wrapManagerInDeprecationProxy(manager);
+  }
+  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];
+    (!(value) && assert('has cached value', value));
+    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);
+    {
+      let lazyInjections;
+      let validationCache = this.container.validationCache;
+      // Ensure that all lazy injections are valid at instantiation time
+      if (!validationCache[this.fullName] && this.class && typeof this.class._lazyInjections === 'function') {
+        lazyInjections = this.class._lazyInjections();
+        lazyInjections = this.container.registry.normalizeInjectionsHash(lazyInjections);
+        this.container.registry.validateInjections(lazyInjections);
+      }
+      validationCache[this.fullName] = true;
+      (!(typeof this.class.create === 'function') && assert(`Failed to create an instance of '${this.normalizedName}'. Most likely an improperly defined class or an invalid module export.`, typeof this.class.create === 'function'));
+    }
+    return this.class.create(props);
+  }
+}
+
+export { Container as C, INIT_FACTORY as I, getFactoryFor as g, setFactoryFor as s };