@tstdl/base 0.90.42 → 0.90.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.42",
+  "version": "0.90.45",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/rxjs/index.d.ts

@@ -4,6 +4,7 @@ export * from './media-query.js';
 export * from './mutation-observer.js';
 export * from './noop.js';
 export * from './performance-observer.js';
+export * from './reject-error.js';
 export * from './resize-observer.js';
 export * from './retry-backoff.js';
 export * from './slow-array.js';

package/rxjs/index.js

@@ -4,6 +4,7 @@ export * from './media-query.js';
 export * from './mutation-observer.js';
 export * from './noop.js';
 export * from './performance-observer.js';
+export * from './reject-error.js';
 export * from './resize-observer.js';
 export * from './retry-backoff.js';
 export * from './slow-array.js';

package/rxjs/reject-error.d.ts

@@ -0,0 +1,2 @@
+import type { MonoTypeOperatorFunction } from 'rxjs';
+export declare function rejectErrors<T>(): MonoTypeOperatorFunction<T>;

package/rxjs/reject-error.js

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+export function rejectErrors() {
+    return function rejectErrors(source) {
+        return new Observable((subscriber) => source.subscribe({
+            next: (value) => subscriber.next(value),
+            complete: () => subscriber.complete()
+        }));
+    };
+}

package/signals/pipe.d.ts

@@ -1,31 +1,30 @@
 import { type OperatorFunction } from 'rxjs';
-import type { Signal, ToSignalOptions } from './api.js';
-export type PipeOptions = Pick<ToSignalOptions, 'rejectErrors'>;
+import type { Signal } 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 declare function pipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>, options?: PipeOptions): Signal<A>;
-export declare function pipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, options?: PipeOptions): Signal<B>;
-export declare function pipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, options?: PipeOptions): Signal<C>;
-export declare 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>, options?: PipeOptions): Signal<D>;
-export declare 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>, options?: PipeOptions): Signal<E>;
-export declare 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>, options?: PipeOptions): Signal<F>;
-export declare 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>, options?: PipeOptions): Signal<G>;
-export declare 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>, options?: PipeOptions): Signal<H>;
-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>, options?: PipeOptions): Signal<I>;
-export declare function pipe(source: Signal<unknown>, ...operatorsAndOptions: (OperatorFunction<unknown, unknown> | PipeOptions | undefined)[]): Signal<unknown>;
+export declare function pipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
+export declare function pipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;
+export declare function pipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
+export declare 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 declare 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 declare 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 declare 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 declare 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 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 `startWith` operator, otherwise an error is thrown.
  */
-export declare function rawPipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>, options?: PipeOptions): Signal<A>;
-export declare function rawPipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, options?: PipeOptions): Signal<B>;
-export declare function rawPipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, options?: PipeOptions): Signal<C>;
-export declare 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>, options?: PipeOptions): Signal<D>;
-export declare 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>, options?: PipeOptions): Signal<E>;
-export declare 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>, options?: PipeOptions): Signal<F>;
-export declare 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>, options?: PipeOptions): Signal<G>;
-export declare 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>, options?: PipeOptions): Signal<H>;
-export declare 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>, options?: PipeOptions): Signal<I>;
-export declare function rawPipe(source: Signal<unknown>, ...operatorsAndOptions: (OperatorFunction<unknown, unknown> | PipeOptions | undefined)[]): Signal<unknown>;
+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>;
+export declare function rawPipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
+export declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare function rawPipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown>;

package/signals/pipe.js

@@ -1,16 +1,11 @@
 import { distinctUntilChanged } from 'rxjs';
 import { startWithProvider } from '../rxjs/start-with-provider.js';
 import { untrack } from '../rxjs/untrack.js';
-import { isNotFunction } from '../utils/type-guards.js';
 import { toObservable, toSignal } from './api.js';
-export function pipe(source, ...operatorsAndOptions) {
-    return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operatorsAndOptions);
+export function pipe(source, ...operators) {
+    return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operators);
 }
-export function rawPipe(source, ...operatorsAndOptions) {
-    const last = operatorsAndOptions.at(-1);
-    const lastIsOptions = isNotFunction(last);
-    const options = lastIsOptions ? last : undefined;
-    const operators = (lastIsOptions ? operatorsAndOptions.slice(0, -1) : operatorsAndOptions);
+export function rawPipe(source, ...operators) {
     const piped = toObservable(source).pipe(...operators, untrack());
-    return toSignal(piped, { ...options, requireSync: true });
+    return toSignal(piped, { requireSync: true });
 }