ember-source 7.2.0-alpha.4 → 7.2.0

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

@@ -1,4 +1,4 @@
-import { k as consumeTag, n as createUpdatableTag, D as DIRTY_TAG } from '../../shared-chunks/cache-CeWOBNQg.js';
+import { c as consumeTag, b as createUpdatableTag, D as DIRTY_TAG } from '../../shared-chunks/cache-DGDPVCpC.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/dev/packages/@ember/renderer/index.js

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

package/dist/dev/packages/@ember/routing/-internals.js

@@ -5,9 +5,9 @@ export { default as generateController, generateControllerFactory } from './lib/
 export { default as BucketCache } from './lib/cache.js';
 export { default as DSL } from './lib/dsl.js';
 export { default as controllerFor } from './lib/controller_for.js';
-import '../../shared-chunks/property_get-BjbsrgpU.js';
+import '../../shared-chunks/property_get-CRP7MFz_.js';
 import '../debug/index.js';
 import '../engine/instance.js';
 import '../../route-recognizer/index.js';
-import '../../shared-chunks/rsvp-C6j8G1D1.js';
-import '../../shared-chunks/unrecognized-url-error-BQdkjTtZ.js';
+import '../../shared-chunks/rsvp-aLN_pQtn.js';
+import '../../shared-chunks/unrecognized-url-error-DyurFqvv.js';

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

@@ -5,11 +5,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, r as getValue, x as untrack } from '../../shared-chunks/cache-CeWOBNQg.js';
-import { t as tagFor } from '../../shared-chunks/meta-Cjo3zQJq.js';
+import { c as consumeTag, g as createCache, h as getValue, u as untrack } from '../../shared-chunks/cache-DGDPVCpC.js';
+import { t as tagFor } from '../../shared-chunks/meta-BqC7f9Ia.js';
 import { on } from '../modifier/on.js';
-import { h as templateFactory } from '../../shared-chunks/index-DkwVSPP5.js';
-import { I as InternalComponent, o as opaquify } from '../../shared-chunks/internal-Bpr6ihB_.js';
+import { t as templateFactory } from '../../shared-chunks/index-DaFzpTIE.js';
+import { I as InternalComponent, o as opaquify } from '../../shared-chunks/internal-DTOXyEGM.js';
 import { d as decorateFieldV2, i as initializeDeferredDecorator, a as decorateMethodV2 } from '../../shared-chunks/runtime-CYyqkz5q-BOdRhmsS.js';
 import { assert } from '../debug/lib/assert.js';
 
@@ -58,15 +58,23 @@ function isQueryParams(value) {
   return typeof value === 'object' && value !== null && value['isQueryParams'] === true;
 }
 
+/**
+ @module @ember/routing
+ */
+
 /**
   The `LinkTo` component renders a link to the supplied `routeName` passing an optionally
   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:
@@ -261,35 +269,11 @@ function isQueryParams(value) {
   </a>
   ```
 
-  @for Ember.Templates.components
-  @method LinkTo
-  @public
-*/
-
-/**
-  @module @ember/routing
-*/
-
-/**
-  See [Ember.Templates.components.LinkTo](/ember/release/classes/Ember.Templates.components/methods/input?anchor=LinkTo).
-
-  @for Ember.Templates.helpers
-  @method link-to
-  @see {Ember.Templates.components.LinkTo}
-  @public
-**/
-
-/**
-  An opaque interface which can be imported and used in strict-mode
-  templates to call <LinkTo>.
-
-  See [Ember.Templates.components.LinkTo](/ember/release/classes/Ember.Templates.components/methods/input?anchor=LinkTo).
-
   @for @ember/routing
   @method LinkTo
-  @see {Ember.Templates.components.LinkTo}
+  @static
   @public
-**/
+*/
 
 class _LinkTo extends InternalComponent {
   static toString() {

package/dist/dev/packages/@ember/routing/lib/generate_controller.js

@@ -1,5 +1,4 @@
-import { g as get } from '../../../shared-chunks/property_get-BjbsrgpU.js';
-import Controller from '../../controller/index.js';
+import { g as get } from '../../../shared-chunks/property_get-CRP7MFz_.js';
 import { info } from '../../debug/index.js';
 import { assert } from '../../debug/lib/assert.js';
 
@@ -54,7 +53,7 @@ function generateController(owner, controllerName) {
   generateControllerFactory(owner, controllerName);
   let fullName = `controller:${controllerName}`;
   let instance = owner.lookup(fullName);
-  (!(instance instanceof Controller) && assert('Expected an instance of controller', instance instanceof Controller));
+  (!(instance != null && instance.isController === true) && assert('Expected an instance of controller', instance != null && instance.isController === true));
   {
     if (get(instance, 'namespace.LOG_ACTIVE_GENERATION')) {
       info(`generated -> ${fullName}`, {

package/dist/dev/packages/@ember/routing/lib/routing-service.js

@@ -3,12 +3,12 @@ import '../../debug/index.js';
 import '../../-internals/meta/lib/meta.js';
 import { assert } from '../../debug/lib/assert.js';
 import '../../../@glimmer/destroyable/index.js';
-import '../../../shared-chunks/cache-CeWOBNQg.js';
+import '../../../shared-chunks/cache-DGDPVCpC.js';
 import '../../../shared-chunks/mandatory-setter-BpbAMTzV.js';
-import '../../../shared-chunks/reference-C-OXd_kp.js';
-import '../../../shared-chunks/decorator-DYQwMItS.js';
-import '../../../shared-chunks/observers-CejcZw5s.js';
-import '../../../shared-chunks/property_get-BjbsrgpU.js';
+import '../../../shared-chunks/reference-BqOLhKFy.js';
+import '../../../shared-chunks/decorator-B5Uh5NFI.js';
+import '../../../shared-chunks/observers-DMlX2nCi.js';
+import '../../../shared-chunks/property_get-CRP7MFz_.js';
 import { readOnly } from '../../object/lib/computed/computed_macros.js';
 import '../../object/core.js';
 import '../../-internals/runtime/lib/mixins/comparable.js';

package/dist/dev/packages/@ember/routing/lib/utils.js

@@ -1,10 +1,10 @@
-import { g as get } from '../../../shared-chunks/property_get-BjbsrgpU.js';
+import { g as get } from '../../../shared-chunks/property_get-CRP7MFz_.js';
 import { getOwner } from '../../-internals/owner/index.js';
 import '../../debug/index.js';
 import EngineInstance from '../../engine/instance.js';
 import '../../../route-recognizer/index.js';
-import '../../../shared-chunks/rsvp-C6j8G1D1.js';
-import { S as STATE_SYMBOL } from '../../../shared-chunks/unrecognized-url-error-BQdkjTtZ.js';
+import '../../../shared-chunks/rsvp-aLN_pQtn.js';
+import { S as STATE_SYMBOL } from '../../../shared-chunks/unrecognized-url-error-DyurFqvv.js';
 import { assert } from '../../debug/lib/assert.js';
 
 const ALL_PERIODS_REGEX = /\./g;

package/dist/dev/packages/@ember/routing/route.js

@@ -1,12 +1,12 @@
 import { privatize } from '../-internals/container/index.js';
-import { f as flushAsyncObservers, b as addObserver } from '../../shared-chunks/observers-CejcZw5s.js';
-import { f as defineProperty, d as computed } from '../../shared-chunks/computed-Daavz6vC.js';
-import { b as descriptorForProperty } from '../../shared-chunks/decorator-DYQwMItS.js';
+import { f as flushAsyncObservers, b as addObserver } from '../../shared-chunks/observers-DMlX2nCi.js';
+import { c as computed, d as defineProperty } from '../../shared-chunks/computed-BPCtuOxQ.js';
+import { d as descriptorForProperty } from '../../shared-chunks/decorator-B5Uh5NFI.js';
 import { getOwner } from '../-internals/owner/index.js';
-import { g as get } from '../../shared-chunks/property_get-BjbsrgpU.js';
-import { s as set } from '../../shared-chunks/property_set-LJskl202.js';
-import { g as getProperties } from '../../shared-chunks/get_properties-B203vZpz.js';
-import { s as setProperties } from '../../shared-chunks/set_properties-CNds2HCH.js';
+import { g as get } from '../../shared-chunks/property_get-CRP7MFz_.js';
+import { s as set } from '../../shared-chunks/property_set-qCUylPEK.js';
+import { g as getProperties } from '../../shared-chunks/get_properties-Cm2sWt5f.js';
+import { s as setProperties } from '../../shared-chunks/set_properties-C4TSebH6.js';
 import EmberObject from '../object/index.js';
 import Evented from '../object/evented.js';
 import { A } from '../array/index.js';
@@ -20,10 +20,10 @@ import { info } from '../debug/index.js';
 import EngineInstance from '../engine/instance.js';
 import { dependentKeyCompat } from '../object/compat.js';
 import { once } from '../runloop/index.js';
-import { c as hasInternalComponentManager } from '../../shared-chunks/api-DG5kRT-o.js';
+import { c as hasInternalComponentManager } from '../../shared-chunks/api-DuLOZMO_.js';
 import '../../route-recognizer/index.js';
-import '../../shared-chunks/rsvp-C6j8G1D1.js';
-import { S as STATE_SYMBOL, P as PARAMS_SYMBOL } from '../../shared-chunks/unrecognized-url-error-BQdkjTtZ.js';
+import '../../shared-chunks/rsvp-aLN_pQtn.js';
+import { S as STATE_SYMBOL, P as PARAMS_SYMBOL } from '../../shared-chunks/unrecognized-url-error-DyurFqvv.js';
 import generateController from './lib/generate_controller.js';
 import { prefixRouteNameArg, stashParamNames, calculateCacheKey, normalizeControllerQueryParams } from './lib/utils.js';
 import { a as decorateMethodV2 } from '../../shared-chunks/runtime-CYyqkz5q-BOdRhmsS.js';
@@ -769,7 +769,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     ```
      Note that for routes with dynamic segments, this hook is not always
     executed. If the route is entered through a transition (e.g. when
-    using the `link-to` Handlebars helper or the `transitionTo` method
+    using the `link-to` helper or the `transitionTo` method
     of routes), and a model context is already provided this hook
     is not called.
      A model context does not include a primitive string or number,
@@ -897,7 +897,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
      If you have defined a file for the post controller,
     the framework will use it.
     If it is not defined, a basic `Controller` instance would be used.
-     @example Behavior of a basic Controller
+     Example Behavior of a basic Controller
      ```app/routes/post.js
     import Route from '@ember/routing/route';
      export default class PostRoute extends Route {