@tstdl/base 0.90.30 → 0.90.32

package/api/server/gateway.js

@@ -186,17 +186,25 @@ let ApiGateway = class ApiGateway {
             getToken: async () => this.requestTokenProvider.getToken(requestContext)
         };
         const result = await context.endpoint.implementation(requestContext);
-        if (result instanceof HttpServerResponse) {
-            return result;
+        const response = (result instanceof HttpServerResponse)
+            ? result
+            : new HttpServerResponse({
+                body: isUint8Array(result) ? { buffer: result }
+                    : isBlob(result) ? { stream: result.stream() }
+                        : isReadableStream(result) ? { stream: result }
+                            : (result instanceof ServerSentEventsSource) ? { events: result }
+                                : (context.endpoint.definition.result == String) ? { text: result }
+                                    : { json: result }
+            });
+        if (isUndefined(response.headers.contentType)) {
+            response.headers.contentType =
+                (isDefined(response.body?.json)) ? 'application/json; charset=utf-8'
+                    : (isDefined(response.body?.text)) ? 'text/plain; charset=utf-8'
+                        : (isDefined(response.body?.buffer)) ? 'application/octet-stream'
+                            : (isDefined(response.body?.stream)) ? 'application/octet-stream'
+                                : (isDefined(response.body?.events)) ? 'text/event-stream'
+                                    : undefined;
         }
-        const response = new HttpServerResponse({
-            body: isUint8Array(result) ? { buffer: result }
-                : isBlob(result) ? { stream: result.stream() }
-                    : isReadableStream(result) ? { stream: result }
-                        : (result instanceof ServerSentEventsSource) ? { events: result }
-                            : (context.endpoint.definition.result == String) ? { text: result }
-                                : { json: result }
-        });
         return response;
     }
     async getBody(request, options, schema) {

package/http/server/node/node-http-server.js

@@ -141,21 +141,6 @@ function getResponder(httpResponse) {
     return respond;
 }
 function writeHeaders(response, httpResponse) {
-    if (isDefined(response.body?.json)) {
-        httpResponse.setHeader('Content-Type', 'application/json; charset=utf-8');
-    }
-    else if (isDefined(response.body?.text)) {
-        httpResponse.setHeader('Content-Type', 'text/plain; charset=utf-8');
-    }
-    else if (isDefined(response.body?.buffer)) {
-        httpResponse.setHeader('Content-Type', 'application/octet-stream');
-    }
-    else if (isDefined(response.body?.stream)) {
-        httpResponse.setHeader('Content-Type', 'application/octet-stream');
-    }
-    else if (isDefined(response.body?.events)) {
-        httpResponse.setHeader('Content-Type', 'text/event-stream');
-    }
     for (const [name, value] of response.headers.normalizedEntries()) {
         httpResponse.setHeader(name, value);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.30",
+  "version": "0.90.32",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -149,7 +149,7 @@
     "mongodb": "^6.2",
     "nodemailer": "^6.9",
     "playwright": "^1.39",
-    "preact": "^10.18",
+    "preact": "^10.19",
     "preact-render-to-string": "^6.3",
     "undici": "^5.27",
     "urlpattern-polyfill": "^9.0"

package/schema/schemas/literal.d.ts

@@ -1,5 +1,5 @@
 import type { Decorator } from '../../reflection/index.js';
 import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
 export type LiteralOptions = ValueSchemaOptions;
-export declare function literal<T>(value: T, options?: LiteralOptions): ValueSchema<T>;
+export declare function literal<const T>(value: T, options?: LiteralOptions): ValueSchema<T>;
 export declare function Literal(value: any): Decorator<'property' | 'accessor'>;

package/signals/computed-with-dependencies.js

@@ -1,10 +1,13 @@
 import { computed as actualComputed } from './api.js';
 export function computedWithDependencies(computation, dependencies, options = {}) {
+    if (dependencies.length == 0) {
+        return actualComputed(computation, options);
+    }
     function computationWithDependencies() {
         for (let i = 0; i < dependencies.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
             dependencies[i]();
         }
         return computation();
     }
-    return actualComputed((dependencies.length == 0) ? computation : computationWithDependencies, options);
+    return actualComputed(computationWithDependencies, options);
 }

package/signals/defer.js

@@ -1,11 +1,8 @@
-import { isUndefined } from '../utils/type-guards.js';
 import { computed, untracked } from './api.js';
 export function defer(signalFactory) {
-    let source;
-    return computed(() => {
-        if (isUndefined(source)) {
-            source = untracked(signalFactory);
-        }
-        return source();
-    });
+    let computation = () => {
+        computation = untracked(signalFactory);
+        return computation();
+    };
+    return computed(() => computation());
 }

package/signals/effect-with-dependencies.js

@@ -1,10 +1,13 @@
 import { effect as actualEffect } from './api.js';
 export function effectWithDependencies(effectFn, dependencies, options) {
+    if (dependencies.length == 0) {
+        return actualEffect(effectFn, options);
+    }
     function effectFnWithDependencies(onCleanup) {
         for (let i = 0; i < dependencies.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
             dependencies[i]();
         }
         effectFn(onCleanup);
     }
-    return actualEffect((dependencies.length == 0) ? effectFn : effectFnWithDependencies, options);
+    return actualEffect(effectFnWithDependencies, options);
 }

package/signals/implementation/asserts.d.ts

@@ -10,7 +10,5 @@
  * to disallow certain code from running inside a reactive context (see {@link toSignal}).
  *
  * @param debugFn a reference to the function making the assertion (used for the error message).
- *
- * @publicApi
  */
 export declare function assertNotInReactiveContext(debugFn: Function, extraContext?: string): void;

package/signals/implementation/asserts.js

@@ -11,8 +11,6 @@ import { getActiveConsumer } from './graph.js';
  * to disallow certain code from running inside a reactive context (see {@link toSignal}).
  *
  * @param debugFn a reference to the function making the assertion (used for the error message).
- *
- * @publicApi
  */
 export function assertNotInReactiveContext(debugFn, extraContext) {
     // Taking a `Function` instead of a string name here prevents the un-minified name of the function

package/signals/implementation/computed.d.ts

@@ -5,10 +5,10 @@
  * 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 { SIGNAL } from '../symbol.js';
 import type { Signal } from './api.js';
 import type { ValueEqualityFn } from './equality.js';
 import type { ReactiveNode } from './graph.js';
+import { SIGNAL } from './graph.js';
 /**
  * A computation, which derives a value from a declarative reactive expression.
  *

package/signals/implementation/computed.js

@@ -1,13 +1,6 @@
-/**
- * @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 { SIGNAL } from '../symbol.js';
+/* eslint-disable */
 import { defaultEquals } from './equality.js';
-import { consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerUpdateValueVersion, REACTIVE_NODE } from './graph.js';
+import { consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerUpdateValueVersion, REACTIVE_NODE, SIGNAL } from './graph.js';
 /**
  * Create a computed signal which derives a reactive value from an expression.
  */

package/signals/implementation/effect.js

@@ -34,7 +34,7 @@ export class TstdlEffectScheduler {
     }
 }
 /**
- * Core reactive node for an Angular effect.
+ * Core reactive node for an effect.
  *
  * `EffectHandle` combines the reactive graph's `Watch` base node for effects with the framework's
  * scheduling abstraction (`EffectScheduler`) as well as automatic cleanup via `DestroyRef` if
@@ -50,7 +50,12 @@ class EffectHandle {
         this.watcher = createWatch((onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);
     }
     runEffect(onCleanup) {
-        this.effectFn(onCleanup);
+        try {
+            this.effectFn(onCleanup);
+        }
+        catch (err) {
+            queueMicrotask(() => { throw err; });
+        }
     }
     run() {
         this.watcher.run();
@@ -58,9 +63,6 @@ class EffectHandle {
     schedule() {
         this.scheduler.scheduleEffect(this);
     }
-    notify() {
-        this.watcher.notify();
-    }
     destroy() {
         this.watcher.destroy();
         // Note: if the effect is currently scheduled, it's not un-scheduled, and so the scheduler will
@@ -72,8 +74,9 @@ const effectScheduler = new TstdlEffectScheduler();
  * Create a global `Effect` for the given reactive function.
  */
 export function effect(effectFn, options) {
-    assertNotInReactiveContext(effect, 'Call `effect` outside of a reactive context. For example, schedule the effect inside the component constructor.');
+    assertNotInReactiveContext(effect, 'Call `effect` outside of a reactive context. For example, schedule the ' +
+        'effect inside the component constructor.');
     const handle = new EffectHandle(effectScheduler, effectFn, options?.allowSignalWrites ?? false);
-    handle.notify();
+    handle.watcher.notify();
     return handle;
 }

package/signals/implementation/equality.js

@@ -1,10 +1,4 @@
-/**
- * @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
- */
+/* eslint-disable */
 /**
  * The default equality function used for `signal` and `computed`, which uses referential equality.
  */

package/signals/implementation/errors.d.ts

@@ -1,9 +1,2 @@
-/**
- * @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 throwInvalidWriteToSignalError(): void;
 export declare function setThrowInvalidWriteToSignalError(fn: () => never): void;

package/signals/implementation/errors.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.

package/signals/implementation/graph.d.ts

@@ -1,11 +1,5 @@
-/**
- * @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 { SIGNAL } from '../symbol.js';
+export { SIGNAL };
 type Version = number & {
     __brand: 'Version';
 };
@@ -37,6 +31,13 @@ export interface ReactiveNode {
      * previous value (by whatever definition of equality is in use).
      */
     version: Version;
+    /**
+     * Epoch at which this node is verified to be clean.
+     *
+     * This allows skipping of some polling operations in the case where no signals have been set
+     * since this node was last read.
+     */
+    lastCleanEpoch: Version;
     /**
      * Whether this node (in its consumer capacity) is dirty.
      *
@@ -110,6 +111,12 @@ export interface ReactiveNode {
  * Called by implementations when a producer's signal is read.
  */
 export declare function producerAccessed(node: ReactiveNode): void;
+/**
+ * Increment the global epoch counter.
+ *
+ * Called by source producers (that is, not computeds) whenever their values change.
+ */
+export declare function producerIncrementEpoch(): void;
 /**
  * Ensure this producer's `version` is up-to-date.
  */
@@ -147,4 +154,3 @@ export declare function consumerPollProducersForChange(node: ReactiveNode): bool
  * Disconnect this consumer from the graph.
  */
 export declare function consumerDestroy(node: ReactiveNode): void;
-export {};

package/signals/implementation/graph.js

@@ -1,3 +1,6 @@
+/* eslint-disable */
+import { SIGNAL } from '../symbol.js';
+export { SIGNAL };
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -5,7 +8,6 @@
  * 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 { SIGNAL } from '../symbol.js';
 /**
  * The currently active consumer `ReactiveNode`, if running code in a reactive context.
  *
@@ -13,6 +15,10 @@ import { SIGNAL } from '../symbol.js';
  */
 let activeConsumer = null;
 let inNotificationPhase = false;
+/**
+ * Global epoch counter. Incremented whenever a source signal is set.
+ */
+let epoch = 1;
 export function setActiveConsumer(consumer) {
     const prev = activeConsumer;
     activeConsumer = consumer;
@@ -29,6 +35,7 @@ export function isReactive(value) {
 }
 export const REACTIVE_NODE = {
     version: 0,
+    lastCleanEpoch: 0,
     dirty: false,
     producerNode: undefined,
     producerLastReadVersion: undefined,
@@ -48,7 +55,7 @@ export const REACTIVE_NODE = {
  */
 export function producerAccessed(node) {
     if (inNotificationPhase) {
-        throw new Error('Assertion error: signal read during notification phase');
+        throw new Error(`Assertion error: signal read during notification phase`);
     }
     if (activeConsumer === null) {
         // Accessed outside of a reactive context, so nothing to record.
@@ -83,6 +90,14 @@ export function producerAccessed(node) {
     }
     activeConsumer.producerLastReadVersion[idx] = node.version;
 }
+/**
+ * Increment the global epoch counter.
+ *
+ * Called by source producers (that is, not computeds) whenever their values change.
+ */
+export function producerIncrementEpoch() {
+    epoch++;
+}
 /**
  * Ensure this producer's `version` is up-to-date.
  */
@@ -92,15 +107,23 @@ export function producerUpdateValueVersion(node) {
         // is guaranteed to be up-to-date.
         return;
     }
+    if (!node.dirty && node.lastCleanEpoch === epoch) {
+        // Even non-live consumers can skip polling if they previously found themselves to be clean at
+        // the current epoch, since their dependencies could not possibly have changed (such a change
+        // would've increased the epoch).
+        return;
+    }
     if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
         // None of our producers report a change since the last time they were read, so no
         // recomputation of our value is necessary, and we can consider ourselves clean.
         node.dirty = false;
+        node.lastCleanEpoch = epoch;
         return;
     }
     node.producerRecomputeValue(node);
     // After recomputing the value, we're no longer dirty.
     node.dirty = false;
+    node.lastCleanEpoch = epoch;
 }
 /**
  * Propagate a dirty notification to live consumers of this producer.

package/signals/implementation/signal.d.ts

@@ -5,10 +5,10 @@
  * 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 { SIGNAL } from '../symbol.js';
-import { Signal } from './api.js';
+import type { Signal } from './api.js';
 import type { ValueEqualityFn } from './equality.js';
 import type { ReactiveNode } from './graph.js';
+import { SIGNAL } from './graph.js';
 export interface SignalNode<T> extends ReactiveNode {
     value: T;
     equal: ValueEqualityFn<T>;
@@ -29,13 +29,16 @@ export declare function signalGetFn<T>(this: SignalNode<T>): T;
 export declare function signalSetFn<T>(node: SignalNode<T>, newValue: T): void;
 export declare function signalUpdateFn<T>(node: SignalNode<T>, updater: (value: T) => T): void;
 export declare function signalMutateFn<T>(node: SignalNode<T>, mutator: (value: T) => void): void;
+/**
+ * A `Signal` with a value that can be mutated via a setter interface.
+ */
 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 itfs current value, and
+     * Update the value of the signal based on its current value, and
      * notify any dependents.
      */
     update(updateFn: (value: T) => T): void;

package/signals/implementation/signal.js

@@ -1,15 +1,7 @@
 /* eslint-disable */
-/**
- * @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 { SIGNAL } from '../symbol.js';
 import { defaultEquals } from './equality.js';
 import { throwInvalidWriteToSignalError } from './errors.js';
-import { producerAccessed, producerNotifyConsumers, producerUpdatesAllowed, REACTIVE_NODE } from './graph.js';
+import { producerAccessed, producerIncrementEpoch, producerNotifyConsumers, producerUpdatesAllowed, REACTIVE_NODE, SIGNAL } from './graph.js';
 /**
  * If set, called after `WritableSignal`s are updated.
  *
@@ -43,7 +35,13 @@ export function signalSetFn(node, newValue) {
     if (!producerUpdatesAllowed()) {
         throwInvalidWriteToSignalError();
     }
-    if (!node.equal(node.value, newValue)) {
+    const value = node.value;
+    if (Object.is(value, newValue)) {
+        if (!node.equal(value, newValue)) {
+            console.warn('Signal value equality implementations should always return `true` for values that are the same according to `Object.is` but returned `false` instead.');
+        }
+    }
+    else if (!node.equal(value, newValue)) {
         node.value = newValue;
         signalValueChanged(node);
     }
@@ -62,18 +60,14 @@ export function signalMutateFn(node, mutator) {
     mutator(node.value);
     signalValueChanged(node);
 }
-// Note: Using an IIFE here to ensure that the spread assignment is not considered
-// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
-// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
-const SIGNAL_NODE = /* @__PURE__ */ (() => {
-    return {
-        ...REACTIVE_NODE,
-        equal: defaultEquals,
-        value: undefined,
-    };
-})();
+const SIGNAL_NODE = {
+    ...REACTIVE_NODE,
+    equal: defaultEquals,
+    value: undefined,
+};
 function signalValueChanged(node) {
     node.version++;
+    producerIncrementEpoch();
     producerNotifyConsumers(node);
     postSignalSetFn?.();
 }

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

@@ -1,5 +1,12 @@
+/**
+ * @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 { Observable, Subscribable } from 'rxjs';
-import { Signal } from './api.js';
+import type { Signal } from './api.js';
 /**
  * Options for `toSignal`.
  */
@@ -19,6 +26,15 @@ export interface ToSignalOptions {
      * not met.
      */
     requireSync?: boolean;
+    /**
+     * Whether `toSignal` should throw errors from the Observable error channel back to RxJS, where
+     * they'll be processed as uncaught exceptions.
+     *
+     * In practice, this means that the signal returned by `toSignal` will keep returning the last
+     * good value forever, as Observables which error produce no further values. This option emulates
+     * the behavior of the `async` pipe.
+     */
+    rejectErrors?: boolean;
 }
 export declare function toSignal<T>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
 export declare function toSignal<T>(source: Observable<T> | Subscribable<T>, options: ToSignalOptions & {

package/signals/implementation/to-signal.js

@@ -1,11 +1,4 @@
 /* eslint-disable */
-/**
- * @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 { registerFinalization } from '../../memory/finalization.js';
 import { assertNotInReactiveContext } from './asserts.js';
 import { computed } from './computed.js';
@@ -23,7 +16,8 @@ import { signal } from './signal.js';
  * does not include an `undefined` type.
  */
 export function toSignal(source, options) {
-    assertNotInReactiveContext(toSignal, 'Invoking `toSignal` causes new subscriptions every time. Consider moving `toSignal` outside of the reactive context and read the signal value where needed.');
+    assertNotInReactiveContext(toSignal, 'Invoking `toSignal` causes new subscriptions every time. ' +
+        'Consider moving `toSignal` outside of the reactive context and read the signal value where needed.');
     // 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;
@@ -43,7 +37,14 @@ export function toSignal(source, options) {
     // https://github.com/angular/angular/pull/50522.
     const sub = source.subscribe({
         next: value => state.set({ kind: StateKind.Value, value }),
-        error: error => state.set({ kind: StateKind.Error, error }),
+        error: error => {
+            if (options?.rejectErrors) {
+                // Kick the error back to RxJS. It will be caught and rethrown in a macrotask, which causes
+                // the error to end up as an uncaught exception.
+                throw error;
+            }
+            state.set({ kind: StateKind.Error, error });
+        },
         // Completion of the Observable is meaningless to the signal. Signals don't have a concept of
         // "complete".
     });
@@ -60,6 +61,8 @@ export function toSignal(source, options) {
             case StateKind.Error:
                 throw current.error;
             case StateKind.NoValue:
+                // This shouldn't really happen because the error is thrown on creation.
+                // TODO(alxhub): use a RuntimeError when we finalize the error semantics
                 throw new Error('`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');
         }
     });

package/signals/implementation/watch.d.ts

@@ -5,8 +5,8 @@
  * 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 { SIGNAL } from '../symbol.js';
 import type { ReactiveNode } from './graph.js';
+import { SIGNAL } 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.

package/signals/implementation/watch.js

@@ -1,13 +1,5 @@
 /* eslint-disable */
-/**
- * @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 { SIGNAL } from '../symbol.js';
-import { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, isInNotificationPhase, REACTIVE_NODE } from './graph.js';
+import { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, isInNotificationPhase, REACTIVE_NODE, SIGNAL } from './graph.js';
 export function createWatch(fn, schedule, allowSignalWrites) {
     const node = Object.create(WATCH_NODE);
     if (allowSignalWrites) {

package/signals/index.d.ts

@@ -5,6 +5,5 @@ export * from './effect-with-dependencies.js';
 export * from './pipe.js';
 export * from './switch-map.js';
 export * from './to-lazy-signal.js';
-export * from './to-observable-2.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/index.js

@@ -5,6 +5,5 @@ export * from './effect-with-dependencies.js';
 export * from './pipe.js';
 export * from './switch-map.js';
 export * from './to-lazy-signal.js';
-export * from './to-observable-2.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/switch-map.js

@@ -1,5 +1,5 @@
 import { computed } from './api.js';
 export function switchMap(source) {
-    const outerSource = computed(() => source());
+    const outerSource = computed(source);
     return computed(() => outerSource()());
 }

package/signals/symbol.js

@@ -3,4 +3,4 @@
  *
  * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
  */
-export const SIGNAL = /* @__PURE__ */ Symbol('SIGNAL');
+export const SIGNAL = Symbol('SIGNAL');

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

@@ -1,23 +1 @@
-import type { Observable } from 'rxjs';
-import type { Signal, ToSignalOptions } from './api.js';
-/**
- * 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.
- * Subscription to observable is cleaned up using finalization (garbage collection) of the signal.
- */
-export declare function toLazySignal<T>(source: Observable<T>): Signal<T | undefined>;
-export declare function toLazySignal<T>(source: Observable<T>, options: ToSignalOptions & {
-    initialValue?: undefined;
-    requireSync?: false;
-}): Signal<T | undefined>;
-export declare function toLazySignal<T>(source: Observable<T>, options: ToSignalOptions & {
-    initialValue?: null;
-    requireSync?: false;
-}): Signal<T | null>;
-export declare function toLazySignal<T>(source: Observable<T>, options: ToSignalOptions & {
-    initialValue?: undefined;
-    requireSync: true;
-}): Signal<T>;
-export declare function toLazySignal<T, const I>(source: Observable<T>, options: ToSignalOptions & {
-    initialValue: I;
-    requireSync?: false;
-}): Signal<T | I>;
+export declare const toLazySignal: typeof import("./implementation/to-signal.js").toSignal;

package/signals/to-lazy-signal.js

@@ -1,20 +1,19 @@
 import { Subject, switchMap } from 'rxjs';
 import { computed, toSignal } from './api.js';
 const LAZY = Symbol('LAZY');
-export function toLazySignal(source, options) {
+export const toLazySignal = function toLazySignal(source, options) {
     const subscribe$ = new Subject();
     const lazySource = subscribe$.pipe(switchMap(() => source));
     const signal = toSignal(lazySource, { initialValue: LAZY, ...options }); // eslint-disable-line @typescript-eslint/no-unsafe-argument
-    let subscribed = false;
-    return computed(() => {
-        if (!subscribed) {
-            subscribed = true;
-            subscribe$.next();
-            subscribe$.complete();
-            if (signal() == LAZY) {
-                throw new Error('`toLazySignal()` called with `requireSync` but `Observable` did not emit synchronously.');
-            }
+    let computation = () => {
+        subscribe$.next();
+        subscribe$.complete();
+        const value = signal();
+        computation = signal;
+        if (value == LAZY) {
+            throw new Error('`toLazySignal()` called with `requireSync` but `Observable` did not emit synchronously.');
         }
-        return signal();
-    });
-}
+        return value;
+    };
+    return computed(() => computation());
+};

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

@@ -1,8 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { Signal } from './api.js';
-/**
- * Exposes the value of an `Signal` as an RxJS `Observable`.
- *
- * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
- */
-export declare function toObservable2<T>(source: Signal<T>): Observable<T>;

package/signals/to-observable-2.js

@@ -1,9 +0,0 @@
-import { toObservable } from './implementation/to-observable.js';
-/**
- * Exposes the value of an `Signal` as an RxJS `Observable`.
- *
- * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
- */
-export function toObservable2(source) {
-    return toObservable(source);
-}