@ember-data/tracking 5.4.0-alpha.32 → 5.4.0-alpha.33

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ember-data/tracking",
   "description": "Tracking Primitives for controlling change notification of Tracked properties when working with EmberData",
-  "version": "5.4.0-alpha.32",
+  "version": "5.4.0-alpha.33",
   "private": false,
   "license": "MIT",
   "author": "Chris Thoburn <runspired@users.noreply.github.com>",
@@ -27,7 +27,7 @@
     }
   },
   "dependencies": {
-    "@ember-data/private-build-infra": "5.4.0-alpha.32",
+    "@ember-data/private-build-infra": "5.4.0-alpha.33",
     "@embroider/macros": "^1.13.5",
     "ember-cached-decorator-polyfill": "^1.0.2",
     "ember-cli-babel": "^8.2.0",
@@ -63,7 +63,7 @@
     "@glimmer/validator": "^0.88.1",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@warp-drive/internal-config": "5.4.0-alpha.32",
+    "@warp-drive/internal-config": "5.4.0-alpha.33",
     "ember-source": "~5.6.0",
     "rollup": "^4.9.6",
     "typescript": "^5.3.3",

package/unstable-preview-types/-private.d.ts

@@ -1,186 +1,188 @@
-/// <reference types="ember-source/types" />
-/// <reference types="ember-source/types" />
-import { tagForProperty } from '@ember/-internals/metal';
-/**
- * This package provides primitives that allow powerful low-level
- * adjustments to change tracking notification behaviors.
- *
- * Typically you want to use these primitives when you want to divorce
- * property accesses on EmberData provided objects from the current
- * tracking context. Typically this sort of thing occurs when serializing
- * tracked data to send in a request: the data itself is often ancillary
- * to the thing which triggered the request in the first place and you
- * would not want to re-trigger the request for any update to the data.
- *
- * @module @ember-data/tracking
- * @main @ember-data/tracking
- */
-type OpaqueFn = (...args: unknown[]) => unknown;
-type Tag = {
-    ref: null;
-    t: boolean;
-};
-/**
- * If there is a current transaction, ensures that the relevant tag (and any
- * array computed chains symbols, if applicable) will be consumed during the
- * transaction.
- *
- * If there is no current transaction, will consume the tag(s) immediately.
- *
- * @internal
- * @param obj
- */
-export declare function subscribe(obj: Tag | Signal): void;
-export declare function addToTransaction(obj: Tag | Signal): void;
-export declare function addTransactionCB(method: OpaqueFn): void;
-/**
- * Run `method` without subscribing to any tracked properties
- * controlled by EmberData.
- *
- * This should rarely be used except by libraries that really
- * know what they are doing. It is most useful for wrapping
- * certain kinds of fetch/query logic from within a `Resource`
- * `hook` or other similar pattern.
- *
- * @function untracked
- * @public
- * @static
- * @for @ember-data/tracking
- * @param method
- * @return result of invoking method
- */
-export declare function untracked<T extends OpaqueFn>(method: T): ReturnType<T>;
-/**
- * Run the method, subscribing to any tracked properties
- * managed by EmberData that were accessed or written during
- * the method's execution as per-normal but while allowing
- * interleaving of reads and writes.
- *
- * This is useful when for instance you want to perform
- * a mutation based on existing state that must be read first.
- *
- * @function transact
- * @public
- * @static
- * @for @ember-data/tracking
- * @param method
- * @return result of invoking method
- */
-export declare function transact<T extends OpaqueFn>(method: T): ReturnType<T>;
-/**
- * A helpful utility for creating a new function that
- * always runs in a transaction. E.G. this "memoizes"
- * calling `transact(fn)`, currying args as necessary.
- *
- * @method memoTransact
- * @public
- * @static
- * @for @ember-data/tracking
- * @param method
- * @return a function that will invoke method in a transaction with any provided args and return its result
- */
-export declare function memoTransact<T extends OpaqueFn>(method: T): (...args: unknown[]) => ReturnType<T>;
-export declare const Signals: unique symbol;
-/**
- *  use to add a signal property to the prototype of something.
- *
- *  First arg is the thing to define on
- *  Second arg is the property name
- *  Third agg is the initial value of the property if any.
- *
- *  for instance
- *
- *  ```ts
- *  class Model {}
- *  defineSignal(Model.prototype, 'isLoading', false);
- *  ```
- *
- *  This is sort of like using a stage-3 decorator but works today
- *  while we are still on legacy decorators.
- *
- *  e.g. it is equivalent to
- *
- *  ```ts
- *  class Model {
- *    @signal accessor isLoading = false;
- *  }
- *  ```
- *
- *  @internal
- */
-export declare function defineSignal<T extends object>(obj: T, key: string, v?: unknown): void;
-export interface Signal {
-    /**
-     * Key on the associated object
-     * @internal
-     */
-    key: string;
-    _debug_base?: string;
-    /**
-     * Whether this signal is part of an active transaction.
-     * @internal
-     */
-    t: boolean;
-    /**
-     * Whether to "bust" the lastValue cache
-     * @internal
-     */
-    shouldReset: boolean;
-    /**
-     * The framework specific "signal" e.g. glimmer "tracked"
-     * or starbeam "cell" to consume/invalidate when appropriate.
-     *
-     * @internal
-     */
-    tag: ReturnType<typeof tagForProperty>;
-    /**
-     * In classic ember, arrays must entangle a `[]` symbol
-     * in addition to any other tag in order for array chains to work.
-     *
-     * Note, this symbol MUST be the one that ember itself generates
-     *
-     * @internal
-     */
-    '[]': ReturnType<typeof tagForProperty> | null;
-    /**
-     * In classic ember, arrays must entangle a `@length` symbol
-     * in addition to any other tag in order for array chains to work.
-     *
-     * Note, this symbol MUST be the one that ember itself generates
-     *
-     * @internal
-     */
-    '@length': ReturnType<typeof tagForProperty> | null;
-    /**
-     * The lastValue computed for this signal when
-     * a signal is also used for storage.
-     * @internal
-     */
-    lastValue: unknown;
-}
-export declare function createArrayTags<T extends object>(obj: T, signal: Signal): void;
-/**
- * Create a signal for the key/object pairing.
- *
- * @internal
- * @param obj Object we're creating the signal on
- * @param key Key to create the signal for
- * @return the signal
- */
-export declare function createSignal<T extends object>(obj: T, key: string): Signal;
-/**
- * Create a signal for the key/object pairing and subscribes to the signal.
- *
- * Use when you need to ensure a signal exists and is subscribed to.
- *
- * @internal
- * @param signals Map of signals
- * @param obj Object we're creating the signal on
- * @param key Key to create the signal for
- * @return the signal
- */
-export declare function entangleSignal<T extends object>(signals: Map<string, Signal>, obj: T, key: string): Signal;
-export declare function getSignal<T extends object>(obj: T, key: string, initialState: boolean): Signal;
-export declare function peekSignal<T extends object>(obj: T, key: string): Signal | undefined;
-export {};
-//# sourceMappingURL=-private.d.ts.map
+declare module '@ember-data/tracking/-private' {
+  /// <reference types="ember-source/types" />
+  /// <reference types="ember-source/types" />
+  import { tagForProperty } from '@ember/-internals/metal';
+  /**
+   * This package provides primitives that allow powerful low-level
+   * adjustments to change tracking notification behaviors.
+   *
+   * Typically you want to use these primitives when you want to divorce
+   * property accesses on EmberData provided objects from the current
+   * tracking context. Typically this sort of thing occurs when serializing
+   * tracked data to send in a request: the data itself is often ancillary
+   * to the thing which triggered the request in the first place and you
+   * would not want to re-trigger the request for any update to the data.
+   *
+   * @module @ember-data/tracking
+   * @main @ember-data/tracking
+   */
+  type OpaqueFn = (...args: unknown[]) => unknown;
+  type Tag = {
+      ref: null;
+      t: boolean;
+  };
+  /**
+   * If there is a current transaction, ensures that the relevant tag (and any
+   * array computed chains symbols, if applicable) will be consumed during the
+   * transaction.
+   *
+   * If there is no current transaction, will consume the tag(s) immediately.
+   *
+   * @internal
+   * @param obj
+   */
+  export declare function subscribe(obj: Tag | Signal): void;
+  export declare function addToTransaction(obj: Tag | Signal): void;
+  export declare function addTransactionCB(method: OpaqueFn): void;
+  /**
+   * Run `method` without subscribing to any tracked properties
+   * controlled by EmberData.
+   *
+   * This should rarely be used except by libraries that really
+   * know what they are doing. It is most useful for wrapping
+   * certain kinds of fetch/query logic from within a `Resource`
+   * `hook` or other similar pattern.
+   *
+   * @function untracked
+   * @public
+   * @static
+   * @for @ember-data/tracking
+   * @param method
+   * @return result of invoking method
+   */
+  export declare function untracked<T extends OpaqueFn>(method: T): ReturnType<T>;
+  /**
+   * Run the method, subscribing to any tracked properties
+   * managed by EmberData that were accessed or written during
+   * the method's execution as per-normal but while allowing
+   * interleaving of reads and writes.
+   *
+   * This is useful when for instance you want to perform
+   * a mutation based on existing state that must be read first.
+   *
+   * @function transact
+   * @public
+   * @static
+   * @for @ember-data/tracking
+   * @param method
+   * @return result of invoking method
+   */
+  export declare function transact<T extends OpaqueFn>(method: T): ReturnType<T>;
+  /**
+   * A helpful utility for creating a new function that
+   * always runs in a transaction. E.G. this "memoizes"
+   * calling `transact(fn)`, currying args as necessary.
+   *
+   * @method memoTransact
+   * @public
+   * @static
+   * @for @ember-data/tracking
+   * @param method
+   * @return a function that will invoke method in a transaction with any provided args and return its result
+   */
+  export declare function memoTransact<T extends OpaqueFn>(method: T): (...args: unknown[]) => ReturnType<T>;
+  export declare const Signals: unique symbol;
+  /**
+   *  use to add a signal property to the prototype of something.
+   *
+   *  First arg is the thing to define on
+   *  Second arg is the property name
+   *  Third agg is the initial value of the property if any.
+   *
+   *  for instance
+   *
+   *  ```ts
+   *  class Model {}
+   *  defineSignal(Model.prototype, 'isLoading', false);
+   *  ```
+   *
+   *  This is sort of like using a stage-3 decorator but works today
+   *  while we are still on legacy decorators.
+   *
+   *  e.g. it is equivalent to
+   *
+   *  ```ts
+   *  class Model {
+   *    @signal accessor isLoading = false;
+   *  }
+   *  ```
+   *
+   *  @internal
+   */
+  export declare function defineSignal<T extends object>(obj: T, key: string, v?: unknown): void;
+  export interface Signal {
+      /**
+       * Key on the associated object
+       * @internal
+       */
+      key: string;
+      _debug_base?: string;
+      /**
+       * Whether this signal is part of an active transaction.
+       * @internal
+       */
+      t: boolean;
+      /**
+       * Whether to "bust" the lastValue cache
+       * @internal
+       */
+      shouldReset: boolean;
+      /**
+       * The framework specific "signal" e.g. glimmer "tracked"
+       * or starbeam "cell" to consume/invalidate when appropriate.
+       *
+       * @internal
+       */
+      tag: ReturnType<typeof tagForProperty>;
+      /**
+       * In classic ember, arrays must entangle a `[]` symbol
+       * in addition to any other tag in order for array chains to work.
+       *
+       * Note, this symbol MUST be the one that ember itself generates
+       *
+       * @internal
+       */
+      '[]': ReturnType<typeof tagForProperty> | null;
+      /**
+       * In classic ember, arrays must entangle a `@length` symbol
+       * in addition to any other tag in order for array chains to work.
+       *
+       * Note, this symbol MUST be the one that ember itself generates
+       *
+       * @internal
+       */
+      '@length': ReturnType<typeof tagForProperty> | null;
+      /**
+       * The lastValue computed for this signal when
+       * a signal is also used for storage.
+       * @internal
+       */
+      lastValue: unknown;
+  }
+  export declare function createArrayTags<T extends object>(obj: T, signal: Signal): void;
+  /**
+   * Create a signal for the key/object pairing.
+   *
+   * @internal
+   * @param obj Object we're creating the signal on
+   * @param key Key to create the signal for
+   * @return the signal
+   */
+  export declare function createSignal<T extends object>(obj: T, key: string): Signal;
+  /**
+   * Create a signal for the key/object pairing and subscribes to the signal.
+   *
+   * Use when you need to ensure a signal exists and is subscribed to.
+   *
+   * @internal
+   * @param signals Map of signals
+   * @param obj Object we're creating the signal on
+   * @param key Key to create the signal for
+   * @return the signal
+   */
+  export declare function entangleSignal<T extends object>(signals: Map<string, Signal>, obj: T, key: string): Signal;
+  export declare function getSignal<T extends object>(obj: T, key: string, initialState: boolean): Signal;
+  export declare function peekSignal<T extends object>(obj: T, key: string): Signal | undefined;
+  export {};
+  //# sourceMappingURL=-private.d.ts.map
+}

package/unstable-preview-types/index.d.ts

@@ -1,8 +1,11 @@
-/// <reference types="ember-source/types" />
-/// <reference types="ember-source/types" />
-import { createCache, getValue } from '@glimmer/tracking/primitives/cache';
-export { transact, memoTransact, untracked } from './-private';
-export { dependentKeyCompat as compat } from '@ember/object/compat';
-export declare function cached<T extends object, K extends keyof T & string>(target: T, key: K, descriptor: PropertyDescriptor): void;
-export { createCache, getValue };
-//# sourceMappingURL=index.d.ts.map
+/// <reference path="./-private.d.ts" />
+declare module '@ember-data/tracking' {
+  /// <reference types="ember-source/types" />
+  /// <reference types="ember-source/types" />
+  import { createCache, getValue } from '@glimmer/tracking/primitives/cache';
+  export { transact, memoTransact, untracked } from '@ember-data/tracking/-private';
+  export { dependentKeyCompat as compat } from '@ember/object/compat';
+  export declare function cached<T extends object, K extends keyof T & string>(target: T, key: K, descriptor: PropertyDescriptor): void;
+  export { createCache, getValue };
+  //# sourceMappingURL=index.d.ts.map
+}