@tstdl/base 0.87.13 → 0.87.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.87.13",
+  "version": "0.87.15",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/signals/implementation/api.d.ts

@@ -5,13 +5,12 @@
  * 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 type { ReactiveNode } from './graph.js';
 /**
  * Symbol used to tell `Signal`s apart from other functions.
  *
  * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
  */
-declare const SIGNAL: unique symbol;
+export declare const SIGNAL: unique symbol;
 /**
  * A reactive value which notifies consumers of any changes.
  *
@@ -28,21 +27,6 @@ export interface Signal<T> {
  * Checks if the given `value` is a reactive `Signal`.
  */
 export declare function isSignal(value: unknown): value is Signal<unknown>;
-/**
- * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`).
- *
- * @param fn A zero-argument function which will be converted into a `Signal`.
- */
-export declare function createSignalFromFunction<T>(node: ReactiveNode, fn: () => T): Signal<T>;
-/**
- * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`), and
- * potentially add some set of extra properties (passed as an object record `extraApi`).
- *
- * @param fn A zero-argument function which will be converted into a `Signal`.
- * @param extraApi An object whose properties will be copied onto `fn` in order to create a specific
- *     desired interface for the `Signal`.
- */
-export declare function createSignalFromFunction<T, U extends Record<string, unknown>>(node: ReactiveNode, fn: () => T, extraApi: U): Signal<T> & U;
 /**
  * A comparison function which can determine if two values are equal.
  */
@@ -55,4 +39,3 @@ export type ValueEqualityFn<T> = (a: T, b: T) => boolean;
  * propagate change notification upon explicit mutation without identity change.
  */
 export declare function defaultEquals<T>(a: T, b: T): boolean;
-export {};

package/signals/implementation/api.js

@@ -18,7 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var api_exports = {};
 __export(api_exports, {
-  createSignalFromFunction: () => createSignalFromFunction,
+  SIGNAL: () => SIGNAL,
   defaultEquals: () => defaultEquals,
   isSignal: () => isSignal
 });
@@ -34,10 +34,6 @@ const SIGNAL = Symbol("SIGNAL");
 function isSignal(value) {
   return typeof value === "function" && value[SIGNAL] !== void 0;
 }
-function createSignalFromFunction(node, fn, extraApi = {}) {
-  fn[SIGNAL] = node;
-  return Object.assign(fn, extraApi);
-}
 function defaultEquals(a, b) {
   return (a === null || typeof a !== "object") && Object.is(a, b);
 }

package/signals/implementation/computed.js

@@ -31,88 +31,53 @@ var import_graph = require("./graph.js");
  * found in the LICENSE file at https://angular.io/license
  */
 function computed(computation, options) {
-  const node = new ComputedImpl(computation, options?.equal ?? import_api.defaultEquals);
-  return (0, import_api.createSignalFromFunction)(node, node.signal.bind(node));
+  const node = Object.create(COMPUTED_NODE);
+  node.computation = computation;
+  options?.equal && (node.equal = options.equal);
+  const computed2 = () => {
+    (0, import_graph.producerUpdateValueVersion)(node);
+    (0, import_graph.producerAccessed)(node);
+    if (node.value === ERRORED) {
+      throw node.error;
+    }
+    return node.value;
+  };
+  computed2[import_api.SIGNAL] = node;
+  return computed2;
 }
 const UNSET = Symbol("UNSET");
 const COMPUTING = Symbol("COMPUTING");
 const ERRORED = Symbol("ERRORED");
-class ComputedImpl extends import_graph.ReactiveNode {
-  computation;
-  equal;
-  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`.
-   */
-  value = UNSET;
-  /**
-   * If `value` is `ERRORED`, the error caught from the last computation attempt which will
-   * be re-thrown.
-   */
-  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.
-   */
-  stale = true;
-  consumerAllowSignalWrites = false;
-  onConsumerDependencyMayHaveChanged() {
-    if (this.stale) {
-      return;
-    }
-    this.stale = true;
-    this.producerMayHaveChanged();
-  }
-  onProducerUpdateValueVersion() {
-    if (!this.stale) {
-      return;
-    }
-    if (this.value !== UNSET && this.value !== COMPUTING && !this.consumerPollProducersForChange()) {
-      this.stale = false;
-      return;
-    }
-    this.recomputeValue();
-  }
-  recomputeValue() {
-    if (this.value === COMPUTING) {
+const COMPUTED_NODE = {
+  ...import_graph.REACTIVE_NODE,
+  value: UNSET,
+  dirty: true,
+  error: null,
+  equal: import_api.defaultEquals,
+  producerMustRecompute(node) {
+    return node.value === UNSET || node.value === COMPUTING;
+  },
+  producerRecomputeValue(node) {
+    if (node.value === COMPUTING) {
       throw new Error("Detected cycle in computations.");
     }
-    const oldValue = this.value;
-    this.value = COMPUTING;
-    this.trackingVersion++;
-    const prevConsumer = (0, import_graph.setActiveConsumer)(this);
+    const oldValue = node.value;
+    node.value = COMPUTING;
+    const prevConsumer = (0, import_graph.consumerBeforeComputation)(node);
     let newValue;
     try {
-      newValue = this.computation();
+      newValue = node.computation();
     } catch (err) {
       newValue = ERRORED;
-      this.error = err;
+      node.error = err;
     } finally {
-      (0, import_graph.setActiveConsumer)(prevConsumer);
+      (0, import_graph.consumerAfterComputation)(node, prevConsumer);
     }
-    this.stale = false;
-    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && this.equal(oldValue, newValue)) {
-      this.value = oldValue;
+    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && node.equal(oldValue, newValue)) {
+      node.value = oldValue;
       return;
     }
-    this.value = newValue;
-    this.valueVersion++;
+    node.value = newValue;
+    node.version++;
   }
-  signal() {
-    this.onProducerUpdateValueVersion();
-    this.producerAccessed();
-    if (this.value === ERRORED) {
-      throw this.error;
-    }
-    return this.value;
-  }
-}
+};

package/signals/implementation/effect.d.ts

@@ -22,7 +22,7 @@ export declare class EffectManager {
     private readonly all;
     private readonly queue;
     private pendingFlush;
-    create(effectFn: (onCleanup: (cleanupFn: EffectCleanupFn) => void) => void, { allowSignalWrites }?: CreateEffectOptions): EffectRef;
+    create(effectFn: (onCleanup: (cleanupFn: EffectCleanupFn) => void) => void, allowSignalWrites: boolean): EffectRef;
     flush(): void;
     get isQueueEmpty(): boolean;
 }

package/signals/implementation/effect.js

@@ -34,12 +34,12 @@ class EffectManager {
   all = /* @__PURE__ */ new Set();
   queue = /* @__PURE__ */ new Set();
   pendingFlush;
-  create(effectFn, { allowSignalWrites = false } = {}) {
-    const watch = new import_watch.Watch(effectFn, (watch2) => {
-      if (!this.all.has(watch2)) {
+  create(effectFn, allowSignalWrites) {
+    const w = (0, import_watch.watch)(effectFn, () => {
+      if (!this.all.has(w)) {
         return;
       }
-      this.queue.add(watch2);
+      this.queue.add(w);
       if (!this.pendingFlush) {
         this.pendingFlush = true;
         queueMicrotask(() => {
@@ -48,24 +48,24 @@ class EffectManager {
         });
       }
     }, allowSignalWrites);
-    this.all.add(watch);
-    watch.notify();
+    this.all.add(w);
+    w.notify();
     const destroy = () => {
-      watch.cleanup();
-      this.all.delete(watch);
-      this.queue.delete(watch);
+      w.cleanup();
+      this.all.delete(w);
+      this.queue.delete(w);
     };
     return {
       destroy
     };
   }
   flush() {
-    if (this.queue.size == 0) {
+    if (this.queue.size === 0) {
       return;
     }
-    for (const watch of this.queue) {
-      this.queue.delete(watch);
-      watch.run();
+    for (const w of this.queue) {
+      this.queue.delete(w);
+      w.run();
     }
   }
   get isQueueEmpty() {
@@ -74,5 +74,5 @@ class EffectManager {
 }
 const effectManager = new EffectManager();
 function effect(effectFn, options) {
-  return effectManager.create(effectFn, options);
+  return effectManager.create(effectFn, options?.allowSignalWrites ?? false);
 }

package/signals/implementation/graph.d.ts

@@ -5,104 +5,149 @@
  * 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
  */
+type Version = number & {
+    __brand: 'Version';
+};
 export declare function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null;
+export declare const REACTIVE_NODE: {
+    version: Version;
+    dirty: boolean;
+    producerNode: undefined;
+    producerLastReadVersion: undefined;
+    producerIndexOfThis: undefined;
+    nextProducerIndex: number;
+    liveConsumerNode: undefined;
+    liveConsumerIndexOfThis: undefined;
+    consumerAllowSignalWrites: boolean;
+    consumerIsAlwaysLive: boolean;
+    producerMustRecompute: () => boolean;
+    producerRecomputeValue: () => void;
+    consumerMarkedDirty: () => void;
+};
 /**
- * A node in the reactive graph.
+ * A producer and/or consumer which participates in the reactive graph.
  *
- * Nodes can be producers of reactive values, consumers of other reactive values, or both.
+ * Producer `ReactiveNode`s which are accessed when a consumer `ReactiveNode` is the
+ * `activeConsumer` are tracked as dependencies of that consumer.
  *
- * Producers are nodes that produce values, and can be depended upon by consumer nodes.
+ * Certain consumers are also tracked as "live" consumers and create edges in the other direction,
+ * from producer to consumer. These edges are used to propagate change notifications when a
+ * producer's value is updated.
  *
- * 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.
+ * A `ReactiveNode` may be both a producer and consumer.
  */
-export declare abstract class ReactiveNode {
-    private readonly id;
-    /**
-     * A cached weak reference to this node, which will be used in `ReactiveEdge`s.
-     */
-    private readonly ref;
-    /**
-     * Edges to producers on which this node depends (in its consumer capacity).
-     */
-    private readonly producers;
-    /**
-     * Edges to consumers on which this node depends (in its producer capacity).
-     */
-    private readonly consumers;
+export interface ReactiveNode {
     /**
-     * Monotonically increasing counter representing a version of this `Consumer`'s
-     * dependencies.
-     */
-    protected trackingVersion: number;
-    /**
-     * Monotonically increasing counter which increases when the value of this `Producer`
-     * semantically changes.
+     * Version of the value that this node produces.
+     *
+     * This is incremented whenever a new value is produced by this node which is not equal to the
+     * previous value (by whatever definition of equality is in use).
      */
-    protected valueVersion: number;
+    version: Version;
     /**
-     * Whether signal writes should be allowed while this `ReactiveNode` is the current consumer.
+     * Whether this node (in its consumer capacity) is dirty.
+     *
+     * Only live consumers become dirty, when receiving a change notification from a dependency
+     * producer.
      */
-    protected abstract readonly consumerAllowSignalWrites: boolean;
+    dirty: boolean;
     /**
-     * Called for consumers whenever one of their dependencies notifies that it might have a new
-     * value.
+     * Producers which are dependencies of this consumer.
+     *
+     * Uses the same indices as the `producerLastReadVersion` and `producerIndexOfThis` arrays.
      */
-    protected abstract onConsumerDependencyMayHaveChanged(): void;
+    producerNode: ReactiveNode[] | undefined;
     /**
-     * Called for producers when a dependent consumer is checking if the producer's value has actually
-     * changed.
+     * `Version` of the value last read by a given producer.
+     *
+     * Uses the same indices as the `producerNode` and `producerIndexOfThis` arrays.
      */
-    protected abstract onProducerUpdateValueVersion(): void;
+    producerLastReadVersion: Version[] | undefined;
     /**
-     * Polls dependencies of a consumer to determine if they have actually changed.
+     * Index of `this` (consumer) in each producer's `liveConsumers` array.
+     *
+     * This value is only meaningful if this node is live (`liveConsumers.length > 0`). Otherwise
+     * these indices are stale.
      *
-     * 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.
+     * Uses the same indices as the `producerNode` and `producerLastReadVersion` arrays.
      */
-    protected consumerPollProducersForChange(): boolean;
+    producerIndexOfThis: number[] | undefined;
     /**
-     * Notify all consumers of this producer that its value may have changed.
+     * Index into the producer arrays that the next dependency of this node as a consumer will use.
+     *
+     * This index is zeroed before this node as a consumer begins executing. When a producer is read,
+     * it gets inserted into the producers arrays at this index. There may be an existing dependency
+     * in this location which may or may not match the incoming producer, depending on whether the
+     * same producers were read in the same order as the last computation.
      */
-    protected producerMayHaveChanged(): void;
+    nextProducerIndex: number;
     /**
-     * Mark that this producer node has been accessed in the current reactive context.
+     * Array of consumers of this producer that are "live" (they require push notifications).
+     *
+     * `liveConsumerNode.length` is effectively our reference count for this node.
      */
-    protected producerAccessed(): void;
+    liveConsumerNode: ReactiveNode[] | undefined;
     /**
-     * Whether this consumer currently has any producers registered.
+     * Index of `this` (producer) in each consumer's `producerNode` array.
+     *
+     * Uses the same indices as the `liveConsumerNode` array.
      */
-    protected get hasProducers(): boolean;
+    liveConsumerIndexOfThis: number[] | undefined;
     /**
-     * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
-     * based on the current consumer context.
+     * Whether writes to signals are allowed when this consumer is the `activeConsumer`.
+     *
+     * This is used to enforce guardrails such as preventing writes to writable signals in the
+     * computation function of computed signals, which is supposed to be pure.
      */
-    protected get producerUpdatesAllowed(): boolean;
+    consumerAllowSignalWrites: boolean;
+    readonly consumerIsAlwaysLive: boolean;
     /**
-     * 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`.
+     * Tracks whether producers need to recompute their value independently of the reactive graph (for
+     * example, if no initial value has been computed).
      */
-    private producerPollStatus;
+    producerMustRecompute(node: unknown): boolean;
+    producerRecomputeValue(node: unknown): void;
+    consumerMarkedDirty(node: unknown): void;
 }
+/**
+ * Called by implementations when a producer's signal is read.
+ */
+export declare function producerAccessed(node: ReactiveNode): void;
+/**
+ * Ensure this producer's `version` is up-to-date.
+ */
+export declare function producerUpdateValueVersion(node: ReactiveNode): void;
+/**
+ * Propagate a dirty notification to live consumers of this producer.
+ */
+export declare function producerNotifyConsumers(node: ReactiveNode): void;
+/**
+ * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
+ * based on the current consumer context.
+ */
+export declare function producerUpdatesAllowed(): boolean;
+export declare function consumerMarkDirty(node: ReactiveNode): void;
+/**
+ * Prepare this consumer to run a computation in its reactive context.
+ *
+ * Must be called by subclasses which represent reactive computations, before those computations
+ * begin.
+ */
+export declare function consumerBeforeComputation(node: ReactiveNode | null): ReactiveNode | null;
+/**
+ * Finalize this consumer's state after a reactive computation has run.
+ *
+ * Must be called by subclasses which represent reactive computations, after those computations
+ * have finished.
+ */
+export declare function consumerAfterComputation(node: ReactiveNode | null, prevConsumer: ReactiveNode | null): void;
+/**
+ * Determine whether this consumer has any dependencies which have changed since the last time
+ * they were read.
+ */
+export declare function consumerPollProducersForChange(node: ReactiveNode): boolean;
+/**
+ * Disconnect this consumer from the graph.
+ */
+export declare function consumerDestroy(node: ReactiveNode): void;
+export {};

package/signals/implementation/graph.js

@@ -18,7 +18,16 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var graph_exports = {};
 __export(graph_exports, {
-  ReactiveNode: () => ReactiveNode,
+  REACTIVE_NODE: () => REACTIVE_NODE,
+  consumerAfterComputation: () => consumerAfterComputation,
+  consumerBeforeComputation: () => consumerBeforeComputation,
+  consumerDestroy: () => consumerDestroy,
+  consumerMarkDirty: () => consumerMarkDirty,
+  consumerPollProducersForChange: () => consumerPollProducersForChange,
+  producerAccessed: () => producerAccessed,
+  producerNotifyConsumers: () => producerNotifyConsumers,
+  producerUpdateValueVersion: () => producerUpdateValueVersion,
+  producerUpdatesAllowed: () => producerUpdatesAllowed,
   setActiveConsumer: () => setActiveConsumer
 });
 module.exports = __toCommonJS(graph_exports);
@@ -29,7 +38,6 @@ module.exports = __toCommonJS(graph_exports);
  * 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
  */
-let _nextReactiveId = 0;
 let activeConsumer = null;
 let inNotificationPhase = false;
 function setActiveConsumer(consumer) {
@@ -37,119 +45,166 @@ function setActiveConsumer(consumer) {
   activeConsumer = consumer;
   return prev;
 }
-class ReactiveNode {
-  id = _nextReactiveId++;
-  /**
-   * A cached weak reference to this node, which will be used in `ReactiveEdge`s.
-   */
-  ref = new WeakRef(this);
-  /**
-   * Edges to producers on which this node depends (in its consumer capacity).
-   */
-  producers = /* @__PURE__ */ new Map();
-  /**
-   * Edges to consumers on which this node depends (in its producer capacity).
-   */
-  consumers = /* @__PURE__ */ new Map();
-  /**
-   * Monotonically increasing counter representing a version of this `Consumer`'s
-   * dependencies.
-   */
-  trackingVersion = 0;
-  /**
-   * Monotonically increasing counter which increases when the value of this `Producer`
-   * semantically changes.
-   */
-  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 == null || edge.atTrackingVersion !== this.trackingVersion) {
-        this.producers.delete(producerId);
-        producer?.consumers.delete(this.id);
-        continue;
-      }
-      if (producer.producerPollStatus(edge.seenValueVersion)) {
-        return true;
-      }
+const REACTIVE_NODE = {
+  version: 0,
+  dirty: false,
+  producerNode: void 0,
+  producerLastReadVersion: void 0,
+  producerIndexOfThis: void 0,
+  nextProducerIndex: 0,
+  liveConsumerNode: void 0,
+  liveConsumerIndexOfThis: void 0,
+  consumerAllowSignalWrites: false,
+  consumerIsAlwaysLive: false,
+  producerMustRecompute: () => false,
+  producerRecomputeValue: () => {
+  },
+  consumerMarkedDirty: () => {
+  }
+};
+function producerAccessed(node) {
+  if (inNotificationPhase) {
+    throw new Error("Assertion error: signal read during notification phase");
+  }
+  if (activeConsumer === null) {
+    return;
+  }
+  const idx = activeConsumer.nextProducerIndex++;
+  assertConsumerNode(activeConsumer);
+  if (idx < activeConsumer.producerNode.length && activeConsumer.producerNode[idx] !== node) {
+    if (consumerIsLive(activeConsumer)) {
+      const staleProducer = activeConsumer.producerNode[idx];
+      producerRemoveLiveConsumerAtIndex(staleProducer, activeConsumer.producerIndexOfThis[idx]);
     }
-    return false;
-  }
-  /**
-   * Notify all consumers of this producer that its value may have changed.
-   */
-  producerMayHaveChanged() {
-    const prev = inNotificationPhase;
-    inNotificationPhase = true;
-    try {
-      for (const [consumerId, edge] of this.consumers) {
-        const consumer = edge.consumerNode.deref();
-        if (consumer == null || consumer.trackingVersion !== edge.atTrackingVersion) {
-          this.consumers.delete(consumerId);
-          consumer?.producers.delete(this.id);
-          continue;
-        }
-        consumer.onConsumerDependencyMayHaveChanged();
+  }
+  if (activeConsumer.producerNode[idx] !== node) {
+    activeConsumer.producerNode[idx] = node;
+    activeConsumer.producerIndexOfThis[idx] = consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;
+  }
+  activeConsumer.producerLastReadVersion[idx] = node.version;
+}
+function producerUpdateValueVersion(node) {
+  if (consumerIsLive(node) && !node.dirty) {
+    return;
+  }
+  if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
+    node.dirty = false;
+    return;
+  }
+  node.producerRecomputeValue(node);
+  node.dirty = false;
+}
+function producerNotifyConsumers(node) {
+  if (node.liveConsumerNode === void 0) {
+    return;
+  }
+  const prev = inNotificationPhase;
+  inNotificationPhase = true;
+  try {
+    for (const consumer of node.liveConsumerNode) {
+      if (!consumer.dirty) {
+        consumerMarkDirty(consumer);
       }
-    } finally {
-      inNotificationPhase = prev;
     }
+  } finally {
+    inNotificationPhase = prev;
+  }
+}
+function producerUpdatesAllowed() {
+  return activeConsumer?.consumerAllowSignalWrites !== false;
+}
+function consumerMarkDirty(node) {
+  node.dirty = true;
+  producerNotifyConsumers(node);
+  node.consumerMarkedDirty?.(node);
+}
+function consumerBeforeComputation(node) {
+  node && (node.nextProducerIndex = 0);
+  return setActiveConsumer(node);
+}
+function consumerAfterComputation(node, prevConsumer) {
+  setActiveConsumer(prevConsumer);
+  if (!node || node.producerNode === void 0 || node.producerIndexOfThis === void 0 || node.producerLastReadVersion === void 0) {
+    return;
+  }
+  if (consumerIsLive(node)) {
+    for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
+      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+    }
+  }
+  for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
+    node.producerNode.pop();
+    node.producerLastReadVersion.pop();
+    node.producerIndexOfThis.pop();
   }
-  /**
-   * Mark that this producer node has been accessed in the current reactive context.
-   */
-  producerAccessed() {
-    if (inNotificationPhase) {
-      throw new Error(`Assertion error: signal read during notification phase`);
+}
+function consumerPollProducersForChange(node) {
+  assertConsumerNode(node);
+  for (let i = 0; i < node.producerNode.length; i++) {
+    const producer = node.producerNode[i];
+    const seenVersion = node.producerLastReadVersion[i];
+    if (seenVersion !== producer.version) {
+      return true;
     }
-    if (activeConsumer === null) {
-      return;
+    producerUpdateValueVersion(producer);
+    if (seenVersion !== producer.version) {
+      return true;
     }
-    let edge = activeConsumer.producers.get(this.id);
-    if (edge === void 0) {
-      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;
+  }
+  return false;
+}
+function consumerDestroy(node) {
+  assertConsumerNode(node);
+  if (consumerIsLive(node)) {
+    for (let i = 0; i < node.producerNode.length; i++) {
+      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
     }
   }
-  /**
-   * Whether this consumer currently has any producers registered.
-   */
-  get hasProducers() {
-    return this.producers.size > 0;
-  }
-  /**
-   * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
-   * based on the current consumer context.
-   */
-  get producerUpdatesAllowed() {
-    return activeConsumer?.consumerAllowSignalWrites !== false;
-  }
-  /**
-   * 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) {
-    if (this.valueVersion !== lastSeenValueVersion) {
-      return true;
+  node.producerNode.length = node.producerLastReadVersion.length = node.producerIndexOfThis.length = 0;
+  if (node.liveConsumerNode) {
+    node.liveConsumerNode.length = node.liveConsumerIndexOfThis.length = 0;
+  }
+}
+function producerAddLiveConsumer(node, consumer, indexOfThis) {
+  assertProducerNode(node);
+  assertConsumerNode(node);
+  if (node.liveConsumerNode.length === 0) {
+    for (let i = 0; i < node.producerNode.length; i++) {
+      node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);
+    }
+  }
+  node.liveConsumerIndexOfThis.push(indexOfThis);
+  return node.liveConsumerNode.push(consumer) - 1;
+}
+function producerRemoveLiveConsumerAtIndex(node, idx) {
+  assertProducerNode(node);
+  assertConsumerNode(node);
+  if (node.liveConsumerNode.length === 1) {
+    for (let i = 0; i < node.producerNode.length; i++) {
+      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
     }
-    this.onProducerUpdateValueVersion();
-    return this.valueVersion !== lastSeenValueVersion;
   }
+  const lastIdx = node.liveConsumerNode.length - 1;
+  node.liveConsumerNode[idx] = node.liveConsumerNode[lastIdx];
+  node.liveConsumerIndexOfThis[idx] = node.liveConsumerIndexOfThis[lastIdx];
+  node.liveConsumerNode.length--;
+  node.liveConsumerIndexOfThis.length--;
+  if (idx < node.liveConsumerNode.length) {
+    const idxProducer = node.liveConsumerIndexOfThis[idx];
+    const consumer = node.liveConsumerNode[idx];
+    assertConsumerNode(consumer);
+    consumer.producerIndexOfThis[idxProducer] = idx;
+  }
+}
+function consumerIsLive(node) {
+  return node.consumerIsAlwaysLive || (node?.liveConsumerNode?.length ?? 0) > 0;
+}
+function assertConsumerNode(node) {
+  node.producerNode ??= [];
+  node.producerIndexOfThis ??= [];
+  node.producerLastReadVersion ??= [];
+}
+function assertProducerNode(node) {
+  node.liveConsumerNode ??= [];
+  node.liveConsumerIndexOfThis ??= [];
 }

package/signals/implementation/signal.js

@@ -33,81 +33,19 @@ var import_graph = require("./graph.js");
  * found in the LICENSE file at https://angular.io/license
  */
 let postSignalSetFn = null;
-class WritableSignalImpl extends import_graph.ReactiveNode {
-  value;
-  equal;
-  readonlySignal;
-  consumerAllowSignalWrites = false;
-  constructor(value, equal) {
-    super();
-    this.value = value;
-    this.equal = equal;
-  }
-  onConsumerDependencyMayHaveChanged() {
-  }
-  onProducerUpdateValueVersion() {
-  }
-  /**
-   * 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.producerUpdatesAllowed) {
-      (0, import_errors.throwInvalidWriteToSignalError)();
-    }
-    if (!this.equal(this.value, newValue)) {
-      this.value = newValue;
-      this.valueVersion++;
-      this.producerMayHaveChanged();
-      postSignalSetFn?.();
-    }
-  }
-  /**
-   * 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) {
-    if (!this.producerUpdatesAllowed) {
-      (0, import_errors.throwInvalidWriteToSignalError)();
-    }
-    this.set(updater(this.value));
-  }
-  /**
-   * Calls `mutator` on the current value and assumes that it has been mutated.
-   */
-  mutate(mutator) {
-    if (!this.producerUpdatesAllowed) {
-      (0, import_errors.throwInvalidWriteToSignalError)();
-    }
-    mutator(this.value);
-    this.valueVersion++;
-    this.producerMayHaveChanged();
-    postSignalSetFn?.();
-  }
-  asReadonly() {
-    if (this.readonlySignal === void 0) {
-      this.readonlySignal = (0, import_api.createSignalFromFunction)(this, () => this.signal());
-    }
-    return this.readonlySignal;
-  }
-  signal() {
-    this.producerAccessed();
-    return this.value;
-  }
-}
 function signal(initialValue, options) {
-  const signalNode = new WritableSignalImpl(initialValue, options?.equal ?? import_api.defaultEquals);
-  const signalFn = (0, import_api.createSignalFromFunction)(signalNode, signalNode.signal.bind(signalNode), {
-    set: signalNode.set.bind(signalNode),
-    update: signalNode.update.bind(signalNode),
-    mutate: signalNode.mutate.bind(signalNode),
-    asReadonly: signalNode.asReadonly.bind(signalNode)
-  });
+  const node = Object.create(SIGNAL_NODE);
+  node.value = initialValue;
+  options?.equal && (node.equal = options.equal);
+  function signalFn() {
+    (0, import_graph.producerAccessed)(node);
+    return node.value;
+  }
+  signalFn.set = signalSetFn;
+  signalFn.update = signalUpdateFn;
+  signalFn.mutate = signalMutateFn;
+  signalFn.asReadonly = signalAsReadonlyFn;
+  signalFn[import_api.SIGNAL] = node;
   return signalFn;
 }
 function setPostSignalSetFn(fn) {
@@ -115,3 +53,46 @@ function setPostSignalSetFn(fn) {
   postSignalSetFn = fn;
   return prev;
 }
+const SIGNAL_NODE = {
+  ...import_graph.REACTIVE_NODE,
+  equal: import_api.defaultEquals,
+  readonlyFn: void 0
+};
+function signalValueChanged(node) {
+  node.version++;
+  (0, import_graph.producerNotifyConsumers)(node);
+  postSignalSetFn?.();
+}
+function signalSetFn(newValue) {
+  const node = this[import_api.SIGNAL];
+  if (!(0, import_graph.producerUpdatesAllowed)()) {
+    (0, import_errors.throwInvalidWriteToSignalError)();
+  }
+  if (!node.equal(node.value, newValue)) {
+    node.value = newValue;
+    signalValueChanged(node);
+  }
+}
+function signalUpdateFn(updater) {
+  if (!(0, import_graph.producerUpdatesAllowed)()) {
+    (0, import_errors.throwInvalidWriteToSignalError)();
+  }
+  signalSetFn.call(this, updater(this[import_api.SIGNAL].value));
+}
+function signalMutateFn(mutator) {
+  const node = this[import_api.SIGNAL];
+  if (!(0, import_graph.producerUpdatesAllowed)()) {
+    (0, import_errors.throwInvalidWriteToSignalError)();
+  }
+  mutator(node.value);
+  signalValueChanged(node);
+}
+function signalAsReadonlyFn() {
+  const node = this[import_api.SIGNAL];
+  if (node.readonlyFn === void 0) {
+    const readonlyFn = () => this();
+    readonlyFn[import_api.SIGNAL] = node;
+    node.readonlyFn = readonlyFn;
+  }
+  return node.readonlyFn;
+}

package/signals/implementation/watch.d.ts

@@ -5,7 +5,6 @@
  * 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 } from './graph.js';
 /**
  * A cleanup function that can be optionally registered from the watch logic. If registered, the
  * cleanup logic runs before the next watch execution.
@@ -15,24 +14,8 @@ export type WatchCleanupFn = () => void;
  * A callback passed to the watch function that makes it possible to register cleanup logic.
  */
 export type WatchCleanupRegisterFn = (cleanupFn: WatchCleanupFn) => void;
-/**
- * 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 declare class Watch extends ReactiveNode {
-    private watch;
-    private schedule;
-    protected readonly consumerAllowSignalWrites: boolean;
-    private dirty;
-    private cleanupFn;
-    private registerOnCleanup;
-    constructor(watch: (onCleanup: WatchCleanupRegisterFn) => void, schedule: (watch: Watch) => void, allowSignalWrites: boolean);
+export interface Watch {
     notify(): void;
-    protected onConsumerDependencyMayHaveChanged(): void;
-    protected onProducerUpdateValueVersion(): void;
     /**
      * Execute the reactive expression in the context of this `Watch` consumer.
      *
@@ -42,3 +25,4 @@ export declare class Watch extends ReactiveNode {
     run(): void;
     cleanup(): void;
 }
+export declare function watch(fn: (onCleanup: WatchCleanupRegisterFn) => void, schedule: (watch: Watch) => void, allowSignalWrites: boolean): Watch;

package/signals/implementation/watch.js

@@ -18,7 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var watch_exports = {};
 __export(watch_exports, {
-  Watch: () => Watch
+  watch: () => watch
 });
 module.exports = __toCommonJS(watch_exports);
 var import_graph = require("./graph.js");
@@ -29,56 +29,47 @@ var import_graph = require("./graph.js");
  * 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
  */
-const NOOP_CLEANUP_FN = () => {
-};
-class Watch extends import_graph.ReactiveNode {
-  watch;
-  schedule;
-  consumerAllowSignalWrites;
-  dirty = false;
-  cleanupFn = NOOP_CLEANUP_FN;
-  registerOnCleanup = (cleanupFn) => {
-    this.cleanupFn = cleanupFn;
-  };
-  constructor(watch, schedule, allowSignalWrites) {
-    super();
-    this.watch = watch;
-    this.schedule = schedule;
-    this.consumerAllowSignalWrites = allowSignalWrites;
-  }
-  notify() {
-    if (!this.dirty) {
-      this.schedule(this);
-    }
-    this.dirty = true;
-  }
-  onConsumerDependencyMayHaveChanged() {
-    this.notify();
+function watch(fn, schedule, allowSignalWrites) {
+  const node = Object.create(WATCH_NODE);
+  if (allowSignalWrites) {
+    node.consumerAllowSignalWrites = true;
   }
-  onProducerUpdateValueVersion() {
-  }
-  /**
-   * 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()) {
+  node.fn = fn;
+  node.schedule = schedule;
+  const registerOnCleanup = (cleanupFn) => {
+    node.cleanupFn = cleanupFn;
+  };
+  const run = () => {
+    node.dirty = false;
+    if (node.hasRun && !(0, import_graph.consumerPollProducersForChange)(node)) {
       return;
     }
-    const prevConsumer = (0, import_graph.setActiveConsumer)(this);
-    this.trackingVersion++;
+    node.hasRun = true;
+    const prevConsumer = (0, import_graph.consumerBeforeComputation)(node);
     try {
-      this.cleanupFn();
-      this.cleanupFn = NOOP_CLEANUP_FN;
-      this.watch(this.registerOnCleanup);
+      node.cleanupFn();
+      node.cleanupFn = NOOP_CLEANUP_FN;
+      node.fn(registerOnCleanup);
     } finally {
-      (0, import_graph.setActiveConsumer)(prevConsumer);
+      (0, import_graph.consumerAfterComputation)(node, prevConsumer);
     }
-  }
-  cleanup() {
-    this.cleanupFn();
-  }
+  };
+  node.ref = {
+    notify: () => (0, import_graph.consumerMarkDirty)(node),
+    run,
+    cleanup: () => node.cleanupFn()
+  };
+  return node.ref;
 }
+const NOOP_CLEANUP_FN = () => {
+};
+const WATCH_NODE = {
+  ...import_graph.REACTIVE_NODE,
+  consumerIsAlwaysLive: true,
+  consumerAllowSignalWrites: false,
+  consumerMarkedDirty: (node) => {
+    node.schedule(node.ref);
+  },
+  hasRun: false,
+  cleanupFn: NOOP_CLEANUP_FN
+};

package/text/dynamic-text.model.js

@@ -30,7 +30,6 @@ __export(dynamic_text_model_exports, {
 });
 module.exports = __toCommonJS(dynamic_text_model_exports);
 var import_rxjs = require("rxjs");
-var import_core = require("../core.js");
 var import_inject = require("../injector/inject.js");
 var import_api = require("../signals/api.js");
 var import_switch_map = require("../signals/switch-map.js");
@@ -38,12 +37,11 @@ var import_untracked_operator = require("../signals/untracked-operator.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_localization_service = require("./localization.service.js");
 const missingLocalizationKeyText = "[MISSING LOCALIZATION KEY]";
-function resolveDynamicText(text, localizationService) {
-  const resolvedLocalizationService = localizationService ?? ((0, import_inject.isInInjectionContext)() ? (0, import_inject.inject)(import_localization_service.LocalizationService) : (0, import_core.getGlobalInjector)().resolve(import_localization_service.LocalizationService));
+function resolveDynamicText(text, localizationService = (0, import_inject.inject)(import_localization_service.LocalizationService)) {
   const localizableTextSignal = (0, import_api.isSignal)(text) ? text : (0, import_rxjs.isObservable)(text) ? (0, import_api.toSignal)(text.pipe((0, import_untracked_operator.runInUntracked)()), { initialValue: missingLocalizationKeyText }) : (0, import_api.computed)(() => text);
   return (0, import_switch_map.switchMap)(() => {
     const localizableText = localizableTextSignal();
-    return (0, import_type_guards.isString)(localizableText) ? (0, import_api.computed)(() => localizableText) : resolvedLocalizationService.localize(localizableText);
+    return (0, import_type_guards.isString)(localizableText) ? (0, import_api.computed)(() => localizableText) : localizationService.localize(localizableText);
   });
 }
 function resolveDynamicText$(text, localizationService) {