ember-source 4.4.0-alpha.1 → 4.4.0-alpha.4

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

@@ -9,8 +9,9 @@ import { untrack, consumeTag, createCache, getValue, tagFor, beginUntrackFrame,
 import { tracked, get, PROPERTY_DID_CHANGE, tagForObject, objectAt, tagForProperty, set, _getProp, _setProp } from '@ember/-internals/metal';
 import { action } from '@ember/object';
 import { hasDOM } from '@ember/-internals/browser-environment';
-import { isSimpleClick, clearElementView, clearViewElement, getViewElement, MUTABLE_CELL, addChildView, setElementView, setViewElement, ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, ViewMixin, ViewStateSupport, constructStyleDeprecationMessage, ActionManager, getViewId } from '@ember/-internals/views';
+import { isSimpleClick, clearElementView, clearViewElement, getViewElement, MUTABLE_CELL, addChildView, setElementView, setViewElement, ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, EventDispatcher, ViewMixin, ViewStateSupport, constructStyleDeprecationMessage, ActionManager, getViewId } from '@ember/-internals/views';
 import { getEngineParent } from '@ember/engine';
+import EngineInstance from '@ember/engine/instance';
 import { flaggedInstrument, _instrumentStart } from '@ember/instrumentation';
 import { service } from '@ember/service';
 import { DEBUG } from '@glimmer/env';
@@ -299,7 +300,7 @@ class ForkedValue {
 class AbstractInput extends InternalComponent {
   constructor() {
     super(...arguments);
-    this._value = valueFrom(this.args.named.value);
+    this._value = valueFrom(this.args.named['value']);
   }
 
   validateArguments() {
@@ -554,7 +555,7 @@ if (hasDOM) {
 class Input extends AbstractInput {
   constructor() {
     super(...arguments);
-    this._checked = valueFrom(this.args.named.checked);
+    this._checked = valueFrom(this.args.named['checked']);
   }
 
   static toString() {
@@ -594,7 +595,7 @@ class Input extends AbstractInput {
 
   get checked() {
     if (this.isCheckbox) {
-      warn('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', untrack(() => this.args.named.checked !== undefined || this.args.named.value === undefined || typeof valueForRef(this.args.named.value) === 'string'), {
+      warn('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', untrack(() => this.args.named['checked'] !== undefined || this.args.named['value'] === undefined || typeof valueForRef(this.args.named['value']) === 'string'), {
         id: 'ember.built-in-components.input-checkbox-value'
       });
       return this._checked.get();
@@ -604,7 +605,7 @@ class Input extends AbstractInput {
   }
 
   set checked(checked) {
-    warn('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', untrack(() => this.args.named.checked !== undefined || this.args.named.value === undefined || typeof valueForRef(this.args.named.value) === 'string'), {
+    warn('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', untrack(() => this.args.named['checked'] !== undefined || this.args.named['value'] === undefined || typeof valueForRef(this.args.named['value']) === 'string'), {
       id: 'ember.built-in-components.input-checkbox-value'
     });
 
@@ -1099,11 +1100,13 @@ class LinkTo extends InternalComponent {
   }
 
   get isEngine() {
-    return getEngineParent(this.owner) !== undefined;
+    let owner = this.owner;
+    return owner instanceof EngineInstance && getEngineParent(owner) !== undefined;
   }
 
   get engineMountPoint() {
-    return this.owner.mountPoint;
+    let owner = this.owner;
+    return owner instanceof EngineInstance ? owner.mountPoint : undefined;
   }
 
   classFor(state) {
@@ -1895,8 +1898,8 @@ var action$1 = internalHelper(args => {
   let [context, action$$1, ...restArgs] = positional;
   assert('hash position arguments', context && action$$1);
   let debugKey = action$$1.debugLabel;
-  let target = 'target' in named && named.target ? named.target : context;
-  let processArgs = makeArgsProcessor('value' in named && named.value || false, restArgs);
+  let target = 'target' in named ? named['target'] : context;
+  let processArgs = makeArgsProcessor('value' in named && named['value'] || false, restArgs);
   let fn$$1;
 
   if (isInvokableRef(action$$1)) {
@@ -1960,13 +1963,12 @@ function makeClosureAction(context, target, action$$1, processArgs, debugKey) {
   let self;
   let fn$$1;
   assert(`Action passed is null or undefined in (action) from ${target}.`, action$$1 !== undefined && action$$1 !== null);
-  let typeofAction = typeof action$$1;
 
-  if (typeofAction === 'string') {
+  if (typeof action$$1 === 'string') {
     self = target;
     fn$$1 = target.actions && target.actions[action$$1];
     assert(`An action named '${action$$1}' was not found in ${target}`, Boolean(fn$$1));
-  } else if (typeofAction === 'function') {
+  } else if (typeof action$$1 === 'function') {
     self = context;
     fn$$1 = action$$1;
   } else {
@@ -2490,625 +2492,6 @@ function isCurlyManager(manager) {
 }
 
 let lazyEventsProcessed = new WeakMap();
-/**
-@module @ember/component
-*/
-
-/**
-  A component is a reusable UI element that consists of a `.hbs` template and an
-  optional JavaScript class that defines its behavior. For example, someone
-  might make a `button` in the template and handle the click behavior in the
-  JavaScript file that shares the same name as the template.
-
-  Components are broken down into two categories:
-
-  - Components _without_ JavaScript, that are based only on a template. These
-    are called Template-only or TO components.
-  - Components _with_ JavaScript, which consist of a template and a backing
-    class.
-
-  Ember ships with two types of JavaScript classes for components:
-
-  1. Glimmer components, imported from `@glimmer/component`, which are the
-     default component's for Ember Octane (3.15) and more recent editions.
-  2. Classic components, imported from `@ember/component`, which were the
-     default for older editions of Ember (pre 3.15).
-
-  Below is the documentation for Classic components. If you are looking for the
-  API documentation for Template-only or Glimmer components, it is
-  [available here](/ember/release/modules/@glimmer%2Fcomponent).
-
-  ## Defining a Classic Component
-
-  If you want to customize the component in order to handle events, transform
-  arguments or maintain internal state, you implement a subclass of `Component`.
-
-  One example is to add computed properties to your component:
-
-  ```app/components/person-profile.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    displayName: computed('person.title', 'person.firstName', 'person.lastName', function() {
-      let { title, firstName, lastName } = this.person;
-
-      if (title) {
-        return `${title} ${lastName}`;
-      } else {
-        return `${firstName} ${lastName}`;
-      }
-    })
-  });
-  ```
-
-  And then use it in the component's template:
-
-  ```app/templates/components/person-profile.hbs
-  <h1>{{this.displayName}}</h1>
-  {{yield}}
-  ```
-
-  ## Customizing a Classic Component's HTML Element in JavaScript
-
-  ### HTML Tag
-
-  The default HTML tag name used for a component's HTML representation is `div`.
-  This can be customized by setting the `tagName` property.
-
-  Consider the following component class:
-
-  ```app/components/emphasized-paragraph.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'em'
-  });
-  ```
-
-  When invoked, this component would produce output that looks something like
-  this:
-
-  ```html
-  <em id="ember1" class="ember-view"></em>
-  ```
-
-  ### HTML `class` Attribute
-
-  The HTML `class` attribute of a component's tag can be set by providing a
-  `classNames` property that is set to an array of strings:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNames: ['my-class', 'my-other-class']
-  });
-  ```
-
-  Invoking this component will produce output that looks like this:
-
-  ```html
-  <div id="ember1" class="ember-view my-class my-other-class"></div>
-  ```
-
-  `class` attribute values can also be set by providing a `classNameBindings`
-  property set to an array of properties names for the component. The return
-  value of these properties will be added as part of the value for the
-  components's `class` attribute. These properties can be computed properties:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-  import { computed } from '@ember/object';
-
-  export default Component.extend({
-    classNames: ['my-class', 'my-other-class'],
-    classNameBindings: ['propertyA', 'propertyB'],
-
-    propertyA: 'from-a',
-    propertyB: computed(function() {
-      if (someLogic) { return 'from-b'; }
-    })
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <div id="ember1" class="ember-view my-class my-other-class from-a from-b"></div>
-  ```
-
-  Note that `classNames` and `classNameBindings` is in addition to the `class`
-  attribute passed with the angle bracket invocation syntax. Therefore, if this
-  component was invoked like so:
-
-  ```handlebars
-  <MyWidget class="from-invocation" />
-  ```
-
-  The resulting HTML will look similar to this:
-
-  ```html
-  <div id="ember1" class="from-invocation ember-view my-class my-other-class from-a from-b"></div>
-  ```
-
-  If the value of a class name binding returns a boolean the property name
-  itself will be used as the class name if the property is true. The class name
-  will not be added if the value is `false` or `undefined`.
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNameBindings: ['hovered'],
-
-    hovered: true
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <div id="ember1" class="ember-view hovered"></div>
-  ```
-
-  ### Custom Class Names for Boolean Values
-
-  When using boolean class name bindings you can supply a string value other
-  than the property name for use as the `class` HTML attribute by appending the
-  preferred value after a ":" character when defining the binding:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNameBindings: ['awesome:so-very-cool'],
-
-    awesome: true
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <div id="ember1" class="ember-view so-very-cool"></div>
-  ```
-
-  Boolean value class name bindings whose property names are in a
-  camelCase-style format will be converted to a dasherized format:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNameBindings: ['isUrgent'],
-
-    isUrgent: true
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <div id="ember1" class="ember-view is-urgent"></div>
-  ```
-
-  Class name bindings can also refer to object values that are found by
-  traversing a path relative to the component itself:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-  import EmberObject from '@ember/object';
-
-  export default Component.extend({
-    classNameBindings: ['messages.empty'],
-
-    messages: EmberObject.create({
-      empty: true
-    })
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <div id="ember1" class="ember-view empty"></div>
-  ```
-
-  If you want to add a class name for a property which evaluates to true and
-  and a different class name if it evaluates to false, you can pass a binding
-  like this:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNameBindings: ['isEnabled:enabled:disabled'],
-    isEnabled: true
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <div id="ember1" class="ember-view enabled"></div>
-  ```
-
-  When isEnabled is `false`, the resulting HTML representation looks like this:
-
-  ```html
-  <div id="ember1" class="ember-view disabled"></div>
-  ```
-
-  This syntax offers the convenience to add a class if a property is `false`:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false
-  export default Component.extend({
-    classNameBindings: ['isEnabled::disabled'],
-    isEnabled: true
-  });
-  ```
-
-  Invoking this component when the `isEnabled` property is true will produce
-  HTML that looks like:
-
-  ```html
-  <div id="ember1" class="ember-view"></div>
-  ```
-
-  Invoking it when the `isEnabled` property on the component is `false` will
-  produce HTML that looks like:
-
-  ```html
-  <div id="ember1" class="ember-view disabled"></div>
-  ```
-
-  Updates to the value of a class name binding will result in automatic update
-  of the  HTML `class` attribute in the component's rendered HTML
-  representation. If the value becomes `false` or `undefined` the class name
-  will be removed.
-
-  Both `classNames` and `classNameBindings` are concatenated properties. See
-  [EmberObject](/ember/release/classes/EmberObject) documentation for more
-  information about concatenated properties.
-
-  ### Other HTML Attributes
-
-  The HTML attribute section of a component's tag can be set by providing an
-  `attributeBindings` property set to an array of property names on the component.
-  The return value of these properties will be used as the value of the component's
-  HTML associated attribute:
-
-  ```app/components/my-anchor.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'a',
-    attributeBindings: ['href'],
-
-    href: 'http://google.com'
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <a id="ember1" class="ember-view" href="http://google.com"></a>
-  ```
-
-  One property can be mapped on to another by placing a ":" between
-  the source property and the destination property:
-
-  ```app/components/my-anchor.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'a',
-    attributeBindings: ['url:href'],
-
-    url: 'http://google.com'
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <a id="ember1" class="ember-view" href="http://google.com"></a>
-  ```
-
-  HTML attributes passed with angle bracket invocations will take precedence
-  over those specified in `attributeBindings`. Therefore, if this component was
-  invoked like so:
-
-  ```handlebars
-  <MyAnchor href="http://bing.com" @url="http://google.com" />
-  ```
-
-  The resulting HTML will looks like this:
-
-  ```html
-  <a id="ember1" class="ember-view" href="http://bing.com"></a>
-  ```
-
-  Note that the `href` attribute is ultimately set to `http://bing.com`,
-  despite it having attribute binidng to the `url` property, which was
-  set to `http://google.com`.
-
-  Namespaced attributes (e.g. `xlink:href`) are supported, but have to be
-  mapped, since `:` is not a valid character for properties in Javascript:
-
-  ```app/components/my-use.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'use',
-    attributeBindings: ['xlinkHref:xlink:href'],
-
-    xlinkHref: '#triangle'
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <use xlink:href="#triangle"></use>
-  ```
-
-  If the value of a property monitored by `attributeBindings` is a boolean, the
-  attribute will be present or absent depending on the value:
-
-  ```app/components/my-text-input.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'input',
-    attributeBindings: ['disabled'],
-
-    disabled: false
-  });
-  ```
-
-  Invoking this component will produce HTML that looks like:
-
-  ```html
-  <input id="ember1" class="ember-view" />
-  ```
-
-  `attributeBindings` can refer to computed properties:
-
-  ```app/components/my-text-input.js
-  import Component from '@ember/component';
-  import { computed } from '@ember/object';
-
-  export default Component.extend({
-    tagName: 'input',
-    attributeBindings: ['disabled'],
-
-    disabled: computed(function() {
-      if (someLogic) {
-        return true;
-      } else {
-        return false;
-      }
-    })
-  });
-  ```
-
-  To prevent setting an attribute altogether, use `null` or `undefined` as the
-  value of the property used in `attributeBindings`:
-
-  ```app/components/my-text-input.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'form',
-    attributeBindings: ['novalidate'],
-    novalidate: null
-  });
-  ```
-
-  Updates to the property of an attribute binding will result in automatic
-  update of the  HTML attribute in the component's HTML output.
-
-  `attributeBindings` is a concatenated property. See
-  [EmberObject](/ember/release/classes/EmberObject) documentation for more
-  information about concatenated properties.
-
-  ## Layouts
-
-  The `layout` property can be used to dynamically specify a template associated
-  with a component class, instead of relying on Ember to link together a
-  component class and a template based on file names.
-
-  In general, applications should not use this feature, but it's commonly used
-  in addons for historical reasons.
-
-  The `layout` property should be set to the default export of a template
-  module, which is the name of a template file without the `.hbs` extension.
-
-  ```app/templates/components/person-profile.hbs
-  <h1>Person's Title</h1>
-  <div class='details'>{{yield}}</div>
-  ```
-
-  ```app/components/person-profile.js
-    import Component from '@ember/component';
-    import layout from '../templates/components/person-profile';
-
-    export default Component.extend({
-      layout
-    });
-  ```
-
-  If you invoke the component:
-
-  ```handlebars
-  <PersonProfile>
-    <h2>Chief Basket Weaver</h2>
-    <h3>Fisherman Industries</h3>
-  </PersonProfile>
-  ```
-
-  or
-
-  ```handlebars
-  {{#person-profile}}
-    <h2>Chief Basket Weaver</h2>
-    <h3>Fisherman Industries</h3>
-  {{/person-profile}}
-  ```
-
-  It will result in the following HTML output:
-
-  ```html
-  <h1>Person's Title</h1>
-    <div class="details">
-    <h2>Chief Basket Weaver</h2>
-    <h3>Fisherman Industries</h3>
-  </div>
-  ```
-
-  ## Handling Browser Events
-
-  Components can respond to user-initiated events in one of three ways: passing
-  actions with angle bracket invocation, adding event handler methods to the
-  component's class, or adding actions to the component's template.
-
-  ### Passing Actions With Angle Bracket Invocation
-
-  For one-off events specific to particular instance of a component, it is possible
-  to pass actions to the component's element using angle bracket invocation syntax.
-
-  ```handlebars
-  <MyWidget {{action 'firstWidgetClicked'}} />
-
-  <MyWidget {{action 'secondWidgetClicked'}} />
-  ```
-
-  In this case, when the first component is clicked on, Ember will invoke the
-  `firstWidgetClicked` action. When the second component is clicked on, Ember
-  will invoke the `secondWidgetClicked` action instead.
-
-  Besides `{{action}}`, it is also possible to pass any arbitrary element modifiers
-  using the angle bracket invocation syntax.
-
-  ### Event Handler Methods
-
-  Components can also respond to user-initiated events by implementing a method
-  that matches the event name. This approach is appropriate when the same event
-  should be handled by all instances of the same component.
-
-  An event object will be passed as the argument to the event handler method.
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    click(event) {
-      // `event.target` is either the component's element or one of its children
-      let tag = event.target.tagName.toLowerCase();
-      console.log('clicked on a `<${tag}>` HTML element!');
-    }
-  });
-  ```
-
-  In this example, whenever the user clicked anywhere inside the component, it
-  will log a message to the console.
-
-  It is possible to handle event types other than `click` by implementing the
-  following event handler methods. In addition, custom events can be registered
-  by using `Application.customEvents`.
-
-  Touch events:
-
-  * `touchStart`
-  * `touchMove`
-  * `touchEnd`
-  * `touchCancel`
-
-  Keyboard events:
-
-  * `keyDown`
-  * `keyUp`
-  * `keyPress`
-
-  Mouse events:
-
-  * `mouseDown`
-  * `mouseUp`
-  * `contextMenu`
-  * `click`
-  * `doubleClick`
-  * `focusIn`
-  * `focusOut`
-
-  Form events:
-
-  * `submit`
-  * `change`
-  * `focusIn`
-  * `focusOut`
-  * `input`
-
-  Drag and drop events:
-
-  * `dragStart`
-  * `drag`
-  * `dragEnter`
-  * `dragLeave`
-  * `dragOver`
-  * `dragEnd`
-  * `drop`
-
-  ### `{{action}}` Helper
-
-  Instead of handling all events of a particular type anywhere inside the
-  component's element, you may instead want to limit it to a particular
-  element in the component's template. In this case, it would be more
-  convenient to implement an action instead.
-
-  For example, you could implement the action `hello` for the `person-profile`
-  component:
-
-  ```app/components/person-profile.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    actions: {
-      hello(name) {
-        console.log("Hello", name);
-      }
-    }
-  });
-  ```
-
-  And then use it in the component's template:
-
-  ```app/templates/components/person-profile.hbs
-  <h1>{{@person.name}}</h1>
-
-  <button {{action 'hello' @person.name}}>
-    Say Hello to {{@person.name}}
-  </button>
-  ```
-
-  When the user clicks the button, Ember will invoke the `hello` action,
-  passing in the current value of `@person.name` as an argument.
-
-  See [Ember.Templates.helpers.action](/ember/release/classes/Ember.Templates.helpers/methods/action?anchor=action).
-
-  @class Component
-  @extends Ember.CoreView
-  @uses Ember.TargetActionSupport
-  @uses Ember.ClassNamesSupport
-  @uses Ember.ActionSupport
-  @uses Ember.ViewMixin
-  @uses Ember.ViewStateSupport
-  @public
-*/
-
 const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassNamesSupport, TargetActionSupport, ActionSupport, ViewMixin, {
   isComponent: true,
 
@@ -3165,6 +2548,7 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
 
       if (owner.lookup('-environment:main').isInteractive) {
         this.__dispatcher = owner.lookup('event_dispatcher:main');
+        assert('Expected dispatcher to be an EventDispatcher', this.__dispatcher instanceof EventDispatcher);
       } else {
         // In FastBoot we have no EventDispatcher. Set to null to not try again to look it up.
         this.__dispatcher = null;
@@ -3414,23 +2798,6 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
    @since 1.13.0
    */
 
-  /**
-    Layout can be used to wrap content in a component.
-    @property layout
-    @type Function
-    @public
-  */
-
-  /**
-    The name of the layout to lookup if no layout is provided.
-    By default `Component` will lookup a template with this name in
-    `Ember.TEMPLATES` (a shared global object).
-    @property layoutName
-    @type String
-    @default null
-    @private
-  */
-
   /**
     The HTML `id` of the component's element in the DOM. You can provide this
     value yourself but it must be unique (just as in HTML):
@@ -3787,11 +3154,9 @@ class OutletComponentManager {
       let currentOwner = valueForRef(currentStateRef).render.owner;
 
       if (parentOwner && parentOwner !== currentOwner) {
-        let engine = currentOwner;
-        assert('invalid engine: missing mountPoint', typeof currentOwner.mountPoint === 'string');
-        assert('invalid engine: missing routable', currentOwner.routable === true);
-        let mountPoint = engine.mountPoint;
-        state.engine = engine;
+        assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EngineInstance);
+        let mountPoint = currentOwner.mountPoint;
+        state.engine = currentOwner;
         state.engineBucket = {
           mountPoint
         };
@@ -4469,7 +3834,7 @@ setGlobalContext({
   },
 
   warnIfStyleNotTrusted(value) {
-    warn(constructStyleDeprecationMessage(value), (() => {
+    warn(constructStyleDeprecationMessage(String(value)), (() => {
       if (value === null || value === undefined || isHTMLSafe$1(value)) {
         return true;
       }
@@ -4557,9 +3922,9 @@ var disallowDynamicResolution = internalHelper(({
 }) => {
   const nameOrValueRef = positional[0];
   assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1 && nameOrValueRef);
-  let typeRef = named.type;
-  let locRef = named.loc;
-  let originalRef = named.original;
+  let typeRef = named['type'];
+  let locRef = named['loc'];
+  let originalRef = named['original'];
   assert(`[BUG] expecting \`type\` named argument`, typeRef);
   assert(`[BUG] expecting \`loc\` named argument`, locRef);
   assert(`[BUG] expecting \`original\` named argument`, originalRef); // Bug: why do these fail?
@@ -4575,7 +3940,7 @@ var disallowDynamicResolution = internalHelper(({
   assert('[BUG] expecting a string literal for the `original` argument', typeof original === 'string');
   return createComputeRef(() => {
     let nameOrValue = valueForRef(nameOrValueRef);
-    assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them to the ${type} keyword. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string');
+    assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them directly. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string');
     return nameOrValue;
   });
 });
@@ -4933,6 +4298,25 @@ var unbound = internalHelper(({
   return createUnboundRef(valueForRef(positional[0]), '(result of an `unbound` helper)');
 });
 
+/**
+@module ember
+*/
+internalHelper(() => {
+  return createConstRef(uniqueId$1(), 'unique-id');
+}); // From https://gist.github.com/selfish/fef2c0ba6cdfe07af76e64cecd74888b
+//
+// This code should be reasonably fast, and provide a unique value every time
+// it's called, which is what we need here. It produces a string formatted as a
+// standard UUID, which avoids accidentally turning Ember-specific
+// implementation details into an intimate API.
+
+function uniqueId$1() {
+  // @ts-expect-error this one-liner abuses weird JavaScript semantics that
+  // TypeScript (legitimately) doesn't like, but they're nonetheless valid and
+  // specced.
+  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, a => (a ^ Math.random() * 16 >> a / 4).toString(16));
+}
+
 const MODIFIERS = ['alt', 'shift', 'meta', 'ctrl'];
 const POINTER_EVENT_TYPE_REGEX = /^click|mouse|touch/;
 
@@ -5165,6 +4549,7 @@ class ActionModifierManager {
 
   ensureEventSetup(actionState) {
     let dispatcher = actionState.owner.lookup('event_dispatcher:main');
+    assert('Expected dispatcher to be an EventDispatcher', dispatcher instanceof EventDispatcher);
     dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.setupHandlerForEmberEvent(actionState.eventName);
   }
 
@@ -5218,6 +4603,7 @@ class MountManager {
     // mount is a runtime helper, this shouldn't use dynamic layout
     // we should resolve the engine app template in the helper
     // it also should use the owner that looked up the mount helper.
+    assert('Expected owner to be an EngineInstance', owner instanceof EngineInstance);
     let engine = owner.buildChildEngineInstance(name);
     engine.boot();
     let applicationFactory = engine.factoryFor(`controller:application`);
@@ -5430,28 +4816,17 @@ const mountHelper = internalHelper((args, owner) => {
   Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
 
   @method outlet
-  @param {String} [name]
   @for Ember.Templates.helpers
   @public
 */
 
-const outletHelper = internalHelper((args, owner, scope) => {
+const outletHelper = internalHelper((_args, owner, scope) => {
   assert('Expected owner to be present, {{outlet}} requires an owner', owner);
   assert('Expected dynamic scope to be present. You may have attempted to use the {{outlet}} keyword dynamically. This keyword cannot be used dynamically.', scope);
-  let nameRef;
-
-  if (args.positional.length === 0) {
-    nameRef = createPrimitiveRef('main');
-  } else {
-    let maybeNameRef = args.positional[0];
-    assert('Expected at least one positional arg', maybeNameRef);
-    nameRef = maybeNameRef;
-  }
-
   let outletRef = createComputeRef(() => {
     let state = valueForRef(scope.get('outletState'));
     let outlets = state !== undefined ? state.outlets : undefined;
-    return outlets !== undefined ? outlets[valueForRef(nameRef)] : undefined;
+    return outlets !== undefined ? outlets['main'] : undefined;
   });
   let lastState = null;
   let definition = null;
@@ -5476,7 +4851,7 @@ const outletHelper = internalHelper((args, owner, scope) => {
         // provide the correct updated value. So we stop updating and return
         // the _last_ model value for that outlet.
 
-        named.model = createComputeRef(() => {
+        named['model'] = createComputeRef(() => {
           if (lastState === state) {
             model = valueForRef(modelRef);
           }
@@ -5485,7 +4860,7 @@ const outletHelper = internalHelper((args, owner, scope) => {
         });
 
         if (DEBUG) {
-          named.model = createDebugAliasRef('@model', named.model);
+          named['model'] = createDebugAliasRef('@model', named['model']);
         }
 
         let args = createCapturedArgs(named, EMPTY_POSITIONAL);
@@ -5541,9 +4916,9 @@ function instrumentationPayload$1(name) {
   };
 }
 
-function componentFor(name, owner, options) {
+function componentFor(name, owner) {
   let fullName = `component:${name}`;
-  return owner.factoryFor(fullName, options) || null;
+  return owner.factoryFor(fullName) || null;
 }
 
 function layoutFor(name, owner, options) {
@@ -5552,7 +4927,7 @@ function layoutFor(name, owner, options) {
 }
 
 function lookupComponentPair(owner, name, options) {
-  let component = componentFor(name, owner, options);
+  let component = componentFor(name, owner);
 
   if (component !== null && component.class !== undefined) {
     let layout = getComponentTemplate(component.class);
@@ -5613,6 +4988,7 @@ const BUILTIN_HELPERS = Object.assign(Object.assign({}, BUILTIN_KEYWORD_HELPERS)
   get: get$1,
   hash
 });
+
 const BUILTIN_KEYWORD_MODIFIERS = {
   action: actionModifier
 };
@@ -5765,6 +5141,104 @@ class ResolverImpl {
 
 }
 
+const TOP_LEVEL_NAME = '-top-level';
+const TOP_LEVEL_OUTLET = 'main';
+class OutletView {
+  constructor(_environment, owner, template, namespace) {
+    this._environment = _environment;
+    this.owner = owner;
+    this.template = template;
+    this.namespace = namespace;
+    let outletStateTag = createTag();
+    let outletState = {
+      outlets: {
+        main: undefined
+      },
+      render: {
+        owner: owner,
+        into: undefined,
+        outlet: TOP_LEVEL_OUTLET,
+        name: TOP_LEVEL_NAME,
+        controller: undefined,
+        model: undefined,
+        template
+      }
+    };
+    let ref = this.ref = createComputeRef(() => {
+      consumeTag(outletStateTag);
+      return outletState;
+    }, state => {
+      dirtyTag(outletStateTag);
+      outletState.outlets['main'] = state;
+    });
+    this.state = {
+      ref,
+      name: TOP_LEVEL_NAME,
+      outlet: TOP_LEVEL_OUTLET,
+      template,
+      controller: undefined,
+      model: undefined
+    };
+  }
+
+  static extend(injections) {
+    return class extends OutletView {
+      static create(options) {
+        if (options) {
+          return super.create(Object.assign({}, injections, options));
+        } else {
+          return super.create(injections);
+        }
+      }
+
+    };
+  }
+
+  static reopenClass(injections) {
+    Object.assign(this, injections);
+  }
+
+  static create(options) {
+    let {
+      environment: _environment,
+      application: namespace,
+      template: templateFactory$$1
+    } = options;
+    let owner = getOwner(options);
+    assert('OutletView is unexpectedly missing an owner', owner);
+    let template = templateFactory$$1(owner);
+    return new OutletView(_environment, owner, template, namespace);
+  }
+
+  appendTo(selector) {
+    let target;
+
+    if (this._environment.hasDOM) {
+      target = typeof selector === 'string' ? document.querySelector(selector) : selector;
+    } else {
+      target = selector;
+    }
+
+    let renderer = this.owner.lookup('renderer:-dom'); // SAFETY: It's not clear that this cast is safe.
+    // The types for appendOutletView may be incorrect or this is a potential bug.
+
+    schedule('render', renderer, 'appendOutletView', this, target);
+  }
+
+  rerender() {
+    /**/
+  }
+
+  setOutletState(state) {
+    updateRef(this.ref, state);
+  }
+
+  destroy() {
+    /**/
+  }
+
+}
+
 class DynamicScope {
   constructor(view, outletState) {
     this.view = view;
@@ -5819,7 +5293,7 @@ class RootState {
     this.root = root;
     this.runtime = runtime;
     assert(`You cannot render \`${valueForRef(self)}\` without a template.`, template !== undefined);
-    this.id = getViewId(root);
+    this.id = root instanceof OutletView ? guidFor(root) : getViewId(root);
     this.result = undefined;
     this.destroyed = false;
     this.render = errorLoopTransaction(() => {
@@ -6251,102 +5725,6 @@ var OutletTemplate = templateFactory({
   "isStrictMode": false
 });
 
-const TOP_LEVEL_NAME = '-top-level';
-const TOP_LEVEL_OUTLET = 'main';
-class OutletView {
-  constructor(_environment, owner, template, namespace) {
-    this._environment = _environment;
-    this.owner = owner;
-    this.template = template;
-    this.namespace = namespace;
-    let outletStateTag = createTag();
-    let outletState = {
-      outlets: {
-        main: undefined
-      },
-      render: {
-        owner: owner,
-        into: undefined,
-        outlet: TOP_LEVEL_OUTLET,
-        name: TOP_LEVEL_NAME,
-        controller: undefined,
-        model: undefined,
-        template
-      }
-    };
-    let ref = this.ref = createComputeRef(() => {
-      consumeTag(outletStateTag);
-      return outletState;
-    }, state => {
-      dirtyTag(outletStateTag);
-      outletState.outlets.main = state;
-    });
-    this.state = {
-      ref,
-      name: TOP_LEVEL_NAME,
-      outlet: TOP_LEVEL_OUTLET,
-      template,
-      controller: undefined,
-      model: undefined
-    };
-  }
-
-  static extend(injections) {
-    return class extends OutletView {
-      static create(options) {
-        if (options) {
-          return super.create(Object.assign({}, injections, options));
-        } else {
-          return super.create(injections);
-        }
-      }
-
-    };
-  }
-
-  static reopenClass(injections) {
-    Object.assign(this, injections);
-  }
-
-  static create(options) {
-    let {
-      environment: _environment,
-      application: namespace,
-      template: templateFactory$$1
-    } = options;
-    let owner = getOwner(options);
-    assert('OutletView is unexpectedly missing an owner', owner);
-    let template = templateFactory$$1(owner);
-    return new OutletView(_environment, owner, template, namespace);
-  }
-
-  appendTo(selector) {
-    let target;
-
-    if (this._environment.hasDOM) {
-      target = typeof selector === 'string' ? document.querySelector(selector) : selector;
-    } else {
-      target = selector;
-    }
-
-    let renderer = this.owner.lookup('renderer:-dom');
-    schedule('render', renderer, 'appendOutletView', this, target);
-  }
-
-  rerender() {
-    /**/
-  }
-
-  setOutletState(state) {
-    updateRef(this.ref, state);
-  }
-
-  destroy() {
-    /**/
-  }
-
-}
-
 function setupApplicationRegistry(registry) {
   // because we are using injections we can't use instantiate false
   // we need to use bind() to copy the function so factory for
@@ -6391,6 +5769,18 @@ function setupEngineRegistry(registry) {
   }
 }
 
+/**
+   Associate a class with a component manager (an object that is responsible for
+   coordinating the lifecycle events that occurs when invoking, rendering and
+   re-rendering a component).
+
+   @method setComponentManager
+   @param {Function} factory a function to create the owner for an object
+   @param {Object} obj the object to associate with the componetn manager
+   @return {Object} the same object passed in
+   @public
+  */
+
 function setComponentManager$1(manager, obj) {
   return setComponentManager(manager, obj);
 }