ember-source 7.2.0-beta.1 → 7.2.1

package/dist/prod/packages/shared-chunks/{arguments-BzAkZVBa.js → arguments-DxmU3uk4.js}

@@ -773,7 +773,11 @@ APPEND_OPCODES.add(VM_DYNAMIC_MODIFIER_OP, vm => {
     }
   }
   if (!isConstRef(ref) || tag) {
-    return vm.updateWith(new UpdateDynamicModifierOpcode(tag, instance, instanceRef));
+    let updateOpcode = new UpdateDynamicModifierOpcode(tag, instance, instanceRef);
+
+    // The block must own this opcode, or instances created on update are never destroyed.
+    vm.associateDestroyable(updateOpcode);
+    return vm.updateWith(updateOpcode);
   }
 });
 class UpdateModifierOpcode {

package/dist/prod/packages/shared-chunks/{curly-IY06zACp.js → curly-D2WsNyFi.js}

@@ -3,7 +3,7 @@ import { g as guidFor } from './guid-Cbq2sNV_.js';
 import { getViewElement, clearElementView, clearViewElement, addChildView, setViewElement, setElementView } from '../@ember/-internals/views/lib/system/utils.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { c as createComputeRef, v as valueForRef, e as createPrimitiveRef, f as childRefFor, g as childRefFromParts, a as createConstRef, b as isUpdatableRef, u as updateRef } from './reference-CG0yPgLy.js';
-import { f as reifyPositional } from './arguments-BzAkZVBa.js';
+import { f as reifyPositional } from './arguments-DxmU3uk4.js';
 import { E as EMPTY_ARRAY } from './array-utils-CZQxrdD3.js';
 import { a as valueForTag, p as beginUntrackFrame, w as endUntrackFrame, o as beginTrackFrame, s as endTrackFrame, c as consumeTag, v as validateTag } from './cache-CofLhaS4.js';
 import { g as get } from './property_get-DAKgbeJX.js';

package/dist/prod/packages/shared-chunks/{element-DgHdPZ8u.js → element-BmBjPjkQ.js}

@@ -65,30 +65,6 @@ function getElementDefinition(tagName) {
 
 // ============ Element Helper ============
 
-/**
-  The `element` helper lets you dynamically set the tag name of an element.
-
-  ```handlebars
-  {{#let (element @tagName) as |Tag|}}
-    <Tag class="my-element">Hello</Tag>
-  {{/let}}
-  ```
-
-  When `@tagName` is `"h1"`, this renders `<h1 class="my-element">Hello</h1>`.
-
-  When `@tagName` is an empty string `""`, the block content is rendered without
-  a wrapping element.
-
-  Passing `null`, `undefined`, or non-string values will throw an assertion error.
-
-  Changing the tag name will tear down and recreate the element and its contents.
- 
-  The `element` helper is built-in and does not need to be imported.
-
-  @method element
-  @for Ember.Templates.helpers
-  @public
-*/
 const element = internalHelper(({
   positional,
   named

package/dist/prod/packages/shared-chunks/get-CMIqiKkx.js

@@ -0,0 +1,40 @@
+import { c as createComputeRef, U as UNDEFINED_REFERENCE, v as valueForRef } from './reference-CG0yPgLy.js';
+import { f as reifyPositional } from './arguments-DxmU3uk4.js';
+import { i as internalHelper } from './hash-BPZcn79q.js';
+import { setPath, getPath } from '../@glimmer/global-context/index.js';
+import { i as isDict } from './collections-GpG8lT2g.js';
+
+const isEmpty = value => {
+  return value === null || value === undefined || typeof value.toString !== 'function';
+};
+const normalizeTextValue = value => {
+  if (isEmpty(value)) {
+    return '';
+  }
+  return String(value);
+};
+const concat = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => reifyPositional(positional).map(normalizeTextValue).join(''), null, 'concat');
+});
+
+const get = internalHelper(({
+  positional
+}) => {
+  let sourceRef = positional[0] ?? UNDEFINED_REFERENCE;
+  let pathRef = positional[1] ?? UNDEFINED_REFERENCE;
+  return createComputeRef(() => {
+    let source = valueForRef(sourceRef);
+    if (isDict(source)) {
+      return getPath(source, String(valueForRef(pathRef)));
+    }
+  }, value => {
+    let source = valueForRef(sourceRef);
+    if (isDict(source)) {
+      return setPath(source, String(valueForRef(pathRef)), value);
+    }
+  }, 'get');
+});
+
+export { concat as c, get as g };

package/dist/prod/packages/shared-chunks/hash-BPZcn79q.js

@@ -0,0 +1,57 @@
+import { c as createComputeRef, d as isInvokableRef, u as updateRef } from './reference-CG0yPgLy.js';
+import { f as reifyPositional, g as check, e as reifyNamed } from './arguments-DxmU3uk4.js';
+import { j as setInternalHelperManager } from './api-DlJKfm_f.js';
+
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+function buildUntouchableThis(source) {
+  let context = null;
+  return context;
+}
+
+function internalHelper(helper) {
+  return setInternalHelperManager(helper, {});
+}
+
+const array = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => reifyPositional(positional), null, 'array');
+});
+
+const context = buildUntouchableThis();
+const fn = internalHelper(({
+  positional
+}) => {
+  let callbackRef = check(positional[0]);
+  return createComputeRef(() => {
+    return (...invocationArgs) => {
+      let [fn, ...args] = reifyPositional(positional);
+      if (isInvokableRef(callbackRef)) {
+        let value = args.length > 0 ? args[0] : invocationArgs[0];
+        return void updateRef(callbackRef, value);
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- @fixme
+        return fn.call(context, ...args, ...invocationArgs);
+      }
+    };
+  }, null, 'fn');
+});
+
+const hash = internalHelper(({
+  named
+}) => {
+  let ref = createComputeRef(() => {
+    return reifyNamed(named);
+  }, null, 'hash');
+
+  // Setup the children so that templates can bypass getting the value of
+  // the reference and treat children lazily
+  let children = new Map();
+  for (let name in named) {
+    children.set(name, named[name]);
+  }
+  ref.children = children;
+  return ref;
+});
+
+export { array as a, fn as f, hash as h, internalHelper as i };

package/dist/prod/packages/shared-chunks/{helper-DkXiTBjc.js → helper-Df5MpdcT.js}

@@ -27,7 +27,7 @@ const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
   Ember Helpers are functions that can compute values, and are used in templates.
   For example, this code calls a helper named `format-currency`:
 
-  ```app/templates/application.gjs
+  ```gjs {data-filename="app/templates/application.gjs"}
   import Cost from '../components/cost';
     
   <template>
@@ -35,7 +35,7 @@ const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
   </template>
   ```
 
-  ```app/components/cost.gjs
+  ```gjs {data-filename="app/components/cost.gjs"}
   import formatCurrency from '../helpers/format-currency';
     
   <template>

package/dist/prod/packages/shared-chunks/{index-CslMfEpb.js → index-DyYpsxuM.js}

@@ -11,10 +11,10 @@ import { artifacts } from '../@glimmer/program/index.js';
 import { R as RuntimeOpImpl } from './program-BAh__OXZ.js';
 import { v as valueForRef, U as UNDEFINED_REFERENCE, c as createComputeRef, a as createConstRef, h as createInvokableRef, j as createReadOnlyRef, k as createUnboundRef, g as childRefFromParts, u as updateRef } from './reference-CG0yPgLy.js';
 import { c as clientBuilder } from './api-CQexacBn.js';
-import { E as EMPTY_ARGS, c as createCapturedArgs, b as EMPTY_POSITIONAL, d as curry } from './arguments-BzAkZVBa.js';
-import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-Dx7lr1hR.js';
+import { E as EMPTY_ARGS, c as createCapturedArgs, b as EMPTY_POSITIONAL, d as curry } from './arguments-DxmU3uk4.js';
+import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-CO2mZxto.js';
 import { d as dict } from './collections-GpG8lT2g.js';
-import { u as unwrapTemplate, a as CurlyComponentManager, i as initialRenderInstrumentDetails, b as ComponentStateBucket, D as DIRTY_TAG, c as isCurlyManager, B as BOUNDS } from './curly-IY06zACp.js';
+import { u as unwrapTemplate, a as CurlyComponentManager, i as initialRenderInstrumentDetails, b as ComponentStateBucket, D as DIRTY_TAG, c as isCurlyManager, B as BOUNDS } from './curly-D2WsNyFi.js';
 import { C as CONSTANT_TAG, c as consumeTag, f as isTracking, D as DIRTY_TAG$1, r as createTag, a as valueForTag, k as CURRENT_TAG, v as validateTag } from './cache-CofLhaS4.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { c as capabilityFlagsFrom } from './capabilities-BuVYh-vx.js';
@@ -34,13 +34,13 @@ import { i as isHTMLSafe } from './index-D-xTBV4B.js';
 import isArray from '../@ember/array/lib/is-array.js';
 import { g as getComponentTemplate } from './template-Dc_cBOoX.js';
 import { c as hasInternalComponentManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-DlJKfm_f.js';
-import { h as hash, f as fn, a as array } from './hash-gEXIsSO4.js';
-import { g as get$1, c as concat } from './get-Dago5uGl.js';
-import { o as on } from './on-BZHAxzdq.js';
+import { h as hash, f as fn, a as array } from './hash-BPZcn79q.js';
+import { g as get$1, c as concat } from './get-CMIqiKkx.js';
+import { o as on } from './on-Ch0e_hqJ.js';
 import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-DKNcKM5b.js';
-import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-DkXiTBjc.js';
+import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-Df5MpdcT.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
-import { a as uniqueId } from './unique-id-o2pS74go.js';
+import { a as uniqueId } from './unique-id-BJb1p8EG.js';
 import { generateControllerFactory } from '../@ember/routing/lib/generate_controller.js';
 import { E as EvaluationContextImpl } from './program-context-COSioH46.js';
 
@@ -231,7 +231,7 @@ class RootComponentDefinition {
 }
 
 /**
-@module ember
+@module @ember/helper
 */
 
 /**
@@ -241,46 +241,91 @@ class RootComponentDefinition {
   The default behavior of `{{#each}}` is to yield its inner block once for every
   item in an array passing the item as the first block parameter.
 
-  Assuming the `@developers` argument contains this array:
+  ```gjs {data-filename="app/components/developer-list.gjs"}
+  import Component from '@glimmer/component';
 
-  ```javascript
-  [{ name: 'Yehuda' },{ name: 'Tom' }, { name: 'Paul' }];
-  ```
+  export default class DeveloperList extends Component {
+    developers = [
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ];
 
-  ```handlebars
-  <ul>
-    {{#each @developers as |person|}}
-      <li>Hello, {{person.name}}!</li>
-    {{/each}}
-  </ul>
+    <template>
+      <ul>
+        {{#each this.developers as |person|}}
+          <li>Hello, {{person.name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
-  The same rules apply to arrays of primitives.
+  The same rules apply to arrays of primitives:
+
+  ```app/components/developer-names.gjs
+  import Component from '@glimmer/component';
+
+  export default class DeveloperNames extends Component {
+    developerNames = ['Yehuda', 'Tom', 'Paul'];
 
-  ```javascript
-  ['Yehuda', 'Tom', 'Paul']
+    <template>
+      <ul>
+        {{#each this.developerNames as |name|}}
+          <li>Hello, {{name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
-  ```handlebars
-  <ul>
-    {{#each @developerNames as |name|}}
-      <li>Hello, {{name}}!</li>
-    {{/each}}
-  </ul>
+  `{{#each}}` also supports native JavaScript [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)
+  values and other iterables:
+
+  ```gjs {data-filename="app/components/developer-set.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperSet extends Component {
+    developers = new Set([
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ]);
+
+    <template>
+      <ul>
+        {{#each this.developers as |person|}}
+          <li>Hello, {{person.name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
-  During iteration, the index of each item in the array is provided as a second block
-  parameter.
+  During iteration, the index of each item in the array is provided as a second
+  block parameter:
 
-  ```handlebars
-  <ul>
-    {{#each @developers as |person index|}}
-      <li>Hello, {{person.name}}! You're number {{index}} in line</li>
-    {{/each}}
-  </ul>
+  ```app/components/developer-list-with-index.gjs
+  import Component from '@glimmer/component';
+
+  export default class DeveloperListWithIndex extends Component {
+    developers = [
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ];
+
+    <template>
+      <ul>
+        {{#each this.developers as |person index|}}
+          <li>Hello, {{person.name}}! You're number {{index}} in line</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
-    
-  `#each` is a keyword and does not need to be imported. 
+
+  `#each` is a keyword and does not need to be imported.
 
   ### Specifying Keys
 
@@ -296,30 +341,38 @@ class RootComponentDefinition {
   needed. However, in some rare cases, the objects' identities may change even
   though they represent the same underlying data.
 
-  For example:
+  For example, mapping over `people` produces a new array of new objects on each
+  render. Use `key` so Ember can match items across those renders:
 
-  ```javascript
-  people.map(person => {
-    return { ...person, type: 'developer' };
-  });
-  ```
+  ```gjs {data-filename="app/components/mapped-developers.gjs"}
+  import Component from '@glimmer/component';
 
-  In this case, each time the `people` array is `map`-ed over, it will produce
-  an new array with completely different objects between renders. In these cases,
-  you can help Ember determine how these objects related to each other with the
-  `key` option:
+  export default class MappedDevelopers extends Component {
+    people = [
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ];
 
-  ```handlebars
-  <ul>
-    {{#each @developers key="name" as |person|}}
-      <li>Hello, {{person.name}}!</li>
-    {{/each}}
-  </ul>
+    get developers() {
+      return this.people.map((person) => {
+        return { ...person, type: 'developer' };
+      });
+    }
+
+    <template>
+      <ul>
+        {{#each this.developers key="name" as |person|}}
+          <li>Hello, {{person.name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
   By doing so, Ember will use the value of the property specified (`person.name`
   in the example) to find a "match" from the previous render. That is, if Ember
-  has previously seen an object from the `@developers` array with a matching
+  has previously seen an object from the `developers` array with a matching
   name, its DOM elements will be re-used.
 
   There are two special values for `key`:
@@ -332,36 +385,47 @@ class RootComponentDefinition {
   `{{#each}}` can have a matching `{{else}}`. The contents of this block will render
   if the collection is empty.
 
-  ```handlebars
-  <ul>
-    {{#each @developers as |person|}}
-      <li>{{person.name}} is available!</li>
-    {{else}}
-      <li>Sorry, nobody is available for this task.</li>
-    {{/each}}
-  </ul>
+  ```gjs {data-filename="app/components/available-developers.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class AvailableDevelopers extends Component {
+    developers = [];
+
+    <template>
+      <ul>
+        {{#each this.developers as |person|}}
+          <li>{{person.name}} is available!</li>
+        {{else}}
+          <li>Sorry, nobody is available for this task.</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
   @method each
-  @for Ember.Templates.helpers
+  @for Keywords
+  @static
+  @noimport
   @public
  */
 
 /**
-  The `{{#each-in}}` keyword loops over properties on an object.
+  The `{{#each-in}}` keyword loops over properties on an object, or entries in a
+  native JavaScript [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map).
 
   For example, given this component definition:
 
-  ```app/components/developer-details.gjs
+  ```gjs {data-filename="app/components/developer-details.gjs"}
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
 
-  export default class extends Component {
+  export default class DeveloperDetails extends Component {
     @tracked developer = {
-      "name": "Shelly Sails",
-      "age": 42
+      name: 'Shelly Sails',
+      age: 42,
     };
-    
+
     <template>
       <ul>
         {{#each-in this.developer as |key value|}}
@@ -381,11 +445,56 @@ class RootComponentDefinition {
     <li>age: 42</li>
   </ul>
   ```
- 
+
+  The same pattern works with a `Map`:
+
+  ```gjs {data-filename="app/components/developer-map.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperMap extends Component {
+    map = new Map([
+      ['name', 'Shelly Sails'],
+      ['age', 42],
+    ]);
+
+    <template>
+      <ul>
+        {{#each-in this.map as |key value|}}
+          <li>{{key}}: {{value}}</li>
+        {{/each-in}}
+      </ul>
+    </template>
+  }
+  ```
+
+  When a `Map` uses object keys, you can pass `key="@identity"` to explicitly
+  track entries across re-renders using the JavaScript identity of each key:
+
+  ```gjs {data-filename="app/components/object-keyed-map.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class ObjectKeyedMap extends Component {
+    map = new Map([
+      [{ name: 'one' }, 'foo'],
+      [{ name: 'two' }, 'bar'],
+    ]);
+
+    <template>
+      <ul>
+        {{#each-in this.map key="@identity" as |key value|}}
+          <li>{{key.name}}: {{value}}</li>
+        {{/each-in}}
+      </ul>
+    </template>
+  }
+  ```
+
   `#each-in` is a keyword and does not need to be imported.
 
   @method each-in
-  @for Ember.Templates.helpers
+  @static
+  @noimport
+  @for Keywords
   @public
   @since 2.1.0
 */
@@ -770,7 +879,7 @@ const trackArray = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 /**
@@ -790,7 +899,7 @@ const trackArray = internalHelper(({
 
   The child `Component` would invoke the function with the new click count:
 
-  ```app/components/my-child.gjs
+  ```gjs {data-filename="app/components/my-child.gjs"}
   import Component from '@glimmer/component';
   import { action } from '@ember/object';
     
@@ -812,7 +921,8 @@ const trackArray = internalHelper(({
 
   @method mut
   @param {Object} [attr] the "two-way" attribute that can be modified.
-  @for Ember.Templates.helpers
+  @static
+  @for Keywords
   @public
 */
 
@@ -824,7 +934,7 @@ const mut = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 
@@ -936,7 +1046,9 @@ const mut = internalHelper(({
 
   @method readonly
   @param {Object} [attr] the read-only attribute.
-  @for Ember.Templates.helpers
+  @for Keywords
+  @noimport
+  @static
   @private
 */
 const readonly = internalHelper(({
@@ -947,7 +1059,7 @@ const readonly = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 
@@ -973,9 +1085,13 @@ const readonly = internalHelper(({
 
   The `unbound` helper only accepts a single argument, and it return an
   unbound value.
+ 
+ `unbound` is a template keyword and does not need to be imported.
 
   @method unbound
-  @for Ember.Templates.helpers
+  @static
+  @noimport
+  @for Keywords
   @public
 */
 
@@ -1112,7 +1228,7 @@ class MountDefinition {
 }
 
 /**
-@module ember
+@module @ember/helper
 */
 
 
@@ -1123,7 +1239,7 @@ class MountDefinition {
 
   For example, the following template mounts the `ember-chat` engine:
 
-  ```app/templates/application.gjs
+  ```gjs {data-filename="app/templates/application.gjs"}
   {{mount "ember-chat"}}
   ```
 
@@ -1157,7 +1273,9 @@ class MountDefinition {
   @param {String} name Name of the engine to mount.
   @param {Object} [model] Object that will be set as
                           the model of the engine.
-  @for Ember.Templates.helpers
+  @for Keywords
+  @static
+  @noimport
   @public
 */
 const mountHelper = internalHelper((args, owner) => {
@@ -1280,12 +1398,16 @@ function makeRouteTemplate(owner, name, template) {
   return curry(0, routeTemplate, owner, null, true);
 }
 
+/**
+ @module @ember/helper
+ */
+
 /**
   The `{{outlet}}` helper lets you specify where a child route will render in
   your template. An important use of the `{{outlet}}` helper is in your
   application's `application.gjs` file:
 
-  ```app/templates/application.gjs
+  ```gjs {data-filename="app/templates/application.gjs"}
   import MyHeader from '../components/my-header';
   import MyFooter from '../components/my-footer';
     
@@ -1308,7 +1430,9 @@ function makeRouteTemplate(owner, name, template) {
   `outlet` is built-in and does not need to be imported. 
  
   @method outlet
-  @for Ember.Templates.helpers
+  @for Keywords
+  @static
+  @noimport
   @public
 */
 const outletHelper = internalHelper((_args, owner, scope) => {

package/dist/prod/packages/shared-chunks/{invoke-DhQ5QRp2.js → invoke-D7d52XJk.js}

@@ -2,7 +2,7 @@ import { associateDestroyableChild } from '../@glimmer/destroyable/index.js';
 import { a as getInternalHelperManager, f as hasValue, h as hasDestroyable } from './api-DlJKfm_f.js';
 import { getOwner } from '../@glimmer/owner/index.js';
 import { e as createCache, g as getValue } from './cache-CofLhaS4.js';
-import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './arguments-BzAkZVBa.js';
+import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './arguments-DxmU3uk4.js';
 
 function getArgs(proxy) {
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme

package/dist/prod/packages/shared-chunks/{not-BOIVROuv.js → not-BGYHtDIW.js}

@@ -1,6 +1,6 @@
 import { toBool } from '../@glimmer/global-context/index.js';
 import { c as createComputeRef, v as valueForRef } from './reference-CG0yPgLy.js';
-import { i as internalHelper } from './hash-gEXIsSO4.js';
+import { i as internalHelper } from './hash-BPZcn79q.js';
 
 /**
  * Performs a strict equality comparison.