@juulsgaard/signal-tools 18.0.0 → 18.0.2

package/dist/index.js

@@ -1,5 +1,16 @@
 export { debouncedSignal, debouncedThrottledSignal, searchSignal, throttledSignal } from './async.js';
 export { subjectToSignal } from './interop.js';
 export { loadingSignal, toLoadingSignal } from './loading-signal.js';
-export { SignalSet } from './data-structures/signal-set.js';
 export { SignalMap } from './data-structures/signal-map.js';
+export { SignalSet } from './data-structures/signal-set.js';
+export { SignalQueue } from './data-structures/signal-queue.js';
+export { SignalStack } from './data-structures/signal-stack.js';
+export { requestState } from './request-state/constructors.js';
+export { IRequestState, IValueRequestState } from './request-state/request-state.js';
+export { AsyncRequestState } from './request-state/async-request-state.js';
+export { EmptyRequestState } from './request-state/empty-request-state.js';
+export { ErrorRequestState } from './request-state/error-request-state.js';
+export { LoadingRequestState } from './request-state/loading-request-state.js';
+export { StaticRequestState } from './request-state/static-request-state.js';
+export { WritableRequestState } from './request-state/writable-request-state.js';
+export { RequestTracker, ValueRequestTracker, requestTracker } from './request-state/request-tracker.js';

package/dist/index.mjs

@@ -0,0 +1,16 @@
+export { debouncedSignal, debouncedThrottledSignal, searchSignal, throttledSignal } from './async.mjs';
+export { subjectToSignal } from './interop.mjs';
+export { loadingSignal, toLoadingSignal } from './loading-signal.mjs';
+export { SignalMap } from './data-structures/signal-map.mjs';
+export { SignalSet } from './data-structures/signal-set.mjs';
+export { SignalQueue } from './data-structures/signal-queue.mjs';
+export { SignalStack } from './data-structures/signal-stack.mjs';
+export { requestState } from './request-state/constructors.mjs';
+export { IRequestState, IValueRequestState } from './request-state/request-state.mjs';
+export { AsyncRequestState } from './request-state/async-request-state.mjs';
+export { EmptyRequestState } from './request-state/empty-request-state.mjs';
+export { ErrorRequestState } from './request-state/error-request-state.mjs';
+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';

package/dist/interop.mjs

@@ -0,0 +1,11 @@
+import { signal } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+function subjectToSignal(subject, initial) {
+  const init = subject instanceof BehaviorSubject ? subject.value : initial;
+  const sig = signal(init);
+  subject.subscribe((val) => sig.set(val));
+  return sig;
+}
+
+export { subjectToSignal };

package/dist/loading-signal.mjs

@@ -0,0 +1,68 @@
+import { signal, assertInInjectionContext, DestroyRef, inject } from '@angular/core';
+import { ILoadingState } from '@juulsgaard/rxjs-tools';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { parseError } from '@juulsgaard/ts-tools';
+
+function loadingSignal(value, options) {
+  const loadingSignal2 = value;
+  loadingSignal2.loading = options?.loading ?? signal(false);
+  loadingSignal2.error = options?.error ?? signal(void 0);
+  loadingSignal2.dispose = options?.dispose ?? (() => void 0);
+  return loadingSignal2;
+}
+function toLoadingSignal(loadingState, options) {
+  const injector = options?.injector;
+  const needsInjector = !!options?.autoDispose;
+  if (needsInjector && !injector) assertInInjectionContext(toLoadingSignal);
+  let state;
+  if (loadingState instanceof ILoadingState) {
+    state = fromLoadingState(loadingState);
+  } else if (loadingState instanceof Promise) {
+    state = fromPromise(loadingState);
+  } else {
+    state = fromObservable(loadingState);
+  }
+  if (options?.autoDispose) {
+    const destroy = injector?.get(DestroyRef) ?? inject(DestroyRef);
+    destroy.onDestroy(() => state.dispose());
+  }
+  return state;
+}
+function fromObservable(value$) {
+  const value = signal(void 0);
+  const loading = signal(true);
+  const error = signal(void 0);
+  const sub = value$.subscribe({
+    next: (val) => {
+      sub.unsubscribe();
+      loading.set(false);
+      value.set(val);
+    },
+    error: (err) => {
+      sub.unsubscribe();
+      loading.set(false);
+      error.set(parseError(err));
+    },
+    complete: () => {
+      sub.unsubscribe();
+      loading.set(false);
+    }
+  });
+  return loadingSignal(value, { loading, error, dispose: () => sub.unsubscribe() });
+}
+function fromPromise(promise) {
+  const value = signal(void 0);
+  const loading = signal(true);
+  const error = signal(void 0);
+  promise.then((val) => value.set(val), (err) => error.set(parseError(err)));
+  promise.finally(() => loading.set(false));
+  return loadingSignal(value, { loading, error });
+}
+function fromLoadingState(state) {
+  const value = toSignal(state.result$, { manualCleanup: true });
+  const loading = toSignal(state.loading$, { manualCleanup: true, initialValue: true });
+  const error = toSignal(state.error$, { manualCleanup: true });
+  return loadingSignal(value, { loading, error, dispose: () => state.cancel() });
+}
+
+export { loadingSignal, toLoadingSignal };

package/dist/operators.js

@@ -0,0 +1,13 @@
+import { computed } from '@angular/core';
+
+function pairwiseSignal(inputSignal, firstValue) {
+  let prevValue = firstValue;
+  return computed(() => {
+    const nextValue = inputSignal();
+    const tuple = [prevValue, nextValue];
+    prevValue = nextValue;
+    return tuple;
+  });
+}
+
+export { pairwiseSignal };

package/dist/operators.mjs

@@ -0,0 +1,13 @@
+import { computed } from '@angular/core';
+
+function pairwiseSignal(inputSignal, firstValue) {
+  let prevValue = firstValue;
+  return computed(() => {
+    const nextValue = inputSignal();
+    const tuple = [prevValue, nextValue];
+    prevValue = nextValue;
+    return tuple;
+  });
+}
+
+export { pairwiseSignal };

package/dist/request-state/async-request-state.js

@@ -0,0 +1,48 @@
+import { ReplaySubject, isObservable, take, from } from 'rxjs';
+import { signal, computed } from '@angular/core';
+import { parseError, isString, isFunction } from '@juulsgaard/ts-tools';
+import { CancelledError } from '@juulsgaard/rxjs-tools';
+import { IValueRequestState } from './request-state.js';
+
+class AsyncRequestState extends IValueRequestState {
+  constructor(request) {
+    super();
+    this._request$ = new ReplaySubject();
+    this.request$ = this._request$.asObservable();
+    this._result$ = new ReplaySubject();
+    this.result$ = this._result$.asObservable();
+    this._result = signal(void 0);
+    this.result = this._result.asReadonly();
+    this._loading = signal(true);
+    this.loading = this._loading.asReadonly();
+    this._error = signal(void 0);
+    this.error = this._error.asReadonly();
+    this.failed = computed(() => this._error() !== void 0);
+    const request$ = isObservable(request) ? request.pipe(take(1)) : from(request);
+    this.sub = request$.subscribe(this._request$);
+    this.request$.subscribe({
+      next: (value) => {
+        this._result$.next(value);
+        this._result.set(value);
+      },
+      error: (error) => {
+        this._error.set(parseError(error));
+        this._result$.complete();
+        this._loading.set(false);
+      },
+      complete: () => {
+        this._result$.complete();
+        this._loading.set(false);
+      }
+    });
+  }
+  cancel(error) {
+    if (this.sub.closed) return false;
+    this.sub.unsubscribe();
+    const fullError = isString(error) ? new CancelledError(error) : isFunction(error) ? error() : error;
+    this._request$.error(fullError);
+    return true;
+  }
+}
+
+export { AsyncRequestState };

package/dist/request-state/async-request-state.mjs

@@ -0,0 +1,48 @@
+import { ReplaySubject, isObservable, take, from } from 'rxjs';
+import { signal, computed } from '@angular/core';
+import { parseError, isString, isFunction } from '@juulsgaard/ts-tools';
+import { CancelledError } from '@juulsgaard/rxjs-tools';
+import { IValueRequestState } from './request-state.mjs';
+
+class AsyncRequestState extends IValueRequestState {
+  constructor(request) {
+    super();
+    this._request$ = new ReplaySubject();
+    this.request$ = this._request$.asObservable();
+    this._result$ = new ReplaySubject();
+    this.result$ = this._result$.asObservable();
+    this._result = signal(void 0);
+    this.result = this._result.asReadonly();
+    this._loading = signal(true);
+    this.loading = this._loading.asReadonly();
+    this._error = signal(void 0);
+    this.error = this._error.asReadonly();
+    this.failed = computed(() => this._error() !== void 0);
+    const request$ = isObservable(request) ? request.pipe(take(1)) : from(request);
+    this.sub = request$.subscribe(this._request$);
+    this.request$.subscribe({
+      next: (value) => {
+        this._result$.next(value);
+        this._result.set(value);
+      },
+      error: (error) => {
+        this._error.set(parseError(error));
+        this._result$.complete();
+        this._loading.set(false);
+      },
+      complete: () => {
+        this._result$.complete();
+        this._loading.set(false);
+      }
+    });
+  }
+  cancel(error) {
+    if (this.sub.closed) return false;
+    this.sub.unsubscribe();
+    const fullError = isString(error) ? new CancelledError(error) : isFunction(error) ? error() : error;
+    this._request$.error(fullError);
+    return true;
+  }
+}
+
+export { AsyncRequestState };

package/dist/request-state/constructors.js

@@ -0,0 +1,25 @@
+import { isObservable } from 'rxjs';
+import { WritableRequestState } from './writable-request-state.js';
+import { AsyncRequestState } from './async-request-state.js';
+import { StaticRequestState } from './static-request-state.js';
+import { ErrorRequestState } from './error-request-state.js';
+import '@angular/core';
+import '@juulsgaard/ts-tools';
+
+function valueRequestState(data) {
+  if (isObservable(data)) return new AsyncRequestState(data);
+  if (data instanceof Promise) return new AsyncRequestState(data);
+  return new StaticRequestState(data);
+}
+function errorRequestState(error) {
+  return new ErrorRequestState(error instanceof Error ? () => error : error);
+}
+function writableRequestState(onCancel) {
+  return new WritableRequestState(onCancel);
+}
+const compiled = valueRequestState;
+compiled.writable = writableRequestState;
+compiled.error = errorRequestState;
+const requestState = compiled;
+
+export { requestState };

package/dist/request-state/constructors.mjs

@@ -0,0 +1,25 @@
+import { isObservable } from 'rxjs';
+import { WritableRequestState } from './writable-request-state.mjs';
+import { AsyncRequestState } from './async-request-state.mjs';
+import { StaticRequestState } from './static-request-state.mjs';
+import { ErrorRequestState } from './error-request-state.mjs';
+import '@angular/core';
+import '@juulsgaard/ts-tools';
+
+function valueRequestState(data) {
+  if (isObservable(data)) return new AsyncRequestState(data);
+  if (data instanceof Promise) return new AsyncRequestState(data);
+  return new StaticRequestState(data);
+}
+function errorRequestState(error) {
+  return new ErrorRequestState(error instanceof Error ? () => error : error);
+}
+function writableRequestState(onCancel) {
+  return new WritableRequestState(onCancel);
+}
+const compiled = valueRequestState;
+compiled.writable = writableRequestState;
+compiled.error = errorRequestState;
+const requestState = compiled;
+
+export { requestState };

package/dist/request-state/empty-request-state.js

@@ -0,0 +1,20 @@
+import { EMPTY } from 'rxjs';
+import { signal } from '@angular/core';
+import { IValueRequestState } from './request-state.js';
+
+class EmptyRequestState extends IValueRequestState {
+  constructor() {
+    super(...arguments);
+    this.request$ = EMPTY;
+    this.result$ = this.request$;
+    this.result = signal(void 0).asReadonly();
+    this.loading = signal(false);
+    this.error = signal(void 0);
+    this.failed = signal(false);
+  }
+  cancel() {
+    return false;
+  }
+}
+
+export { EmptyRequestState };

package/dist/request-state/empty-request-state.mjs

@@ -0,0 +1,20 @@
+import { EMPTY } from 'rxjs';
+import { signal } from '@angular/core';
+import { IValueRequestState } from './request-state.mjs';
+
+class EmptyRequestState extends IValueRequestState {
+  constructor() {
+    super(...arguments);
+    this.request$ = EMPTY;
+    this.result$ = this.request$;
+    this.result = signal(void 0).asReadonly();
+    this.loading = signal(false);
+    this.error = signal(void 0);
+    this.failed = signal(false);
+  }
+  cancel() {
+    return false;
+  }
+}
+
+export { EmptyRequestState };

package/dist/request-state/error-request-state.js

@@ -0,0 +1,20 @@
+import { EMPTY, throwError } from 'rxjs';
+import { signal } from '@angular/core';
+import { IValueRequestState } from './request-state.js';
+
+class ErrorRequestState extends IValueRequestState {
+  constructor(getError) {
+    super();
+    this.result$ = EMPTY;
+    this.result = signal(void 0).asReadonly();
+    this.loading = signal(false);
+    this.failed = signal(true);
+    this.error = signal(getError());
+    this.request$ = throwError(getError);
+  }
+  cancel() {
+    return false;
+  }
+}
+
+export { ErrorRequestState };

package/dist/request-state/error-request-state.mjs

@@ -0,0 +1,20 @@
+import { EMPTY, throwError } from 'rxjs';
+import { signal } from '@angular/core';
+import { IValueRequestState } from './request-state.mjs';
+
+class ErrorRequestState extends IValueRequestState {
+  constructor(getError) {
+    super();
+    this.result$ = EMPTY;
+    this.result = signal(void 0).asReadonly();
+    this.loading = signal(false);
+    this.failed = signal(true);
+    this.error = signal(getError());
+    this.request$ = throwError(getError);
+  }
+  cancel() {
+    return false;
+  }
+}
+
+export { ErrorRequestState };

package/dist/request-state/loading-request-state.js

@@ -0,0 +1,25 @@
+import { Subject } from 'rxjs';
+import { signal } from '@angular/core';
+import { IValueRequestState } from './request-state.js';
+
+class LoadingRequestState extends IValueRequestState {
+  constructor() {
+    super(...arguments);
+    this._request$ = new Subject();
+    this.request$ = this._request$.asObservable();
+    this.result$ = this.request$;
+    this.result = signal(void 0).asReadonly();
+    this._loading = signal(true);
+    this.loading = this._loading.asReadonly();
+    this.error = signal(void 0);
+    this.failed = signal(false);
+  }
+  cancel() {
+    if (this._request$.closed) return false;
+    this._request$.complete();
+    this._loading.set(false);
+    return false;
+  }
+}
+
+export { LoadingRequestState };

package/dist/request-state/loading-request-state.mjs

@@ -0,0 +1,25 @@
+import { Subject } from 'rxjs';
+import { signal } from '@angular/core';
+import { IValueRequestState } from './request-state.mjs';
+
+class LoadingRequestState extends IValueRequestState {
+  constructor() {
+    super(...arguments);
+    this._request$ = new Subject();
+    this.request$ = this._request$.asObservable();
+    this.result$ = this.request$;
+    this.result = signal(void 0).asReadonly();
+    this._loading = signal(true);
+    this.loading = this._loading.asReadonly();
+    this.error = signal(void 0);
+    this.failed = signal(false);
+  }
+  cancel() {
+    if (this._request$.closed) return false;
+    this._request$.complete();
+    this._loading.set(false);
+    return false;
+  }
+}
+
+export { LoadingRequestState };

package/dist/request-state/request-state.js

@@ -0,0 +1,39 @@
+import { first } from 'rxjs';
+import { parseError } from '@juulsgaard/ts-tools';
+
+class IRequestState {
+  /**
+   * Subscribe to the underlying request Observable
+   * @param observer
+   */
+  subscribe(observer) {
+    return this.request$.subscribe(observer);
+  }
+}
+class IValueRequestState extends IRequestState {
+  subscribe(observer) {
+    return this.request$.subscribe(observer);
+  }
+  then(onValue, onError) {
+    this.request$.pipe(first()).subscribe({
+      next: (v) => onValue(v),
+      error: (e) => onError?.(parseError(e))
+    });
+    return this;
+  }
+  catch(onError) {
+    this.request$.subscribe({
+      error: (e) => onError(parseError(e))
+    });
+    return this;
+  }
+  finally(onComplete) {
+    this.request$.subscribe({
+      error: (e) => onComplete(parseError(e)),
+      complete: () => onComplete()
+    });
+    return this;
+  }
+}
+
+export { IRequestState, IValueRequestState };

package/dist/request-state/request-state.mjs

@@ -0,0 +1,39 @@
+import { first } from 'rxjs';
+import { parseError } from '@juulsgaard/ts-tools';
+
+class IRequestState {
+  /**
+   * Subscribe to the underlying request Observable
+   * @param observer
+   */
+  subscribe(observer) {
+    return this.request$.subscribe(observer);
+  }
+}
+class IValueRequestState extends IRequestState {
+  subscribe(observer) {
+    return this.request$.subscribe(observer);
+  }
+  then(onValue, onError) {
+    this.request$.pipe(first()).subscribe({
+      next: (v) => onValue(v),
+      error: (e) => onError?.(parseError(e))
+    });
+    return this;
+  }
+  catch(onError) {
+    this.request$.subscribe({
+      error: (e) => onError(parseError(e))
+    });
+    return this;
+  }
+  finally(onComplete) {
+    this.request$.subscribe({
+      error: (e) => onComplete(parseError(e)),
+      complete: () => onComplete()
+    });
+    return this;
+  }
+}
+
+export { IRequestState, IValueRequestState };

package/dist/request-state/request-tracker.js

@@ -0,0 +1,64 @@
+import { computed, signal, untracked } from '@angular/core';
+import { IValueRequestState } from './request-state.js';
+import { requestState } from './constructors.js';
+
+class RequestTracker {
+  constructor(request) {
+    /** Emits true if the current RequestState is loading */
+    this.loading = computed(() => this._request().loading());
+    /** Emits an error if the current RequestState is in an error state */
+    this.error = computed(() => this._request().error());
+    /** Emits true if the current RequestState has failed */
+    this.failed = computed(() => this._request().failed());
+    this._request = signal(request ?? requestState.empty());
+    this.request = this._request.asReadonly();
+  }
+  /** The currently active RequestState */
+  set current(req) {
+    this.set(req);
+  }
+  get current() {
+    return untracked(this.request);
+  }
+  /**
+   * Set a new current RequestState
+   * @param state - The new RequestState
+   */
+  set(state) {
+    this._request.set(state);
+  }
+  /**
+   * Resets the Tracker to an Empty state
+   */
+  reset() {
+    this._request.set(requestState.empty());
+  }
+}
+class ValueRequestTracker extends RequestTracker {
+  set current(req) {
+    this.set(req);
+  }
+  get current() {
+    return untracked(this.request);
+  }
+  constructor(request) {
+    super();
+    this._valueRequest = signal(request ?? requestState.empty());
+    this.request = this._valueRequest.asReadonly();
+  }
+  set(req) {
+    super.set(req);
+    this._valueRequest.set(req);
+  }
+  reset() {
+    super.reset();
+    this.set(requestState.empty());
+  }
+}
+function requestTracker(request) {
+  if (!request) return new ValueRequestTracker();
+  if (request instanceof IValueRequestState) return new ValueRequestTracker(request);
+  return new RequestTracker(request);
+}
+
+export { RequestTracker, ValueRequestTracker, requestTracker };

package/dist/request-state/request-tracker.mjs

@@ -0,0 +1,64 @@
+import { computed, signal, untracked } from '@angular/core';
+import { IValueRequestState } from './request-state.mjs';
+import { requestState } from './constructors.mjs';
+
+class RequestTracker {
+  constructor(request) {
+    /** Emits true if the current RequestState is loading */
+    this.loading = computed(() => this._request().loading());
+    /** Emits an error if the current RequestState is in an error state */
+    this.error = computed(() => this._request().error());
+    /** Emits true if the current RequestState has failed */
+    this.failed = computed(() => this._request().failed());
+    this._request = signal(request ?? requestState.empty());
+    this.request = this._request.asReadonly();
+  }
+  /** The currently active RequestState */
+  set current(req) {
+    this.set(req);
+  }
+  get current() {
+    return untracked(this.request);
+  }
+  /**
+   * Set a new current RequestState
+   * @param state - The new RequestState
+   */
+  set(state) {
+    this._request.set(state);
+  }
+  /**
+   * Resets the Tracker to an Empty state
+   */
+  reset() {
+    this._request.set(requestState.empty());
+  }
+}
+class ValueRequestTracker extends RequestTracker {
+  set current(req) {
+    this.set(req);
+  }
+  get current() {
+    return untracked(this.request);
+  }
+  constructor(request) {
+    super();
+    this._valueRequest = signal(request ?? requestState.empty());
+    this.request = this._valueRequest.asReadonly();
+  }
+  set(req) {
+    super.set(req);
+    this._valueRequest.set(req);
+  }
+  reset() {
+    super.reset();
+    this.set(requestState.empty());
+  }
+}
+function requestTracker(request) {
+  if (!request) return new ValueRequestTracker();
+  if (request instanceof IValueRequestState) return new ValueRequestTracker(request);
+  return new RequestTracker(request);
+}
+
+export { RequestTracker, ValueRequestTracker, requestTracker };

package/dist/request-state/static-request-state.js

@@ -0,0 +1,32 @@
+import { of } from 'rxjs';
+import { signal } from '@angular/core';
+import { IValueRequestState } from './request-state.js';
+
+class StaticRequestState extends IValueRequestState {
+  constructor(value) {
+    super();
+    this.value = value;
+    this.loading = signal(false);
+    this.error = signal(void 0);
+    this.failed = signal(false);
+    this.request$ = of(value);
+    this.result$ = this.request$;
+    this.result = signal(value);
+  }
+  cancel() {
+    return false;
+  }
+  then(next, _error) {
+    next(this.value);
+    return this;
+  }
+  catch(_onError) {
+    return this;
+  }
+  finally(onComplete) {
+    onComplete();
+    return this;
+  }
+}
+
+export { StaticRequestState };