@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/signals/implementation/to-signal.js

@@ -1,3 +1,31 @@
+"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.
@@ -5,51 +33,39 @@
  * 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 (StateKind) {
-    StateKind[StateKind["NoValue"] = 0] = "NoValue";
-    StateKind[StateKind["Value"] = 1] = "Value";
-    StateKind[StateKind["Error"] = 2] = "Error";
+(function(StateKind2) {
+  StateKind2[StateKind2["NoValue"] = 0] = "NoValue";
+  StateKind2[StateKind2["Value"] = 1] = "Value";
+  StateKind2[StateKind2["Error"] = 2] = "Error";
 })(StateKind || (StateKind = {}));
-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 });
+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.");
     }
-    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;
+  });
+  (0, import_finalization.registerFinalization)(result, () => sub.unsubscribe());
+  return result;
 }

package/signals/implementation/untracked.js

@@ -1,3 +1,27 @@
+"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.
@@ -5,19 +29,11 @@
  * 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 { 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);
-    }
+function untracked(nonReactiveReadsFn) {
+  const prevConsumer = (0, import_graph.setActiveConsumer)(null);
+  try {
+    return nonReactiveReadsFn();
+  } finally {
+    (0, import_graph.setActiveConsumer)(prevConsumer);
+  }
 }

package/signals/implementation/watch.js

@@ -1,3 +1,27 @@
+"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.
@@ -5,65 +29,56 @@
  * 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, setActiveConsumer } from './graph.js';
-const NOOP_CLEANUP_FN = () => { };
-/**
- * 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 class Watch extends 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() {
-        // Watches are not producers.
+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);
     }
-    /**
-     * 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 = setActiveConsumer(this);
-        this.trackingVersion++;
-        try {
-            this.cleanupFn();
-            this.cleanupFn = NOOP_CLEANUP_FN;
-            this.watch(this.registerOnCleanup);
-        }
-        finally {
-            setActiveConsumer(prevConsumer);
-        }
+    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;
     }
-    cleanup() {
-        this.cleanupFn();
+    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

@@ -1,7 +1,9 @@
 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/index.js

@@ -1,7 +1,26 @@
-export * from './api.js';
-export * from './computed-with-dependencies.js';
-export * from './effect-with-dependencies.js';
-export * from './pipe.js';
-export * from './switch-map.js';
-export * from './types.js';
-export * from './untracked-operator.js';
+"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);

package/signals/lazylize.d.ts

@@ -0,0 +1,2 @@
+import { type Signal } from './api.js';
+export declare function lazylize<T>(signalProvider: () => Signal<T>): Signal<T>;

package/signals/lazylize.js

@@ -0,0 +1,28 @@
+"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()))());
+}

package/signals/pipe.d.ts

@@ -16,7 +16,7 @@ export declare function pipe<T, A, B, C, D, E, F, G, H>(source: Signal<T>, op1:
 export declare function pipe<T, A, B, C, D, E, F, G, H, I>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Signal<I>;
 export declare function pipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown>;
 /**
- * As we need an synchronous value for the resulting signal and effect scheduling is async, you have to provide an immediate value on subscription, for example via the {@link startWith} operator, otherwise an error is thrown.
+ * As we need an synchronous value for the resulting signal and effect scheduling is async, you have to provide an immediate value on subscription, for example via the `startWith` operator, otherwise an error is thrown.
  */
 export declare function rawPipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
 export declare function rawPipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;

package/signals/pipe.js

@@ -1,9 +1,35 @@
-import { distinctUntilChanged, startWith } from 'rxjs';
-import { toObservable, toSignal } from './api.js';
-export function pipe(source, ...operators) {
-    return rawPipe(source, startWith(source()), distinctUntilChanged(), ...operators);
+"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);
 }
-export function rawPipe(source, ...operators) {
-    const piped = toObservable(source).pipe(...operators);
-    return toSignal(piped, { requireSync: true });
+function rawPipe(source, ...operators) {
+  const piped = (0, import_api.toObservable)(source).pipe(...operators);
+  return (0, import_to_signal_2.toSignal2)(piped, { requireSync: true });
 }

package/signals/switch-map.js

@@ -1,5 +1,28 @@
-import { computed } from './api.js';
-export function switchMap(source) {
-    const outerSource = computed(() => source());
-    return computed(() => outerSource()());
+"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()());
 }

package/signals/to-signal-2.d.ts

@@ -0,0 +1,14 @@
+import type { Subscribable } from 'rxjs';
+import type { Signal, ToSignalOptions } from './api.js';
+export type ToSignal2Options<T> = ToSignalOptions<T> & {
+    /** defer subscription until signal is used */
+    lazy?: boolean;
+};
+/** like `toSignal`, except that it uses untracked internal operations (required for some scenarios, but might be less safe in terms of bugs catching) and has the ability to subscribe lazily */
+export declare function toSignal2<T>(source: Subscribable<T>): Signal<T | undefined>;
+export declare function toSignal2<T>(source: Subscribable<T>, options: ToSignal2Options<undefined> & {
+    requireSync: true;
+}): Signal<T>;
+export declare function toSignal2<T, const I = undefined>(source: Subscribable<T>, options: ToSignal2Options<I> & {
+    requireSync?: false;
+}): Signal<T | I>;

package/signals/to-signal-2.js

@@ -0,0 +1,67 @@
+"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");
+var StateKind;
+(function(StateKind2) {
+  StateKind2[StateKind2["NoValue"] = 0] = "NoValue";
+  StateKind2[StateKind2["Value"] = 1] = "Value";
+  StateKind2[StateKind2["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);
+    }
+    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;
+}
+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;
+}

package/signals/types.js

@@ -1 +1,16 @@
-export {};
+"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);

package/signals/untracked-operator.js

@@ -1,12 +1,34 @@
-import { Observable } from 'rxjs';
-import { untracked } from './api.js';
-/** wraps observer in {@link untracked} */
-export function runInUntracked() {
-    return function runInUntracked(source) {
-        return new Observable((subscriber) => source.subscribe({
-            next: (state) => untracked(() => subscriber.next(state)),
-            complete: () => untracked(() => subscriber.complete()),
-            error: (error) => untracked(() => subscriber.error(error))
-        }));
-    };
+"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_operator_exports = {};
+__export(untracked_operator_exports, {
+  runInUntracked: () => runInUntracked
+});
+module.exports = __toCommonJS(untracked_operator_exports);
+var import_rxjs = require("rxjs");
+var import_api = require("./api.js");
+function runInUntracked() {
+  return function runInUntracked2(source) {
+    return new import_rxjs.Observable((subscriber) => source.subscribe({
+      next: (state) => (0, import_api.untracked)(() => subscriber.next(state)),
+      complete: () => (0, import_api.untracked)(() => subscriber.complete()),
+      error: (error) => (0, import_api.untracked)(() => subscriber.error(error))
+    }));
+  };
 }

package/sse/index.js

@@ -1,2 +1,19 @@
-export * from './server-sent-events-source.js';
-export * from './server-sent-events.js';
+"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 sse_exports = {};
+module.exports = __toCommonJS(sse_exports);
+__reExport(sse_exports, require("./server-sent-events-source.js"), module.exports);
+__reExport(sse_exports, require("./server-sent-events.js"), module.exports);