@angular/core 16.0.0-next.3 → 16.0.0-next.5

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

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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';
+/**
+ * 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));
+}
+/**
+ * A dedicated symbol used before a computed value has been calculated for the first time.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const UNSET = Symbol('UNSET');
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * is in progress. Used to detect cycles in computation chains.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const COMPUTING = Symbol('COMPUTING');
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * failed. The thrown error is cached until the computation gets dirty again.
+ * 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;
+    }
+    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) {
+            // 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);
+        let newValue;
+        try {
+            newValue = this.computation();
+        }
+        catch (err) {
+            newValue = ERRORED;
+            this.error = err;
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
+        this.stale = false;
+        if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+            this.equal(oldValue, newValue)) {
+            // No change to `valueVersion` - old and new values are
+            // semantically equivalent.
+            this.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 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"]}

package/esm2022/src/signals/src/graph.mjs

@@ -0,0 +1,165 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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 { newWeakRef } from './weak_ref';
+/**
+ * Counter tracking the next `ProducerId` or `ConsumerId`.
+ */
+let _nextReactiveId = 0;
+/**
+ * Tracks the currently active reactive consumer (or `null` if there is no active
+ * consumer).
+ */
+let activeConsumer = null;
+export function setActiveConsumer(consumer) {
+    const prev = activeConsumer;
+    activeConsumer = consumer;
+    return prev;
+}
+/**
+ * A node in the reactive graph.
+ *
+ * Nodes can be producers of reactive values, consumers of other reactive values, or both.
+ *
+ * Producers are nodes that produce values, and can be depended upon by consumer nodes.
+ *
+ * Producers expose a monotonic `valueVersion` counter, and are responsible for incrementing this
+ * version when their value semantically changes. Some producers may produce their values lazily and
+ * thus at times need to be polled for potential updates to their value (and by extension their
+ * `valueVersion`). This is accomplished via the `onProducerUpdateValueVersion` method for
+ * implemented by producers, which should perform whatever calculations are necessary to ensure
+ * `valueVersion` is up to date.
+ *
+ * Consumers are nodes that depend on the values of producers and are notified when those values
+ * might have changed.
+ *
+ * Consumers do not wrap the reads they consume themselves, but rather can be set as the active
+ * reader via `setActiveConsumer`. Reads of producers that happen while a consumer is active will
+ * result in those producers being added as dependencies of that consumer node.
+ *
+ * The set of dependencies of a consumer is dynamic. Implementers expose a monotonically increasing
+ * `trackingVersion` counter, which increments whenever the consumer is about to re-run any reactive
+ * reads it needs and establish a new set of dependencies as a result.
+ *
+ * Producers store the last `trackingVersion` they've seen from `Consumer`s which have read them.
+ * This allows a producer to identify whether its record of the dependency is current or stale, by
+ * comparing the consumer's `trackingVersion` to the version at which the dependency was
+ * last observed.
+ */
+export class ReactiveNode {
+    constructor() {
+        this.id = _nextReactiveId++;
+        /**
+         * A cached weak reference to this node, which will be used in `ReactiveEdge`s.
+         */
+        this.ref = newWeakRef(this);
+        /**
+         * Edges to producers on which this node depends (in its consumer capacity).
+         */
+        this.producers = new Map();
+        /**
+         * Edges to consumers on which this node depends (in its producer capacity).
+         */
+        this.consumers = new Map();
+        /**
+         * Monotonically increasing counter representing a version of this `Consumer`'s
+         * dependencies.
+         */
+        this.trackingVersion = 0;
+        /**
+         * Monotonically increasing counter which increases when the value of this `Producer`
+         * semantically changes.
+         */
+        this.valueVersion = 0;
+    }
+    /**
+     * Polls dependencies of a consumer to determine if they have actually changed.
+     *
+     * If this returns `false`, then even though the consumer may have previously been notified of a
+     * change, the values of its dependencies have not actually changed and the consumer should not
+     * rerun any reactions.
+     */
+    consumerPollProducersForChange() {
+        for (const [producerId, edge] of this.producers) {
+            const producer = edge.producerNode.deref();
+            if (producer === undefined || edge.atTrackingVersion !== this.trackingVersion) {
+                // This dependency edge is stale, so remove it.
+                this.producers.delete(producerId);
+                producer?.consumers.delete(this.id);
+                continue;
+            }
+            if (producer.producerPollStatus(edge.seenValueVersion)) {
+                // One of the dependencies reports a real value change.
+                return true;
+            }
+        }
+        // No dependency reported a real value change, so the `Consumer` has also not been
+        // impacted.
+        return false;
+    }
+    /**
+     * Notify all consumers of this producer that its value may have changed.
+     */
+    producerMayHaveChanged() {
+        for (const [consumerId, edge] of this.consumers) {
+            const consumer = edge.consumerNode.deref();
+            if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {
+                this.consumers.delete(consumerId);
+                consumer?.producers.delete(this.id);
+                continue;
+            }
+            consumer.onConsumerDependencyMayHaveChanged();
+        }
+    }
+    /**
+     * Mark that this producer node has been accessed in the current reactive context.
+     */
+    producerAccessed() {
+        if (activeConsumer === null) {
+            return;
+        }
+        // Either create or update the dependency `Edge` in both directions.
+        let edge = activeConsumer.producers.get(this.id);
+        if (edge === undefined) {
+            edge = {
+                consumerNode: activeConsumer.ref,
+                producerNode: this.ref,
+                seenValueVersion: this.valueVersion,
+                atTrackingVersion: activeConsumer.trackingVersion,
+            };
+            activeConsumer.producers.set(this.id, edge);
+            this.consumers.set(activeConsumer.id, edge);
+        }
+        else {
+            edge.seenValueVersion = this.valueVersion;
+            edge.atTrackingVersion = activeConsumer.trackingVersion;
+        }
+    }
+    /**
+     * Whether this consumer currently has any producers registered.
+     */
+    get hasProducers() {
+        return this.producers.size > 0;
+    }
+    /**
+     * Checks if a `Producer` has a current value which is different than the value
+     * last seen at a specific version by a `Consumer` which recorded a dependency on
+     * this `Producer`.
+     */
+    producerPollStatus(lastSeenValueVersion) {
+        // `producer.valueVersion` may be stale, but a mismatch still means that the value
+        // last seen by the `Consumer` is also stale.
+        if (this.valueVersion !== lastSeenValueVersion) {
+            return true;
+        }
+        // Trigger the `Producer` to update its `valueVersion` if necessary.
+        this.onProducerUpdateValueVersion();
+        // At this point, we can trust `producer.valueVersion`.
+        return this.valueVersion !== lastSeenValueVersion;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/signals/src/graph.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 {newWeakRef, WeakRef} from './weak_ref';\n\n/**\n * Counter tracking the next `ProducerId` or `ConsumerId`.\n */\nlet _nextReactiveId: number = 0;\n\n/**\n * Tracks the currently active reactive consumer (or `null` if there is no active\n * consumer).\n */\nlet activeConsumer: ReactiveNode|null = null;\n\nexport function setActiveConsumer(consumer: ReactiveNode|null): ReactiveNode|null {\n  const prev = activeConsumer;\n  activeConsumer = consumer;\n  return prev;\n}\n\n/**\n * A bidirectional edge in the dependency graph of `ReactiveNode`s.\n */\ninterface ReactiveEdge {\n  /**\n   * Weakly held reference to the consumer side of this edge.\n   */\n  readonly producerNode: WeakRef<ReactiveNode>;\n\n  /**\n   * Weakly held reference to the producer side of this edge.\n   */\n  readonly consumerNode: WeakRef<ReactiveNode>;\n  /**\n   * `trackingVersion` of the consumer at which this dependency edge was last observed.\n   *\n   * If this doesn't match the consumer's current `trackingVersion`, then this dependency record\n   * is stale, and needs to be cleaned up.\n   */\n  atTrackingVersion: number;\n\n  /**\n   * `valueVersion` of the producer at the time this dependency was last accessed.\n   */\n  seenValueVersion: number;\n}\n\n/**\n * A node in the reactive graph.\n *\n * Nodes can be producers of reactive values, consumers of other reactive values, or both.\n *\n * Producers are nodes that produce values, and can be depended upon by consumer nodes.\n *\n * Producers expose a monotonic `valueVersion` counter, and are responsible for incrementing this\n * version when their value semantically changes. Some producers may produce their values lazily and\n * thus at times need to be polled for potential updates to their value (and by extension their\n * `valueVersion`). This is accomplished via the `onProducerUpdateValueVersion` method for\n * implemented by producers, which should perform whatever calculations are necessary to ensure\n * `valueVersion` is up to date.\n *\n * Consumers are nodes that depend on the values of producers and are notified when those values\n * might have changed.\n *\n * Consumers do not wrap the reads they consume themselves, but rather can be set as the active\n * reader via `setActiveConsumer`. Reads of producers that happen while a consumer is active will\n * result in those producers being added as dependencies of that consumer node.\n *\n * The set of dependencies of a consumer is dynamic. Implementers expose a monotonically increasing\n * `trackingVersion` counter, which increments whenever the consumer is about to re-run any reactive\n * reads it needs and establish a new set of dependencies as a result.\n *\n * Producers store the last `trackingVersion` they've seen from `Consumer`s which have read them.\n * This allows a producer to identify whether its record of the dependency is current or stale, by\n * comparing the consumer's `trackingVersion` to the version at which the dependency was\n * last observed.\n */\nexport abstract class ReactiveNode {\n  private readonly id = _nextReactiveId++;\n\n  /**\n   * A cached weak reference to this node, which will be used in `ReactiveEdge`s.\n   */\n  private readonly ref = newWeakRef(this);\n\n  /**\n   * Edges to producers on which this node depends (in its consumer capacity).\n   */\n  private readonly producers = new Map<number, ReactiveEdge>();\n\n  /**\n   * Edges to consumers on which this node depends (in its producer capacity).\n   */\n  private readonly consumers = new Map<number, ReactiveEdge>();\n\n  /**\n   * Monotonically increasing counter representing a version of this `Consumer`'s\n   * dependencies.\n   */\n  protected trackingVersion = 0;\n\n  /**\n   * Monotonically increasing counter which increases when the value of this `Producer`\n   * semantically changes.\n   */\n  protected valueVersion = 0;\n\n  /**\n   * Called for consumers whenever one of their dependencies notifies that it might have a new\n   * value.\n   */\n  protected abstract onConsumerDependencyMayHaveChanged(): void;\n\n  /**\n   * Called for producers when a dependent consumer is checking if the producer's value has actually\n   * changed.\n   */\n  protected abstract onProducerUpdateValueVersion(): void;\n\n  /**\n   * Polls dependencies of a consumer to determine if they have actually changed.\n   *\n   * If this returns `false`, then even though the consumer may have previously been notified of a\n   * change, the values of its dependencies have not actually changed and the consumer should not\n   * rerun any reactions.\n   */\n  protected consumerPollProducersForChange(): boolean {\n    for (const [producerId, edge] of this.producers) {\n      const producer = edge.producerNode.deref();\n\n      if (producer === undefined || edge.atTrackingVersion !== this.trackingVersion) {\n        // This dependency edge is stale, so remove it.\n        this.producers.delete(producerId);\n        producer?.consumers.delete(this.id);\n        continue;\n      }\n\n      if (producer.producerPollStatus(edge.seenValueVersion)) {\n        // One of the dependencies reports a real value change.\n        return true;\n      }\n    }\n\n    // No dependency reported a real value change, so the `Consumer` has also not been\n    // impacted.\n    return false;\n  }\n\n  /**\n   * Notify all consumers of this producer that its value may have changed.\n   */\n  protected producerMayHaveChanged(): void {\n    for (const [consumerId, edge] of this.consumers) {\n      const consumer = edge.consumerNode.deref();\n      if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {\n        this.consumers.delete(consumerId);\n        consumer?.producers.delete(this.id);\n        continue;\n      }\n\n      consumer.onConsumerDependencyMayHaveChanged();\n    }\n  }\n\n  /**\n   * Mark that this producer node has been accessed in the current reactive context.\n   */\n  protected producerAccessed(): void {\n    if (activeConsumer === null) {\n      return;\n    }\n\n    // Either create or update the dependency `Edge` in both directions.\n    let edge = activeConsumer.producers.get(this.id);\n    if (edge === undefined) {\n      edge = {\n        consumerNode: activeConsumer.ref,\n        producerNode: this.ref,\n        seenValueVersion: this.valueVersion,\n        atTrackingVersion: activeConsumer.trackingVersion,\n      };\n      activeConsumer.producers.set(this.id, edge);\n      this.consumers.set(activeConsumer.id, edge);\n    } else {\n      edge.seenValueVersion = this.valueVersion;\n      edge.atTrackingVersion = activeConsumer.trackingVersion;\n    }\n  }\n\n  /**\n   * Whether this consumer currently has any producers registered.\n   */\n  protected get hasProducers(): boolean {\n    return this.producers.size > 0;\n  }\n\n  /**\n   * Checks if a `Producer` has a current value which is different than the value\n   * last seen at a specific version by a `Consumer` which recorded a dependency on\n   * this `Producer`.\n   */\n  private producerPollStatus(lastSeenValueVersion: number): boolean {\n    // `producer.valueVersion` may be stale, but a mismatch still means that the value\n    // last seen by the `Consumer` is also stale.\n    if (this.valueVersion !== lastSeenValueVersion) {\n      return true;\n    }\n\n    // Trigger the `Producer` to update its `valueVersion` if necessary.\n    this.onProducerUpdateValueVersion();\n\n    // At this point, we can trust `producer.valueVersion`.\n    return this.valueVersion !== lastSeenValueVersion;\n  }\n}\n"]}

package/esm2022/src/signals/src/signal.mjs

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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 } from './graph';
+class WritableSignalImpl extends ReactiveNode {
+    constructor(value, equal) {
+        super();
+        this.value = value;
+        this.equal = equal;
+    }
+    onConsumerDependencyMayHaveChanged() {
+        // This never happens for writable signals as they're not consumers.
+    }
+    onProducerUpdateValueVersion() {
+        // Writable signal value versions are always up to date.
+    }
+    /**
+     * Directly update the value of the signal to a new value, which may or may not be
+     * equal to the previous.
+     *
+     * In the event that `newValue` is semantically equal to the current value, `set` is
+     * a no-op.
+     */
+    set(newValue) {
+        if (!this.equal(this.value, newValue)) {
+            this.value = newValue;
+            this.valueVersion++;
+            this.producerMayHaveChanged();
+        }
+    }
+    /**
+     * Derive a new value for the signal from its current value using the `updater` function.
+     *
+     * This is equivalent to calling `set` on the result of running `updater` on the current
+     * value.
+     */
+    update(updater) {
+        this.set(updater(this.value));
+    }
+    /**
+     * Calls `mutator` on the current value and assumes that it has been mutated.
+     */
+    mutate(mutator) {
+        // Mutate bypasses equality checks as it's by definition changing the value.
+        mutator(this.value);
+        this.valueVersion++;
+        this.producerMayHaveChanged();
+    }
+    signal() {
+        this.producerAccessed();
+        return this.value;
+    }
+}
+/**
+ * Create a `Signal` that can be set or updated directly.
+ *
+ * @developerPreview
+ */
+export function signal(initialValue, options) {
+    const signalNode = new WritableSignalImpl(initialValue, options?.equal ?? defaultEquals);
+    // Casting here is required for g3, as TS inference behavior is slightly different between our
+    // version/options and g3's.
+    const signalFn = createSignalFromFunction(signalNode, signalNode.signal.bind(signalNode), {
+        set: signalNode.set.bind(signalNode),
+        update: signalNode.update.bind(signalNode),
+        mutate: signalNode.mutate.bind(signalNode),
+    });
+    return signalFn;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/signals/src/watch.mjs

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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 { ReactiveNode, setActiveConsumer } from './graph';
+const NOOP_CLEANUP_FN = () => { };
+/**
+ * Watches a reactive expression and allows it to be scheduled to re-run
+ * when any dependencies notify of a change.
+ *
+ * `Watch` doesn't run reactive expressions itself, but relies on a consumer-
+ * provided scheduling operation to coordinate calling `Watch.run()`.
+ */
+export class Watch extends ReactiveNode {
+    constructor(watch, schedule) {
+        super();
+        this.watch = watch;
+        this.schedule = schedule;
+        this.dirty = false;
+        this.cleanupFn = NOOP_CLEANUP_FN;
+    }
+    notify() {
+        if (!this.dirty) {
+            this.schedule(this);
+        }
+        this.dirty = true;
+    }
+    onConsumerDependencyMayHaveChanged() {
+        this.notify();
+    }
+    onProducerUpdateValueVersion() {
+        // Watches are not producers.
+    }
+    /**
+     * Execute the reactive expression in the context of this `Watch` consumer.
+     *
+     * Should be called by the user scheduling algorithm when the provided
+     * `schedule` hook is called by `Watch`.
+     */
+    run() {
+        this.dirty = false;
+        if (this.trackingVersion !== 0 && !this.consumerPollProducersForChange()) {
+            return;
+        }
+        const prevConsumer = setActiveConsumer(this);
+        this.trackingVersion++;
+        try {
+            this.cleanupFn();
+            this.cleanupFn = this.watch() ?? NOOP_CLEANUP_FN;
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
+    }
+    cleanup() {
+        this.cleanupFn();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9zaWduYWxzL3NyYy93YXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsWUFBWSxFQUFFLGlCQUFpQixFQUFDLE1BQU0sU0FBUyxDQUFDO0FBUXhELE1BQU0sZUFBZSxHQUFtQixHQUFHLEVBQUUsR0FBRSxDQUFDLENBQUM7QUFFakQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxPQUFPLEtBQU0sU0FBUSxZQUFZO0lBSXJDLFlBQW9CLEtBQWdDLEVBQVUsUUFBZ0M7UUFDNUYsS0FBSyxFQUFFLENBQUM7UUFEVSxVQUFLLEdBQUwsS0FBSyxDQUEyQjtRQUFVLGFBQVEsR0FBUixRQUFRLENBQXdCO1FBSHRGLFVBQUssR0FBRyxLQUFLLENBQUM7UUFDZCxjQUFTLEdBQUcsZUFBZSxDQUFDO0lBSXBDLENBQUM7SUFFRCxNQUFNO1FBQ0osSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUU7WUFDZixJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO1NBQ3JCO1FBQ0QsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUM7SUFDcEIsQ0FBQztJQUVrQixrQ0FBa0M7UUFDbkQsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBQ2hCLENBQUM7SUFFa0IsNEJBQTRCO1FBQzdDLDZCQUE2QjtJQUMvQixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxHQUFHO1FBQ0QsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDbkIsSUFBSSxJQUFJLENBQUMsZUFBZSxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyw4QkFBOEIsRUFBRSxFQUFFO1lBQ3hFLE9BQU87U0FDUjtRQUVELE1BQU0sWUFBWSxHQUFHLGlCQUFpQixDQUFDLElBQUksQ0FBQyxDQUFDO1FBQzdDLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQztRQUN2QixJQUFJO1lBQ0YsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLEtBQUssRUFBRSxJQUFJLGVBQWUsQ0FBQztTQUNsRDtnQkFBUztZQUNSLGlCQUFpQixDQUFDLFlBQVksQ0FBQyxDQUFDO1NBQ2pDO0lBQ0gsQ0FBQztJQUVELE9BQU87UUFDTCxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDbkIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7UmVhY3RpdmVOb2RlLCBzZXRBY3RpdmVDb25zdW1lcn0gZnJvbSAnLi9ncmFwaCc7XG5cbi8qKlxuICogQSBjbGVhbnVwIGZ1bmN0aW9uIHRoYXQgY2FuIGJlIG9wdGlvbmFsbHkgcmV0dXJuZWQgZnJvbSB0aGUgd2F0Y2ggbG9naWMuIFdoZW4gcmV0dXJuZWQsIHRoZVxuICogY2xlYW51cCBsb2dpYyBydW5zIGJlZm9yZSB0aGUgbmV4dCB3YXRjaCBleGVjdXRpb24uXG4gKi9cbmV4cG9ydCB0eXBlIFdhdGNoQ2xlYW51cEZuID0gKCkgPT4gdm9pZDtcblxuY29uc3QgTk9PUF9DTEVBTlVQX0ZOOiBXYXRjaENsZWFudXBGbiA9ICgpID0+IHt9O1xuXG4vKipcbiAqIFdhdGNoZXMgYSByZWFjdGl2ZSBleHByZXNzaW9uIGFuZCBhbGxvd3MgaXQgdG8gYmUgc2NoZWR1bGVkIHRvIHJlLXJ1blxuICogd2hlbiBhbnkgZGVwZW5kZW5jaWVzIG5vdGlmeSBvZiBhIGNoYW5nZS5cbiAqXG4gKiBgV2F0Y2hgIGRvZXNuJ3QgcnVuIHJlYWN0aXZlIGV4cHJlc3Npb25zIGl0c2VsZiwgYnV0IHJlbGllcyBvbiBhIGNvbnN1bWVyLVxuICogcHJvdmlkZWQgc2NoZWR1bGluZyBvcGVyYXRpb24gdG8gY29vcmRpbmF0ZSBjYWxsaW5nIGBXYXRjaC5ydW4oKWAuXG4gKi9cbmV4cG9ydCBjbGFzcyBXYXRjaCBleHRlbmRzIFJlYWN0aXZlTm9kZSB7XG4gIHByaXZhdGUgZGlydHkgPSBmYWxzZTtcbiAgcHJpdmF0ZSBjbGVhbnVwRm4gPSBOT09QX0NMRUFOVVBfRk47XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSB3YXRjaDogKCkgPT4gdm9pZHxXYXRjaENsZWFudXBGbiwgcHJpdmF0ZSBzY2hlZHVsZTogKHdhdGNoOiBXYXRjaCkgPT4gdm9pZCkge1xuICAgIHN1cGVyKCk7XG4gIH1cblxuICBub3RpZnkoKTogdm9pZCB7XG4gICAgaWYgKCF0aGlzLmRpcnR5KSB7XG4gICAgICB0aGlzLnNjaGVkdWxlKHRoaXMpO1xuICAgIH1cbiAgICB0aGlzLmRpcnR5ID0gdHJ1ZTtcbiAgfVxuXG4gIHByb3RlY3RlZCBvdmVycmlkZSBvbkNvbnN1bWVyRGVwZW5kZW5jeU1heUhhdmVDaGFuZ2VkKCk6IHZvaWQge1xuICAgIHRoaXMubm90aWZ5KCk7XG4gIH1cblxuICBwcm90ZWN0ZWQgb3ZlcnJpZGUgb25Qcm9kdWNlclVwZGF0ZVZhbHVlVmVyc2lvbigpOiB2b2lkIHtcbiAgICAvLyBXYXRjaGVzIGFyZSBub3QgcHJvZHVjZXJzLlxuICB9XG5cbiAgLyoqXG4gICAqIEV4ZWN1dGUgdGhlIHJlYWN0aXZlIGV4cHJlc3Npb24gaW4gdGhlIGNvbnRleHQgb2YgdGhpcyBgV2F0Y2hgIGNvbnN1bWVyLlxuICAgKlxuICAgKiBTaG91bGQgYmUgY2FsbGVkIGJ5IHRoZSB1c2VyIHNjaGVkdWxpbmcgYWxnb3JpdGhtIHdoZW4gdGhlIHByb3ZpZGVkXG4gICAqIGBzY2hlZHVsZWAgaG9vayBpcyBjYWxsZWQgYnkgYFdhdGNoYC5cbiAgICovXG4gIHJ1bigpOiB2b2lkIHtcbiAgICB0aGlzLmRpcnR5ID0gZmFsc2U7XG4gICAgaWYgKHRoaXMudHJhY2tpbmdWZXJzaW9uICE9PSAwICYmICF0aGlzLmNvbnN1bWVyUG9sbFByb2R1Y2Vyc0ZvckNoYW5nZSgpKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgY29uc3QgcHJldkNvbnN1bWVyID0gc2V0QWN0aXZlQ29uc3VtZXIodGhpcyk7XG4gICAgdGhpcy50cmFja2luZ1ZlcnNpb24rKztcbiAgICB0cnkge1xuICAgICAgdGhpcy5jbGVhbnVwRm4oKTtcbiAgICAgIHRoaXMuY2xlYW51cEZuID0gdGhpcy53YXRjaCgpID8/IE5PT1BfQ0xFQU5VUF9GTjtcbiAgICB9IGZpbmFsbHkge1xuICAgICAgc2V0QWN0aXZlQ29uc3VtZXIocHJldkNvbnN1bWVyKTtcbiAgICB9XG4gIH1cblxuICBjbGVhbnVwKCkge1xuICAgIHRoaXMuY2xlYW51cEZuKCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/src/signals/src/weak_ref.mjs

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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 { global } from '../../util/global';
+/**
+ * A `WeakRef`-compatible reference that fakes the API with a strong reference
+ * internally.
+ */
+class LeakyRef {
+    constructor(ref) {
+        this.ref = ref;
+    }
+    deref() {
+        return this.ref;
+    }
+}
+// `WeakRef` is not always defined in every TS environment where Angular is compiled. Instead,
+// read it off of the global context if available.
+// tslint:disable-next-line: no-toplevel-property-access
+let WeakRefImpl = global['WeakRef'] ?? LeakyRef;
+export function newWeakRef(value) {
+    if (typeof ngDevMode !== 'undefined' && ngDevMode && WeakRefImpl === undefined) {
+        throw new Error(`Angular requires a browser which supports the 'WeakRef' API`);
+    }
+    return new WeakRefImpl(value);
+}
+export function setAlternateWeakRefImpl(impl) {
+    // no-op since the alternate impl is included by default by the framework. Remove once internal
+    // migration is complete.
+}
+//# sourceMappingURL=data:application/json;base64,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