ember-source 6.12.0 → 7.0.0-alpha.1

package/dist/prod/packages/@ember/-internals/owner/index.js

@@ -0,0 +1,252 @@
+import { getOwner as getOwner$1, setOwner as setOwner$1 } from '../../../@glimmer/owner/index.js';
+
+/**
+  @module @ember/owner
+ */
+
+/**
+  The name for a factory consists of a namespace and the name of a specific type
+  within that namespace, like `'service:session'`.
+
+  **Note:** `FullName` is *not* a class, just a contract for strings used in the
+  DI system. It is currently documented as a class only due to limits in our
+  documentation infrastructure.
+
+  @for @ember/owner
+  @class FullName
+  @public
+ */
+
+/**
+  A type registry for the DI system, which other participants in the DI system
+  can register themselves into with declaration merging. The contract for this
+  type is that its keys are the `Type` from a `FullName`, and each value for a
+  `Type` is another registry whose keys are the `Name` from a `FullName`. The
+  mechanic for providing a registry is [declaration merging][handbook].
+
+  [handbook]: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
+
+  For example, Ember's `@ember/service` module includes this set of definitions:
+
+  ```ts
+  export default class Service extends EmberObject {}
+
+  // For concrete singleton classes to be merged into.
+  interface Registry extends Record<string, Service> {}
+
+  declare module '@ember/owner' {
+    service: Registry;
+  }
+  ```
+
+  Declarations of services can then include the registry:
+
+  ```ts
+  import Service from '@ember/service';
+
+  export default class Session extends Service {
+    login(username: string, password: string) {
+      // ...
+    }
+  }
+
+  declare module '@ember/service' {
+    interface Registry {
+      session: Session;
+    }
+  }
+  ```
+
+  Then users of the `Owner` API will be able to do things like this with strong
+  type safety guarantees:
+
+  ```ts
+  getOwner(this)?.lookup('service:session').login("hello", "1234abcd");
+  ```
+
+  @for @ember/owner
+  @private
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+// Convenience utility for pulling a specific factory manager off `DIRegistry`
+// if one exists, or falling back to the default definition otherwise.
+/**
+  @private
+ */
+
+/**
+  The common interface for the ability to `register()` an item, shared by the
+  `Owner` and `RegistryProxy` interfaces.
+
+  @for @ember/owner
+  @class BasicRegistry
+  @private
+ */
+
+/**
+  The common interface for the ability to `lookup()` or get the `factoryFor` an
+  item, shared by the `Owner` and `ContainerProxy` interfaces.
+
+  @for @ember/owner
+  @class BasicContainer
+  @private
+ */
+
+/**
+  Framework objects in an Ember application (components, services, routes,
+  etc.) are created via a factory and dependency injection system. Each of
+  these objects is the responsibility of an "owner", which handles its
+  instantiation and manages its lifetime.
+
+  An `Owner` is not a class you construct; it is one the framework constructs
+  for you. The normal way to get access to the relevant `Owner` is using the
+  `getOwner` function.
+
+  @for @ember/owner
+  @uses BasicRegistry
+  @uses BasicContainer
+  @class Owner
+  @since 4.10.0
+  @public
+ */
+
+/**
+ * Interface representing the options for registering an item as a factory.
+ *
+ * @for @ember/owner
+ * @class RegisterOptions
+ * @public
+ */
+
+/**
+  Registered factories are instantiated by having create called on them.
+  Additionally they are singletons by default, so each time they are looked up
+  they return the same instance.
+
+  However, that behavior can be modified with the `instantiate` and `singleton`
+  options to the `Owner.register()` method.
+
+  @for @ember/owner
+  @class Factory
+  @since 4.10.0
+  @public
+ */
+
+/**
+  The interface representing a manager which can be used for introspection of
+  the factory's class or for the creation of factory instances with initial
+  properties. The manager is an object with the following properties:
+
+  - `class` - The registered or resolved class.
+  - `create` - A function that will create an instance of the class with any
+  dependencies injected.
+
+  **Note:** `FactoryManager` is *not* user-constructible; the only legal way
+  to get a `FactoryManager` is via `Owner.factoryFor`.
+
+  @for @ember/owner
+  @class FactoryManager
+  @extends Factory
+  @public
+ */
+
+/**
+ * A record mapping all known items of a given type: if the item is known it
+ * will be `true`; otherwise it will be `false` or `undefined`.
+ */
+
+/**
+  A `Resolver` is the mechanism responsible for looking up code in your
+  application and converting its naming conventions into the actual classes,
+  functions, and templates that Ember needs to resolve its dependencies, for
+  example, what template to render for a given route. It is a system that helps
+  the app resolve the lookup of JavaScript modules agnostic of what kind of
+  module system is used, which can be AMD, CommonJS or just plain globals. It
+  is used to lookup routes, models, components, templates, or anything that is
+  used in your Ember app.
+
+  This interface is not a concrete class; instead, it represents the contract a
+  custom resolver must implement. Most apps never need to think about this: in
+  the default blueprint, this is supplied by the `ember-resolver` package.
+
+  @for @ember/owner
+  @class Resolver
+  @since 4.10.0
+  @public
+ */
+
+/**
+  The internal representation of a `Factory`, for the extra detail available for
+  private use internally than we expose to consumers.
+
+  @for @ember/owner
+  @class InternalFactory
+  @private
+ */
+
+/**
+  @private
+  @method isFactory
+  @param {Object} obj
+  @return {Boolean}
+  @static
+ */
+function isFactory(obj) {
+  return obj != null && typeof obj.create === 'function';
+}
+
+// NOTE: For docs, see the definition at the public API site in `@ember/owner`;
+// we document it there for the sake of public API docs and for TS consumption,
+// while having the richer `InternalOwner` representation for Ember itself.
+function getOwner(object) {
+  // SAFETY: this is a convention. From the glimmer perspective, the owner really can be any object.
+  return getOwner$1(object);
+}
+
+/**
+  `setOwner` forces a new owner on a given object instance. This is primarily
+  useful in some testing cases.
+
+  @method setOwner
+  @static
+  @for @ember/owner
+  @param {Object} object An object instance.
+  @param {Owner} object The new owner object of the object instance.
+  @since 2.3.0
+  @public
+*/
+function setOwner(object, owner) {
+  setOwner$1(object, owner);
+}
+
+// Defines the type for the ContainerProxyMixin. When we rationalize our Owner
+// *not* to work via mixins, we will be able to delete this entirely, in favor
+// of just using the Owner class itself.
+/**
+ * The interface for a container proxy, which is itself a private API used
+ * by the private `ContainerProxyMixin` as part of the base definition of
+ * `EngineInstance`.
+ *
+ * @class ContainerProxy
+ * @for @ember/owner
+ * @private
+ * @extends BasicContainer
+ */
+
+/**
+ * @class RegistryProxy
+ * @extends BasicRegistry
+ * @private
+ * @for @ember/owner
+ */
+
+/**
+ * @internal This is the same basic interface which is implemented (via the
+ *   mixins) by `EngineInstance` and therefore `ApplicationInstance`, which are
+ *   the normal interfaces to an `Owner` for end user applications now. However,
+ *   going forward, we expect to progressively deprecate and remove the "extra"
+ *   APIs which are not exposed on `Owner` itself.
+ */
+
+export { getOwner, isFactory, setOwner };

package/dist/prod/packages/@ember/-internals/routing/index.js

@@ -0,0 +1,14 @@
+import '../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../environment/index.js';
+import '../../../@glimmer/validator/index.js';
+import '../../../shared-chunks/reference-BNqcwZWH.js';
+import '../../../shared-chunks/capabilities-DGmQ_mz4.js';
+import '../../../shared-chunks/observers-R1ZklwWy.js';
+import '../../engine/instance.js';
+import '../../../route-recognizer/index.js';
+import '../../../shared-chunks/rsvp-CnCSY930.js';
+import '../../../shared-chunks/unrecognized-url-error-DDBwfzdm.js';
+import '../../routing/lib/routing-service.js';
+export { default as generateController, generateControllerFactory } from '../../routing/lib/generate_controller.js';
+export { default as RouterDSL } from '../../routing/lib/dsl.js';
+export { default as controllerFor } from '../../routing/lib/controller_for.js';

package/dist/prod/packages/@ember/-internals/runtime/index.js

@@ -0,0 +1,9 @@
+export { default as RegistryProxyMixin } from './lib/mixins/registry_proxy.js';
+export { default as ContainerProxyMixin } from './lib/mixins/container_proxy.js';
+export { default as Comparable } from './lib/mixins/comparable.js';
+export { default as ActionHandler } from './lib/mixins/action_handler.js';
+export { default as _ProxyMixin, contentFor as _contentFor } from './lib/mixins/-proxy.js';
+export { default as MutableEnumerable } from '../../enumerable/mutable.js';
+export { default as TargetActionSupport } from './lib/mixins/target_action_support.js';
+export { onerrorDefault } from './lib/ext/rsvp.js';
+export { R as RSVP } from '../../../shared-chunks/rsvp-CnCSY930.js';

package/dist/prod/packages/@ember/-internals/runtime/lib/ext/rsvp.js

@@ -0,0 +1,51 @@
+import { c as configure, o as on, R as RSVP } from '../../../../../shared-chunks/rsvp-CnCSY930.js';
+import { _backburner, _rsvpErrorQueue } from '../../../../runloop/index.js';
+import { getDispatchOverride } from '../../../error-handling/index.js';
+import '../../../environment/index.js';
+
+configure('async', (callback, promise) => {
+  _backburner.schedule('actions', null, callback, promise);
+});
+configure('after', cb => {
+  _backburner.schedule(_rsvpErrorQueue, null, cb);
+});
+on('error', onerrorDefault);
+function onerrorDefault(reason) {
+  let error = errorFor(reason);
+  if (error) {
+    let overrideDispatch = getDispatchOverride();
+    if (overrideDispatch) {
+      overrideDispatch(error);
+    } else {
+      throw error;
+    }
+  }
+}
+function errorFor(reason) {
+  if (!reason) return;
+  let withErrorThrown = reason;
+  if (withErrorThrown.errorThrown) {
+    return unwrapErrorThrown(withErrorThrown);
+  }
+  let withName = reason;
+  if (withName.name === 'UnrecognizedURLError') {
+    return;
+  }
+  if (reason.name === 'TransitionAborted') {
+    return;
+  }
+  return reason;
+}
+function unwrapErrorThrown(reason) {
+  let error = reason.errorThrown;
+  if (typeof error === 'string') {
+    error = new Error(error);
+  }
+  Object.defineProperty(error, '__reason_with_error_thrown__', {
+    value: reason,
+    enumerable: false
+  });
+  return error;
+}
+
+export { RSVP as default, onerrorDefault };

package/dist/prod/packages/@ember/-internals/runtime/lib/mixins/-proxy.js

@@ -0,0 +1,89 @@
+import { meta } from '../../../meta/lib/meta.js';
+import Mixin from '../../../../object/mixin.js';
+import { d as defineProperty, c as computed } from '../../../../../shared-chunks/namespace_search-Aog9nySA.js';
+import '../../../environment/index.js';
+import { updateTag as UPDATE_TAG, tagMetaFor, tagFor, combine } from '../../../../../@glimmer/validator/index.js';
+import { i as isObject } from '../../../../../shared-chunks/super-Cm_a_cLQ.js';
+import { s as setProxy } from '../../../../../shared-chunks/is_proxy-Cr1qlMv_.js';
+import { g as get, t as tagForObject, a as tagForProperty } from '../../../../../shared-chunks/observers-R1ZklwWy.js';
+import { s as set } from '../../../../../shared-chunks/property_set-O080KTKZ.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
+*/
+
+function contentFor(proxy) {
+  let content = get(proxy, 'content');
+  // SAFETY: Ideally we'd assert instead of casting, but @glimmer/validator doesn't give us
+  // sufficient public types for this. Previously this code was .js and worked correctly so
+  // hopefully this is sufficiently reliable.
+  UPDATE_TAG(tagForObject(proxy), tagForObject(content));
+  return content;
+}
+function customTagForProxy(proxy, key, addMandatorySetter) {
+  let meta = tagMetaFor(proxy);
+  let tag = tagFor(proxy, key, meta);
+  if (key in proxy) {
+    return tag;
+  } else {
+    let tags = [tag, tagFor(proxy, 'content', meta)];
+    let content = contentFor(proxy);
+    if (isObject(content)) {
+      tags.push(tagForProperty(content, key, addMandatorySetter));
+    }
+    return combine(tags);
+  }
+}
+
+/**
+  `ProxyMixin` forwards all properties not defined by the proxy itself
+  to a proxied `content` object.  See ObjectProxy for more details.
+
+  @class ProxyMixin
+  @namespace Ember
+  @private
+*/
+
+const ProxyMixin = Mixin.create({
+  /**
+    The object whose properties will be forwarded.
+     @property content
+    @type {unknown}
+    @default null
+    @public
+  */
+  content: null,
+  init() {
+    this._super(...arguments);
+    setProxy(this);
+    tagForObject(this);
+    setCustomTagFor(this, customTagForProxy);
+  },
+  willDestroy() {
+    this.set('content', null);
+    this._super(...arguments);
+  },
+  isTruthy: computed('content', function () {
+    return Boolean(get(this, 'content'));
+  }),
+  unknownProperty(key) {
+    let content = contentFor(this);
+    return content ? get(content, key) : undefined;
+  },
+  setUnknownProperty(key, value) {
+    let m = meta(this);
+    if (m.isInitializing() || m.isPrototypeMeta(this)) {
+      // if marked as prototype or object is initializing then just
+      // defineProperty rather than delegate
+      defineProperty(this, key, null, value);
+      return value;
+    }
+    let content = contentFor(this);
+    return set(content, key, value);
+  }
+});
+
+export { contentFor, ProxyMixin as default };

package/dist/prod/packages/@ember/-internals/runtime/lib/mixins/action_handler.js

@@ -0,0 +1,187 @@
+import Mixin from '../../../../object/mixin.js';
+import '../../../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../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';
+
+/**
+@module ember
+*/
+
+
+/**
+  `ActionHandler` is available on some familiar classes including
+  `Route`, `Component`, and `Controller`.
+  (Internally the mixin is used by `CoreView`, `ControllerMixin`,
+  and `Route` and available to the above classes through
+  inheritance.)
+
+  @class ActionHandler
+  @namespace Ember
+  @private
+*/
+
+const ActionHandler = Mixin.create({
+  mergedProperties: ['actions'],
+  /**
+    The collection of functions, keyed by name, available on this
+    `ActionHandler` as action targets.
+     These functions will be invoked when a matching `{{action}}` is triggered
+    from within a template and the application's current route is this route.
+     Actions can also be invoked from other parts of your application
+    via `ActionHandler#send`.
+     The `actions` hash will inherit action handlers from
+    the `actions` hash defined on extended parent classes
+    or mixins rather than just replace the entire hash, e.g.:
+     ```app/mixins/can-display-banner.js
+    import Mixin from '@ember/object/mixin';
+     export default Mixin.create({
+      actions: {
+        displayBanner(msg) {
+          // ...
+        }
+      }
+    });
+    ```
+     ```app/routes/welcome.js
+    import Route from '@ember/routing/route';
+    import CanDisplayBanner from '../mixins/can-display-banner';
+     export default Route.extend(CanDisplayBanner, {
+      actions: {
+        playMusic() {
+          // ...
+        }
+      }
+    });
+     // `WelcomeRoute`, when active, will be able to respond
+    // to both actions, since the actions hash is merged rather
+    // then replaced when extending mixins / parent classes.
+    this.send('displayBanner');
+    this.send('playMusic');
+    ```
+     Within a Controller, Route or Component's action handler,
+    the value of the `this` context is the Controller, Route or
+    Component object:
+     ```app/routes/song.js
+    import Route from '@ember/routing/route';
+     export default Route.extend({
+      actions: {
+        myAction() {
+          this.controllerFor("song");
+          this.transitionTo("other.route");
+          ...
+        }
+      }
+    });
+    ```
+     It is also possible to call `this._super(...arguments)` from within an
+    action handler if it overrides a handler defined on a parent
+    class or mixin:
+     Take for example the following routes:
+     ```app/mixins/debug-route.js
+    import Mixin from '@ember/object/mixin';
+     export default Mixin.create({
+      actions: {
+        debugRouteInformation() {
+          console.debug("It's a-me, console.debug!");
+        }
+      }
+    });
+    ```
+     ```app/routes/annoying-debug.js
+    import Route from '@ember/routing/route';
+    import DebugRoute from '../mixins/debug-route';
+     export default Route.extend(DebugRoute, {
+      actions: {
+        debugRouteInformation() {
+          // also call the debugRouteInformation of mixed in DebugRoute
+          this._super(...arguments);
+           // show additional annoyance
+          window.alert(...);
+        }
+      }
+    });
+    ```
+     ## Bubbling
+     By default, an action will stop bubbling once a handler defined
+    on the `actions` hash handles it. To continue bubbling the action,
+    you must return `true` from the handler:
+     ```app/router.js
+    Router.map(function() {
+      this.route("album", function() {
+        this.route("song");
+      });
+    });
+    ```
+     ```app/routes/album.js
+    import Route from '@ember/routing/route';
+     export default Route.extend({
+      actions: {
+        startPlaying: function() {
+        }
+      }
+    });
+    ```
+     ```app/routes/album-song.js
+    import Route from '@ember/routing/route';
+     export default Route.extend({
+      actions: {
+        startPlaying() {
+          // ...
+           if (actionShouldAlsoBeTriggeredOnParentRoute) {
+            return true;
+          }
+        }
+      }
+    });
+    ```
+     @property actions
+    @type Object
+    @default null
+    @public
+  */
+
+  /**
+    Triggers a named action on the `ActionHandler`. Any parameters
+    supplied after the `actionName` string will be passed as arguments
+    to the action target function.
+     If the `ActionHandler` has its `target` property set, actions may
+    bubble to the `target`. Bubbling happens when an `actionName` can
+    not be found in the `ActionHandler`'s `actions` hash or if the
+    action target function returns `true`.
+     Example
+     ```app/routes/welcome.js
+    import Route from '@ember/routing/route';
+     export default Route.extend({
+      actions: {
+        playTheme() {
+          this.send('playMusic', 'theme.mp3');
+        },
+        playMusic(track) {
+          // ...
+        }
+      }
+    });
+    ```
+     @method send
+    @param {String} actionName The action to trigger
+    @param {*} context a context to send with the action
+    @public
+  */
+  send(actionName, ...args) {
+    if (this.actions && this.actions[actionName]) {
+      let shouldBubble = this.actions[actionName].apply(this, args) === true;
+      if (!shouldBubble) {
+        return;
+      }
+    }
+    let target = get(this, 'target');
+    if (target) {
+      target.send(...arguments);
+    }
+  }
+});
+
+export { ActionHandler as default };

package/dist/prod/packages/@ember/-internals/runtime/lib/mixins/comparable.js

@@ -0,0 +1,37 @@
+import Mixin from '../../../../object/mixin.js';
+
+/**
+@module ember
+*/
+
+/**
+  Implements some standard methods for comparing objects. Add this mixin to
+  any class you create that can compare its instances.
+
+  You should implement the `compare()` method.
+
+  @class Comparable
+  @namespace Ember
+  @since Ember 0.9
+  @private
+*/
+
+const Comparable = Mixin.create({
+  /**
+    __Required.__ You must implement this method to apply this mixin.
+     Override to return the result of the comparison of the two parameters. The
+    compare method should return:
+     - `-1` if `a < b`
+    - `0` if `a == b`
+    - `1` if `a > b`
+     Default implementation raises an exception.
+     @method compare
+    @param a {Object} the first object to compare
+    @param b {Object} the second object to compare
+    @return {Number} the result of the comparison
+    @private
+  */
+  compare: null
+});
+
+export { Comparable as default };

package/dist/prod/packages/@ember/-internals/runtime/lib/mixins/container_proxy.js

@@ -0,0 +1,44 @@
+import { join, schedule } from '../../../../runloop/index.js';
+import Mixin from '../../../../object/mixin.js';
+
+// This is defined as a separate interface so that it can be used in the definition of
+// `Owner` without also including the `__container__` property.
+
+/**
+  ContainerProxyMixin is used to provide public access to specific
+  container functionality.
+
+  @class ContainerProxyMixin
+  @extends ContainerProxy
+  @private
+*/
+
+const ContainerProxyMixin = Mixin.create({
+  /**
+   The container stores state.
+    @private
+   @property {Ember.Container} __container__
+   */
+  __container__: null,
+  ownerInjection() {
+    return this.__container__.ownerInjection();
+  },
+  lookup(fullName, options) {
+    return this.__container__.lookup(fullName, options);
+  },
+  destroy() {
+    let container = this.__container__;
+    if (container) {
+      join(() => {
+        container.destroy();
+        schedule('destroy', container, 'finalizeDestroy');
+      });
+    }
+    this._super();
+  },
+  factoryFor(fullName) {
+    return this.__container__.factoryFor(fullName);
+  }
+});
+
+export { ContainerProxyMixin as default };