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

package/build-metadata.json

@@ -1,6 +1,6 @@
 {
-  "version": "7.1.0-alpha.4",
+  "version": "7.1.0-alpha.5",
   "buildType": "tag",
-  "SHA": "8c2698de3c91133065de0d0cded1a2667f592abb",
-  "assetPath": "/tag/shas/8c2698de3c91133065de0d0cded1a2667f592abb.tgz"
+  "SHA": "26161bd055345407cf98bd10c9c925670efcc05b",
+  "assetPath": "/tag/shas/26161bd055345407cf98bd10c9c925670efcc05b.tgz"
 }

package/dist/dev/packages/@ember/-internals/container/index.js

@@ -1,407 +1,10 @@
 import { m as makeDictionary } from '../../../shared-chunks/dictionary-gc5gpyOG.js';
-import { c as intern } from '../../../shared-chunks/mandatory-setter-DHZe7-kW.js';
+import { i as intern } from '../../../shared-chunks/intern-zquhAEIg.js';
 import '../../debug/index.js';
-import { setOwner } from '../owner/index.js';
+import { C as Container } from '../../../shared-chunks/container-BzzHmCNj.js';
+export { I as INIT_FACTORY, g as getFactoryFor, s as setFactoryFor } from '../../../shared-chunks/container-BzzHmCNj.js';
 import { assert } from '../../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);
-  }
-}
-
 const VALID_FULL_NAME_REGEXP = /^[^:]+:[^:]+$/;
 
 /**
@@ -820,4 +423,4 @@ function privatize([fullName]) {
   return privateNames[fullName] = intern(`${type}:${rawName}-${privateSuffix}`);
 }
 
-export { Container, INIT_FACTORY, Registry, getFactoryFor, privatize, setFactoryFor };
+export { Container, Registry, privatize };

package/dist/dev/packages/@ember/-internals/deprecations/index.js

@@ -1,4 +1,4 @@
-import { ENV } from '../environment/index.js';
+import { E as ENV } from '../../../shared-chunks/env-g-kaAFLN.js';
 import VERSION from '../../../ember/version.js';
 import { deprecate } from '../../debug/index.js';
 import { dasherize } from '../string/index.js';

package/dist/dev/packages/@ember/-internals/environment/index.js

@@ -1,3 +1,5 @@
+export { E as ENV, g as getENV } from '../../../shared-chunks/env-g-kaAFLN.js';
+
 const global = globalThis;
 const Ember = global['Ember'];
 
@@ -21,164 +23,4 @@ function setLookup(value) {
   context.lookup = value;
 }
 
-/**
-  The hash of environment variables used to control various configuration
-  settings. To specify your own or override default settings, add the
-  desired properties to a global hash named `EmberENV` (or `ENV` for
-  backwards compatibility with earlier versions of Ember). The `EmberENV`
-  hash must be created before loading Ember.
-
-  @class EmberENV
-  @type Object
-  @public
-*/
-const ENV = {
-  ENABLE_OPTIONAL_FEATURES: false,
-  /**
-    Determines whether Ember should add to `Array`
-    native object prototypes, a few extra methods in order to provide a more
-    friendly API.
-     The behavior from setting this option to `true` was deprecated in Ember 5.10.
-     @property EXTEND_PROTOTYPES
-    @type Boolean
-    @default true
-    @for EmberENV
-    @private
-    @deprecated in v5.10
-  */
-  EXTEND_PROTOTYPES: {
-    Array: false
-  },
-  /**
-    The `LOG_STACKTRACE_ON_DEPRECATION` property, when true, tells Ember to log
-    a full stack trace during deprecation warnings.
-     @property LOG_STACKTRACE_ON_DEPRECATION
-    @type Boolean
-    @default true
-    @for EmberENV
-    @public
-  */
-  LOG_STACKTRACE_ON_DEPRECATION: true,
-  /**
-    The `LOG_VERSION` property, when true, tells Ember to log versions of all
-    dependent libraries in use.
-     @property LOG_VERSION
-    @type Boolean
-    @default true
-    @for EmberENV
-    @public
-  */
-  LOG_VERSION: true,
-  /**
-    The `LOG_INSPECTOR_HINT` property, when true, tells Ember to log a hint
-    suggesting the Ember Inspector browser extension when it is not detected.
-     @property LOG_INSPECTOR_HINT
-    @type Boolean
-    @default true
-    @for EmberENV
-    @public
-  */
-  LOG_INSPECTOR_HINT: true,
-  RAISE_ON_DEPRECATION: false,
-  STRUCTURED_PROFILE: false,
-  /**
-    Whether to perform extra bookkeeping needed to make the `captureRenderTree`
-    API work.
-     This has to be set before the ember JavaScript code is evaluated. This is
-    usually done by setting `window.EmberENV = { _DEBUG_RENDER_TREE: true };`
-    before the "vendor" `<script>` tag in `index.html`.
-     Setting the flag after Ember is already loaded will not work correctly. It
-    may appear to work somewhat, but fundamentally broken.
-     This is not intended to be set directly. Ember Inspector will enable the
-    flag on behalf of the user as needed.
-     This flag is always on in development mode.
-     The flag is off by default in production mode, due to the cost associated
-    with the the bookkeeping work.
-     The expected flow is that Ember Inspector will ask the user to refresh the
-    page after enabling the feature. It could also offer a feature where the
-    user add some domains to the "always on" list. In either case, Ember
-    Inspector will inject the code on the page to set the flag if needed.
-     @property _DEBUG_RENDER_TREE
-    @for EmberENV
-    @type Boolean
-    @default false
-    @private
-  */
-  _DEBUG_RENDER_TREE: true /* DEBUG */,
-  /**
-   Whether to force all deprecations to be enabled. This is used internally by
-   Ember to enable deprecations in tests. It is not intended to be set in
-   projects.
-    @property _ALL_DEPRECATIONS_ENABLED
-   @for EmberENV
-   @type Boolean
-   @default false
-   @private
-   */
-  _ALL_DEPRECATIONS_ENABLED: false,
-  /**
-   Override the version of ember-source used to determine when deprecations "break".
-   This is used internally by Ember to test with deprecated features "removed".
-   This is never intended to be set by projects.
-   @property _OVERRIDE_DEPRECATION_VERSION
-   @for EmberENV
-   @type string | null
-   @default null
-   @private
-   */
-  _OVERRIDE_DEPRECATION_VERSION: null,
-  /**
-    Whether the app defaults to using async observers.
-     This is not intended to be set directly, as the implementation may change in
-    the future. Use `@ember/optional-features` instead.
-     @property _DEFAULT_ASYNC_OBSERVERS
-    @for EmberENV
-    @type Boolean
-    @default false
-    @private
-  */
-  _DEFAULT_ASYNC_OBSERVERS: false,
-  /**
-    Controls the maximum number of scheduled rerenders without "settling". In general,
-    applications should not need to modify this environment variable, but please
-    open an issue so that we can determine if a better default value is needed.
-     @property _RERENDER_LOOP_LIMIT
-    @for EmberENV
-    @type number
-    @default 1000
-    @private
-   */
-  _RERENDER_LOOP_LIMIT: 1000,
-  FEATURES: {}
-};
-const EmberENV = globalThis.EmberENV;
-if (typeof EmberENV === 'object' && EmberENV !== null) {
-  for (let flag in EmberENV) {
-    if (!Object.prototype.hasOwnProperty.call(EmberENV, flag) || flag === 'EXTEND_PROTOTYPES' || flag === 'EMBER_LOAD_HOOKS') continue;
-    let defaultValue = ENV[flag];
-    if (defaultValue === true) {
-      ENV[flag] = EmberENV[flag] !== false;
-    } else if (defaultValue === false) {
-      ENV[flag] = EmberENV[flag] === true;
-    } else {
-      ENV[flag] = EmberENV[flag];
-    }
-  }
-  let {
-    FEATURES
-  } = EmberENV;
-  if (typeof FEATURES === 'object' && FEATURES !== null) {
-    for (let feature in FEATURES) {
-      if (!Object.prototype.hasOwnProperty.call(FEATURES, feature)) continue;
-      ENV.FEATURES[feature] = FEATURES[feature] === true;
-    }
-  }
-  {
-    ENV._DEBUG_RENDER_TREE = true;
-  }
-}
-function getENV() {
-  return ENV;
-}
-
-export { ENV, context, getENV, getLookup, setLookup };
+export { context, getLookup, setLookup };

package/dist/dev/packages/@ember/-internals/glimmer/index.js

@@ -1,20 +1,19 @@
-import '../../../shared-chunks/fragment-Cc5k9Oy4.js';
-import '../../../shared-chunks/debug-to-string-CFb7h0lY.js';
-import '../../../@glimmer/global-context/index.js';
-import '../../../@glimmer/validator/index.js';
-import '../../../shared-chunks/reference-C3TKDRnP.js';
-export { t as template, a as templateCacheCounters } from '../../../shared-chunks/index-BUPd6pkm.js';
+export { t as template, a as templateCacheCounters } from '../../../shared-chunks/index-DmGmwWPJ.js';
+export { R as RootTemplate, s as setupApplicationRegistry, a as setupEngineRegistry } from '../../../shared-chunks/setup-registry-XxD0xvgf.js';
+export { I as Input, T as Textarea } from '../../../shared-chunks/textarea-C0Us0PNJ.js';
+export { LinkTo } from '../../routing/index.js';
+export { default as Component, setComponentManager } from '../../component/index.js';
+export { H as Helper, h as helper } from '../../../shared-chunks/helper-DlC4YesW.js';
+export { S as SafeString, T as TrustedHTML, h as htmlSafe, i as isHTMLSafe, a as isTrustedHTML, t as trustHTML } from '../../../shared-chunks/index-D-xTBV4B.js';
+export { O as OutletView, R as Renderer, _ as _resetRenderers, a as renderComponent, r as renderSettled } from '../../../shared-chunks/index-CTxkmV78.js';
+export { D as DOMChanges } from '../../../shared-chunks/render-DDdabL30.js';
+export { D as DOMTreeConstruction } from '../../../shared-chunks/element-builder-kHVx0F__.js';
 import '../../../@glimmer/destroyable/index.js';
-import '../../../shared-chunks/capabilities-O_xc7Yqk.js';
-export { componentCapabilities, modifierCapabilities } from '../../../@glimmer/manager/index.js';
-export { C as Component, H as Helper, I as Input, L as LinkTo, O as OutletView, b as Renderer, R as RootTemplate, S as SafeString, T as Textarea, c as TrustedHTML, _ as _resetRenderers, g as element, h as helper, d as htmlSafe, i as isHTMLSafe, e as isTrustedHTML, f as renderComponent, r as renderSettled, t as trustHTML, u as uniqueId } from '../../../shared-chunks/index-RzG0Jvjx.js';
-export { s as setupApplicationRegistry, a as setupEngineRegistry } from '../../../shared-chunks/setup-registry-DxchCIL2.js';
-export { D as DOMChanges } from '../../../shared-chunks/dynamic-CgX8M02_.js';
-import '../../../shared-chunks/constants-BbdWMvgs.js';
-export { i as isSerializationFirstNode } from '../../../shared-chunks/rehydrate-builder-BRH0p0wA.js';
+export { i as isSerializationFirstNode } from '../../../shared-chunks/rehydrate-builder-DdzXTaJk.js';
 export { NodeDOMTreeConstruction } from '../../../@glimmer/node/index.js';
-export { setComponentManager } from '../../component/index.js';
-export { D as DOMTreeConstruction } from '../../../shared-chunks/element-builder-BpJIoi99.js';
+export { e as element } from '../../../shared-chunks/element-C-QcIABg.js';
+export { u as uniqueId } from '../../../shared-chunks/unique-id-A83bjEE-.js';
+export { c as componentCapabilities, m as modifierCapabilities } from '../../../shared-chunks/api-AYt3zE12.js';
 
 // STATE within a module is frowned upon, this exists
 // to support Ember.TEMPLATES but shield ember internals from this legacy

package/dist/dev/packages/@ember/-internals/meta/lib/meta.js

@@ -1,4 +1,3 @@
-import '../../../../shared-chunks/mandatory-setter-DHZe7-kW.js';
 import { t as toString } from '../../../../shared-chunks/to-string-C7M8LBLH.js';
 import '../../../debug/index.js';
 import { isDestroyed } from '../../../../@glimmer/destroyable/index.js';