@tstdl/base 0.93.36 → 0.93.37

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

@@ -1,212 +0,0 @@
-/* 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

@@ -1,24 +0,0 @@
-/**
- * @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

@@ -1,145 +0,0 @@
-/**
- * @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

@@ -1,79 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,6 +0,0 @@
-/**
- * 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');