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

package/dist/prod/packages/@ember/object/computed.js

@@ -1,4 +1,4 @@
-export { C as default, i as expandProperties } from '../../shared-chunks/computed-D6MVTTDd.js';
-export { a as alias } from '../../shared-chunks/alias-DsIh-16z.js';
+export { C as default, e as expandProperties } from '../../shared-chunks/computed-DtIStxvq.js';
+export { a as alias } from '../../shared-chunks/alias-Bod6qdNp.js';
 export { and, bool, deprecatingAlias, empty, equal, gt, gte, lt, lte, match, none, not, notEmpty, oneWay, or, readOnly, oneWay as reads } from './lib/computed/computed_macros.js';
 export { collect, filter, filterBy, intersect, map, mapBy, max, min, setDiff, sort, sum, union, uniq, uniqBy } from './lib/computed/reduce_computed_macros.js';

package/dist/prod/packages/@ember/object/core.js

@@ -1,14 +1,14 @@
 import { g as getFactoryFor, s as setFactoryFor } from '../../shared-chunks/container-BYOnjnwz.js';
 import { getOwner } from '../-internals/owner/index.js';
-import { a as guidFor } from '../../shared-chunks/guid-PO2v9BaN.js';
+import { g as guidFor } from '../../shared-chunks/guid-Cbq2sNV_.js';
 import { meta } from '../-internals/meta/lib/meta.js';
-import '../../shared-chunks/property_get-Sw0SicEZ.js';
-import { s as sendEvent } from '../../shared-chunks/events-C7aYCy0N.js';
-import { a as activateObserver } from '../../shared-chunks/observers-Ci31SE36.js';
-import { b as descriptorForProperty } from '../../shared-chunks/decorator-B8Lpq40g.js';
+import '../../shared-chunks/property_get-DAKgbeJX.js';
+import { s as sendEvent } from '../../shared-chunks/events-DYrYz3V8.js';
+import { a as activateObserver } from '../../shared-chunks/observers-BmobpXAF.js';
+import { d as descriptorForProperty } from '../../shared-chunks/decorator-9ikVwsjY.js';
 import { registerDestructor, isDestroyed, isDestroying, destroy } from '../../@glimmer/destroyable/index.js';
-import '../../shared-chunks/cache-CG6_L9db.js';
-import '../../shared-chunks/reference-D2agTt1V.js';
+import '../../shared-chunks/cache-CofLhaS4.js';
+import '../../shared-chunks/reference-CG0yPgLy.js';
 import Mixin, { applyMixin } from './mixin.js';
 import '../-internals/runtime/lib/mixins/action_handler.js';
 import makeArray from '../array/lib/make-array.js';

package/dist/prod/packages/@ember/object/evented.js

@@ -1,5 +1,5 @@
-import { h as hasListeners, r as removeListener, s as sendEvent, a as addListener } from '../../shared-chunks/events-C7aYCy0N.js';
-export { o as on } from '../../shared-chunks/events-C7aYCy0N.js';
+import { h as hasListeners, r as removeListener, s as sendEvent, a as addListener } from '../../shared-chunks/events-DYrYz3V8.js';
+export { o as on } from '../../shared-chunks/events-DYrYz3V8.js';
 import Mixin from './mixin.js';
 
 /**

package/dist/prod/packages/@ember/object/events.js

@@ -1 +1 @@
-export { a as addListener, r as removeListener, s as sendEvent } from '../../shared-chunks/events-C7aYCy0N.js';
+export { a as addListener, r as removeListener, s as sendEvent } from '../../shared-chunks/events-DYrYz3V8.js';

package/dist/prod/packages/@ember/object/index.js

@@ -1,15 +1,15 @@
 import { E as ENV } from '../../shared-chunks/env-DXxsTFkM.js';
-import { s as setClassicDecorator, c as isElementDescriptor } from '../../shared-chunks/decorator-B8Lpq40g.js';
-import { i as expandProperties } from '../../shared-chunks/computed-D6MVTTDd.js';
-export { d as computed, f as defineProperty, n as notifyPropertyChange } from '../../shared-chunks/computed-D6MVTTDd.js';
+import { s as setClassicDecorator, i as isElementDescriptor } from '../../shared-chunks/decorator-9ikVwsjY.js';
+import { e as expandProperties } from '../../shared-chunks/computed-DtIStxvq.js';
+export { c as computed, d as defineProperty, n as notifyPropertyChange } from '../../shared-chunks/computed-DtIStxvq.js';
 import { g as getFactoryFor } from '../../shared-chunks/container-BYOnjnwz.js';
-import { a as setObservers } from '../../shared-chunks/super-D4qkU4uq.js';
+import { s as setObservers } from '../../shared-chunks/super-BBBjgF69.js';
 import CoreObject from './core.js';
 import Observable from './observable.js';
-export { g as get } from '../../shared-chunks/property_get-Sw0SicEZ.js';
-export { s as set, t as trySet } from '../../shared-chunks/property_set-SHEIPMUG.js';
-export { g as getProperties } from '../../shared-chunks/get_properties-wj_Qmotj.js';
-export { s as setProperties } from '../../shared-chunks/set_properties-CcLLHg1w.js';
+export { g as get } from '../../shared-chunks/property_get-DAKgbeJX.js';
+export { s as set, t as trySet } from '../../shared-chunks/property_set-BaQJdVfS.js';
+export { g as getProperties } from '../../shared-chunks/get_properties-Dg3xFpiS.js';
+export { s as setProperties } from '../../shared-chunks/set_properties-Qxhw4qzw.js';
 
 /**
 @module @ember/object
@@ -38,8 +38,8 @@ class EmberObject extends CoreObject.extend(Observable) {
   Decorator that turns the target function into an Action which can be accessed
   directly by reference.
 
-  ```js
-  import Component from '@ember/component';
+  ```gjs
+  import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
   import { action } from '@ember/object';
 
@@ -50,24 +50,24 @@ class EmberObject extends CoreObject.extend(Observable) {
     toggleShowing() {
       this.isShowing = !this.isShowing;
     }
+    
+    <template>
+      <button {{on "click" this.toggleShowing}}>Show tooltip</button>
+    
+      {{#if isShowing}}
+        <div class="tooltip">
+          I'm a tooltip!
+        </div>
+      {{/if}}
+    </template>
   }
   ```
-  ```hbs
-  <!-- template.hbs -->
-  <button {{on "click" this.toggleShowing}}>Show tooltip</button>
-
-  {{#if isShowing}}
-    <div class="tooltip">
-      I'm a tooltip!
-    </div>
-  {{/if}}
-  ```
 
   It also binds the function directly to the instance, so it can be used in any
   context and will correctly refer to the class it came from:
 
-  ```js
-  import Component from '@ember/component';
+  ```gjs
+  import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
   import { action } from '@ember/object';
 
@@ -86,6 +86,10 @@ class EmberObject extends CoreObject.extend(Observable) {
     toggleShowing() {
       this.isShowing = !this.isShowing;
     }
+    
+    <template>
+      {{!-- ...--}}
+    </template>
   }
   ```
 
@@ -164,9 +168,10 @@ setClassicDecorator(action);
   });
   ```
 
-  Also available as `Function.prototype.observes` if prototype extensions are
-  enabled.
-
+  While observers are still supported, there are [plans to deprecate them](https://github.com/emberjs/rfcs/pull/1115)
+  See the [in-progress deprecation guide](https://github.com/ember-learn/deprecation-app/pull/1407) 
+  for guidance on how to avoid using observers.
+ 
   @method observer
   @for @ember/object
   @param {String} propertyNames*

package/dist/prod/packages/@ember/object/internals.js

@@ -1,4 +1,4 @@
 export { g as cacheFor } from '../../shared-chunks/computed_cache-DmYKevAP.js';
-export { a as guidFor } from '../../shared-chunks/guid-PO2v9BaN.js';
-import '../../shared-chunks/super-D4qkU4uq.js';
+export { g as guidFor } from '../../shared-chunks/guid-Cbq2sNV_.js';
+import '../../shared-chunks/super-BBBjgF69.js';
 import './index.js';

package/dist/prod/packages/@ember/object/lib/computed/computed_macros.js

@@ -1,7 +1,7 @@
-import { d as computed, i as expandProperties } from '../../../../shared-chunks/computed-D6MVTTDd.js';
-import { a as alias } from '../../../../shared-chunks/alias-DsIh-16z.js';
-import { g as get } from '../../../../shared-chunks/property_get-Sw0SicEZ.js';
-import { s as set } from '../../../../shared-chunks/property_set-SHEIPMUG.js';
+import { c as computed, e as expandProperties } from '../../../../shared-chunks/computed-DtIStxvq.js';
+import { a as alias } from '../../../../shared-chunks/alias-Bod6qdNp.js';
+import { g as get } from '../../../../shared-chunks/property_get-DAKgbeJX.js';
+import { s as set } from '../../../../shared-chunks/property_set-BaQJdVfS.js';
 import isEmpty from '../../../utils/lib/is_empty.js';
 import isNone from '../../../utils/lib/is_none.js';
 

package/dist/prod/packages/@ember/object/lib/computed/reduce_computed_macros.js

@@ -1,5 +1,5 @@
-import { d as computed, a as autoComputed } from '../../../../shared-chunks/computed-D6MVTTDd.js';
-import { g as get } from '../../../../shared-chunks/property_get-Sw0SicEZ.js';
+import { c as computed, i as autoComputed } from '../../../../shared-chunks/computed-DtIStxvq.js';
+import { g as get } from '../../../../shared-chunks/property_get-DAKgbeJX.js';
 import compare from '../../../utils/lib/compare.js';
 import EmberArray, { A, uniqBy as uniqBy$1 } from '../../../array/index.js';
 

package/dist/prod/packages/@ember/object/mixin.js

@@ -1,10 +1,10 @@
 import { peekMeta, meta } from '../-internals/meta/lib/meta.js';
-import { R as ROOT, o as observerListenerMetaFor, w as wrap } from '../../shared-chunks/super-D4qkU4uq.js';
-import { n as nativeDescDecorator, i as isClassicDecorator, d as descriptorForDecorator, m as makeComputedDecorator } from '../../shared-chunks/decorator-B8Lpq40g.js';
-import { g as defineValue, e as defineDecorator, C as ComputedProperty } from '../../shared-chunks/computed-D6MVTTDd.js';
-import { e as setUnprocessedMixins } from '../../shared-chunks/namespace_search-TFdmjK_a.js';
-import { e as revalidateObservers, b as addObserver, r as removeObserver } from '../../shared-chunks/observers-Ci31SE36.js';
-import { a as addListener, r as removeListener } from '../../shared-chunks/events-C7aYCy0N.js';
+import { R as ROOT, o as observerListenerMetaFor, w as wrap } from '../../shared-chunks/super-BBBjgF69.js';
+import { n as nativeDescDecorator, a as isClassicDecorator, b as descriptorForDecorator, m as makeComputedDecorator } from '../../shared-chunks/decorator-9ikVwsjY.js';
+import { g as defineValue, h as defineDecorator, C as ComputedProperty } from '../../shared-chunks/computed-DtIStxvq.js';
+import { s as setUnprocessedMixins } from '../../shared-chunks/namespace_search-BfvzEQzN.js';
+import { c as revalidateObservers, b as addObserver, r as removeObserver } from '../../shared-chunks/observers-BmobpXAF.js';
+import { a as addListener, r as removeListener } from '../../shared-chunks/events-DYrYz3V8.js';
 
 /**
 @module @ember/object/mixin

package/dist/prod/packages/@ember/object/observable.js

@@ -1,11 +1,11 @@
 import { peekMeta } from '../-internals/meta/lib/meta.js';
-import { h as hasListeners } from '../../shared-chunks/events-C7aYCy0N.js';
-import { n as notifyPropertyChange, h as endPropertyChanges, b as beginPropertyChanges } from '../../shared-chunks/computed-D6MVTTDd.js';
-import { r as removeObserver, b as addObserver } from '../../shared-chunks/observers-Ci31SE36.js';
-import { g as get } from '../../shared-chunks/property_get-Sw0SicEZ.js';
-import { s as set } from '../../shared-chunks/property_set-SHEIPMUG.js';
-import { g as getProperties } from '../../shared-chunks/get_properties-wj_Qmotj.js';
-import { s as setProperties } from '../../shared-chunks/set_properties-CcLLHg1w.js';
+import { h as hasListeners } from '../../shared-chunks/events-DYrYz3V8.js';
+import { n as notifyPropertyChange, a as endPropertyChanges, b as beginPropertyChanges } from '../../shared-chunks/computed-DtIStxvq.js';
+import { r as removeObserver, b as addObserver } from '../../shared-chunks/observers-BmobpXAF.js';
+import { g as get } from '../../shared-chunks/property_get-DAKgbeJX.js';
+import { s as set } from '../../shared-chunks/property_set-BaQJdVfS.js';
+import { g as getProperties } from '../../shared-chunks/get_properties-Dg3xFpiS.js';
+import { s as setProperties } from '../../shared-chunks/set_properties-Qxhw4qzw.js';
 import Mixin from './mixin.js';
 
 /**

package/dist/prod/packages/@ember/object/observers.js

@@ -1 +1 @@
-export { b as addObserver, r as removeObserver } from '../../shared-chunks/observers-Ci31SE36.js';
+export { b as addObserver, r as removeObserver } from '../../shared-chunks/observers-BmobpXAF.js';

package/dist/prod/packages/@ember/object/promise-proxy-mixin.js

@@ -1,6 +1,6 @@
-import { g as get } from '../../shared-chunks/property_get-Sw0SicEZ.js';
-import { s as setProperties } from '../../shared-chunks/set_properties-CcLLHg1w.js';
-import { d as computed } from '../../shared-chunks/computed-D6MVTTDd.js';
+import { g as get } from '../../shared-chunks/property_get-DAKgbeJX.js';
+import { s as setProperties } from '../../shared-chunks/set_properties-Qxhw4qzw.js';
+import { c as computed } from '../../shared-chunks/computed-DtIStxvq.js';
 import Mixin from './mixin.js';
 
 /**

package/dist/prod/packages/@ember/reactive/collections.js

@@ -1,4 +1,4 @@
-import { k as consumeTag, n as createUpdatableTag, D as DIRTY_TAG } from '../../shared-chunks/cache-CG6_L9db.js';
+import { c as consumeTag, b as createUpdatableTag, D as DIRTY_TAG } from '../../shared-chunks/cache-CofLhaS4.js';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // Unfortunately, TypeScript's ability to do inference *or* type-checking in a
@@ -147,102 +147,6 @@ function trackedArray(data, options) {
   });
 }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// Using a Proxy-based approach so that any new methods added to the Map
-// interface (like getOrInsert, getOrInsertComputed, etc.) are automatically
-// supported without needing to manually re-implement each one.
-
-function trackedMap(data, options) {
-  const equals = options?.equals ?? Object.is;
-  // TypeScript doesn't correctly resolve the overloads for calling the `Map`
-  // constructor for the no-value constructor. This resolves that.
-  const target = data instanceof Map ? new Map(data.entries()) : new Map(data ?? []);
-  const collection = createUpdatableTag();
-  const storages = new Map();
-  function storageFor(key) {
-    let storage = storages.get(key);
-    if (storage === undefined) {
-      storage = createUpdatableTag();
-      storages.set(key, storage);
-    }
-    return storage;
-  }
-  function dirtyStorageFor(key) {
-    const storage = storages.get(key);
-    if (storage) {
-      DIRTY_TAG(storage);
-    }
-  }
-  const proxy = new Proxy(target, {
-    get(target, prop, receiver) {
-      if (prop === 'set') {
-        return function (key, value) {
-          const hasExisting = target.has(key);
-          if (hasExisting) {
-            // TS doesn't know about the relationship between has and get
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const isUnchanged = equals(target.get(key), value);
-            if (isUnchanged) return proxy;
-          }
-          dirtyStorageFor(key);
-          DIRTY_TAG(collection);
-          target.set(key, value);
-          return proxy;
-        };
-      }
-      if (prop === 'delete') {
-        return function (key) {
-          if (!target.has(key)) return false;
-          dirtyStorageFor(key);
-          DIRTY_TAG(collection);
-          storages.delete(key);
-          return target.delete(key);
-        };
-      }
-      if (prop === 'clear') {
-        return function () {
-          if (target.size === 0) return;
-          storages.forEach(s => DIRTY_TAG(s));
-          storages.clear();
-          DIRTY_TAG(collection);
-          target.clear();
-        };
-      }
-      if (prop === 'get') {
-        return function (key) {
-          consumeTag(storageFor(key));
-          return target.get(key);
-        };
-      }
-      if (prop === 'has') {
-        return function (key) {
-          consumeTag(storageFor(key));
-          return target.has(key);
-        };
-      }
-      if (prop === 'size') {
-        consumeTag(collection);
-        return target.size;
-      }
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      const value = Reflect.get(target, prop, receiver);
-      if (typeof value === 'function') {
-        return function (...args) {
-          consumeTag(collection);
-
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-          return value.apply(target, args);
-        };
-      }
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return value;
-    }
-  });
-  return proxy;
-}
-
 class TrackedObject {
   #options;
   #storages = new Map();
@@ -422,19 +326,108 @@ function trackedSet(data, options) {
   return proxy;
 }
 
-// Using a Proxy-based approach so that any new methods added to the WeakMap
+// Using a Proxy-based approach so that any new methods added to the WeakSet
+// interface are automatically supported without needing to manually
+// re-implement each one.
+
+/**
+ * NOTE: we cannot pass a WeakSet because WeakSets are not iterable
+ */
+/**
+ * Creates an instanceof WeakSet from an optional list of entries
+ *
+ */
+function trackedWeakSet(data, options) {
+  const equals = options?.equals ?? Object.is;
+  const target = new WeakSet(data ?? []);
+  const storages = new WeakMap();
+  function storageFor(key) {
+    let storage = storages.get(key);
+    if (storage === undefined) {
+      storage = createUpdatableTag();
+      storages.set(key, storage);
+    }
+    return storage;
+  }
+  function dirtyStorageFor(key) {
+    const storage = storages.get(key);
+    if (storage) {
+      DIRTY_TAG(storage);
+    }
+  }
+  const proxy = new Proxy(target, {
+    get(target, prop, receiver) {
+      if (prop === 'add') {
+        return function (value) {
+          /**
+           * In a WeakSet, there is no `.get()`, but if there was,
+           * we could assume it's the same value as what we passed.
+           *
+           * So for a WeakSet, if we try to add something that already exists
+           * we no-op.
+           *
+           * WeakSet already does this internally for us,
+           * but we want the ability for the reactive behavior to reflect the same behavior.
+           *
+           * i.e.: doing weakSet.add(value) should never dirty with the defaults
+           *       if the `value` is already in the weakSet
+           */
+          if (target.has(value)) {
+            /**
+             * This looks a little silly, where a always will === b,
+             * but see the note above.
+             */
+            const isUnchanged = equals(value, value);
+            if (isUnchanged) return proxy;
+          }
+
+          // Add to vals first to get better error message
+          target.add(value);
+          dirtyStorageFor(value);
+          return proxy;
+        };
+      }
+      if (prop === 'delete') {
+        return function (value) {
+          if (!target.has(value)) return false;
+          dirtyStorageFor(value);
+          storages.delete(value);
+          return target.delete(value);
+        };
+      }
+      if (prop === 'has') {
+        return function (value) {
+          consumeTag(storageFor(value));
+          return target.has(value);
+        };
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+        return value.bind(target);
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return value;
+    }
+  });
+  return proxy;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Using a Proxy-based approach so that any new methods added to the Map
 // interface (like getOrInsert, getOrInsertComputed, etc.) are automatically
 // supported without needing to manually re-implement each one.
 
-function trackedWeakMap(data, options) {
+function trackedMap(data, options) {
   const equals = options?.equals ?? Object.is;
-  const existing = data ?? [];
-  /**
-   * SAFETY: note that when passing in an existing weak map, we can't
-   *         clone it as it is not iterable and not a supported type of structuredClone
-   */
-  const target = existing instanceof WeakMap ? existing : new WeakMap(existing);
-  const storages = new WeakMap();
+  // TypeScript doesn't correctly resolve the overloads for calling the `Map`
+  // constructor for the no-value constructor. This resolves that.
+  const target = data instanceof Map ? new Map(data.entries()) : new Map(data ?? []);
+  const collection = createUpdatableTag();
+  const storages = new Map();
   function storageFor(key) {
     let storage = storages.get(key);
     if (storage === undefined) {
@@ -455,10 +448,13 @@ function trackedWeakMap(data, options) {
         return function (key, value) {
           const hasExisting = target.has(key);
           if (hasExisting) {
+            // TS doesn't know about the relationship between has and get
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const isUnchanged = equals(target.get(key), value);
             if (isUnchanged) return proxy;
           }
           dirtyStorageFor(key);
+          DIRTY_TAG(collection);
           target.set(key, value);
           return proxy;
         };
@@ -467,10 +463,20 @@ function trackedWeakMap(data, options) {
         return function (key) {
           if (!target.has(key)) return false;
           dirtyStorageFor(key);
+          DIRTY_TAG(collection);
           storages.delete(key);
           return target.delete(key);
         };
       }
+      if (prop === 'clear') {
+        return function () {
+          if (target.size === 0) return;
+          storages.forEach(s => DIRTY_TAG(s));
+          storages.clear();
+          DIRTY_TAG(collection);
+          target.clear();
+        };
+      }
       if (prop === 'get') {
         return function (key) {
           consumeTag(storageFor(key));
@@ -483,12 +489,20 @@ function trackedWeakMap(data, options) {
           return target.has(key);
         };
       }
+      if (prop === 'size') {
+        consumeTag(collection);
+        return target.size;
+      }
 
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       const value = Reflect.get(target, prop, receiver);
       if (typeof value === 'function') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-        return value.bind(target);
+        return function (...args) {
+          consumeTag(collection);
+
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+          return value.apply(target, args);
+        };
       }
 
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
@@ -498,20 +512,18 @@ function trackedWeakMap(data, options) {
   return proxy;
 }
 
-// Using a Proxy-based approach so that any new methods added to the WeakSet
-// interface are automatically supported without needing to manually
-// re-implement each one.
+// Using a Proxy-based approach so that any new methods added to the WeakMap
+// interface (like getOrInsert, getOrInsertComputed, etc.) are automatically
+// supported without needing to manually re-implement each one.
 
-/**
- * NOTE: we cannot pass a WeakSet because WeakSets are not iterable
- */
-/**
- * Creates an instanceof WeakSet from an optional list of entries
- *
- */
-function trackedWeakSet(data, options) {
+function trackedWeakMap(data, options) {
   const equals = options?.equals ?? Object.is;
-  const target = new WeakSet(data ?? []);
+  const existing = data ?? [];
+  /**
+   * SAFETY: note that when passing in an existing weak map, we can't
+   *         clone it as it is not iterable and not a supported type of structuredClone
+   */
+  const target = existing instanceof WeakMap ? existing : new WeakMap(existing);
   const storages = new WeakMap();
   function storageFor(key) {
     let storage = storages.get(key);
@@ -529,48 +541,36 @@ function trackedWeakSet(data, options) {
   }
   const proxy = new Proxy(target, {
     get(target, prop, receiver) {
-      if (prop === 'add') {
-        return function (value) {
-          /**
-           * In a WeakSet, there is no `.get()`, but if there was,
-           * we could assume it's the same value as what we passed.
-           *
-           * So for a WeakSet, if we try to add something that already exists
-           * we no-op.
-           *
-           * WeakSet already does this internally for us,
-           * but we want the ability for the reactive behavior to reflect the same behavior.
-           *
-           * i.e.: doing weakSet.add(value) should never dirty with the defaults
-           *       if the `value` is already in the weakSet
-           */
-          if (target.has(value)) {
-            /**
-             * This looks a little silly, where a always will === b,
-             * but see the note above.
-             */
-            const isUnchanged = equals(value, value);
+      if (prop === 'set') {
+        return function (key, value) {
+          const hasExisting = target.has(key);
+          if (hasExisting) {
+            const isUnchanged = equals(target.get(key), value);
             if (isUnchanged) return proxy;
           }
-
-          // Add to vals first to get better error message
-          target.add(value);
-          dirtyStorageFor(value);
+          dirtyStorageFor(key);
+          target.set(key, value);
           return proxy;
         };
       }
       if (prop === 'delete') {
-        return function (value) {
-          if (!target.has(value)) return false;
-          dirtyStorageFor(value);
-          storages.delete(value);
-          return target.delete(value);
+        return function (key) {
+          if (!target.has(key)) return false;
+          dirtyStorageFor(key);
+          storages.delete(key);
+          return target.delete(key);
+        };
+      }
+      if (prop === 'get') {
+        return function (key) {
+          consumeTag(storageFor(key));
+          return target.get(key);
         };
       }
       if (prop === 'has') {
-        return function (value) {
-          consumeTag(storageFor(value));
-          return target.has(value);
+        return function (key) {
+          consumeTag(storageFor(key));
+          return target.has(key);
         };
       }
 

package/dist/prod/packages/@ember/renderer/index.js

@@ -1 +1 @@
-export { r as renderComponent, a as renderSettled } from '../../shared-chunks/index-DabsnYit.js';
+export { r as renderComponent, a as renderSettled } from '../../shared-chunks/index-npr2B-vu.js';

package/dist/prod/packages/@ember/routing/index.js

@@ -3,11 +3,11 @@ import { getEngineParent } from '../engine/lib/engine-parent.js';
 import { flaggedInstrument } from '../instrumentation/index.js';
 import { action } from '../object/index.js';
 import { service } from '../service/index.js';
-import { k as consumeTag, l as createCache, q as getValue, w as untrack } from '../../shared-chunks/cache-CG6_L9db.js';
-import { t as tagFor } from '../../shared-chunks/meta-Ce6-qROq.js';
+import { c as consumeTag, e as createCache, g as getValue, u as untrack } from '../../shared-chunks/cache-CofLhaS4.js';
+import { t as tagFor } from '../../shared-chunks/meta-BJtIZDir.js';
 import { on } from '../modifier/on.js';
-import { h as templateFactory } from '../../shared-chunks/index-D-rcNBLp.js';
-import { I as InternalComponent, o as opaquify } from '../../shared-chunks/internal-BEJC2IJ-.js';
+import { t as templateFactory } from '../../shared-chunks/index-Bf53M8eS.js';
+import { I as InternalComponent, o as opaquify } from '../../shared-chunks/internal-BQ7zHrqS.js';
 import { d as decorateFieldV2, i as initializeDeferredDecorator, a as decorateMethodV2 } from '../../shared-chunks/runtime-CYyqkz5q-BOdRhmsS.js';
 
 const LinkToTemplate = templateFactory(
@@ -58,10 +58,14 @@ function isQueryParams(value) {
   supplied model to the route as its `model` context of the route. The block for `LinkTo`
   becomes the contents of the rendered element:
 
-  ```handlebars
-  <LinkTo @route='photoGallery'>
-    Great Hamster Photos
-  </LinkTo>
+  ```gjs
+  import { LinkTo } from '@ember/routing';
+    
+  <template>
+    <LinkTo @route='photoGallery'>
+      Great Hamster Photos
+    </LinkTo>
+  </template>
   ```
 
   This will result in: