@juulsgaard/signal-tools 18.0.0 → 18.0.1

package/dist/data-structures/signal-queue.js

@@ -0,0 +1,115 @@
+import { signal, computed, untracked } from '@angular/core';
+import { pairwiseSignal } from '../operators.js';
+
+class SignalQueue {
+  constructor(options) {
+    this._items = signal([]);
+    /** A signal emitting the items of the queue */
+    this.items = this._items.asReadonly();
+    /** A signal emitting the number of items in the queue */
+    this.length = computed(() => this.items().length);
+    /** A signal emitting true if there are no items in the queue */
+    this.empty = computed(() => this.length() <= 0);
+    this._maxSize = options?.size;
+    this.front = computed(() => this.items().at(0));
+    this.back = computed(() => this.items().at(-1));
+    const delta = pairwiseSignal(this.items, []);
+    this.frontDelta = computed(() => {
+      const [prev, next] = delta();
+      const item = next.at(0);
+      return { item, added: !item ? false : !prev.includes(item) };
+    }, { equal: (a, b) => a.item === b.item });
+    this.backDelta = computed(() => {
+      const [prev, next] = delta();
+      const item = next.at(-1);
+      return { item, added: !item ? false : !prev.includes(item) };
+    }, { equal: (a, b) => a.item === b.item });
+  }
+  /** The max size of the queue */
+  get maxSize() {
+    return this._maxSize;
+  }
+  //</editor-fold>
+  //<editor-fold desc="Actions">
+  /**
+   * Removes an item from the scheduler
+   * @param item
+   */
+  removeItem(item) {
+    const index = untracked(this.items).indexOf(item);
+    if (index < 0) return false;
+    const arr = [...untracked(this.items)];
+    arr.splice(index, 1);
+    this._items.set(arr);
+    return true;
+  }
+  dequeue(count) {
+    if (count !== void 0) {
+      if (count < 1) return [];
+      if (!untracked(this.length)) return [];
+      const items = untracked(this.items).slice(0, count);
+      this._items.set(untracked(this.items).slice(count));
+      return items;
+    }
+    if (!untracked(this.length)) return void 0;
+    const item = untracked(this.items).at(0);
+    this._items.set(untracked(this.items).slice(1));
+    return item;
+  }
+  removeFromBack(count) {
+    if (count !== void 0) {
+      if (count < 1) return [];
+      if (!untracked(this.length)) return [];
+      const start = count * -1;
+      const items = untracked(this.items).slice(start);
+      this._items.set(untracked(this.items).slice(0, start));
+      return items;
+    }
+    if (!untracked(this.length)) return void 0;
+    const item = untracked(this.items).at(-1);
+    this._items.set(untracked(this.items).slice(0, -1));
+    return item;
+  }
+  enqueue(...items) {
+    let list = [...untracked(this.items), ...items];
+    if (this.maxSize !== void 0 && list.length > this.maxSize) {
+      const delta = list.length - this.maxSize;
+      list = list.slice(delta);
+    }
+    this._items.set(list);
+  }
+  addToFront(...items) {
+    let list = [...items, ...untracked(this.items)];
+    if (this.maxSize !== void 0 && list.length > this.maxSize) {
+      const delta = list.length - this.maxSize;
+      list = list.slice(0, -delta);
+    }
+    this._items.set(list);
+  }
+  /**
+   * Checks if the item exists in the queue
+   * @param item
+   */
+  contains(item) {
+    return untracked(this.items).includes(item);
+  }
+  /**
+   * Remove all elements from the set
+   */
+  clear() {
+    this._items.set([]);
+  }
+  //</editor-fold>
+  /**
+   * Change the max size of the queue
+   * @param size - The new max size
+   */
+  setMaxSize(size) {
+    this._maxSize = size;
+    if (size === void 0 || untracked(this.length) <= size) return;
+    const delta = untracked(this.length) - size;
+    this._items.set(untracked(this.items).slice(delta));
+  }
+}
+
+export { SignalQueue };

package/dist/data-structures/signal-stack.js

@@ -0,0 +1,90 @@
+import { signal, computed, untracked } from '@angular/core';
+import { pairwiseSignal } from '../operators.js';
+
+class SignalStack {
+  constructor() {
+    this._items = signal([]);
+    /** A signal containing the items of the stack from bottom to top */
+    this.items = this._items.asReadonly();
+    /** A signal emitting the number of items in the stack */
+    this.length = computed(() => this.items().length);
+    /** A signal emitting true if there are no items in the stack */
+    this.empty = computed(() => this.length() <= 0);
+    this.top = computed(() => this.items().at(-1));
+    this.bottom = computed(() => this.items().at(0));
+    const delta = pairwiseSignal(this.items, []);
+    this.topDelta = computed(() => {
+      const [prev, next] = delta();
+      const item = next.at(-1);
+      return { item, added: !item ? false : !prev.includes(item) };
+    }, { equal: (a, b) => a.item === b.item });
+    this.bottomDelta = computed(() => {
+      const [prev, next] = delta();
+      const item = next.at(0);
+      return { item, added: !item ? false : !prev.includes(item) };
+    }, { equal: (a, b) => a.item === b.item });
+  }
+  //</editor-fold>
+  //<editor-fold desc="Actions">
+  /**
+   * Removes an item from the scheduler
+   * @param item
+   */
+  removeItem(item) {
+    const index = untracked(this.items).indexOf(item);
+    if (index < 0) return false;
+    const arr = [...untracked(this.items)];
+    arr.splice(index, 1);
+    this._items.set(arr);
+    return true;
+  }
+  removeFromBottom(count) {
+    if (count !== void 0) {
+      if (count < 1) return [];
+      if (!untracked(this.length)) return [];
+      const items = untracked(this.items).slice(0, count);
+      this._items.set(untracked(this.items).slice(count));
+      return items;
+    }
+    if (!untracked(this.length)) return void 0;
+    const item = untracked(this.items).at(0);
+    this._items.set(untracked(this.items).slice(1));
+    return item;
+  }
+  pop(count) {
+    if (count !== void 0) {
+      if (count < 1) return [];
+      if (!untracked(this.length)) return [];
+      const start = count * -1;
+      const items = untracked(this.items).slice(start);
+      this._items.set(untracked(this.items).slice(0, start));
+      return items;
+    }
+    if (!untracked(this.length)) return void 0;
+    const item = untracked(this.items).at(-1);
+    this._items.set(untracked(this.items).slice(0, -1));
+    return item;
+  }
+  push(...items) {
+    this._items.set([...untracked(this.items), ...items]);
+  }
+  addToBottom(...items) {
+    this._items.set([...items, ...untracked(this.items)]);
+  }
+  /**
+   * Checks if the item exists in the queue
+   * @param item
+   */
+  contains(item) {
+    return untracked(this.items).includes(item);
+  }
+  /**
+   * Remove all elements from the set
+   */
+  clear() {
+    this._items.set([]);
+  }
+  //</editor-fold>
+}
+
+export { SignalStack };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
+import * as _angular_core from '@angular/core';
 import { Signal, Injector } from '@angular/core';
-import { BehaviorSubject, Subject, Subscribable } from 'rxjs';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Subject, Subscribable, Observable, Observer, Unsubscribable } from 'rxjs';
 import { IValueLoadingState } from '@juulsgaard/rxjs-tools';
 
 /**
@@ -120,6 +122,86 @@ declare function toLoadingSignal<T>(observable: Subscribable<T>, options?: Loadi
  */
 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
+ */
+declare class SignalMap<TKey, TVal> implements ReadonlySignalMap<TKey, TVal> {
+    private readonly _map;
+    /** @inheritDoc */
+    readonly value: Signal<ReadonlyMap<TKey, TVal>>;
+    /** @inheritDoc */
+    readonly size: Signal<number>;
+    /** @inheritDoc */
+    readonly empty: Signal<boolean>;
+    constructor(values?: ReadonlyMap<TKey, TVal>);
+    [Symbol.iterator](): IterableIterator<[TKey, TVal]>;
+    private getCopy;
+    /**
+     * Remove all keys not in the whitelist
+     * @param whitelist - The keys to keep
+     */
+    filter(whitelist: ReadonlyArray<TKey> | ReadonlySet<TKey> | undefined): boolean;
+    /** Clear the collection */
+    clear(): boolean;
+    /**
+     * Add a value to the collection if the key is not in use
+     * @param key - The key to use
+     * @param value - The value to add
+     * @return added - Returns true if the value was added
+     */
+    add(key: TKey, value: TVal): boolean;
+    /**
+     * Add a value to the collection
+     * @param key - The key to use
+     * @param value - The value to add
+     * @return added - Returns true if the value was added or changed
+     */
+    set(key: TKey, value: TVal): boolean;
+    /**
+     * Remove a key from the collection
+     * @param key - The key to remove
+     * @return removed - True if an item was removed
+     */
+    delete(key: TKey): boolean;
+    /**
+     * Remove keys from the collection
+     * @param values - The keys to remove
+     * @return removed - True if items were removed
+     */
+    deleteRange(values: TKey[]): boolean;
+    /**
+     * Toggle a value in the map
+     * @param key - The key to toggle
+     * @param value - The value to insert if applicable
+     * @param state - A forced state (`true` = always add, `false` = always delete)
+     * @returns The applied change (`true` = item added, `false` = item removed, `undefined` = nothing changed)
+     */
+    toggle(key: TKey, value: TVal, state?: boolean): boolean | undefined;
+    /** Manually modify the inner collection */
+    modify(modify: (map: Map<TKey, TVal>) => void): void;
+    /** @inheritDoc */
+    has(key: TKey): Signal<boolean>;
+    /** @inheritDoc */
+    get(key: TKey): Signal<TVal | undefined>;
+}
+/**
+ * An immutable Map where the state and values are accessible as signals
+ * @category Signal Collections
+ */
+interface ReadonlySignalMap<TKey, TVal> extends Iterable<[TKey, TVal]> {
+    /** A signal emitting the number of items in the collection */
+    readonly size: Signal<number>;
+    /** A signal emitting true if the collection is empty */
+    readonly empty: Signal<boolean>;
+    /** A signal emitting the inner non-signal map */
+    readonly value: Signal<ReadonlyMap<TKey, TVal>>;
+    /** Create a signal emitting true if a key exists in the collection */
+    has(key: TKey): Signal<boolean>;
+    /** Create a signal emitting the value under a given key */
+    get(key: TKey): Signal<TVal | undefined>;
+}
+
 /**
  * A Set where the state and values are accessible as signals
  * @category Signal Collections
@@ -205,83 +287,502 @@ interface ReadonlySignalSet<T> extends Iterable<T> {
 }
 
 /**
- * A Map where the state and values are accessible as signals
+ * A signal FIFO queue
  * @category Signal Collections
  */
-declare class SignalMap<TKey, TVal> implements ReadonlySignalMap<TKey, TVal> {
-    private readonly _map;
-    /** @inheritDoc */
-    readonly value: Signal<ReadonlyMap<TKey, TVal>>;
-    /** @inheritDoc */
-    readonly size: Signal<number>;
-    /** @inheritDoc */
+declare class SignalQueue<T> {
+    private readonly _items;
+    /** A signal emitting the items of the queue */
+    readonly items: Signal<T[]>;
+    /** A signal emitting the number of items in the queue */
+    readonly length: Signal<number>;
+    /** A signal emitting true if there are no items in the queue */
     readonly empty: Signal<boolean>;
-    constructor(values?: ReadonlyMap<TKey, TVal>);
-    [Symbol.iterator](): IterableIterator<[TKey, TVal]>;
-    private getCopy;
+    private _maxSize;
+    /** The max size of the queue */
+    get maxSize(): number | undefined;
+    constructor(options?: SignalQueueOptions);
     /**
-     * Remove all keys not in the whitelist
-     * @param whitelist - The keys to keep
+     * Signal returning the element at the front of the queue
      */
-    filter(whitelist: ReadonlyArray<TKey> | ReadonlySet<TKey> | undefined): boolean;
-    /** Clear the collection */
-    clear(): boolean;
+    readonly front: Signal<T | undefined>;
+    /** Signal returning the current front element and whether it was just added */
+    readonly frontDelta: Signal<SignalQueueDelta<T>>;
     /**
-     * Add a value to the collection if the key is not in use
-     * @param key - The key to use
-     * @param value - The value to add
-     * @return added - Returns true if the value was added
+     * Signal returning the element at the back of the queue
      */
-    add(key: TKey, value: TVal): boolean;
+    readonly back: Signal<T | undefined>;
+    /** Signal returning the current back element and whether it was just added */
+    readonly backDelta: Signal<SignalQueueDelta<T>>;
     /**
-     * Add a value to the collection
-     * @param key - The key to use
-     * @param value - The value to add
-     * @return added - Returns true if the value was added or changed
+     * Removes an item from the scheduler
+     * @param item
      */
-    set(key: TKey, value: TVal): boolean;
+    removeItem(item: T): boolean;
     /**
-     * Remove a key from the collection
-     * @param key - The key to remove
-     * @return removed - True if an item was removed
+     * Remove the front element from the queue and return it
      */
-    delete(key: TKey): boolean;
+    dequeue(): T | undefined;
     /**
-     * Remove keys from the collection
-     * @param values - The keys to remove
-     * @return removed - True if items were removed
+     * Remove the front x elements from the queue and return them
+     * @param count - The amount of elements to remove
      */
-    deleteRange(values: TKey[]): boolean;
+    dequeue(count: number): T[];
     /**
-     * Toggle a value in the map
-     * @param key - The key to toggle
-     * @param value - The value to insert if applicable
-     * @param state - A forced state (`true` = always add, `false` = always delete)
-     * @returns The applied change (`true` = item added, `false` = item removed, `undefined` = nothing changed)
+     * Remove the back element from the queue and return it
      */
-    toggle(key: TKey, value: TVal, state?: boolean): boolean | undefined;
-    /** Manually modify the inner collection */
-    modify(modify: (map: Map<TKey, TVal>) => void): void;
-    /** @inheritDoc */
-    has(key: TKey): Signal<boolean>;
-    /** @inheritDoc */
-    get(key: TKey): Signal<TVal | undefined>;
+    removeFromBack(): T | undefined;
+    /**
+     * Remove the back x elements from the queue and return it
+     * @param count - The amount of elements to remove
+     */
+    removeFromBack(count: number): T[];
+    /**
+     * Add item to the back of the queue
+     * @param item - Item to add
+     */
+    enqueue(item: T): void;
+    /**
+     * Add items to the back of the queue
+     * @param items - Items to add
+     */
+    enqueue(...items: T[]): void;
+    /**
+     * Add item to the front of the queue
+     * @param item - Item to add
+     */
+    addToFront(item: T): void;
+    /**
+     * Add items to the front of the queue
+     * @param items - Items to add
+     */
+    addToFront(...items: T[]): void;
+    /**
+     * Checks if the item exists in the queue
+     * @param item
+     */
+    contains(item: T): boolean;
+    /**
+     * Remove all elements from the set
+     */
+    clear(): void;
+    /**
+     * Change the max size of the queue
+     * @param size - The new max size
+     */
+    setMaxSize(size: number | undefined): void;
 }
 /**
- * An immutable Map where the state and values are accessible as signals
+ * Options for creating a Queue
  * @category Signal Collections
  */
-interface ReadonlySignalMap<TKey, TVal> extends Iterable<[TKey, TVal]> {
-    /** A signal emitting the number of items in the collection */
-    readonly size: Signal<number>;
-    /** A signal emitting true if the collection is empty */
+interface SignalQueueOptions {
+    size?: number | undefined;
+}
+/**
+ * Data indicating the change in state for a location in the Queue
+ * @category Signal Collections
+ */
+interface SignalQueueDelta<T> {
+    added: boolean;
+    item?: T;
+}
+
+/**
+ * A signal based FILO stack
+ * @category Signal Collections
+ */
+declare class SignalStack<T> {
+    private readonly _items;
+    /** A signal containing the items of the stack from bottom to top */
+    readonly items: Signal<T[]>;
+    /** A signal emitting the number of items in the stack */
+    readonly length: Signal<number>;
+    /** A signal emitting true if there are no items in the stack */
     readonly empty: Signal<boolean>;
-    /** A signal emitting the inner non-signal map */
-    readonly value: Signal<ReadonlyMap<TKey, TVal>>;
-    /** Create a signal emitting true if a key exists in the collection */
-    has(key: TKey): Signal<boolean>;
-    /** Create a signal emitting the value under a given key */
-    get(key: TKey): Signal<TVal | undefined>;
+    constructor();
+    /** Signal returning the element at the top of the stack */
+    readonly top: Signal<T | undefined>;
+    /** Signal returning the current top element and whether it was just added */
+    readonly topDelta: Signal<SignalStackDelta<T>>;
+    /** Signal returning the element at the bottom of the stack */
+    readonly bottom: Signal<T | undefined>;
+    /** Signal returning the current bottom element and whether it was just added */
+    readonly bottomDelta: Signal<SignalStackDelta<T>>;
+    /**
+     * Removes an item from the scheduler
+     * @param item
+     */
+    removeItem(item: T): boolean;
+    /**
+     * Remove the bottom element from the stack and return it
+     */
+    removeFromBottom(): T | undefined;
+    /**
+     * Remove the bottom x elements from the stack and return them
+     * @param count - The amount of elements to remove
+     */
+    removeFromBottom(count: number): T[];
+    /**
+     * Remove the top element from the stack and return it
+     */
+    pop(): T | undefined;
+    /**
+     * Remove the top x elements from the stack and return it
+     * @param count - The amount of elements to remove
+     */
+    pop(count: number): T[];
+    /**
+     * Add item to the top of the stack
+     * @param item - Item to add
+     */
+    push(item: T): void;
+    /**
+     * Add items to the top of the stack
+     * @param items - Items to add
+     */
+    push(...items: T[]): void;
+    /**
+     * Add item to the bottom of the stack
+     * @param item - Item to add
+     */
+    addToBottom(item: T): void;
+    /**
+     * Add items to the bottom of the stack
+     * @param items - Items to add
+     */
+    addToBottom(...items: T[]): void;
+    /**
+     * Checks if the item exists in the queue
+     * @param item
+     */
+    contains(item: T): boolean;
+    /**
+     * Remove all elements from the set
+     */
+    clear(): void;
+}
+/**
+ * Data indicating the change in state for a location in the Stack
+ * @category Signal Collections
+ */
+interface SignalStackDelta<T> {
+    item?: T;
+    added: boolean;
+}
+
+/**
+ * A class representing the state of a request
+ * @category RequestState
+ */
+declare abstract class IRequestState implements Subscribable<unknown> {
+    /** The underlying request */
+    abstract readonly request$: Observable<unknown>;
+    /** The result of the request */
+    abstract readonly result$: Observable<unknown>;
+    /** The result of the request, or undefined when unresolved */
+    abstract readonly result: Signal<unknown | undefined>;
+    /** Emits true when the request is running */
+    abstract readonly loading: Signal<boolean>;
+    /** Emits the error if one is thrown by the request. Otherwise undefined */
+    abstract readonly error: Signal<Error | undefined>;
+    /** Emits true if the request failed */
+    abstract readonly failed: Signal<boolean>;
+    /** Cancel a running request */
+    abstract cancel(): boolean;
+    /**
+     * Perform actions when the request finishes
+     * @param onValue - Action to perform on successful resolution
+     * @param onError - Action to perform on error
+     */
+    abstract then(onValue: (value: unknown) => void, onError?: (error: Error) => void): this;
+    /**
+     * Perform an action if the request fails
+     * @param onError
+     */
+    abstract catch(onError: (error: Error) => void): this;
+    /**
+     * Perform an action when the request finishes (Error or Success)
+     * @param onComplete
+     */
+    abstract finally(onComplete: (error?: Error) => void): this;
+    /**
+     * Subscribe to the underlying request Observable
+     * @param observer
+     */
+    subscribe(observer: Partial<Observer<unknown>>): Unsubscribable;
+}
+/**
+ * A class representing the state of a request with a known return type
+ * @category RequestState
+ */
+declare abstract class IValueRequestState<T> extends IRequestState implements Subscribable<T> {
+    abstract readonly request$: Observable<T>;
+    abstract readonly result$: Observable<T>;
+    abstract readonly result: Signal<T | undefined>;
+    subscribe(observer: Partial<Observer<T>>): Unsubscribable;
+    then(onValue: (value: T) => void, onError?: (error: Error) => void): this;
+    catch(onError: (error: Error) => void): this;
+    finally(onComplete: (error?: Error) => void): this;
+    /**
+     * Cancel a running request
+     * @param error - Optionally provide a custom error to throw when cancelling the request
+     */
+    abstract cancel(error?: string | Error | (() => Error)): boolean;
+}
+
+/**
+ * A manually populated RequestState
+ * @category RequestState
+ */
+declare class WritableRequestState<T> extends IValueRequestState<T> {
+    private readonly onCancel?;
+    private _completed;
+    get completed(): boolean;
+    private readonly _request$;
+    readonly request$: rxjs.Observable<T>;
+    private readonly _result$;
+    readonly result$: rxjs.Observable<T>;
+    private readonly _result;
+    readonly result: _angular_core.Signal<T | undefined>;
+    private readonly _loading;
+    readonly loading: _angular_core.Signal<boolean>;
+    private readonly _error;
+    readonly error: _angular_core.Signal<Error | undefined>;
+    readonly failed: _angular_core.Signal<boolean>;
+    private readonly _cancelled;
+    /** Emits true when the RequestState has been cancelled by a consumer, otherwise emits false */
+    readonly cancelled: _angular_core.Signal<boolean>;
+    private readonly _cancelled$;
+    /** Emits true when the RequestState has been cancelled by a consumer */
+    readonly cancelled$: rxjs.Observable<true>;
+    constructor(onCancel?: (() => void) | undefined);
+    /**
+     * Create a Readonly version of the RequestState
+     */
+    asReadonly(): IValueRequestState<T>;
+    /**
+     * Set the RequestState to an Error state
+     * @param error - The error for the RequestState
+     */
+    setError(error: unknown | Error): void;
+    /**
+     * Set the RequestState to a completed state with a given value
+     * @param value - The value to emit
+     */
+    setValue(value: T): void;
+    cancel(error?: string | Error | (() => Error)): boolean;
+}
+
+/**
+ * Create a RequestState from a request or Value
+ * @param data - The request or value
+ * @category RequestState
+ */
+declare function valueRequestState<T>(data: T | Promise<T> | Observable<T>): IValueRequestState<T>;
+/** @category RequestState */
+interface AltConstructors {
+    /**
+     * Create a writable RequestState
+     * @param onCancel - Optional cancellation handler
+     * @category RequestState
+     */
+    writable<T>(onCancel?: () => void): WritableRequestState<T>;
+    /**
+     * Create a RequestState emitting an error
+     * @param error - The error to emit
+     * @category RequestState
+     */
+    error(error: Error | (() => Error)): IRequestState;
+    /**
+     * Create a typed RequestState emitting an error
+     * @param error - The error to emit
+     * @category RequestState
+     */
+    error<T>(error: Error | (() => Error)): IValueRequestState<T>;
+    /**
+     * Create a RequestState which is always loading
+     * @category RequestState
+     */
+    loading(): IRequestState;
+    /**
+     * Create a typed RequestState which is always loading
+     * @category RequestState
+     */
+    loading<T>(): IValueRequestState<T>;
+    /**
+     * Create a RequestState that resolves after an amount of time
+     * @param duration - The loading duration in milliseconds
+     * @category RequestState
+     */
+    loading(duration: number): IRequestState;
+    /**
+     * Create a RequestState that resolves with a value after an amount of time
+     * @param duration - The loading duration in milliseconds
+     * @param value - The value to resolve with after the delay
+     * @category RequestState
+     */
+    loading<T>(duration: number, value: T): IValueRequestState<T>;
+    /**
+     * Create an empty RequestState
+     * @category RequestState
+     */
+    empty(): IRequestState;
+    /**
+     * Create a typed empty RequestState
+     * @category RequestState
+     */
+    empty<T>(): IValueRequestState<T>;
+}
+declare const requestState: typeof valueRequestState & AltConstructors;
+
+/**
+ * A RequestState representing a pending async action
+ * @category RequestState
+ */
+declare class AsyncRequestState<T> extends IValueRequestState<T> {
+    private readonly _request$;
+    readonly request$: Observable<T>;
+    private readonly _result$;
+    readonly result$: Observable<T>;
+    private readonly _result;
+    readonly result: _angular_core.Signal<T | undefined>;
+    private readonly _loading;
+    readonly loading: _angular_core.Signal<boolean>;
+    private readonly _error;
+    readonly error: _angular_core.Signal<Error | undefined>;
+    readonly failed: _angular_core.Signal<boolean>;
+    private readonly sub;
+    constructor(request: Promise<T> | Observable<T>);
+    cancel(error?: string | Error | (() => Error)): boolean;
+}
+
+/**
+ * An Empty RequestState
+ * @category RequestState
+ */
+declare class EmptyRequestState<T> extends IValueRequestState<T> {
+    readonly request$: rxjs.Observable<never>;
+    readonly result$: rxjs.Observable<never>;
+    readonly result: Signal<undefined>;
+    readonly loading: Signal<false>;
+    readonly error: Signal<undefined>;
+    readonly failed: Signal<false>;
+    cancel(): boolean;
+}
+
+/**
+ * A RequestState which always emits an error
+ * @category RequestState
+ */
+declare class ErrorRequestState<T> extends IValueRequestState<T> {
+    readonly request$: Observable<never>;
+    readonly result$: Observable<never>;
+    readonly result: Signal<undefined>;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<Error | undefined>;
+    readonly failed: Signal<boolean>;
+    constructor(getError: () => Error);
+    cancel(): boolean;
+}
+
+/**
+ * A RequestState which is perpetually loading
+ * @category RequestState
+ */
+declare class LoadingRequestState<T> extends IValueRequestState<T> {
+    private readonly _request$;
+    readonly request$: rxjs.Observable<T>;
+    readonly result$: rxjs.Observable<T>;
+    readonly result: Signal<undefined>;
+    private readonly _loading;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<undefined>;
+    readonly failed: Signal<false>;
+    cancel(): boolean;
+}
+
+/**
+ * A RequestState which always returns the same value immediately
+ * @category RequestState
+ */
+declare class StaticRequestState<T> extends IValueRequestState<T> {
+    private readonly value;
+    readonly request$: Observable<T>;
+    readonly result$: Observable<T>;
+    readonly result: Signal<T>;
+    readonly loading: Signal<false>;
+    readonly error: Signal<undefined>;
+    readonly failed: Signal<false>;
+    constructor(value: T);
+    cancel(): boolean;
+    then(next: (value: T) => void, _error?: (error: Error) => void): this;
+    catch(_onError: (error: Error) => void): this;
+    finally(onComplete: () => void): this;
 }
 
-export { type CreateLoadingSignalOptions, type LoadingSignal, type LoadingSignalOptions, type ReadonlySignalMap, type ReadonlySignalSet, SignalMap, SignalSet, debouncedSignal, debouncedThrottledSignal, loadingSignal, searchSignal, subjectToSignal, throttledSignal, toLoadingSignal };
+/**
+ * A container which keeps track of a replaceable RequestState
+ * @category RequestState
+ */
+declare class RequestTracker {
+    private readonly _request;
+    /** The currently active RequestState */
+    readonly request: Signal<IRequestState>;
+    /** The currently active RequestState */
+    set current(req: IRequestState);
+    get current(): IRequestState;
+    /** Emits true if the current RequestState is loading */
+    readonly loading: Signal<boolean>;
+    /** Emits an error if the current RequestState is in an error state */
+    readonly error: Signal<Error | undefined>;
+    /** Emits true if the current RequestState has failed */
+    readonly failed: Signal<boolean>;
+    constructor(request?: IRequestState);
+    /**
+     * Set a new current RequestState
+     * @param state - The new RequestState
+     */
+    set(state: IRequestState): void;
+    /**
+     * Resets the Tracker to an Empty state
+     */
+    reset(): void;
+}
+/**
+ * A container which keeps track of a replaceable RequestState of a known return type
+ * @category RequestState
+ */
+declare class ValueRequestTracker<T> extends RequestTracker {
+    private readonly _valueRequest;
+    request: Signal<IValueRequestState<T>>;
+    set current(req: IValueRequestState<T>);
+    get current(): IValueRequestState<T>;
+    constructor(request?: IValueRequestState<T>);
+    set(req: IValueRequestState<T>): void;
+    reset(): void;
+}
+/**
+ * Create an empty and untyped RequestTracker
+ * @category RequestState
+ */
+declare function requestTracker(): RequestTracker;
+/**
+ * Create an empty RequestTracker with a known RequestState return type
+ * @category RequestState
+ */
+declare function requestTracker<T>(): ValueRequestTracker<T>;
+/**
+ * Create a typed RequestTracker from a types RequestState
+ * @param request - The initial RequestState
+ * @category RequestState
+ */
+declare function requestTracker<T>(request: IValueRequestState<T>): ValueRequestTracker<T>;
+/**
+ * Create an untyped RequestTracker from an untyped RequestState
+ * @param request - The initial RequestState
+ * @category RequestState
+ */
+declare function requestTracker(request: IRequestState): RequestTracker;
+
+export { AsyncRequestState, type CreateLoadingSignalOptions, EmptyRequestState, ErrorRequestState, IRequestState, IValueRequestState, LoadingRequestState, type LoadingSignal, type LoadingSignalOptions, type ReadonlySignalMap, type ReadonlySignalSet, RequestTracker, SignalMap, SignalQueue, type SignalQueueDelta, type SignalQueueOptions, SignalSet, SignalStack, type SignalStackDelta, StaticRequestState, ValueRequestTracker, WritableRequestState, debouncedSignal, debouncedThrottledSignal, loadingSignal, requestState, requestTracker, searchSignal, subjectToSignal, throttledSignal, toLoadingSignal };

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/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/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/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/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/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/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/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-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/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 };

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

@@ -0,0 +1,75 @@
+import { ReplaySubject } 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 WritableRequestState extends IValueRequestState {
+  constructor(onCancel) {
+    super();
+    this.onCancel = onCancel;
+    this._completed = false;
+    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);
+    this._cancelled = signal(false);
+    /** Emits true when the RequestState has been cancelled by a consumer, otherwise emits false */
+    this.cancelled = this._cancelled.asReadonly();
+    this._cancelled$ = new ReplaySubject();
+    /** Emits true when the RequestState has been cancelled by a consumer */
+    this.cancelled$ = this._cancelled$.asObservable();
+  }
+  get completed() {
+    return this._completed;
+  }
+  /**
+   * Create a Readonly version of the RequestState
+   */
+  asReadonly() {
+    return this;
+  }
+  /**
+   * Set the RequestState to an Error state
+   * @param error - The error for the RequestState
+   */
+  setError(error) {
+    if (this.completed) return;
+    this._completed = true;
+    this._request$.error(error);
+    this._result$.complete();
+    this._loading.set(false);
+    this._error.set(parseError(error));
+  }
+  /**
+   * Set the RequestState to a completed state with a given value
+   * @param value - The value to emit
+   */
+  setValue(value) {
+    if (this.completed) return;
+    this._completed = true;
+    this._request$.next(value);
+    this._request$.complete();
+    this._loading.set(false);
+    this._result.set(value);
+  }
+  cancel(error) {
+    if (this.completed) return false;
+    const fullError = isString(error) ? new CancelledError(error) : isFunction(error) ? error() : error;
+    this.setError(fullError);
+    this._cancelled.set(true);
+    this._cancelled$.next(true);
+    this._cancelled$.complete();
+    this.onCancel?.();
+    return true;
+  }
+}
+
+export { WritableRequestState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juulsgaard/signal-tools",
-  "version": "18.0.0",
+  "version": "18.0.1",
   "description": "Tools for working with Angular signals",
   "repository": "git@github.com:Juulsgaard/signal-tools.git",
   "homepage": "https://juulsgaard.github.io/signal-tools/",
@@ -14,24 +14,24 @@
     "dist/**"
   ],
   "peerDependencies": {
-    "@angular/core": "^18.2.5",
+    "@angular/core": "^18.2.8",
     "@juulsgaard/ts-tools": "^1.6.4",
-    "@juulsgaard/rxjs-tools": "^1.7.4",
+    "@juulsgaard/rxjs-tools": "^1.7.6",
     "rxjs": "^7.8.1",
     "tslib": "^2.7.0",
     "typescript": "~5.5.4"
   },
   "devDependencies": {
-    "@angular/core": "18.2.5",
-    "@juulsgaard/rxjs-tools": "1.7.4",
-    "@types/jest": "^29.5.12",
+    "@angular/core": "18.2.8",
+    "@juulsgaard/rxjs-tools": "1.7.6",
+    "@types/jest": "^29.5.13",
     "jest": "^29.7.0",
-    "rollup": "^4.19.1",
+    "rollup": "^4.24.0",
     "rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-esbuild": "^6.1.1",
     "rxjs": "7.8.1",
-    "ts-jest": "^29.2.3",
-    "typedoc": "^0.26.7",
+    "ts-jest": "^29.2.5",
+    "typedoc": "^0.26.8",
     "typescript": "~5.5.4",
     "tslib": "2.7.0"
   },