ember-source 7.2.0-alpha.4 → 7.3.0-alpha.1

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

@@ -1,6 +1,6 @@
-import { b as createComputeRef, v as valueForRef, N as NULL_REFERENCE } from './reference-D2agTt1V.js';
-import { s as setInternalComponentManager } from './api-DOLN_cR2.js';
-import { i as internalHelper } from './internal-helper-CoxiRnnb.js';
+import { c as createComputeRef, v as valueForRef, N as NULL_REFERENCE } from './reference-CG0yPgLy.js';
+import { s as setInternalComponentManager } from './api-DlJKfm_f.js';
+import { i as internalHelper } from './internal-helper-Bz1lpDXr.js';
 
 /**
   @module @ember/helper
@@ -82,6 +82,8 @@ function getElementDefinition(tagName) {
   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

package/dist/prod/packages/shared-chunks/{events-C7aYCy0N.js → events-DYrYz3V8.js}

@@ -1,5 +1,5 @@
 import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
-import { s as setListeners } from './super-D4qkU4uq.js';
+import { a as setListeners } from './super-BBBjgF69.js';
 
 /**
 @module @ember/object

package/dist/{dev/packages/shared-chunks/flags-B9qxc-pB.js → prod/packages/shared-chunks/flags-BZxHQ0yn.js}

@@ -21,4 +21,4 @@ const TYPE_MASK = 0b00000000000000000000000011111111;
 const OPERAND_LEN_MASK = 0b00000000000000000000001100000000;
 const MACHINE_MASK = 0b00000000000000000000010000000000;
 
-export { ARG_SHIFT as A, InternalComponentCapabilities as I, MACHINE_MASK as M, OPERAND_LEN_MASK as O, TYPE_MASK as T, MAX_SIZE as a, TYPE_SIZE as b };
+export { ARG_SHIFT as A, InternalComponentCapabilities as I, MACHINE_MASK as M, OPERAND_LEN_MASK as O, TYPE_MASK as T, TYPE_SIZE as a, MAX_SIZE as b };

package/dist/prod/packages/shared-chunks/{get-tlL23wmp.js → get-Dago5uGl.js}

@@ -1,8 +1,8 @@
-import { b as createComputeRef, U as UNDEFINED_REFERENCE, v as valueForRef } from './reference-D2agTt1V.js';
-import { l as reifyPositional } from './debug-render-tree-CYENUjgX.js';
-import { i as internalHelper } from './hash-C6IoC4eR.js';
+import { c as createComputeRef, U as UNDEFINED_REFERENCE, v as valueForRef } from './reference-CG0yPgLy.js';
+import { f as reifyPositional } from './arguments-BzAkZVBa.js';
+import { i as internalHelper } from './hash-gEXIsSO4.js';
 import { setPath, getPath } from '../@glimmer/global-context/index.js';
-import { i as isDict } from './collections-By4M3cTy.js';
+import { i as isDict } from './collections-GpG8lT2g.js';
 
 const isEmpty = value => {
   return value === null || value === undefined || typeof value.toString !== 'function';
@@ -19,10 +19,15 @@ const normalizeTextValue = value => {
 
   Example:
 
-  ```handlebars
-  {{some-component name=(concat firstName " " lastName)}}
 
-  {{! would pass name="<first name value> <last name value>" to the component}}
+  ```gjs
+  import { concat } from '@ember/helper';
+
+  <template>
+  {{yield (concat firstName " " lastName)}}
+
+  {{! would yield name="<first name value> <last name value>" to the component}}
+  </template>
   ```
 
   or for angle bracket invocation, you actually don't need concat at all.
@@ -46,28 +51,31 @@ const concat = internalHelper(({
 
   For example, these two usages are equivalent:
 
-  ```app/components/developer-detail.js
+  ```app/components/developer-detail.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
+  import { get } from '@ember/object';
 
   export default class extends Component {
     @tracked developer = {
       name: "Sandi Metz",
       language: "Ruby"
     }
+    
+    <template>
+      {{this.developer.name}}
+      {{get this.developer "name"}}
+    </template>
   }
   ```
 
-  ```handlebars
-  {{this.developer.name}}
-  {{get this.developer "name"}}
-  ```
-
   If there were several facts about a person, the `{{get}}` helper can dynamically
   pick one:
 
-  ```app/templates/application.hbs
-  <DeveloperDetail @factName="language" />
+  ```app/templates/application.gjs
+  <template>
+    <DeveloperDetail @factName="language" />
+  </template>
   ```
 
   ```handlebars
@@ -77,10 +85,11 @@ const concat = internalHelper(({
   For a more complex example, this template would allow the user to switch
   between showing the user's height and weight with a click:
 
-  ```app/components/developer-detail.js
+  ```app/components/developer-detail.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
-
+  import { get } from '@ember/object';
+    
   export default class extends Component {
     @tracked developer = {
       name: "Sandi Metz",
@@ -92,28 +101,16 @@ const concat = internalHelper(({
     showFact = (fact) => {
       this.currentFact = fact;
     }
-  }
-  ```
-
-  ```app/components/developer-detail.js
-  {{get this.developer this.currentFact}}
-
-  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
-  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
-  ```
+    
+    <template>
+      {{get this.developer this.currentFact}}
 
-  The `{{get}}` helper can also respect mutable values itself. For example:
-
-  ```app/components/developer-detail.js
-  <Input @value={{mut (get this.person this.currentFact)}} />
-
-  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
-  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+      <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
+      <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+    </template>
+  }
   ```
 
-  Would allow the user to swap what fact is being displayed, and also edit
-  that fact via a two-way mutable binding.
-
   @public
   @method get
  */

package/dist/{dev/packages/shared-chunks/get_properties-B203vZpz.js → prod/packages/shared-chunks/get_properties-Dg3xFpiS.js}

@@ -1,4 +1,4 @@
-import { g as get } from './property_get-BjbsrgpU.js';
+import { g as get } from './property_get-DAKgbeJX.js';
 
 /**
  @module @ember/object

package/dist/prod/packages/shared-chunks/{guid-PO2v9BaN.js → guid-Cbq2sNV_.js}

@@ -120,4 +120,4 @@ function guidFor(value) {
   return guid;
 }
 
-export { GUID_KEY as G, guidFor as a, generateGuid as g, uuid as u };
+export { GUID_KEY as G, generateGuid as a, guidFor as g, uuid as u };

package/dist/prod/packages/shared-chunks/{hash-C6IoC4eR.js → hash-gEXIsSO4.js}

@@ -1,6 +1,12 @@
-import { b as createComputeRef, k as isInvokableRef, u as updateRef } from './reference-D2agTt1V.js';
-import { l as reifyPositional, e as check, k as reifyNamed } from './debug-render-tree-CYENUjgX.js';
-import { j as setInternalHelperManager } from './api-DOLN_cR2.js';
+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-BzAkZVBa.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, {});
@@ -19,7 +25,7 @@ function internalHelper(helper) {
    ```
     or
    ```handlebars
-   {{my-component people=(array
+   {{yield people=(array
      'Tom Dale'
      'Yehuda Katz'
      this.myOtherPerson)
@@ -46,12 +52,6 @@ const array = internalHelper(({
   return createComputeRef(() => reifyPositional(positional), null, 'array');
 });
 
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-function buildUntouchableThis(source) {
-  let context = null;
-  return context;
-}
-
 const context = buildUntouchableThis();
 
 /**
@@ -64,13 +64,17 @@ const context = buildUntouchableThis();
   to a component invoked within the loop. Here's how you could use the `fn`
   helper to pass both the function and its arguments together:
 
-    ```app/templates/components/items-listing.hbs
-  {{#each @items as |item|}}
-    <DisplayItem @item=item @select={{fn this.handleSelected item}} />
-  {{/each}}
+  ```app/components/items-listing.gjs
+  import DisplayItem from './display-item';
+    
+  <template>
+    {{#each @items as |item|}}
+      <DisplayItem @item=item @select={{fn this.handleSelected item}} />
+    {{/each}}
+  </template>
   ```
 
-  ```app/components/items-list.js
+  ```app/components/items-list.gjs
   import Component from '@glimmer/component';
   import { action } from '@ember/object';
 
@@ -81,7 +85,7 @@ const context = buildUntouchableThis();
   }
   ```
 
-  In this case the `display-item` component will receive a normal function
+  In this case the `DisplayItem` component will receive a normal function
   that it can invoke. When it invokes the function, the `handleSelected`
   function will receive the `item` and any arguments passed, thanks to the
   `fn` helper.
@@ -98,7 +102,7 @@ const context = buildUntouchableThis();
   `handleSelected` is properly bound to the `items-list`, but let's explore what
   happens if we left out the arrow function:
 
-  ```app/components/items-list.js
+  ```app/components/items-list.gjs
   import Component from '@glimmer/component';
 
   export default class ItemsList extends Component {
@@ -115,6 +119,8 @@ const context = buildUntouchableThis();
 
   See also [partial application](https://en.wikipedia.org/wiki/Partial_application).
 
+  `fn` is built-in and does not require any additional imports.
+ 
   @method fn
   @public
 */
@@ -138,7 +144,7 @@ const fn = internalHelper(({
 
 /**
    Use the `{{hash}}` helper to create a hash to pass as an option to your
-   components. This is specially useful for contextual components where you can
+   components. This is especially useful for contextual components where you can
    just yield a hash:
 
    ```handlebars

package/dist/prod/packages/shared-chunks/helper-brand-C9_8vvOf.js

@@ -0,0 +1,12 @@
+/**
+ * The brand for classic (class-based) helpers lives in its own module so that
+ * code which only needs to *detect* classic helpers (e.g. the resolver) does
+ * not have to import the classic `Helper` base class (and with it the classic
+ * object model: `EmberObject`, `Mixin`, meta, etc.).
+ */
+const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
+function isClassicHelper(obj) {
+  return obj[IS_CLASSIC_HELPER] === true;
+}
+
+export { IS_CLASSIC_HELPER as I, isClassicHelper as i };

package/dist/prod/packages/shared-chunks/{index-D-rcNBLp.js → index-Bf53M8eS.js}

@@ -1,15 +1,15 @@
 import { a as assign } from './object-utils-AijlD-JH.js';
-import { b as EMPTY_STRING_ARRAY, E as EMPTY_ARRAY, c as enumerate, r as reverse } from './array-utils-BEaSKdEb.js';
-import { ab as VM_PRIMITIVE_OP, aE as encodeHandle, o as VM_CONCAT_OP, O as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, N as VM_GET_PROPERTY_OP, P as VM_HAS_BLOCK_OP, au as VM_SPREAD_BLOCK_OP, m as VM_COMPILE_BLOCK_OP, Q as VM_HAS_BLOCK_PARAMS_OP, S as VM_IF_INLINE_OP, a2 as VM_NOT_OP, M as VM_GET_DYNAMIC_VAR_OP, $ as VM_LOG_OP, G as VM_FETCH_OP, ac as VM_PRIMITIVE_REFERENCE_OP, R as VM_HELPER_OP, x as VM_DUP_OP, A as VM_DYNAMIC_HELPER_OP, a7 as VM_POP_OP, h as VM_CAPTURE_ARGS_OP, t as VM_CURRY_OP, aH as isSmallInt, aF as encodeImmediate, ah as VM_PUSH_DYNAMIC_SCOPE_OP, g as VM_BIND_DYNAMIC_SCOPE_OP, a6 as VM_POP_DYNAMIC_SCOPE_OP, I as VM_GET_BLOCK_OP, U as VM_INVOKE_YIELD_OP, a9 as VM_POP_SCOPE_OP, i as VM_CHILD_SCOPE_OP, at as VM_SET_VARIABLE_OP, p as VM_CONSTANT_OP, ae as VM_PUSH_BLOCK_SCOPE_OP, ak as VM_PUSH_SYMBOL_TABLE_OP, ai as VM_PUSH_EMPTY_ARGS_OP, ad as VM_PUSH_ARGS_OP, D as VM_ENTER_OP, X as VM_JUMP_EQ_OP, F as VM_EXIT_OP, Z as VM_JUMP_UNLESS_OP, af as VM_PUSH_COMPONENT_DEFINITION_OP, _ as VM_LOAD_OP, f as VM_BEGIN_COMPONENT_TRANSACTION_OP, s as VM_CREATE_COMPONENT_OP, am as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, K as VM_GET_COMPONENT_SELF_OP, ap as VM_ROOT_SCOPE_OP, ar as VM_SET_BLOCK_OP, w as VM_DID_RENDER_LAYOUT_OP, l as VM_COMMIT_COMPONENT_TRANSACTION_OP, aa as VM_PREPARE_ARGS_OP, aA as VM_VIRTUAL_ROOT_SCOPE_OP, as as VM_SET_NAMED_VARIABLES_OP, aq as VM_SET_BLOCKS_OP, T as VM_INVOKE_COMPONENT_LAYOUT_OP, al as VM_PUT_COMPONENT_OPERATIONS_OP, a3 as VM_OPEN_DYNAMIC_ELEMENT_OP, v as VM_DID_CREATE_ELEMENT_OP, H as VM_FLUSH_ELEMENT_OP, j as VM_CLOSE_ELEMENT_OP, an as VM_RESOLVE_CURRIED_COMPONENT_OP, ao as VM_RESOLVE_DYNAMIC_COMPONENT_OP, ag as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, J as VM_GET_COMPONENT_LAYOUT_OP, a5 as VM_POPULATE_LAYOUT_OP, L as VM_GET_COMPONENT_TAG_NAME_OP, k as VM_COMMENT_OP, a1 as VM_MODIFIER_OP, B as VM_DYNAMIC_MODIFIER_OP, av as VM_STATIC_ATTR_OP, aw as VM_STATIC_COMPONENT_ATTR_OP, y as VM_DYNAMIC_ATTR_OP, n as VM_COMPONENT_ATTR_OP, a4 as VM_OPEN_ELEMENT_OP, u as VM_DEBUGGER_OP, ay as VM_TEXT_OP, z as VM_DYNAMIC_CONTENT_TYPE_OP, aj as VM_PUSH_REMOTE_ELEMENT_OP, a8 as VM_POP_REMOTE_ELEMENT_OP, az as VM_TO_BOOLEAN_OP, C as VM_ENTER_LIST_OP, W as VM_ITERATE_OP, E as VM_EXIT_LIST_OP } from './syscall-ops-nrBHMOTp.js';
-import { e as VM_RETURN_OP, i as isMachineOp, d as VM_PUSH_FRAME_OP, c as VM_POP_FRAME_OP, a as VM_INVOKE_VIRTUAL_OP, b as VM_JUMP_OP, f as VM_RETURN_TO_OP, V as VM_INVOKE_STATIC_OP } from './vm-ops-5QCUIRx4.js';
-import { b as expect, u as unwrap, S as StackImpl, h as isPresentArray, d as dict } from './collections-By4M3cTy.js';
+import { b as EMPTY_STRING_ARRAY, E as EMPTY_ARRAY, e as enumerate, r as reverse } from './array-utils-CZQxrdD3.js';
+import { r as VM_PRIMITIVE_OP, aE as encodeHandle, au as VM_CONCAT_OP, al as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, ap as VM_GET_PROPERTY_OP, as as VM_HAS_BLOCK_OP, ar as VM_SPREAD_BLOCK_OP, E as VM_COMPILE_BLOCK_OP, at as VM_HAS_BLOCK_PARAMS_OP, av as VM_IF_INLINE_OP, aw as VM_NOT_OP, ax as VM_GET_DYNAMIC_VAR_OP, ay as VM_LOG_OP, y as VM_FETCH_OP, u as VM_PRIMITIVE_REFERENCE_OP, ak as VM_HELPER_OP, v as VM_DUP_OP, aj as VM_DYNAMIC_HELPER_OP, w as VM_POP_OP, $ as VM_CAPTURE_ARGS_OP, ai as VM_CURRY_OP, aF as isSmallInt, aG as encodeImmediate, m as VM_PUSH_DYNAMIC_SCOPE_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, aq as VM_GET_BLOCK_OP, F as VM_INVOKE_YIELD_OP, l as VM_POP_SCOPE_OP, k as VM_CHILD_SCOPE_OP, am as VM_SET_VARIABLE_OP, o as VM_CONSTANT_OP, D as VM_PUSH_BLOCK_SCOPE_OP, C as VM_PUSH_SYMBOL_TABLE_OP, _ as VM_PUSH_EMPTY_ARGS_OP, Z as VM_PUSH_ARGS_OP, A as VM_ENTER_OP, I as VM_JUMP_EQ_OP, B as VM_EXIT_OP, H as VM_JUMP_UNLESS_OP, X as VM_PUSH_COMPONENT_DEFINITION_OP, x as VM_LOAD_OP, a3 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a1 as VM_CREATE_COMPONENT_OP, a2 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a8 as VM_GET_COMPONENT_SELF_OP, ao as VM_ROOT_SCOPE_OP, an as VM_SET_BLOCK_OP, ag as VM_DID_RENDER_LAYOUT_OP, ah as VM_COMMIT_COMPONENT_TRANSACTION_OP, a0 as VM_PREPARE_ARGS_OP, ac as VM_VIRTUAL_ROOT_SCOPE_OP, ad as VM_SET_NAMED_VARIABLES_OP, ae as VM_SET_BLOCKS_OP, af as VM_INVOKE_COMPONENT_LAYOUT_OP, a4 as VM_PUT_COMPONENT_OPERATIONS_OP, N as VM_OPEN_DYNAMIC_ELEMENT_OP, a7 as VM_DID_CREATE_ELEMENT_OP, Q as VM_FLUSH_ELEMENT_OP, R as VM_CLOSE_ELEMENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, Y as VM_RESOLVE_DYNAMIC_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, aa as VM_GET_COMPONENT_LAYOUT_OP, ab as VM_POPULATE_LAYOUT_OP, a9 as VM_GET_COMPONENT_TAG_NAME_OP, L as VM_COMMENT_OP, S as VM_MODIFIER_OP, T as VM_DYNAMIC_MODIFIER_OP, U as VM_STATIC_ATTR_OP, a6 as VM_STATIC_COMPONENT_ATTR_OP, W as VM_DYNAMIC_ATTR_OP, a5 as VM_COMPONENT_ATTR_OP, M as VM_OPEN_ELEMENT_OP, aA as VM_DEBUGGER_OP, K as VM_TEXT_OP, b as VM_ASSERT_SAME_OP, az as VM_DYNAMIC_CONTENT_TYPE_OP, O as VM_PUSH_REMOTE_ELEMENT_OP, P as VM_POP_REMOTE_ELEMENT_OP, J as VM_TO_BOOLEAN_OP, aB as VM_ENTER_LIST_OP, aD as VM_ITERATE_OP, aC as VM_EXIT_LIST_OP } from './syscall-ops-CN7STuUn.js';
+import { b as VM_RETURN_OP, i as isMachineOp, f as VM_PUSH_FRAME_OP, e as VM_POP_FRAME_OP, d as VM_INVOKE_VIRTUAL_OP, c as VM_JUMP_OP, a as VM_RETURN_TO_OP, V as VM_INVOKE_STATIC_OP } from './vm-ops-ImHv0Wtg.js';
+import { e as expect, u as unwrap, S as StackImpl, a as isPresentArray, d as dict } from './collections-GpG8lT2g.js';
 import { a as assert } from './assert-Zqc4wiAV.js';
 import { InstructionEncoderImpl } from '../@glimmer/encoder/index.js';
-import { A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+import { A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-BZxHQ0yn.js';
 import { o as opcodes } from './opcodes-CplRyHl_.js';
-import { h as $v0, $ as $fp, c as $s0, e as $sp, d as $s1 } from './registers-Buvdhhxx.js';
+import { a as $v0, f as $fp, $ as $s0, g as $sp, h as $s1 } from './registers-C_W2qYHJ.js';
 import { ContentType } from '../@glimmer/vm/index.js';
-import { h as hasCapability } from './capabilities-_5e35539.js';
+import { h as hasCapability } from './capabilities-BuVYh-vx.js';
 
 function isGetLikeTuple(opcode) {
   return Array.isArray(opcode) && opcode.length === 2;
@@ -1558,6 +1558,7 @@ STATEMENTS.add(opcodes.Append, (op, [, value]) => {
         op(VM_DYNAMIC_CONTENT_TYPE_OP);
       }, when => {
         when(ContentType.Component, () => {
+          op(VM_ASSERT_SAME_OP);
           op(VM_RESOLVE_CURRIED_COMPONENT_OP);
           op(VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP);
           InvokeNonStaticComponent(op, {
@@ -1900,4 +1901,4 @@ class TemplateImpl {
   }
 }
 
-export { CallDynamic as C, EMPTY_BLOCKS as E, InvokeBareComponent as I, SwitchCases as S, WrappedBuilder as W, EncoderImpl as a, InvokeStaticBlock as b, InvokeStaticBlockWithStack as c, compilable as d, compileStatements as e, encodeOp as f, templateCompilationContext as g, templateFactory as h, invokePreparedComponent as i, meta as m, templateCacheCounters as t };
+export { CallDynamic as C, EMPTY_BLOCKS as E, InvokeStaticBlock as I, SwitchCases as S, WrappedBuilder as W, templateCacheCounters as a, compileStatements as b, compilable as c, InvokeStaticBlockWithStack as d, templateCompilationContext as e, EncoderImpl as f, encodeOp as g, InvokeBareComponent as h, invokePreparedComponent as i, meta as m, templateFactory as t };