@tstdl/base 0.87.15 → 0.88.0-alpha2

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();
+    });
 }

package/signals/implementation/to-signal.js

@@ -1,31 +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 to_signal_exports = {};
-__export(to_signal_exports, {
-  toSignal: () => toSignal
-});
-module.exports = __toCommonJS(to_signal_exports);
-var import_core = require("../../core.js");
-var import_finalization = require("../../memory/finalization.js");
-var import_computed = require("./computed.js");
-var import_signal = require("./signal.js");
-var import_untracked = require("./untracked.js");
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -33,39 +5,51 @@ var import_untracked = require("./untracked.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 { isDevMode } from '../../core.js';
+import { registerFinalization } from '../../memory/finalization.js';
+import { computed } from './computed.js';
+import { signal } from './signal.js';
+import { untracked } from './untracked.js';
 var StateKind;
-(function(StateKind2) {
-  StateKind2[StateKind2["NoValue"] = 0] = "NoValue";
-  StateKind2[StateKind2["Value"] = 1] = "Value";
-  StateKind2[StateKind2["Error"] = 2] = "Error";
+(function (StateKind) {
+    StateKind[StateKind["NoValue"] = 0] = "NoValue";
+    StateKind[StateKind["Value"] = 1] = "Value";
+    StateKind[StateKind["Error"] = 2] = "Error";
 })(StateKind || (StateKind = {}));
-function toSignal(source, options) {
-  let state;
-  if (options?.requireSync) {
-    state = (0, import_signal.signal)({ kind: StateKind.NoValue });
-  } else {
-    state = (0, import_signal.signal)({ kind: StateKind.Value, value: options?.initialValue });
-  }
-  const sub = source.subscribe({
-    next: (value) => state.set({ kind: StateKind.Value, value }),
-    error: (error) => state.set({ kind: StateKind.Error, error })
-    // Completion of the Observable is meaningless to the signal. Signals don't have a concept of
-    // "complete".
-  });
-  if ((0, import_core.isDevMode)() && options?.requireSync && (0, import_untracked.untracked)(state).kind === StateKind.NoValue) {
-    throw new Error("`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.");
-  }
-  const result = (0, import_computed.computed)(() => {
-    const current = state();
-    switch (current.kind) {
-      case StateKind.Value:
-        return current.value;
-      case StateKind.Error:
-        throw current.error;
-      case StateKind.NoValue:
-        throw new Error("`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.");
+export function toSignal(source, options) {
+    // Note: T is the Observable value type, and U is the initial value type. They don't have to be
+    // the same - the returned signal gives values of type `T`.
+    let state;
+    if (options?.requireSync) {
+        // Initially the signal is in a `NoValue` state.
+        state = signal({ kind: StateKind.NoValue });
     }
-  });
-  (0, import_finalization.registerFinalization)(result, () => sub.unsubscribe());
-  return result;
+    else {
+        // If an initial value was passed, use it. Otherwise, use `undefined` as the initial value.
+        state = signal({ kind: StateKind.Value, value: options?.initialValue });
+    }
+    const sub = source.subscribe({
+        next: value => state.set({ kind: StateKind.Value, value }),
+        error: error => state.set({ kind: StateKind.Error, error }),
+        // Completion of the Observable is meaningless to the signal. Signals don't have a concept of
+        // "complete".
+    });
+    if (isDevMode() && options?.requireSync && untracked(state).kind === StateKind.NoValue) {
+        throw new Error('`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');
+    }
+    // The actual returned signal is a `computed` of the `State` signal, which maps the various states
+    // to either values or errors.
+    const result = computed(() => {
+        const current = state();
+        switch (current.kind) {
+            case StateKind.Value:
+                return current.value;
+            case StateKind.Error:
+                throw current.error;
+            case StateKind.NoValue:
+                throw new Error('`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');
+        }
+    });
+    registerFinalization(result, () => sub.unsubscribe());
+    return result;
 }

package/signals/implementation/untracked.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 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.
@@ -29,11 +5,19 @@ 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
  */
-function untracked(nonReactiveReadsFn) {
-  const prevConsumer = (0, import_graph.setActiveConsumer)(null);
-  try {
-    return nonReactiveReadsFn();
-  } finally {
-    (0, import_graph.setActiveConsumer)(prevConsumer);
-  }
+import { setActiveConsumer } from './graph.js';
+/**
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
+ */
+export function untracked(nonReactiveReadsFn) {
+    const prevConsumer = setActiveConsumer(null);
+    // We are not trying to catch any particular errors here, just making sure that the consumers
+    // stack is restored in case of errors.
+    try {
+        return nonReactiveReadsFn();
+    }
+    finally {
+        setActiveConsumer(prevConsumer);
+    }
 }

package/signals/implementation/watch.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 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.
@@ -29,47 +5,48 @@ 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
  */
-function watch(fn, schedule, allowSignalWrites) {
-  const node = Object.create(WATCH_NODE);
-  if (allowSignalWrites) {
-    node.consumerAllowSignalWrites = true;
-  }
-  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;
+import { consumerAfterComputation, consumerBeforeComputation, consumerMarkDirty, consumerPollProducersForChange, REACTIVE_NODE } from './graph.js';
+export function watch(fn, schedule, allowSignalWrites) {
+    const node = Object.create(WATCH_NODE);
+    if (allowSignalWrites) {
+        node.consumerAllowSignalWrites = true;
     }
-    node.hasRun = true;
-    const prevConsumer = (0, import_graph.consumerBeforeComputation)(node);
-    try {
-      node.cleanupFn();
-      node.cleanupFn = NOOP_CLEANUP_FN;
-      node.fn(registerOnCleanup);
-    } finally {
-      (0, import_graph.consumerAfterComputation)(node, prevConsumer);
-    }
-  };
-  node.ref = {
-    notify: () => (0, import_graph.consumerMarkDirty)(node),
-    run,
-    cleanup: () => node.cleanupFn()
-  };
-  return node.ref;
+    node.fn = fn;
+    node.schedule = schedule;
+    const registerOnCleanup = (cleanupFn) => {
+        node.cleanupFn = cleanupFn;
+    };
+    const run = () => {
+        node.dirty = false;
+        if (node.hasRun && !consumerPollProducersForChange(node)) {
+            return;
+        }
+        node.hasRun = true;
+        const prevConsumer = consumerBeforeComputation(node);
+        try {
+            node.cleanupFn();
+            node.cleanupFn = NOOP_CLEANUP_FN;
+            node.fn(registerOnCleanup);
+        }
+        finally {
+            consumerAfterComputation(node, prevConsumer);
+        }
+    };
+    node.ref = {
+        notify: () => consumerMarkDirty(node),
+        run,
+        cleanup: () => node.cleanupFn(),
+    };
+    return node.ref;
 }
-const NOOP_CLEANUP_FN = () => {
-};
+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
+    ...REACTIVE_NODE,
+    consumerIsAlwaysLive: true,
+    consumerAllowSignalWrites: false,
+    consumerMarkedDirty: (node) => {
+        node.schedule(node.ref);
+    },
+    hasRun: false,
+    cleanupFn: NOOP_CLEANUP_FN,
 };

package/signals/index.js

@@ -1,26 +1,9 @@
-"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("./effect-with-dependencies.js"), module.exports);
-__reExport(signals_exports, require("./lazylize.js"), module.exports);
-__reExport(signals_exports, require("./pipe.js"), module.exports);
-__reExport(signals_exports, require("./switch-map.js"), module.exports);
-__reExport(signals_exports, require("./to-signal-2.js"), module.exports);
-__reExport(signals_exports, require("./types.js"), module.exports);
-__reExport(signals_exports, require("./untracked-operator.js"), module.exports);
+export * from './api.js';
+export * from './computed-with-dependencies.js';
+export * from './effect-with-dependencies.js';
+export * from './lazylize.js';
+export * from './pipe.js';
+export * from './switch-map.js';
+export * from './to-signal-2.js';
+export * from './types.js';
+export * from './untracked-operator.js';

package/signals/lazylize.js

@@ -1,28 +1,5 @@
-"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 lazylize_exports = {};
-__export(lazylize_exports, {
-  lazylize: () => lazylize
-});
-module.exports = __toCommonJS(lazylize_exports);
-var import_api = require("./api.js");
-function lazylize(signalProvider) {
-  let source;
-  return (0, import_api.computed)(() => (source ??= (0, import_api.untracked)(() => signalProvider()))());
+import { computed, untracked } from './api.js';
+export function lazylize(signalProvider) {
+    let source;
+    return computed(() => (source ??= untracked(() => signalProvider()))());
 }

package/signals/pipe.js

@@ -1,35 +1,11 @@
-"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,
-  rawPipe: () => rawPipe
-});
-module.exports = __toCommonJS(pipe_exports);
-var import_rxjs = require("rxjs");
-var import_start_with_provider = require("../rxjs/start-with-provider.js");
-var import_api = require("./api.js");
-var import_to_signal_2 = require("./to-signal-2.js");
-function pipe(source, ...operators) {
-  return rawPipe(source, (0, import_start_with_provider.startWithProvider)(source), (0, import_rxjs.distinctUntilChanged)(), ...operators);
+import { distinctUntilChanged } from 'rxjs';
+import { startWithProvider } from '../rxjs/start-with-provider.js';
+import { toObservable } from './api.js';
+import { toSignal2 } from './to-signal-2.js';
+export function pipe(source, ...operators) {
+    return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operators);
 }
-function rawPipe(source, ...operators) {
-  const piped = (0, import_api.toObservable)(source).pipe(...operators);
-  return (0, import_to_signal_2.toSignal2)(piped, { requireSync: true });
+export function rawPipe(source, ...operators) {
+    const piped = toObservable(source).pipe(...operators);
+    return toSignal2(piped, { requireSync: true });
 }

package/signals/switch-map.js

@@ -1,28 +1,5 @@
-"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 switch_map_exports = {};
-__export(switch_map_exports, {
-  switchMap: () => switchMap
-});
-module.exports = __toCommonJS(switch_map_exports);
-var import_api = require("./api.js");
-function switchMap(source) {
-  const outerSource = (0, import_api.computed)(() => source());
-  return (0, import_api.computed)(() => outerSource()());
+import { computed } from './api.js';
+export function switchMap(source) {
+    const outerSource = computed(() => source());
+    return computed(() => outerSource()());
 }

package/signals/to-signal-2.js

@@ -1,67 +1,44 @@
-"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_signal_2_exports = {};
-__export(to_signal_2_exports, {
-  toSignal2: () => toSignal2
-});
-module.exports = __toCommonJS(to_signal_2_exports);
-var import_core = require("../core.js");
-var import_finalization = require("../memory/finalization.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_api = require("./api.js");
+import { isDevMode } from '../core.js';
+import { registerFinalization } from '../memory/finalization.js';
+import { isUndefined } from '../utils/type-guards.js';
+import { computed, signal, untracked } from './api.js';
 var StateKind;
-(function(StateKind2) {
-  StateKind2[StateKind2["NoValue"] = 0] = "NoValue";
-  StateKind2[StateKind2["Value"] = 1] = "Value";
-  StateKind2[StateKind2["Error"] = 2] = "Error";
+(function (StateKind) {
+    StateKind[StateKind["NoValue"] = 0] = "NoValue";
+    StateKind[StateKind["Value"] = 1] = "Value";
+    StateKind[StateKind["Error"] = 2] = "Error";
 })(StateKind || (StateKind = {}));
-function toSignal2(source, options) {
-  const initialState = options?.requireSync == true ? { kind: StateKind.NoValue } : { kind: StateKind.Value, value: options?.initialValue };
-  const state = (0, import_api.signal)(initialState);
-  let subscription;
-  if (options?.lazy != true) {
-    subscription = subscribe(source, state, options);
-  }
-  const result = (0, import_api.computed)(() => {
-    if ((0, import_type_guards.isUndefined)(subscription)) {
-      subscription = subscribe(source, state, options);
+export function toSignal2(source, options) {
+    const initialState = (options?.requireSync == true) ? { kind: StateKind.NoValue } : { kind: StateKind.Value, value: options?.initialValue };
+    const state = signal(initialState);
+    let subscription;
+    if (options?.lazy != true) {
+        subscription = subscribe(source, state, options);
     }
-    const current = state();
-    switch (current.kind) {
-      case StateKind.Value:
-        return current.value;
-      case StateKind.Error:
-        throw current.error;
-      case StateKind.NoValue:
-        throw new Error("`toSignalLazy()` called with `requireSync` but `Observable` did not emit synchronously.");
-    }
-  });
-  (0, import_finalization.registerFinalization)(result, () => subscription?.unsubscribe());
-  return result;
+    const result = computed(() => {
+        if (isUndefined(subscription)) {
+            subscription = subscribe(source, state, options);
+        }
+        const current = state();
+        switch (current.kind) { // eslint-disable-line default-case
+            case StateKind.Value:
+                return current.value;
+            case StateKind.Error:
+                throw current.error;
+            case StateKind.NoValue:
+                throw new Error('`toSignalLazy()` called with `requireSync` but `Observable` did not emit synchronously.');
+        }
+    });
+    registerFinalization(result, () => subscription?.unsubscribe());
+    return result;
 }
 function subscribe(source, state, options) {
-  const subscription = source.subscribe({
-    next: (value) => (0, import_api.untracked)(() => state.set({ kind: StateKind.Value, value })),
-    error: (error) => (0, import_api.untracked)(() => state.set({ kind: StateKind.Error, error }))
-  });
-  if ((0, import_core.isDevMode)() && options?.requireSync == true && (0, import_api.untracked)(state).kind == StateKind.NoValue) {
-    throw new Error("`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.");
-  }
-  return subscription;
+    const subscription = source.subscribe({
+        next: (value) => untracked(() => state.set({ kind: StateKind.Value, value })),
+        error: (error) => untracked(() => state.set({ kind: StateKind.Error, error }))
+    });
+    if (isDevMode() && (options?.requireSync == true) && untracked(state).kind == StateKind.NoValue) {
+        throw new Error('`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');
+    }
+    return subscription;
 }

package/signals/types.js

@@ -1,16 +1 @@
-"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+export {};