@angular/core 17.0.0-next.2 → 17.0.0-next.4

package/esm2022/src/signals/src/computed.mjs

@@ -5,18 +5,29 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { createSignalFromFunction, defaultEquals } from './api';
-import { ReactiveNode, setActiveConsumer } from './graph';
+import { defaultEquals, SIGNAL } from './api';
+import { consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerUpdateValueVersion, REACTIVE_NODE } from './graph';
 /**
  * Create a computed `Signal` which derives a reactive value from an expression.
  *
  * @developerPreview
  */
 export function computed(computation, options) {
-    const node = new ComputedImpl(computation, options?.equal ?? defaultEquals);
-    // Casting here is required for g3, as TS inference behavior is slightly different between our
-    // version/options and g3's.
-    return createSignalFromFunction(node, node.signal.bind(node));
+    const node = Object.create(COMPUTED_NODE);
+    node.computation = computation;
+    options?.equal && (node.equal = options.equal);
+    const computed = () => {
+        // Check if the value needs updating before returning it.
+        producerUpdateValueVersion(node);
+        // Record that someone looked at this signal.
+        producerAccessed(node);
+        if (node.value === ERRORED) {
+            throw node.error;
+        }
+        return node.value;
+    };
+    computed[SIGNAL] = node;
+    return computed;
 }
 /**
  * A dedicated symbol used before a computed value has been calculated for the first time.
@@ -35,106 +46,45 @@ const COMPUTING = Symbol('COMPUTING');
  * Explicitly typed as `any` so we can use it as signal's value.
  */
 const ERRORED = Symbol('ERRORED');
-/**
- * A computation, which derives a value from a declarative reactive expression.
- *
- * `Computed`s are both producers and consumers of reactivity.
- */
-class ComputedImpl extends ReactiveNode {
-    constructor(computation, equal) {
-        super();
-        this.computation = computation;
-        this.equal = equal;
-        /**
-         * Current value of the computation.
-         *
-         * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.
-         */
-        this.value = UNSET;
-        /**
-         * If `value` is `ERRORED`, the error caught from the last computation attempt which will
-         * be re-thrown.
-         */
-        this.error = null;
-        /**
-         * Flag indicating that the computation is currently stale, meaning that one of the
-         * dependencies has notified of a potential change.
-         *
-         * It's possible that no dependency has _actually_ changed, in which case the `stale`
-         * state can be resolved without recomputing the value.
-         */
-        this.stale = true;
-        this.consumerAllowSignalWrites = false;
-    }
-    onConsumerDependencyMayHaveChanged() {
-        if (this.stale) {
-            // We've already notified consumers that this value has potentially changed.
-            return;
-        }
-        // Record that the currently cached value may be stale.
-        this.stale = true;
-        // Notify any consumers about the potential change.
-        this.producerMayHaveChanged();
-    }
-    onProducerUpdateValueVersion() {
-        if (!this.stale) {
-            // The current value and its version are already up to date.
-            return;
-        }
-        // The current value is stale. Check whether we need to produce a new one.
-        if (this.value !== UNSET && this.value !== COMPUTING &&
-            !this.consumerPollProducersForChange()) {
-            // Even though we were previously notified of a potential dependency update, all of
-            // our dependencies report that they have not actually changed in value, so we can
-            // resolve the stale state without needing to recompute the current value.
-            this.stale = false;
-            return;
-        }
-        // The current value is stale, and needs to be recomputed. It still may not change -
-        // that depends on whether the newly computed value is equal to the old.
-        this.recomputeValue();
-    }
-    recomputeValue() {
-        if (this.value === COMPUTING) {
+const COMPUTED_NODE = {
+    ...REACTIVE_NODE,
+    value: UNSET,
+    dirty: true,
+    error: null,
+    equal: defaultEquals,
+    producerMustRecompute(node) {
+        // Force a recomputation if there's no current value, or if the current value is in the process
+        // of being calculated (which should throw an error).
+        return node.value === UNSET || node.value === COMPUTING;
+    },
+    producerRecomputeValue(node) {
+        if (node.value === COMPUTING) {
             // Our computation somehow led to a cyclic read of itself.
             throw new Error('Detected cycle in computations.');
         }
-        const oldValue = this.value;
-        this.value = COMPUTING;
-        // As we're re-running the computation, update our dependent tracking version number.
-        this.trackingVersion++;
-        const prevConsumer = setActiveConsumer(this);
+        const oldValue = node.value;
+        node.value = COMPUTING;
+        const prevConsumer = consumerBeforeComputation(node);
         let newValue;
         try {
-            newValue = this.computation();
+            newValue = node.computation();
         }
         catch (err) {
             newValue = ERRORED;
-            this.error = err;
+            node.error = err;
         }
         finally {
-            setActiveConsumer(prevConsumer);
+            consumerAfterComputation(node, prevConsumer);
         }
-        this.stale = false;
         if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
-            this.equal(oldValue, newValue)) {
+            node.equal(oldValue, newValue)) {
             // No change to `valueVersion` - old and new values are
             // semantically equivalent.
-            this.value = oldValue;
+            node.value = oldValue;
             return;
         }
-        this.value = newValue;
-        this.valueVersion++;
-    }
-    signal() {
-        // Check if the value needs updating before returning it.
-        this.onProducerUpdateValueVersion();
-        // Record that someone looked at this signal.
-        this.producerAccessed();
-        if (this.value === ERRORED) {
-            throw this.error;
-        }
-        return this.value;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computed.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/computed.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {createSignalFromFunction, defaultEquals, Signal, ValueEqualityFn} from './api';\nimport {ReactiveNode, setActiveConsumer} from './graph';\n\n/**\n * Options passed to the `computed` creation function.\n *\n * @developerPreview\n */\nexport interface CreateComputedOptions<T> {\n  /**\n   * A comparison function which defines equality for computed values.\n   */\n  equal?: ValueEqualityFn<T>;\n}\n\n\n/**\n * Create a computed `Signal` which derives a reactive value from an expression.\n *\n * @developerPreview\n */\nexport function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T> {\n  const node = new ComputedImpl(computation, options?.equal ?? defaultEquals);\n\n  // Casting here is required for g3, as TS inference behavior is slightly different between our\n  // version/options and g3's.\n  return createSignalFromFunction(node, node.signal.bind(node)) as unknown as Signal<T>;\n}\n\n/**\n * A dedicated symbol used before a computed value has been calculated for the first time.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst UNSET: any = Symbol('UNSET');\n\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * is in progress. Used to detect cycles in computation chains.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst COMPUTING: any = Symbol('COMPUTING');\n\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * failed. The thrown error is cached until the computation gets dirty again.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst ERRORED: any = Symbol('ERRORED');\n\n/**\n * A computation, which derives a value from a declarative reactive expression.\n *\n * `Computed`s are both producers and consumers of reactivity.\n */\nclass ComputedImpl<T> extends ReactiveNode {\n  constructor(private computation: () => T, private equal: (oldValue: T, newValue: T) => boolean) {\n    super();\n  }\n  /**\n   * Current value of the computation.\n   *\n   * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.\n   */\n  private value: T = UNSET;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  private error: unknown = null;\n\n  /**\n   * Flag indicating that the computation is currently stale, meaning that one of the\n   * dependencies has notified of a potential change.\n   *\n   * It's possible that no dependency has _actually_ changed, in which case the `stale`\n   * state can be resolved without recomputing the value.\n   */\n  private stale = true;\n\n  protected override readonly consumerAllowSignalWrites = false;\n\n  protected override onConsumerDependencyMayHaveChanged(): void {\n    if (this.stale) {\n      // We've already notified consumers that this value has potentially changed.\n      return;\n    }\n\n    // Record that the currently cached value may be stale.\n    this.stale = true;\n\n    // Notify any consumers about the potential change.\n    this.producerMayHaveChanged();\n  }\n\n  protected override onProducerUpdateValueVersion(): void {\n    if (!this.stale) {\n      // The current value and its version are already up to date.\n      return;\n    }\n\n    // The current value is stale. Check whether we need to produce a new one.\n\n    if (this.value !== UNSET && this.value !== COMPUTING &&\n        !this.consumerPollProducersForChange()) {\n      // Even though we were previously notified of a potential dependency update, all of\n      // our dependencies report that they have not actually changed in value, so we can\n      // resolve the stale state without needing to recompute the current value.\n      this.stale = false;\n      return;\n    }\n\n    // The current value is stale, and needs to be recomputed. It still may not change -\n    // that depends on whether the newly computed value is equal to the old.\n    this.recomputeValue();\n  }\n\n  private recomputeValue(): void {\n    if (this.value === COMPUTING) {\n      // Our computation somehow led to a cyclic read of itself.\n      throw new Error('Detected cycle in computations.');\n    }\n\n    const oldValue = this.value;\n    this.value = COMPUTING;\n\n    // As we're re-running the computation, update our dependent tracking version number.\n    this.trackingVersion++;\n    const prevConsumer = setActiveConsumer(this);\n    let newValue: T;\n    try {\n      newValue = this.computation();\n    } catch (err) {\n      newValue = ERRORED;\n      this.error = err;\n    } finally {\n      setActiveConsumer(prevConsumer);\n    }\n\n    this.stale = false;\n\n    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&\n        this.equal(oldValue, newValue)) {\n      // No change to `valueVersion` - old and new values are\n      // semantically equivalent.\n      this.value = oldValue;\n      return;\n    }\n\n    this.value = newValue;\n    this.valueVersion++;\n  }\n\n  signal(): T {\n    // Check if the value needs updating before returning it.\n    this.onProducerUpdateValueVersion();\n\n    // Record that someone looked at this signal.\n    this.producerAccessed();\n\n    if (this.value === ERRORED) {\n      throw this.error;\n    }\n\n    return this.value;\n  }\n}\n"]}
+        node.value = newValue;
+        node.version++;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computed.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/computed.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,aAAa,EAAE,MAAM,EAA0B,MAAM,OAAO,CAAC;AACrE,OAAO,EAAC,wBAAwB,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,aAAa,EAAe,MAAM,SAAS,CAAC;AAcvJ;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAI,WAAoB,EAAE,OAAkC;IAClF,MAAM,IAAI,GAAoB,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IAC3D,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IAC/B,OAAO,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAE/C,MAAM,QAAQ,GAAG,GAAG,EAAE;QACpB,yDAAyD;QACzD,0BAA0B,CAAC,IAAI,CAAC,CAAC;QAEjC,6CAA6C;QAC7C,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAEvB,IAAI,IAAI,CAAC,KAAK,KAAK,OAAO,EAAE;YAC1B,MAAM,IAAI,CAAC,KAAK,CAAC;SAClB;QAED,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC,CAAC;IACD,QAAgB,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IACjC,OAAO,QAA4B,CAAC;AACtC,CAAC;AAGD;;;GAGG;AACH,MAAM,KAAK,GAAQ,MAAM,CAAC,OAAO,CAAC,CAAC;AAEnC;;;;GAIG;AACH,MAAM,SAAS,GAAQ,MAAM,CAAC,WAAW,CAAC,CAAC;AAE3C;;;;GAIG;AACH,MAAM,OAAO,GAAQ,MAAM,CAAC,SAAS,CAAC,CAAC;AA4BvC,MAAM,aAAa,GAAG;IACpB,GAAG,aAAa;IAChB,KAAK,EAAE,KAAK;IACZ,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,aAAa;IAEpB,qBAAqB,CAAC,IAA2B;QAC/C,+FAA+F;QAC/F,qDAAqD;QACrD,OAAO,IAAI,CAAC,KAAK,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,CAAC;IAC1D,CAAC;IAED,sBAAsB,CAAC,IAA2B;QAChD,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;YAC5B,0DAA0D;YAC1D,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;SACpD;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;QAEvB,MAAM,YAAY,GAAG,yBAAyB,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,QAAiB,CAAC;QACtB,IAAI;YACF,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;SAC/B;QAAC,OAAO,GAAG,EAAE;YACZ,QAAQ,GAAG,OAAO,CAAC;YACnB,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC;SAClB;gBAAS;YACR,wBAAwB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;SAC9C;QAED,IAAI,QAAQ,KAAK,KAAK,IAAI,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,OAAO;YAClE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE;YAClC,uDAAuD;YACvD,2BAA2B;YAC3B,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;YACtB,OAAO;SACR;QAED,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;QACtB,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;CACF,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {defaultEquals, SIGNAL, Signal, ValueEqualityFn} from './api';\nimport {consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerUpdateValueVersion, REACTIVE_NODE, ReactiveNode} from './graph';\n\n/**\n * Options passed to the `computed` creation function.\n *\n * @developerPreview\n */\nexport interface CreateComputedOptions<T> {\n  /**\n   * A comparison function which defines equality for computed values.\n   */\n  equal?: ValueEqualityFn<T>;\n}\n\n/**\n * Create a computed `Signal` which derives a reactive value from an expression.\n *\n * @developerPreview\n */\nexport function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T> {\n  const node: ComputedNode<T> = Object.create(COMPUTED_NODE);\n  node.computation = computation;\n  options?.equal && (node.equal = options.equal);\n\n  const computed = () => {\n    // Check if the value needs updating before returning it.\n    producerUpdateValueVersion(node);\n\n    // Record that someone looked at this signal.\n    producerAccessed(node);\n\n    if (node.value === ERRORED) {\n      throw node.error;\n    }\n\n    return node.value;\n  };\n  (computed as any)[SIGNAL] = node;\n  return computed as any as Signal<T>;\n}\n\n\n/**\n * A dedicated symbol used before a computed value has been calculated for the first time.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst UNSET: any = Symbol('UNSET');\n\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * is in progress. Used to detect cycles in computation chains.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst COMPUTING: any = Symbol('COMPUTING');\n\n/**\n * A dedicated symbol used in place of a computed signal value to indicate that a given computation\n * failed. The thrown error is cached until the computation gets dirty again.\n * Explicitly typed as `any` so we can use it as signal's value.\n */\nconst ERRORED: any = Symbol('ERRORED');\n\n/**\n * A computation, which derives a value from a declarative reactive expression.\n *\n * `Computed`s are both producers and consumers of reactivity.\n */\ninterface ComputedNode<T> extends ReactiveNode {\n  /**\n   * Current value of the computation, or one of the sentinel values above (`UNSET`, `COMPUTING`,\n   * `ERROR`).\n   */\n  value: T;\n\n  /**\n   * If `value` is `ERRORED`, the error caught from the last computation attempt which will\n   * be re-thrown.\n   */\n  error: unknown;\n\n  /**\n   * The computation function which will produce a new value.\n   */\n  computation: () => T;\n\n  equal: ValueEqualityFn<T>;\n}\n\nconst COMPUTED_NODE = {\n  ...REACTIVE_NODE,\n  value: UNSET,\n  dirty: true,\n  error: null,\n  equal: defaultEquals,\n\n  producerMustRecompute(node: ComputedNode<unknown>): boolean {\n    // Force a recomputation if there's no current value, or if the current value is in the process\n    // of being calculated (which should throw an error).\n    return node.value === UNSET || node.value === COMPUTING;\n  },\n\n  producerRecomputeValue(node: ComputedNode<unknown>): void {\n    if (node.value === COMPUTING) {\n      // Our computation somehow led to a cyclic read of itself.\n      throw new Error('Detected cycle in computations.');\n    }\n\n    const oldValue = node.value;\n    node.value = COMPUTING;\n\n    const prevConsumer = consumerBeforeComputation(node);\n    let newValue: unknown;\n    try {\n      newValue = node.computation();\n    } catch (err) {\n      newValue = ERRORED;\n      node.error = err;\n    } finally {\n      consumerAfterComputation(node, prevConsumer);\n    }\n\n    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&\n        node.equal(oldValue, newValue)) {\n      // No change to `valueVersion` - old and new values are\n      // semantically equivalent.\n      node.value = oldValue;\n      return;\n    }\n\n    node.value = newValue;\n    node.version++;\n  },\n};\n"]}