ember-source 7.2.0-alpha.4 → 7.2.0

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-DpBAICuC.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-BzAkZVBa.js';
+import { i as internalHelper } from './hash-D31JO-BD.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/{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-D31JO-BD.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-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, {});
+}
+
+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-CCK8Ef0x.js → helper-Df5MpdcT.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}} />
+  ```gjs {data-filename="app/templates/application.gjs"}
+  import Cost from '../components/cost';
+    
+  <template>
+    <Cost @cents={{230}} />
+  </template>
   ```
 
-  ```app/components/cost.hbs
-  <div>{{format-currency @cents currency="$"}}</div>
+  ```gjs {data-filename="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: