@tstdl/base 0.93.34 → 0.93.36

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

@@ -0,0 +1,212 @@
+/* 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 type { Observable, Subscribable } from 'rxjs';
+
+import { registerFinalization } from '#/memory/finalization.js';
+import type { SignalsInjector } from '../api.js';
+import type { Signal } from './api.js';
+import { assertNotInReactiveContext } from './asserts.js';
+import { computed } from './computed.js';
+import type { ValueEqualityFn } from './equality.js';
+import { signal, type WritableSignal } from './writable-signal.js';
+
+export interface ToSignalOptions<T> {
+  /**
+   * Initial value for the signal produced by `toSignal`.
+   *
+   * This will be the value of the signal until the observable emits its first value.
+   */
+  initialValue?: unknown;
+
+  /**
+   * Whether to require that the observable emits synchronously when `toSignal` subscribes.
+   *
+   * If this is `true`, `toSignal` will assert that the observable produces a value immediately upon
+   * subscription. Setting this option removes the need to either deal with `undefined` in the
+   * signal type or provide an `initialValue`, at the cost of a runtime error if this requirement is
+   * not met.
+   */
+  requireSync?: boolean;
+
+  /**
+   * `Injector` which will provide the `DestroyRef` used to clean up the Observable subscription.
+   *
+   * If this is not provided, a `DestroyRef` will be retrieved from the current [injection
+   * context](guide/di/dependency-injection-context), unless manual cleanup is requested.
+   */
+  injector?: SignalsInjector;
+
+  /**
+   * Whether the subscription should be automatically cleaned up (via `DestroyRef`) when
+   * `toSignal`'s creation context is destroyed.
+   *
+   * If manual cleanup is enabled, then `DestroyRef` is not used, and the subscription will persist
+   * until the `Observable` itself completes.
+   */
+  manualCleanup?: 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;
+
+  /**
+   * A comparison function which defines equality for values emitted by the observable.
+   *
+   * Equality comparisons are executed against the initial value if one is provided.
+   */
+  equal?: ValueEqualityFn<T>;
+}
+
+// Base case: no options -> `undefined` in the result type.
+export function toSignal<T>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
+// Options with `undefined` initial value and no `requiredSync` -> `undefined`.
+export function toSignal<T>(
+  source: Observable<T> | Subscribable<T>,
+  options: NoInfer<ToSignalOptions<T | undefined>> & {
+    initialValue?: undefined;
+    requireSync?: false;
+  },
+): Signal<T | undefined>;
+// Options with `null` initial value -> `null`.
+export function toSignal<T>(
+  source: Observable<T> | Subscribable<T>,
+  options: NoInfer<ToSignalOptions<T | null>> & { initialValue?: null; requireSync?: false },
+): Signal<T | null>;
+// Options with `undefined` initial value and `requiredSync` -> strict result type.
+export function toSignal<T>(
+  source: Observable<T> | Subscribable<T>,
+  options: NoInfer<ToSignalOptions<T>> & { initialValue?: undefined; requireSync: true },
+): Signal<T>;
+// Options with a more specific initial value type.
+export function toSignal<T, const U extends T>(
+  source: Observable<T> | Subscribable<T>,
+  options: NoInfer<ToSignalOptions<T | U>> & { initialValue: U; requireSync?: false },
+): Signal<T | U>;
+
+/**
+ * Get the current value of an `Observable` as a reactive `Signal`.
+ *
+ * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
+ * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
+ * have the most recent value emitted by the subscription, and will throw an error if the
+ * `Observable` errors.
+ *
+ * With `requireSync` set to `true`, `toSignal` will assert that the `Observable` produces a value
+ * immediately upon subscription. No `initialValue` is needed in this case, and the returned signal
+ * does not include an `undefined` type.
+ */
+export function toSignal<T, U = undefined>(
+  source: Observable<T> | Subscribable<T>,
+  options?: ToSignalOptions<T | U> & { initialValue?: U },
+): Signal<T | U> {
+  assertNotInReactiveContext(
+    toSignal,
+    'Invoking `toSignal` causes new subscriptions every time. ' +
+    'Consider moving `toSignal` outside of the reactive context and read the signal value where needed.',
+  );
+
+  const equal = makeToSignalEqual(options?.equal);
+
+  // 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: WritableSignal<State<T | U>>;
+  if (options?.requireSync) {
+    // Initially the signal is in a `NoValue` state.
+    state = signal({ kind: StateKind.NoValue }, { equal });
+  } else {
+    // If an initial value was passed, use it. Otherwise, use `undefined` as the initial value.
+    state = signal<State<T | U>>(
+      { kind: StateKind.Value, value: options?.initialValue as U },
+      { equal },
+    );
+  }
+
+  // Note: This code cannot run inside a reactive context (see assertion above). If we'd support
+  // this, we would subscribe to the observable outside of the current reactive context, avoiding
+  // that side-effect signal reads/writes are attribute to the current consumer. The current
+  // consumer only needs to be notified when the `state` signal changes through the observable
+  // subscription. Additional context (related to async pipe):
+  // https://github.com/angular/angular/pull/50522.
+  const sub = source.subscribe({
+    next: (value) => state.set({ kind: StateKind.Value, value }),
+    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".
+  });
+
+  if (options?.requireSync && 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:
+          // This shouldn't really happen because the error is thrown on creation.
+          throw new Error('`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');
+      }
+    },
+    { equal: options?.equal },
+  );
+
+  registerFinalization(result, () => sub.unsubscribe());
+
+  return result;
+}
+
+function makeToSignalEqual<T>(
+  userEquality: ValueEqualityFn<T> = Object.is,
+): ValueEqualityFn<State<T>> {
+  return (a, b) =>
+    a.kind === StateKind.Value && b.kind === StateKind.Value && userEquality(a.value, b.value);
+}
+
+const enum StateKind {
+  NoValue,
+  Value,
+  Error,
+}
+
+interface NoValueState {
+  kind: StateKind.NoValue;
+}
+
+interface ValueState<T> {
+  kind: StateKind.Value;
+  value: T;
+}
+
+interface ErrorState {
+  kind: StateKind.Error;
+  error: unknown;
+}
+
+type State<T> = NoValueState | ValueState<T> | ErrorState;

package/source/signals/implementation/untracked.ts

@@ -0,0 +1,24 @@
+/**
+ * @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 { 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<T>(nonReactiveReadsFn: () => T): T {
+  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/source/signals/implementation/watch.ts

@@ -0,0 +1,145 @@
+/**
+ * @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 {
+  consumerAfterComputation,
+  consumerBeforeComputation,
+  consumerDestroy,
+  consumerMarkDirty,
+  consumerPollProducersForChange,
+  isInNotificationPhase,
+  REACTIVE_NODE,
+  type ReactiveNode,
+  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.
+ */
+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;
+
+export interface Watch {
+  notify(): 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;
+
+  /**
+   * Destroy the watcher:
+   * - disconnect it from the reactive graph;
+   * - mark it as destroyed so subsequent run and notify operations are noop.
+   */
+  destroy(): void;
+
+  [SIGNAL]: WatchNode;
+}
+export interface WatchNode extends ReactiveNode {
+  hasRun: boolean;
+  fn: ((onCleanup: WatchCleanupRegisterFn) => void) | null;
+  schedule: ((watch: Watch) => void) | null;
+  cleanupFn: WatchCleanupFn;
+  ref: Watch;
+}
+
+export function createWatch(
+  fn: (onCleanup: WatchCleanupRegisterFn) => void,
+  schedule: (watch: Watch) => void,
+  allowSignalWrites: boolean,
+): Watch {
+  const node: WatchNode = Object.create(WATCH_NODE);
+  if (allowSignalWrites) {
+    node.consumerAllowSignalWrites = true;
+  }
+
+  node.fn = fn;
+  node.schedule = schedule;
+
+  const registerOnCleanup = (cleanupFn: WatchCleanupFn) => {
+    node.cleanupFn = cleanupFn;
+  };
+
+  function isWatchNodeDestroyed(node: WatchNode) {
+    return node.fn === null && node.schedule === null;
+  }
+
+  function destroyWatchNode(node: WatchNode) {
+    if (!isWatchNodeDestroyed(node)) {
+      consumerDestroy(node); // disconnect watcher from the reactive graph
+      node.cleanupFn();
+
+      // nullify references to the integration functions to mark node as destroyed
+      node.fn = null;
+      node.schedule = null;
+      node.cleanupFn = NOOP_CLEANUP_FN;
+    }
+  }
+
+  const run = () => {
+    if (node.fn === null) {
+      // trying to run a destroyed watch is noop
+      return;
+    }
+
+    if (isInNotificationPhase()) {
+      throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
+    }
+
+    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(),
+    destroy: () => destroyWatchNode(node),
+    [SIGNAL]: node,
+  };
+
+  return node.ref;
+}
+
+const NOOP_CLEANUP_FN: WatchCleanupFn = () => { };
+
+const WATCH_NODE: Partial<WatchNode> = {
+  ...REACTIVE_NODE,
+  consumerIsAlwaysLive: true,
+  consumerAllowSignalWrites: false,
+  consumerMarkedDirty: (node: WatchNode) => {
+    if (node.schedule !== null) {
+      node.schedule(node.ref);
+    }
+  },
+  hasRun: false,
+  cleanupFn: NOOP_CLEANUP_FN,
+};

package/source/signals/implementation/writable-signal.ts

@@ -0,0 +1,79 @@
+import { SIGNAL } from '../symbol.js';
+import { isSignal, type Signal } from './api.js';
+import type { ValueEqualityFn } from './equality.js';
+import { createSignal, type SignalGetter, type SignalNode, signalSetFn, signalUpdateFn } from './signal.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
+ */
+
+/**
+ * A `Signal` with a value that can be mutated via a setter interface.
+ */
+/* eslint-disable */
+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;
+
+  /**
+   * Returns a readonly version of this signal. Readonly signals can be accessed to read their value
+   * but can't be changed using set or update 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.
+ */
+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.
+ */
+export function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T> {
+  const signalFn = createSignal(initialValue) as SignalGetter<T> & WritableSignal<T>;
+  const node = signalFn[SIGNAL];
+  if (options?.equal) {
+    node.equal = options.equal;
+  }
+
+  signalFn.set = (newValue: T) => signalSetFn(node, newValue);
+  signalFn.update = (updateFn: (value: T) => T) => signalUpdateFn(node, updateFn);
+  signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn as any) as () => Signal<T>;
+  return signalFn as WritableSignal<T>;
+}
+
+export function signalAsReadonlyFn<T>(this: SignalGetter<T>): Signal<T> {
+  const node = this[SIGNAL] as SignalNode<T> & { readonlyFn?: Signal<T> };
+  if (node.readonlyFn === undefined) {
+    const readonlyFn = () => this();
+    (readonlyFn as any)[SIGNAL] = node;
+    node.readonlyFn = readonlyFn as Signal<T>;
+  }
+  return node.readonlyFn;
+}
+
+/**
+ * Checks if the given `value` is a writeable signal.
+ */
+export function isWritableSignal(value: unknown): value is WritableSignal<unknown> {
+  return isSignal(value) && typeof (value as any).set === 'function';
+}

package/source/signals/index.ts

@@ -0,0 +1,9 @@
+export * from './api.js';
+export * from './computed-with-dependencies.js';
+export * from './effect-with-dependencies.js';
+export * from './notifier.js';
+export * from './operators/index.js';
+export * from './pipe.js';
+export * from './to-lazy-signal.js';
+export * from './types.js';
+export * from './untracked-operator.js';

package/source/signals/notifier.ts

@@ -0,0 +1,22 @@
+import { computed, type CreateComputedOptions, signal, type Signal } from './api.js';
+
+type Notifier = {
+  listen: Signal<number>,
+  notify: () => void,
+  computed: typeof computed
+};
+
+export function createNotifier(): Notifier {
+  const sourceSignal = signal(0);
+
+  const notifier = {
+    listen: sourceSignal.asReadonly(),
+    notify: () => sourceSignal.update((v) => v + 1),
+    computed: <T>(computation: () => T, options?: CreateComputedOptions<T>) => computed(() => {
+      notifier.listen();
+      return computation();
+    }, options)
+  } satisfies Notifier;
+
+  return notifier;
+}

package/source/signals/operators/combine.ts

@@ -0,0 +1,16 @@
+import { mapObjectValues } from '#/utils/object/object.js';
+import { isArray } from '#/utils/type-guards.js';
+import { computed, type Signal } from '../api.js';
+import type { UnwrappedSignal } from '../types.js';
+
+export type CombineInput = Signal<any>[];
+
+export function combine<const T extends Signal<any>[]>(sources: T): Signal<{ [I in keyof T]: UnwrappedSignal<T[I]> }>;
+export function combine<const T extends Record<any, Signal<any>>>(sources: T): Signal<{ [P in keyof T]: UnwrappedSignal<T[P]> }>;
+export function combine<T>(sources: Signal<T>[] | Record<any, Signal<T>>): Signal<T[] | Record<any, T>> {
+  const computation: () => T[] | Record<any, T> = isArray(sources)
+    ? () => sources.map((source) => source())
+    : () => mapObjectValues(sources, (source) => source());
+
+  return computed(computation);
+}

package/source/signals/operators/defer.ts

@@ -0,0 +1,10 @@
+import { computed, untracked, type Signal } from '../api.js';
+
+export function defer<T>(signalFactory: () => Signal<T>): Signal<T> {
+  let computation = (): T => {
+    computation = untracked(signalFactory);
+    return computation();
+  };
+
+  return computed(() => computation());
+}

package/source/signals/operators/derive-async.ts

@@ -0,0 +1,64 @@
+import { Subject, concatAll, exhaustAll, from, isObservable, mergeAll, of, switchAll, takeUntil, type Observable } from 'rxjs';
+
+import { registerFinalization } from '#/memory/finalization.js';
+import { isPromise } from '#/utils/type-guards.js';
+import { computed, effect, toSignal, untracked, type Signal, type ToSignalOptions } from '../api.js';
+
+export type DeriveAsyncOptions<T> = ToSignalOptions<T> & {
+  behavior?: DeriveAsyncBehavior
+};
+
+const operatorMap = {
+  merge: mergeAll,
+  concat: concatAll,
+  exhaust: exhaustAll,
+  switch: switchAll,
+};
+
+export type DeriveAsyncBehavior = keyof typeof operatorMap;
+
+type DeriveAsyncSourceParameter<T> = () => (T | Promise<T> | Observable<T>);
+
+export function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>): Signal<T | undefined>;
+export function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions<T> & { initialValue?: undefined, requireSync?: false }): Signal<T | undefined>;
+export function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions<T> & { initialValue?: null, requireSync?: false }): Signal<T | null>;
+export function deriveAsync<T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions<T> & { initialValue?: undefined, requireSync: true }): Signal<T>;
+export function deriveAsync<T, const U extends T>(source: DeriveAsyncSourceParameter<T>, options: DeriveAsyncOptions<T> & { initialValue: U, requireSync?: false }): Signal<T | U>;
+export function deriveAsync<T, I>(source: () => (T | Promise<T> | Observable<T>), options?: DeriveAsyncOptions<T>): Signal<T | I> {
+  const outerSource = computed(() => {
+    const rawSource = source();
+
+    if (isPromise(rawSource)) {
+      return from(rawSource);
+    }
+
+    if (isObservable(rawSource)) {
+      return rawSource;
+    }
+
+    return of(rawSource);
+  });
+
+  const source$ = new Subject<Promise<T | I> | Observable<T | I>>();
+  const destroy$ = new Subject<void>();
+
+  const operator = operatorMap[options?.behavior ?? 'switch'];
+  const valueSource$ = source$.pipe(
+    operator(),
+    takeUntil(destroy$)
+  );
+
+  const result = toSignal(valueSource$, options as any) as Signal<T | I>;
+
+  const effectRef = effect(() => {
+    const observableInput = outerSource();
+    untracked(() => source$.next(observableInput));
+  });
+
+  registerFinalization(result, () => {
+    destroy$.next();
+    effectRef.destroy();
+  });
+
+  return result;
+}

package/source/signals/operators/index.ts

@@ -0,0 +1,5 @@
+export * from './combine.js';
+export * from './defer.js';
+export * from './derive-async.js';
+export * from './map.js';
+export * from './switchAll.js';

package/source/signals/operators/map.ts

@@ -0,0 +1,5 @@
+import { computed, type Signal } from '../api.js';
+
+export function map<T, R>(source: Signal<T>, mapper: (value: T) => R): Signal<R> {
+  return computed(() => mapper(source()));
+}

package/source/signals/operators/switchAll.ts

@@ -0,0 +1,6 @@
+import { computed, type Signal } from '../api.js';
+
+export function switchAll<T>(source: () => Signal<T>): Signal<T> {
+  const outerSource = computed(source);
+  return computed(() => outerSource()());
+}

package/source/signals/pipe.ts

@@ -0,0 +1,41 @@
+import { distinctUntilChanged, type Observable, type OperatorFunction } from 'rxjs';
+
+import { startWithProvider, untrack } from '#/rxjs-utils/index.js';
+import { type Signal, toObservable, toSignal } from './api.js';
+
+/**
+ * As we need an synchronous value for the resulting signal and effect scheduling is async, it uses the source signals value as the initial value for the pipe.
+ * This would normally result in double emission inside the pipe, but is mitigated by using {@link SignalPipeOptions.distinctUntilChanged}. Because of this, mutating source signals are not supported.
+ * If you have an mutating signal or require more control for whatever reason, use {@link rawPipe} instead.
+ */
+export function pipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
+export function pipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;
+export function pipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
+export function pipe<T, A, B, C, D>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Signal<D>;
+export function pipe<T, A, B, C, D, E>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Signal<E>;
+export function pipe<T, A, B, C, D, E, F>(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>): Signal<F>;
+export function pipe<T, A, B, C, D, E, F, G>(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>): Signal<G>;
+export function pipe<T, A, B, C, D, E, F, G, H>(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>): Signal<H>;
+export 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 function pipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown>;
+export function pipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown> {
+  return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operators);
+}
+
+/**
+ * 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 function rawPipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
+export function rawPipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;
+export function rawPipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
+export function rawPipe<T, A, B, C, D>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Signal<D>;
+export function rawPipe<T, A, B, C, D, E>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Signal<E>;
+export function rawPipe<T, A, B, C, D, E, F>(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>): Signal<F>;
+export function rawPipe<T, A, B, C, D, E, F, G>(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>): Signal<G>;
+export function rawPipe<T, A, B, C, D, E, F, G, H>(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>): Signal<H>;
+export function rawPipe<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 function rawPipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown>;
+export function rawPipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown> {
+  const piped = (toObservable(source).pipe as (...operators: OperatorFunction<unknown, unknown>[]) => Observable<unknown>)(...operators, untrack());
+  return toSignal(piped, { requireSync: true });
+}

package/source/signals/symbol.ts

@@ -0,0 +1,6 @@
+/**
+ * Symbol used to tell `Signal`s apart from other functions.
+ *
+ * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ */
+export const SIGNAL = Symbol('SIGNAL');