@tstdl/base 0.84.4 → 0.84.5

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,7 @@
+export * from './api.js';
+export * from './computed.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,24 @@
+"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("./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,4 @@
+export * from './api.js';
+export * from './pipe.js';
+export * from './to-observable.js';
+export * from './to-signal.js';

package/signals/index.js

@@ -0,0 +1,21 @@
+"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("./pipe.js"), module.exports);
+__reExport(signals_exports, require("./to-observable.js"), module.exports);
+__reExport(signals_exports, require("./to-signal.js"), module.exports);

package/signals/pipe.d.ts

@@ -0,0 +1,7 @@
+import type { OperatorFunction } from 'rxjs';
+import type { Signal } from './api.js';
+export declare function pipe<I, A>(signal: Signal<I>, op1: OperatorFunction<I, A>): Signal<A>;
+export declare function pipe<I, A, B>(signal: Signal<I>, op1: OperatorFunction<I, A>, op2: OperatorFunction<A, B>): Signal<B>;
+export declare function pipe<I, A, B, C>(signal: Signal<I>, op1: OperatorFunction<I, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
+export declare function pipe<I, A, B, C, D>(signal: Signal<I>, op1: OperatorFunction<I, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Signal<D>;
+export declare function pipe<I, A, B, C, D, E>(signal: Signal<I>, op1: OperatorFunction<I, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Signal<E>;

package/signals/pipe.js

@@ -0,0 +1,30 @@
+"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 pipe_exports = {};
+__export(pipe_exports, {
+  pipe: () => pipe
+});
+module.exports = __toCommonJS(pipe_exports);
+var import_to_observable = require("./to-observable.js");
+var import_to_signal = require("./to-signal.js");
+function pipe(signal, ...operators) {
+  const observable = (0, import_to_observable.toObservable)(signal, { emitImmediately: true });
+  const piped = observable.pipe(...operators);
+  return (0, import_to_signal.toSignal)(piped, { requireSync: true });
+}

package/signals/to-observable.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import type { Signal } from './api.js';
+export type ToObservableOptions = {
+    /**
+     * Immediately run inner effect after creation without scheduling - for advanced use cases.
+     */
+    emitImmediately: boolean;
+};
+/**
+ * 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`.
+ *
+ * `toObservable` must be called in an injection context.
+ */
+export declare function toObservable<T>(source: Signal<T>, options?: ToObservableOptions): Observable<T>;

package/signals/to-observable.js

@@ -0,0 +1,38 @@
+"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_api = require("./api.js");
+function toObservable(source, options) {
+  return new import_rxjs.Observable((subscriber) => {
+    const effectRef = (0, import_api.effect)(() => {
+      try {
+        const value = source();
+        (0, import_api.untracked)(() => subscriber.next(value));
+      } catch (error) {
+        (0, import_api.untracked)(() => subscriber.error(error));
+      }
+    }, { allowSignalWrites: true, runImmediately: options?.emitImmediately });
+    return () => effectRef.destroy();
+  });
+}