@juulsgaard/signal-tools 22.0.0 → 22.0.2

package/dist/index.d.ts

@@ -1,128 +1,9 @@
 import * as _angular_core from '@angular/core';
-import { Signal, Injector } from '@angular/core';
+import { Signal, Injector, WritableSignal } from '@angular/core';
 import * as rxjs from 'rxjs';
-import { BehaviorSubject, Subject, Subscribable, Observable, Observer, Unsubscribable } from 'rxjs';
+import { Subscribable, Observable, Observer, Unsubscribable, BehaviorSubject, Subject } from 'rxjs';
 import { IValueLoadingState } from '@juulsgaard/rxjs-tools';
 
-/**
- * Create a signal where values are only emitted after the values have settled for `delay` ms
- * @category Async Signals
- * @param inputSignal - The input value to debounce
- * @param delay - The required delay between values
- * @param options - Additional options
- */
-declare function debouncedSignal<T>(inputSignal: Signal<T>, delay?: number, options?: {
-    injector?: Injector;
-}): Signal<T>;
-/**
- * Create a signal where values are throttled
- * @category Async Signals
- * @param inputSignal - The input value to throttle
- * @param delay - The delay between values
- * @param options - Additional options
- */
-declare function throttledSignal<T>(inputSignal: Signal<T>, delay?: number, options?: {
-    injector?: Injector;
-    emitLeading?: boolean;
-}): Signal<T>;
-/**
- * Create a signal where values are throttled and debounced
- * @category Async Signals
- * @param inputSignal - The input value to throttle and debounce
- * @param throttleDelay - The delay between value emissions during continual input
- * @param debounceDelay - The amount of time the input needs to settle before a value is emitted
- * @param options - Additional options
- */
-declare function debouncedThrottledSignal<T extends string | undefined>(inputSignal: Signal<T>, throttleDelay?: number, debounceDelay?: number, options?: {
-    injector?: Injector;
-}): Signal<T>;
-/**
- * Create a signal where values are throttled and debounced, but where empty strings skip the delay
- * @category Async Signals
- * @param inputSignal - The input value to throttle and debounce
- * @param throttleDelay - The delay between value emissions during continual input
- * @param debounceDelay - The amount of time the input needs to settle before a value is emitted
- * @param options - Additional options
- */
-declare function searchSignal<T extends string | undefined>(inputSignal: Signal<T>, throttleDelay?: number, debounceDelay?: number, options?: {
-    injector?: Injector;
-}): Signal<T>;
-
-/**
- * A simple conversion of Behaviour Subject to signal.
- * This will not handle unsubscription, and should only be used when the subject itself is closed / unloaded properly.
- * @category Interop
- * @param subject
- */
-declare function subjectToSignal<T>(subject: BehaviorSubject<T>): Signal<T>;
-/**
- * A simple conversion of Subject to signal.
- * This will not handle unsubscription, and should only be used when the subject itself is closed / unloaded properly.
- * @category Interop
- * @param subject
- * @param initial - An initial value for the signal.
- */
-declare function subjectToSignal<T>(subject: Subject<T>, initial: T): Signal<T>;
-
-interface LoadingSignalProps {
-    /** The current error state */
-    readonly error: Signal<Error | undefined>;
-    /** The current loading state */
-    readonly loading: Signal<boolean>;
-    /** Dispose the underlying request / action */
-    readonly dispose: () => void;
-}
-/** @category Loading Signal */
-type LoadingSignal<T> = Signal<T | undefined> & LoadingSignalProps;
-/**
- * Options for creating a LoadingSignal
- * @category Loading Signal
- */
-interface CreateLoadingSignalOptions {
-    /** The loading state */
-    loading?: Signal<boolean>;
-    /** The error state */
-    error?: Signal<Error | undefined>;
-    /** An optional disposal method */
-    dispose?: () => void;
-}
-/**
- * Create a Loading Signal
- * @param value - The value signal
- * @param options - Optional state data
- * @category Loading Signal
- * @constructor
- */
-declare function loadingSignal<T>(value: Signal<T | undefined>, options?: CreateLoadingSignalOptions): LoadingSignal<T>;
-/** @category Loading Signal */
-interface LoadingSignalOptions {
-    /** Dispose the loading signal on destroy */
-    autoDispose?: boolean;
-    /** Pass an injector for running outside of injection context */
-    injector?: Injector;
-}
-/**
- * Convert a LoadingState to a LoadingSignal
- * @param loadingState
- * @param options
- * @category Loading Signal
- */
-declare function toLoadingSignal<T>(loadingState: IValueLoadingState<T>, options?: LoadingSignalOptions): LoadingSignal<T>;
-/**
- * Convert a Subscribable to a LoadingSignal
- * @param observable
- * @param options
- * @category Loading Signal
- */
-declare function toLoadingSignal<T>(observable: Subscribable<T>, options?: LoadingSignalOptions): LoadingSignal<T>;
-/**
- * Convert a promise to a LoadingSignal
- * @param promise
- * @param options
- * @category Loading Signal
- */
-declare function toLoadingSignal<T>(promise: Promise<T>, options?: LoadingSignalOptions): LoadingSignal<T>;
-
 /**
  * A Map where the state and values are accessible as signals
  * @category Signal Collections
@@ -817,5 +698,141 @@ declare function requestTracker<T>(request: IValueRequestState<T>): ValueRequest
  */
 declare function requestTracker(request: IRequestState): RequestTracker;
 
-export { AsyncRequestState, EmptyRequestState, ErrorRequestState, IRequestState, IValueRequestState, LoadingRequestState, RequestTracker, SignalMap, SignalQueue, SignalSet, SignalStack, StaticRequestState, ValueRequestTracker, WritableRequestState, debouncedSignal, debouncedThrottledSignal, loadingSignal, requestState, requestTracker, searchSignal, signalMap, signalQueue, signalSet, signalStack, subjectToSignal, throttledSignal, toLoadingSignal };
-export type { CreateLoadingSignalOptions, LoadingSignal, LoadingSignalOptions, ReadonlySignalMap, ReadonlySignalSet, SignalQueueDelta, SignalQueueOptions, SignalStackDelta };
+/**
+ * Create a signal where values are only emitted after the values have settled for `delay` ms
+ * @category Async Signals
+ * @param inputSignal - The input value to debounce
+ * @param delay - The required delay between values
+ * @param options - Additional options
+ */
+declare function debouncedSignal<T>(inputSignal: Signal<T>, delay?: number, options?: {
+    injector?: Injector;
+}): Signal<T>;
+/**
+ * Create a signal where values are throttled
+ * @category Async Signals
+ * @param inputSignal - The input value to throttle
+ * @param delay - The delay between values
+ * @param options - Additional options
+ */
+declare function throttledSignal<T>(inputSignal: Signal<T>, delay?: number, options?: {
+    injector?: Injector;
+    emitLeading?: boolean;
+}): Signal<T>;
+/**
+ * Create a signal where values are throttled and debounced
+ * @category Async Signals
+ * @param inputSignal - The input value to throttle and debounce
+ * @param throttleDelay - The delay between value emissions during continual input
+ * @param debounceDelay - The amount of time the input needs to settle before a value is emitted
+ * @param options - Additional options
+ */
+declare function debouncedThrottledSignal<T extends string | undefined>(inputSignal: Signal<T>, throttleDelay?: number, debounceDelay?: number, options?: {
+    injector?: Injector;
+}): Signal<T>;
+/**
+ * Create a signal where values are throttled and debounced, but where empty strings skip the delay
+ * @category Async Signals
+ * @param inputSignal - The input value to throttle and debounce
+ * @param throttleDelay - The delay between value emissions during continual input
+ * @param debounceDelay - The amount of time the input needs to settle before a value is emitted
+ * @param options - Additional options
+ */
+declare function searchSignal<T extends string | undefined>(inputSignal: Signal<T>, throttleDelay?: number, debounceDelay?: number, options?: {
+    injector?: Injector;
+}): Signal<T>;
+
+/**
+ * A simple conversion of Behaviour Subject to signal.
+ * This will not handle unsubscription, and should only be used when the subject itself is closed / unloaded properly.
+ * @category Interop
+ * @param subject
+ */
+declare function subjectToSignal<T>(subject: BehaviorSubject<T>): Signal<T>;
+/**
+ * A simple conversion of Subject to signal.
+ * This will not handle unsubscription, and should only be used when the subject itself is closed / unloaded properly.
+ * @category Interop
+ * @param subject
+ * @param initial - An initial value for the signal.
+ */
+declare function subjectToSignal<T>(subject: Subject<T>, initial: T): Signal<T>;
+
+interface LoadingSignalProps {
+    /** The current error state */
+    readonly error: Signal<Error | undefined>;
+    /** The current loading state */
+    readonly loading: Signal<boolean>;
+    /** Dispose the underlying request / action */
+    readonly dispose: () => void;
+}
+/** @category Loading Signal */
+type LoadingSignal<T> = Signal<T | undefined> & LoadingSignalProps;
+/**
+ * Options for creating a LoadingSignal
+ * @category Loading Signal
+ */
+interface CreateLoadingSignalOptions {
+    /** The loading state */
+    loading?: Signal<boolean>;
+    /** The error state */
+    error?: Signal<Error | undefined>;
+    /** An optional disposal method */
+    dispose?: () => void;
+}
+/**
+ * Create a Loading Signal
+ * @param value - The value signal
+ * @param options - Optional state data
+ * @category Loading Signal
+ * @constructor
+ */
+declare function loadingSignal<T>(value: Signal<T | undefined>, options?: CreateLoadingSignalOptions): LoadingSignal<T>;
+/** @category Loading Signal */
+interface LoadingSignalOptions {
+    /** Dispose the loading signal on destroy */
+    autoDispose?: boolean;
+    /** Pass an injector for running outside of injection context */
+    injector?: Injector;
+}
+/**
+ * Convert a LoadingState to a LoadingSignal
+ * @param loadingState
+ * @param options
+ * @category Loading Signal
+ */
+declare function toLoadingSignal<T>(loadingState: IValueLoadingState<T>, options?: LoadingSignalOptions): LoadingSignal<T>;
+/**
+ * Convert a Subscribable to a LoadingSignal
+ * @param observable
+ * @param options
+ * @category Loading Signal
+ */
+declare function toLoadingSignal<T>(observable: Subscribable<T>, options?: LoadingSignalOptions): LoadingSignal<T>;
+/**
+ * Convert a promise to a LoadingSignal
+ * @param promise
+ * @param options
+ * @category Loading Signal
+ */
+declare function toLoadingSignal<T>(promise: Promise<T>, options?: LoadingSignalOptions): LoadingSignal<T>;
+
+/**
+ * Create a signal containing the last 2 values emitted by the input signal
+ * @param inputSignal - The signal emitting values
+ * @param firstValue - The value to seed as the initial value in the new signal state
+ */
+declare function pairwiseSignal<T>(inputSignal: Signal<T>, firstValue: T): Signal<[prev: T, next: T]>;
+/**
+ * Create a writable signal that proxies another signal via a custom setter
+ * @param signal - The signal to proxy
+ * @param getter - The getter for the proxy
+ * @param setter - The setter for the proxy
+ */
+declare function proxySignal<T, TOut>(signal: WritableSignal<T>, getter: (value: T) => TOut, setter: (value: TOut) => T): ProxySignal<TOut>;
+type ProxySignal<T> = WritableSignal<T> & {
+    readonly error: Signal<Error | undefined>;
+};
+
+export { AsyncRequestState, EmptyRequestState, ErrorRequestState, IRequestState, IValueRequestState, LoadingRequestState, RequestTracker, SignalMap, SignalQueue, SignalSet, SignalStack, StaticRequestState, ValueRequestTracker, WritableRequestState, debouncedSignal, debouncedThrottledSignal, loadingSignal, pairwiseSignal, proxySignal, requestState, requestTracker, searchSignal, signalMap, signalQueue, signalSet, signalStack, subjectToSignal, throttledSignal, toLoadingSignal };
+export type { CreateLoadingSignalOptions, LoadingSignal, LoadingSignalOptions, ProxySignal, ReadonlySignalMap, ReadonlySignalSet, SignalQueueDelta, SignalQueueOptions, SignalStackDelta };

package/dist/index.mjs

@@ -1,6 +1,3 @@
-export { debouncedSignal, debouncedThrottledSignal, searchSignal, throttledSignal } from './async.mjs';
-export { subjectToSignal } from './interop.mjs';
-export { loadingSignal, toLoadingSignal } from './loading-signal.mjs';
 export { SignalMap, signalMap } from './data-structures/signal-map.mjs';
 export { SignalSet, signalSet } from './data-structures/signal-set.mjs';
 export { SignalQueue, signalQueue } from './data-structures/signal-queue.mjs';
@@ -14,3 +11,7 @@ export { LoadingRequestState } from './request-state/loading-request-state.mjs';
 export { StaticRequestState } from './request-state/static-request-state.mjs';
 export { WritableRequestState } from './request-state/writable-request-state.mjs';
 export { RequestTracker, ValueRequestTracker, requestTracker } from './request-state/request-tracker.mjs';
+export { debouncedSignal, debouncedThrottledSignal, searchSignal, throttledSignal } from './async.mjs';
+export { subjectToSignal } from './interop.mjs';
+export { loadingSignal, toLoadingSignal } from './loading-signal.mjs';
+export { pairwiseSignal, proxySignal } from './operators.mjs';

package/dist/operators.mjs

@@ -1,4 +1,5 @@
-import { computed } from '@angular/core';
+import { computed, linkedSignal } from '@angular/core';
+import { parseError } from '@juulsgaard/ts-tools';
 
 function pairwiseSignal(inputSignal, firstValue) {
   let prevValue = firstValue;
@@ -9,5 +10,21 @@ function pairwiseSignal(inputSignal, firstValue) {
     return tuple;
   });
 }
+function proxySignal(signal, getter, setter) {
+  const output = linkedSignal(() => getter(signal()));
+  const error = linkedSignal({
+    source: signal,
+    computation: () => void 0
+  });
+  output.set = (value) => {
+    try {
+      signal.set(setter(value));
+    } catch (e) {
+      error.set(parseError(e));
+    }
+  };
+  output.error = error.asReadonly();
+  return output;
+}
 
-export { pairwiseSignal };
+export { pairwiseSignal, proxySignal };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juulsgaard/signal-tools",
-  "version": "22.0.0",
+  "version": "22.0.2",
   "description": "Tools for working with Angular signals",
   "repository": "git@github.com:Juulsgaard/signal-tools.git",
   "homepage": "https://juulsgaard.github.io/signal-tools/",