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

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-CCK8Ef0x.js → helper-DkXiTBjc.js}

@@ -2,9 +2,9 @@ import { setOwner } from '../@ember/-internals/owner/index.js';
 import { FrameworkObject } from '../@ember/object/-internals.js';
 import { g as getDebugName } from './get-debug-name-BDxIL2Y1.js';
 import { join } from '../@ember/runloop/index.js';
-import { a as getInternalHelperManager, i as helperCapabilities } from './api-DOLN_cR2.js';
-import { b as setHelperManager } from './api-CGZbGcvX.js';
-import { m as createTag, D as DIRTY_TAG, k as consumeTag } from './cache-CG6_L9db.js';
+import { a as getInternalHelperManager, i as helperCapabilities } from './api-DlJKfm_f.js';
+import { b as setHelperManager } from './api-B_poQGXS.js';
+import { r as createTag, D as DIRTY_TAG, c as consumeTag } from './cache-CofLhaS4.js';
 
 /**
 @module @ember/component
@@ -27,20 +27,32 @@ 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.hbs
-  <Cost @cents={{230}} />
+  ```app/templates/application.gjs
+  import Cost from '../components/cost';
+    
+  <template>
+    <Cost @cents={{230}} />
+  </template>
   ```
 
-  ```app/components/cost.hbs
-  <div>{{format-currency @cents currency="$"}}</div>
+  ```app/components/cost.gjs
+  import formatCurrency from '../helpers/format-currency';
+    
+  <template>
+    <div>{{formatCurrency @cents currency="$"}}</div>
+  </template>
   ```
 
   Additionally a helper can be called as a nested helper.
   In this example, we show the formatted currency value if the `showMoney`
   named argument is truthy.
 
-  ```handlebars
-  {{if @showMoney (format-currency @cents currency="$")}}
+  ```gjs
+  import formatCurrency from '../helpers/format-currency';
+
+  <template>
+    {{if @showMoney (formatCurrency @cents currency="$")}}
+  </template>
   ```
 
   Helpers defined using a class must provide a `compute` function. For example:

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 };