ember-source 6.12.0 → 7.0.0-beta.1

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

@@ -0,0 +1,450 @@
+export { getEngineParent, setEngineParent } from './lib/engine-parent.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import Controller from '../controller/index.js';
+import Namespace from '../application/namespace.js';
+import { Registry } from '../-internals/container/index.js';
+import DAG from '../../dag-map/index.js';
+import ContainerDebugAdapter from '../debug/container-debug-adapter.js';
+import '../object/index.js';
+import EngineInstance from './instance.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 { s as set } from '../../shared-chunks/property_set-O080KTKZ.js';
+import '../../route-recognizer/index.js';
+import '../../shared-chunks/rsvp-CnCSY930.js';
+import '../../shared-chunks/unrecognized-url-error-DDBwfzdm.js';
+import RoutingService from '../routing/lib/routing-service.js';
+import ComponentLookup from '../-internals/views/lib/component_lookup.js';
+import '../-internals/views/lib/views/core_view.js';
+import '../-internals/views/lib/mixins/action_support.js';
+import '../-internals/views/lib/views/states.js';
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../shared-chunks/index-CSVCFS_p.js';
+import '../../shared-chunks/index-DZLHQAlb.js';
+import { a as setupEngineRegistry } from '../../shared-chunks/setup-registry-CMNYh2jY.js';
+import '../../shared-chunks/on-CrTl7JQU.js';
+import '../../shared-chunks/constants-b-2IVErl.js';
+import '../runloop/index.js';
+import RegistryProxyMixin from '../-internals/runtime/lib/mixins/registry_proxy.js';
+import '../-internals/runtime/lib/mixins/container_proxy.js';
+import '../-internals/runtime/lib/mixins/comparable.js';
+import '../-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';
+
+function props(obj) {
+  let properties = [];
+  for (let key in obj) {
+    properties.push(key);
+  }
+  return properties;
+}
+
+/**
+@module @ember/engine
+*/
+
+/**
+  The `Engine` class contains core functionality for both applications and
+  engines.
+
+  Each engine manages a registry that's used for dependency injection and
+  exposed through `RegistryProxy`.
+
+  Engines also manage initializers and instance initializers.
+
+  Engines can spawn `EngineInstance` instances via `buildInstance()`.
+
+  @class Engine
+  @extends Ember.Namespace
+  @uses RegistryProxyMixin
+  @public
+*/
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+class Engine extends Namespace.extend(RegistryProxyMixin) {
+  static initializers = Object.create(null);
+  static instanceInitializers = Object.create(null);
+
+  /**
+    The goal of initializers should be to register dependencies and injections.
+    This phase runs once. Because these initializers may load code, they are
+    allowed to defer application readiness and advance it. If you need to access
+    the container or store you should use an InstanceInitializer that will be run
+    after all initializers and therefore after all code is loaded and the app is
+    ready.
+     Initializer receives an object which has the following attributes:
+    `name`, `before`, `after`, `initialize`. The only required attribute is
+    `initialize`, all others are optional.
+     * `name` allows you to specify under which name the initializer is registered.
+    This must be a unique name, as trying to register two initializers with the
+    same name will result in an error.
+     ```app/initializer/named-initializer.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Running namedInitializer!');
+    }
+     export default {
+      name: 'named-initializer',
+      initialize
+    };
+    ```
+     * `before` and `after` are used to ensure that this initializer is ran prior
+    or after the one identified by the value. This value can be a single string
+    or an array of strings, referencing the `name` of other initializers.
+     An example of ordering initializers, we create an initializer named `first`:
+     ```app/initializer/first.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('First initializer!');
+    }
+     export default {
+      name: 'first',
+      initialize
+    };
+    ```
+     ```bash
+    // DEBUG: First initializer!
+    ```
+     We add another initializer named `second`, specifying that it should run
+    after the initializer named `first`:
+     ```app/initializer/second.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Second initializer!');
+    }
+     export default {
+      name: 'second',
+      after: 'first',
+      initialize
+    };
+    ```
+     ```
+    // DEBUG: First initializer!
+    // DEBUG: Second initializer!
+    ```
+     Afterwards we add a further initializer named `pre`, this time specifying
+    that it should run before the initializer named `first`:
+     ```app/initializer/pre.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Pre initializer!');
+    }
+     export default {
+      name: 'pre',
+      before: 'first',
+      initialize
+    };
+    ```
+     ```bash
+    // DEBUG: Pre initializer!
+    // DEBUG: First initializer!
+    // DEBUG: Second initializer!
+    ```
+     Finally we add an initializer named `post`, specifying it should run after
+    both the `first` and the `second` initializers:
+     ```app/initializer/post.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Post initializer!');
+    }
+     export default {
+      name: 'post',
+      after: ['first', 'second'],
+      initialize
+    };
+    ```
+     ```bash
+    // DEBUG: Pre initializer!
+    // DEBUG: First initializer!
+    // DEBUG: Second initializer!
+    // DEBUG: Post initializer!
+    ```
+     * `initialize` is a callback function that receives one argument,
+      `application`, on which you can operate.
+     Example of using `application` to register an adapter:
+     ```app/initializer/api-adapter.js
+    import ApiAdapter from '../utils/api-adapter';
+     export function initialize(application) {
+      application.register('api-adapter:main', ApiAdapter);
+    }
+     export default {
+      name: 'post',
+      after: ['first', 'second'],
+      initialize
+    };
+    ```
+     @method initializer
+    @param initializer {Object}
+    @public
+  */
+
+  static initializer = buildInitializerMethod('initializers');
+
+  /**
+    Instance initializers run after all initializers have run. Because
+    instance initializers run after the app is fully set up. We have access
+    to the store, container, and other items. However, these initializers run
+    after code has loaded and are not allowed to defer readiness.
+     Instance initializer receives an object which has the following attributes:
+    `name`, `before`, `after`, `initialize`. The only required attribute is
+    `initialize`, all others are optional.
+     * `name` allows you to specify under which name the instanceInitializer is
+    registered. This must be a unique name, as trying to register two
+    instanceInitializer with the same name will result in an error.
+     ```app/initializer/named-instance-initializer.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Running named-instance-initializer!');
+    }
+     export default {
+      name: 'named-instance-initializer',
+      initialize
+    };
+    ```
+     * `before` and `after` are used to ensure that this initializer is ran prior
+    or after the one identified by the value. This value can be a single string
+    or an array of strings, referencing the `name` of other initializers.
+     * See Application.initializer for discussion on the usage of before
+    and after.
+     Example instanceInitializer to preload data into the store.
+     ```app/initializer/preload-data.js
+     export function initialize(application) {
+        var userConfig, userConfigEncoded, store;
+        // We have a HTML escaped JSON representation of the user's basic
+        // configuration generated server side and stored in the DOM of the main
+        // index.html file. This allows the app to have access to a set of data
+        // without making any additional remote calls. Good for basic data that is
+        // needed for immediate rendering of the page. Keep in mind, this data,
+        // like all local models and data can be manipulated by the user, so it
+        // should not be relied upon for security or authorization.
+         // Grab the encoded data from the meta tag
+        userConfigEncoded = document.querySelector('head meta[name=app-user-config]').attr('content');
+         // Unescape the text, then parse the resulting JSON into a real object
+        userConfig = JSON.parse(unescape(userConfigEncoded));
+         // Lookup the store
+        store = application.lookup('service:store');
+         // Push the encoded JSON into the store
+        store.pushPayload(userConfig);
+    }
+     export default {
+      name: 'named-instance-initializer',
+      initialize
+    };
+    ```
+     @method instanceInitializer
+    @param instanceInitializer
+    @public
+  */
+  static instanceInitializer = buildInitializerMethod('instanceInitializers');
+
+  /**
+    This creates a registry with the default Ember naming conventions.
+     It also configures the registry:
+     * registered views are created every time they are looked up (they are
+      not singletons)
+    * registered templates are not factories; the registered value is
+      returned directly.
+    * the router receives the application as its `namespace` property
+    * all controllers receive the router as their `target` and `controllers`
+      properties
+    * all controllers receive the application as their `namespace` property
+    * the application view receives the application controller as its
+      `controller` property
+    * the application view receives the application template as its
+      `defaultTemplate` property
+     @method buildRegistry
+    @static
+    @param {Application} namespace the application for which to
+      build the registry
+    @return {Ember.Registry} the built registry
+    @private
+  */
+  static buildRegistry(namespace) {
+    let registry = new Registry({
+      resolver: resolverFor(namespace)
+    });
+    registry.set = set;
+    registry.register('application:main', namespace, {
+      instantiate: false
+    });
+    commonSetupRegistry(registry);
+    setupEngineRegistry(registry);
+    return registry;
+  }
+
+  /**
+    Set this to provide an alternate class to `DefaultResolver`
+     @property resolver
+    @public
+  */
+
+  init(properties) {
+    super.init(properties);
+    this.buildRegistry();
+  }
+
+  /**
+    A private flag indicating whether an engine's initializers have run yet.
+     @private
+    @property _initializersRan
+  */
+  _initializersRan = false;
+
+  /**
+    Ensure that initializers are run once, and only once, per engine.
+     @private
+    @method ensureInitializers
+  */
+  ensureInitializers() {
+    if (!this._initializersRan) {
+      this.runInitializers();
+      this._initializersRan = true;
+    }
+  }
+
+  /**
+    Create an EngineInstance for this engine.
+     @public
+    @method buildInstance
+    @return {EngineInstance} the engine instance
+  */
+  buildInstance(options = {}) {
+    this.ensureInitializers();
+    return EngineInstance.create({
+      ...options,
+      base: this
+    });
+  }
+
+  /**
+    Build and configure the registry for the current engine.
+     @private
+    @method buildRegistry
+    @return {Ember.Registry} the configured registry
+  */
+  buildRegistry() {
+    let registry = this.__registry__ = this.constructor.buildRegistry(this);
+    return registry;
+  }
+
+  /**
+    @private
+    @method initializer
+  */
+  initializer(initializer) {
+    this.constructor.initializer(initializer);
+  }
+
+  /**
+    @private
+    @method instanceInitializer
+  */
+  instanceInitializer(initializer) {
+    this.constructor.instanceInitializer(initializer);
+  }
+
+  /**
+    @private
+    @method runInitializers
+  */
+  runInitializers() {
+    this._runInitializer('initializers', (name, initializer) => {
+      initializer.initialize(this);
+    });
+  }
+
+  /**
+    @private
+    @since 1.12.0
+    @method runInstanceInitializers
+  */
+  runInstanceInitializers(instance) {
+    this._runInitializer('instanceInitializers', (name, initializer) => {
+      initializer.initialize(instance);
+    });
+  }
+  _runInitializer(bucketName, cb) {
+    let initializersByName = get(this.constructor, bucketName);
+    let initializers = props(initializersByName);
+    let graph = new DAG();
+    let initializer;
+    for (let name of initializers) {
+      initializer = initializersByName[name];
+      graph.add(initializer.name, initializer, initializer.before, initializer.after);
+    }
+    graph.topsort(cb);
+  }
+}
+
+/**
+  This function defines the default lookup rules for container lookups:
+
+  * templates are looked up on `Ember.TEMPLATES`
+  * other names are looked up on the application after classifying the name.
+    For example, `controller:post` looks up `App.PostController` by default.
+  * if the default lookup fails, look for registered classes on the container
+
+  This allows the application to register default injections in the container
+  that could be overridden by the normal naming convention.
+
+  @private
+  @method resolverFor
+  @param {Ember.Enginer} namespace the namespace to look for classes
+  @return {*} the resolved value for a given lookup
+*/
+function resolverFor(namespace) {
+  let ResolverClass = namespace.Resolver;
+  let props = {
+    namespace
+  };
+  return ResolverClass.create(props);
+}
+
+/** @internal */
+function buildInitializerMethod(bucketName, humanName) {
+  return function (initializer) {
+    // If this is the first initializer being added to a subclass, we are going to reopen the class
+    // to make sure we have a new `initializers` object, which extends from the parent class' using
+    // prototypal inheritance. Without this, attempting to add initializers to the subclass would
+    // pollute the parent class as well as other subclasses.
+    // SAFETY: The superclass may be an Engine, we don't call unless we confirmed it was ok.
+    let superclass = this.superclass;
+    if (superclass[bucketName] !== undefined && superclass[bucketName] === this[bucketName]) {
+      let attrs = {
+        [bucketName]: Object.create(this[bucketName])
+      };
+      this.reopenClass(attrs);
+    }
+    let initializers = this[bucketName];
+    initializers[initializer.name] = initializer;
+  };
+}
+function commonSetupRegistry(registry) {
+  registry.optionsForType('component', {
+    singleton: false
+  });
+  registry.optionsForType('view', {
+    singleton: false
+  });
+  registry.register('controller:basic', Controller, {
+    instantiate: false
+  });
+
+  // Register the routing service...
+  registry.register('service:-routing', RoutingService);
+
+  // DEBUGGING
+  registry.register('resolver-for-debugging:main', registry.resolver, {
+    instantiate: false
+  });
+  registry.register('container-debug-adapter:main', ContainerDebugAdapter);
+  registry.register('component-lookup:main', ComponentLookup);
+}
+
+export { buildInitializerMethod, Engine as default };

package/dist/{packages → prod/packages}/@ember/engine/instance.js

@@ -7,19 +7,36 @@ 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';
-import '../debug/index.js';
-import { R as Registry, p as privatize } from '../../shared-chunks/registry-XY5cfmbH.js';
-import { g as guidFor } from '../../shared-chunks/mandatory-setter-DLKyVs4Q.js';
-import { isDevelopingApp } from '@embroider/macros';
-import { ENGINE_PARENT, getEngineParent, setEngineParent } from './lib/engine-parent.js';
-import { isFactory } from '../-internals/owner/index.js';
-import { assert } from '../debug/lib/assert.js';
+import '../-internals/environment/index.js';
+import { Registry, privatize } from '../-internals/container/index.js';
+import { g as guidFor } from '../../shared-chunks/super-Cm_a_cLQ.js';
+import { ENGINE_PARENT, setEngineParent, getEngineParent } from './lib/engine-parent.js';
 import { R as RSVP } from '../../shared-chunks/rsvp-CnCSY930.js';
 
 /**
 @module @ember/engine
 */
 
+
+/**
+  The `EngineInstance` encapsulates all of the stateful aspects of a
+  running `Engine`.
+
+  @public
+  @class EngineInstance
+  @extends EmberObject
+  @uses RegistryProxyMixin
+  @uses ContainerProxyMixin
+*/
+
+// Note on types: since `EngineInstance` uses `RegistryProxyMixin` and
+// `ContainerProxyMixin`, which respectively implement the same `RegistryMixin`
+// and `ContainerMixin` types used to define `InternalOwner`, this is the same
+// type as `InternalOwner` from TS's POV. The point of the explicit `extends`
+// clauses for `InternalOwner` and `Owner` is to keep us honest: if this stops
+// type checking, we have broken part of our public API contract. Medium-term,
+// the goal here is to `EngineInstance` simple be `Owner`.
+
 class EngineInstance extends EmberObject.extend(RegistryProxyMixin, ContainerProxyMixin) {
   /**
    @private
@@ -97,7 +114,6 @@ class EngineInstance extends EmberObject.extend(RegistryProxyMixin, ContainerPro
     if (this._booted) {
       return this;
     }
-    (isDevelopingApp() && !(getEngineParent(this)) && assert("An engine instance's parent must be set via `setEngineParent(engine, parent)` prior to calling `engine.boot()`.", getEngineParent(this)));
     this.cloneParentDependencies();
     this.setupRegistry(options);
     this.base.runInstanceInitializers(this);
@@ -150,11 +166,9 @@ class EngineInstance extends EmberObject.extend(RegistryProxyMixin, ContainerPro
   */
   cloneParentDependencies() {
     const parent = getEngineParent(this);
-    (isDevelopingApp() && !(parent) && assert('expected parent', parent));
     let registrations = ['route:basic', 'service:-routing'];
     registrations.forEach(key => {
       let registration = parent.resolveRegistration(key);
-      (isDevelopingApp() && !(isFactory(registration)) && assert('expected registration to be a factory', isFactory(registration)));
       this.register(key, registration);
     });
     let env = parent.lookup('-environment:main');

package/dist/prod/packages/@ember/engine/lib/engine-parent.js

@@ -0,0 +1,33 @@
+/**
+@module @ember/engine
+*/
+
+const ENGINE_PARENT = Symbol('ENGINE_PARENT');
+
+/**
+  `getEngineParent` retrieves an engine instance's parent instance.
+
+  @method getEngineParent
+  @param {EngineInstance} engine An engine instance.
+  @return {EngineInstance} The parent engine instance.
+  @for @ember/engine
+  @static
+  @private
+*/
+function getEngineParent(engine) {
+  return engine[ENGINE_PARENT];
+}
+
+/**
+  `setEngineParent` sets an engine instance's parent instance.
+
+  @method setEngineParent
+  @param {EngineInstance} engine An engine instance.
+  @param {EngineInstance} parent The parent engine instance.
+  @private
+*/
+function setEngineParent(engine, parent) {
+  engine[ENGINE_PARENT] = parent;
+}
+
+export { ENGINE_PARENT, getEngineParent, setEngineParent };

package/dist/prod/packages/@ember/engine/parent.js

@@ -0,0 +1 @@
+export { ENGINE_PARENT, getEngineParent, setEngineParent } from './lib/engine-parent.js';

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

@@ -0,0 +1,20 @@
+import Mixin from '../object/mixin.js';
+
+/**
+@module @ember/enumerable
+@private
+*/
+
+/**
+  The methods in this mixin have been moved to [MutableArray](/ember/release/classes/MutableArray). This mixin has
+  been intentionally preserved to avoid breaking Enumerable.detect checks
+  until the community migrates away from them.
+
+  @class Enumerable
+  @private
+*/
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+const Enumerable = Mixin.create();
+
+export { Enumerable as default };

package/dist/prod/packages/@ember/enumerable/mutable.js

@@ -0,0 +1,22 @@
+import Enumerable from './index.js';
+import Mixin from '../object/mixin.js';
+
+/**
+@module ember
+*/
+
+/**
+  The methods in this mixin have been moved to MutableArray. This mixin has
+  been intentionally preserved to avoid breaking MutableEnumerable.detect
+  checks until the community migrates away from them.
+
+  @class MutableEnumerable
+  @namespace Ember
+  @uses Enumerable
+  @private
+*/
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+const MutableEnumerable = Mixin.create(Enumerable);
+
+export { MutableEnumerable as default };