@tstdl/base 0.84.4 → 0.84.6

package/signals/implementation/graph.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @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
+ */
+export declare function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null;
+/**
+ * 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 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;
+    /**
+     * 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.
+     */
+    protected valueVersion: number;
+    /**
+     * Whether signal writes should be allowed while this `ReactiveNode` is the current consumer.
+     */
+    protected abstract readonly consumerAllowSignalWrites: boolean;
+    /**
+     * Called for consumers whenever one of their dependencies notifies that it might have a new
+     * value.
+     */
+    protected abstract onConsumerDependencyMayHaveChanged(): void;
+    /**
+     * Called for producers when a dependent consumer is checking if the producer's value has actually
+     * changed.
+     */
+    protected abstract onProducerUpdateValueVersion(): void;
+    /**
+     * 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.
+     */
+    protected consumerPollProducersForChange(): boolean;
+    /**
+     * Notify all consumers of this producer that its value may have changed.
+     */
+    protected producerMayHaveChanged(): void;
+    /**
+     * Mark that this producer node has been accessed in the current reactive context.
+     */
+    protected producerAccessed(): void;
+    /**
+     * Whether this consumer currently has any producers registered.
+     */
+    protected get hasProducers(): boolean;
+    /**
+     * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
+     * based on the current consumer context.
+     */
+    protected get producerUpdatesAllowed(): 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`.
+     */
+    private producerPollStatus;
+}

package/signals/implementation/graph.js

@@ -0,0 +1,155 @@
+"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.
+ *
+ * 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) {
+  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;
+      }
+    }
+    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;
+        }
+        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`);
+    }
+    if (activeConsumer === null) {
+      return;
+    }
+    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 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;
+    }
+    this.onProducerUpdateValueVersion();
+    return this.valueVersion !== lastSeenValueVersion;
+  }
+}

package/signals/implementation/index.d.ts

@@ -0,0 +1,8 @@
+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 './untracked.js';
+export * from './watch.js';

package/signals/implementation/index.js

@@ -0,0 +1,25 @@
+"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("./untracked.js"), module.exports);
+__reExport(implementation_exports, require("./watch.js"), module.exports);

package/signals/implementation/signal.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @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 type { Signal, ValueEqualityFn } from './api.js';
+/**
+ * A `Signal` with a value that can be mutated via a setter interface.
+ *
+ * @developerPreview
+ */
+export interface WritableSignal<T> extends Signal<T> {
+    /**
+     * Directly set the signal to a new value, and notify any dependents.
+     */
+    set(value: T): void;
+    /**
+     * Update the value of the signal based on its current value, and
+     * notify any dependents.
+     */
+    update(updateFn: (value: T) => T): void;
+    /**
+     * Update the current value by mutating it in-place, and
+     * notify any dependents.
+     */
+    mutate(mutatorFn: (value: T) => void): void;
+    /**
+     * Returns a readonly version of this signal. Readonly signals can be accessed to read their value
+     * but can't be changed using set, update or mutate methods. The readonly signals do _not_ have
+     * any built-in mechanism that would prevent deep-mutation of their value.
+     */
+    asReadonly(): Signal<T>;
+}
+/**
+ * Options passed to the `signal` creation function.
+ *
+ * @developerPreview
+ */
+export interface CreateSignalOptions<T> {
+    /**
+     * A comparison function which defines equality for signal values.
+     */
+    equal?: ValueEqualityFn<T>;
+}
+/**
+ * Create a `Signal` that can be set or updated directly.
+ *
+ * @developerPreview
+ */
+export declare function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T>;
+export declare function setPostSignalSetFn(fn: (() => void) | null): (() => void) | null;

package/signals/implementation/signal.js

@@ -0,0 +1,117 @@
+"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.
+ *
+ * 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 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)
+  });
+  return signalFn;
+}
+function setPostSignalSetFn(fn) {
+  const prev = postSignalSetFn;
+  postSignalSetFn = fn;
+  return prev;
+}

package/signals/implementation/untracked.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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
+ */
+/**
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
+ *
+ * @developerPreview
+ */
+export declare function untracked<T>(nonReactiveReadsFn: () => T): T;

package/signals/implementation/untracked.js

@@ -0,0 +1,39 @@
+"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 untracked_exports = {};
+__export(untracked_exports, {
+  untracked: () => untracked
+});
+module.exports = __toCommonJS(untracked_exports);
+var import_graph = require("./graph.js");
+/**
+ * @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
+ */
+function untracked(nonReactiveReadsFn) {
+  const prevConsumer = (0, import_graph.setActiveConsumer)(null);
+  try {
+    return nonReactiveReadsFn();
+  } finally {
+    (0, import_graph.setActiveConsumer)(prevConsumer);
+  }
+}

package/signals/implementation/watch.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @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 } 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.
+ */
+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);
+    notify(): void;
+    protected onConsumerDependencyMayHaveChanged(): void;
+    protected onProducerUpdateValueVersion(): void;
+    /**
+     * 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(): void;
+    cleanup(): void;
+}

package/signals/implementation/watch.js

@@ -0,0 +1,84 @@
+"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 watch_exports = {};
+__export(watch_exports, {
+  Watch: () => Watch
+});
+module.exports = __toCommonJS(watch_exports);
+var import_graph = require("./graph.js");
+/**
+ * @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
+ */
+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();
+  }
+  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()) {
+      return;
+    }
+    const prevConsumer = (0, import_graph.setActiveConsumer)(this);
+    this.trackingVersion++;
+    try {
+      this.cleanupFn();
+      this.cleanupFn = NOOP_CLEANUP_FN;
+      this.watch(this.registerOnCleanup);
+    } finally {
+      (0, import_graph.setActiveConsumer)(prevConsumer);
+    }
+  }
+  cleanup() {
+    this.cleanupFn();
+  }
+}

package/signals/index.d.ts

@@ -0,0 +1,5 @@
+export * from './api.js';
+export * from './computed-with-dependencies.js';
+export * from './pipe.js';
+export * from './to-observable.js';
+export * from './to-signal.js';

package/signals/index.js

@@ -0,0 +1,22 @@
+"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 signals_exports = {};
+module.exports = __toCommonJS(signals_exports);
+__reExport(signals_exports, require("./api.js"), module.exports);
+__reExport(signals_exports, require("./computed-with-dependencies.js"), module.exports);
+__reExport(signals_exports, require("./pipe.js"), module.exports);
+__reExport(signals_exports, require("./to-observable.js"), module.exports);
+__reExport(signals_exports, require("./to-signal.js"), module.exports);