@tstdl/base 0.90.40 → 0.90.42

package/authentication/client/authentication.service.d.ts

@@ -18,6 +18,8 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
     readonly isLoggedIn: import("../../signals/api.js").Signal<boolean>;
     readonly subject: import("../../signals/api.js").Signal<string | undefined>;
     readonly sessionId: import("../../signals/api.js").Signal<string | undefined>;
+    readonly impersonator: import("../../signals/api.js").Signal<string | undefined>;
+    readonly impersonated: import("../../signals/api.js").Signal<boolean>;
     readonly token$: import("rxjs").Observable<TokenPayload<AdditionalTokenPayload> | undefined>;
     readonly definedToken$: import("rxjs").Observable<Exclude<TokenPayload<AdditionalTokenPayload>, void | undefined>>;
     readonly validToken$: import("rxjs").Observable<Exclude<TokenPayload<AdditionalTokenPayload>, void | undefined>>;

package/authentication/client/authentication.service.js

@@ -48,6 +48,8 @@ let AuthenticationClientService = class AuthenticationClientService {
     isLoggedIn = computed(() => isDefined(this.token()));
     subject = computed(() => this.token()?.subject);
     sessionId = computed(() => this.token()?.sessionId);
+    impersonator = computed(() => this.token()?.impersonator);
+    impersonated = computed(() => isDefined(this.impersonator()));
     token$ = toObservable(this.token);
     definedToken$ = this.token$.pipe(filter(isDefined));
     validToken$ = this.definedToken$.pipe(filter((token) => token.exp > currentTimestampSeconds()));

package/package.json

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

package/signals/pipe.d.ts

@@ -1,30 +1,31 @@
 import { type OperatorFunction } from 'rxjs';
-import type { Signal } from './api.js';
+import type { Signal, ToSignalOptions } from './api.js';
+export type PipeOptions = Pick<ToSignalOptions, 'rejectErrors'>;
 /**
  * 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>): 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>;
+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>;
 /**
  * As we need an synchronous value for the resulting signal and effect scheduling is async, you have to provide an immediate value on subscription, for example via the `startWith` operator, otherwise an error is thrown.
  */
-export declare function rawPipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
-export declare function rawPipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;
-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>;
+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>;

package/signals/pipe.js

@@ -1,11 +1,16 @@
 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, ...operators) {
-    return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operators);
+export function pipe(source, ...operatorsAndOptions) {
+    return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operatorsAndOptions);
 }
-export function rawPipe(source, ...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);
     const piped = toObservable(source).pipe(...operators, untrack());
-    return toSignal(piped, { requireSync: true });
+    return toSignal(piped, { ...options, requireSync: true });
 }