@tstdl/base 0.85.13 → 0.86.0-beta1

package/signals/implementation/graph.js

@@ -1,27 +1,3 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var graph_exports = {};
-__export(graph_exports, {
-  ReactiveNode: () => ReactiveNode,
-  setActiveConsumer: () => setActiveConsumer
-});
-module.exports = __toCommonJS(graph_exports);
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -29,127 +5,179 @@ 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
  */
+/**
+ * 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;
+/**
+ * Whether the graph is currently propagating change notifications.
+ */
 let inNotificationPhase = false;
-function setActiveConsumer(consumer) {
-  const prev = activeConsumer;
-  activeConsumer = consumer;
-  return prev;
+export function setActiveConsumer(consumer) {
+    const prev = activeConsumer;
+    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 === void 0 || edge.atTrackingVersion !== this.trackingVersion) {
-        this.producers.delete(producerId);
-        producer?.consumers.delete(this.id);
-        continue;
-      }
-      if (producer.producerPollStatus(edge.seenValueVersion)) {
-        return true;
-      }
+/**
+ * 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 {
+    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 = new Map();
+    /**
+     * Edges to consumers on which this node depends (in its producer capacity).
+     */
+    consumers = 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 === 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;
     }
-    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 === void 0 || consumer.trackingVersion !== edge.atTrackingVersion) {
-          this.consumers.delete(consumerId);
-          consumer?.producers.delete(this.id);
-          continue;
+    /**
+     * Notify all consumers of this producer that its value may have changed.
+     */
+    producerMayHaveChanged() {
+        // Prevent signal reads when we're updating the graph
+        const prev = inNotificationPhase;
+        inNotificationPhase = true;
+        try {
+            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();
+            }
+        }
+        finally {
+            inNotificationPhase = prev;
         }
-        consumer.onConsumerDependencyMayHaveChanged();
-      }
-    } finally {
-      inNotificationPhase = prev;
     }
-  }
-  /**
-   * 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`);
+    /**
+     * 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`);
+        }
+        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;
+        }
     }
-    if (activeConsumer === null) {
-      return;
+    /**
+     * Whether this consumer currently has any producers registered.
+     */
+    get hasProducers() {
+        return this.producers.size > 0;
     }
-    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;
+    /**
+     * 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;
     }
-  }
-  /**
-   * 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;
+    /**
+     * 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;
     }
-    this.onProducerUpdateValueVersion();
-    return this.valueVersion !== lastSeenValueVersion;
-  }
 }

package/signals/implementation/index.js

@@ -1,27 +1,10 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var implementation_exports = {};
-module.exports = __toCommonJS(implementation_exports);
-__reExport(implementation_exports, require("./api.js"), module.exports);
-__reExport(implementation_exports, require("./computed.js"), module.exports);
-__reExport(implementation_exports, require("./configure.js"), module.exports);
-__reExport(implementation_exports, require("./effect.js"), module.exports);
-__reExport(implementation_exports, require("./graph.js"), module.exports);
-__reExport(implementation_exports, require("./signal.js"), module.exports);
-__reExport(implementation_exports, require("./to-observable.js"), module.exports);
-__reExport(implementation_exports, require("./to-signal.js"), module.exports);
-__reExport(implementation_exports, require("./untracked.js"), module.exports);
-__reExport(implementation_exports, require("./watch.js"), module.exports);
+export * from './api.js';
+export * from './computed.js';
+export * from './configure.js';
+export * from './effect.js';
+export * from './graph.js';
+export * from './signal.js';
+export * from './to-observable.js';
+export * from './to-signal.js';
+export * from './untracked.js';
+export * from './watch.js';

package/signals/implementation/signal.js

@@ -1,30 +1,3 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var signal_exports = {};
-__export(signal_exports, {
-  setPostSignalSetFn: () => setPostSignalSetFn,
-  signal: () => signal
-});
-module.exports = __toCommonJS(signal_exports);
-var import_api = require("./api.js");
-var import_errors = require("./errors.js");
-var import_graph = require("./graph.js");
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -32,86 +5,103 @@ 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
  */
+import { createSignalFromFunction, defaultEquals } from './api.js';
+import { throwInvalidWriteToSignalError } from './errors.js';
+import { ReactiveNode } from './graph.js';
+/**
+ * If set, called after `WritableSignal`s are updated.
+ *
+ * This hook can be used to achieve various effects, such as running effects synchronously as part
+ * of setting a signal.
+ */
 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)();
+class WritableSignalImpl extends ReactiveNode {
+    value;
+    equal;
+    readonlySignal;
+    consumerAllowSignalWrites = false;
+    constructor(value, equal) {
+        super();
+        this.value = value;
+        this.equal = equal;
+    }
+    onConsumerDependencyMayHaveChanged() {
+        // This never happens for writable signals as they're not consumers.
     }
-    if (!this.equal(this.value, newValue)) {
-      this.value = newValue;
-      this.valueVersion++;
-      this.producerMayHaveChanged();
-      postSignalSetFn?.();
+    onProducerUpdateValueVersion() {
+        // Writable signal value versions are always up to date.
     }
-  }
-  /**
-   * 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)();
+    /**
+     * 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) {
+            throwInvalidWriteToSignalError();
+        }
+        if (!this.equal(this.value, newValue)) {
+            this.value = newValue;
+            this.valueVersion++;
+            this.producerMayHaveChanged();
+            postSignalSetFn?.();
+        }
     }
-    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)();
+    /**
+     * 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) {
+            throwInvalidWriteToSignalError();
+        }
+        this.set(updater(this.value));
     }
-    mutator(this.value);
-    this.valueVersion++;
-    this.producerMayHaveChanged();
-    postSignalSetFn?.();
-  }
-  asReadonly() {
-    if (this.readonlySignal === void 0) {
-      this.readonlySignal = (0, import_api.createSignalFromFunction)(this, () => this.signal());
+    /**
+     * Calls `mutator` on the current value and assumes that it has been mutated.
+     */
+    mutate(mutator) {
+        if (!this.producerUpdatesAllowed) {
+            throwInvalidWriteToSignalError();
+        }
+        // Mutate bypasses equality checks as it's by definition changing the value.
+        mutator(this.value);
+        this.valueVersion++;
+        this.producerMayHaveChanged();
+        postSignalSetFn?.();
+    }
+    asReadonly() {
+        if (this.readonlySignal === undefined) {
+            this.readonlySignal = createSignalFromFunction(this, () => this.signal());
+        }
+        return this.readonlySignal;
+    }
+    signal() {
+        this.producerAccessed();
+        return this.value;
     }
-    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)
-  });
-  return signalFn;
+/**
+ * Create a `Signal` that can be set or updated directly.
+ */
+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),
+        asReadonly: signalNode.asReadonly.bind(signalNode)
+    });
+    return signalFn;
 }
-function setPostSignalSetFn(fn) {
-  const prev = postSignalSetFn;
-  postSignalSetFn = fn;
-  return prev;
+export function setPostSignalSetFn(fn) {
+    const prev = postSignalSetFn;
+    postSignalSetFn = fn;
+    return prev;
 }

package/signals/implementation/to-observable.js

@@ -1,39 +1,22 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var to_observable_exports = {};
-__export(to_observable_exports, {
-  toObservable: () => toObservable
-});
-module.exports = __toCommonJS(to_observable_exports);
-var import_rxjs = require("rxjs");
-var import_effect = require("./effect.js");
-var import_untracked = require("./untracked.js");
-function toObservable(source) {
-  return new import_rxjs.Observable((subscriber) => {
-    const effectRef = (0, import_effect.effect)(() => {
-      try {
-        const value = source();
-        (0, import_untracked.untracked)(() => subscriber.next(value));
-      } catch (error) {
-        (0, import_untracked.untracked)(() => subscriber.error(error));
-      }
-    }, { allowSignalWrites: true });
-    return () => effectRef.destroy();
-  });
+import { Observable } from 'rxjs';
+import { effect } from './effect.js';
+import { untracked } from './untracked.js';
+/**
+ * Exposes the value of an Angular `Signal` as an RxJS `Observable`.
+ *
+ * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
+ */
+export function toObservable(source) {
+    return new Observable((subscriber) => {
+        const effectRef = effect(() => {
+            try {
+                const value = source();
+                untracked(() => subscriber.next(value));
+            }
+            catch (error) {
+                untracked(() => subscriber.error(error));
+            }
+        }, { allowSignalWrites: true });
+        return () => effectRef.destroy();
+    });
 }