@juulsgaard/signal-tools 18.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Frederik Juulsgaard Sørensen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# Signal Tools
+
+![NPM License](https://img.shields.io/npm/v/@juulsgaard/signal-tools)
+![NPM License](https://img.shields.io/npm/l/@juulsgaard/signal-tools)
+![NPM Downloads](https://img.shields.io/npm/dw/@juulsgaard/signal-tools)
+
+A utility library for Angular Signals
+
+## Description
+
+This library contains utility methods, types and classes to facilitate complicated operations with Angular Signals.
+
+Documentation of all the types, tools and classes can be found in the [Documentation](https://juulsgaard.github.io/signal-tools/)

package/dist/async.js

@@ -0,0 +1,96 @@
+import { assertInInjectionContext, signal, effect, DestroyRef, inject } from '@angular/core';
+
+function debouncedSignal(inputSignal, delay = 500, options) {
+  if (options?.injector) assertInInjectionContext(debouncedSignal);
+  const output = signal(inputSignal());
+  effect((onDestroy) => {
+    const value = inputSignal();
+    const timeout = setTimeout(() => output.set(value), delay);
+    onDestroy(() => clearTimeout(timeout));
+  }, { allowSignalWrites: true, injector: options?.injector });
+  return output;
+}
+function throttledSignal(inputSignal, delay = 500, options) {
+  if (options?.injector) assertInInjectionContext(throttledSignal);
+  const output = signal(inputSignal());
+  let nextValue = inputSignal();
+  let timeout = void 0;
+  effect(() => {
+    const value = inputSignal();
+    nextValue = value;
+    if (timeout) return;
+    if (options?.emitLeading) {
+      output.set(value);
+    }
+    timeout = setTimeout(() => {
+      output.set(nextValue);
+      timeout = void 0;
+    }, delay);
+  }, { allowSignalWrites: true, injector: options?.injector });
+  const onDestroy = options?.injector?.get(DestroyRef) ?? inject(DestroyRef);
+  onDestroy.onDestroy(() => clearTimeout(timeout));
+  return output;
+}
+function debouncedThrottledSignal(inputSignal, throttleDelay = 1e3, debounceDelay = 300, options) {
+  if (options?.injector) assertInInjectionContext(debouncedThrottledSignal);
+  const output = signal(inputSignal());
+  let nextValue = inputSignal();
+  let longTimeout = void 0;
+  function clearThrottle() {
+    if (!longTimeout) return;
+    clearTimeout(longTimeout);
+    longTimeout = void 0;
+  }
+  effect((onDestroy2) => {
+    const value = inputSignal();
+    const shortTimeout = setTimeout(() => {
+      output.set(value);
+      clearThrottle();
+    }, debounceDelay);
+    onDestroy2(() => clearTimeout(shortTimeout));
+    nextValue = value;
+    if (longTimeout) return;
+    longTimeout = setTimeout(() => {
+      output.set(nextValue);
+      longTimeout = void 0;
+    }, throttleDelay);
+  }, { allowSignalWrites: true, injector: options?.injector });
+  const onDestroy = options?.injector?.get(DestroyRef) ?? inject(DestroyRef);
+  onDestroy.onDestroy(() => clearTimeout(longTimeout));
+  return output;
+}
+function searchSignal(inputSignal, throttleDelay = 1e3, debounceDelay = 300, options) {
+  if (options?.injector) assertInInjectionContext(searchSignal);
+  const query = signal(inputSignal());
+  let nextValue = inputSignal();
+  let longTimeout = void 0;
+  function clearThrottle() {
+    if (!longTimeout) return;
+    clearTimeout(longTimeout);
+    longTimeout = void 0;
+  }
+  effect((onDestroy2) => {
+    const value = inputSignal();
+    if (value === void 0 || value === "") {
+      query.set(value);
+      clearThrottle();
+      return;
+    }
+    const shortTimeout = setTimeout(() => {
+      query.set(value);
+      clearThrottle();
+    }, debounceDelay);
+    onDestroy2(() => clearTimeout(shortTimeout));
+    nextValue = value;
+    if (longTimeout) return;
+    longTimeout = setTimeout(() => {
+      query.set(nextValue);
+      longTimeout = void 0;
+    }, throttleDelay);
+  }, { allowSignalWrites: true, injector: options?.injector });
+  const onDestroy = options?.injector?.get(DestroyRef) ?? inject(DestroyRef);
+  onDestroy.onDestroy(() => clearTimeout(longTimeout));
+  return query;
+}
+
+export { debouncedSignal, debouncedThrottledSignal, searchSignal, throttledSignal };

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

@@ -0,0 +1,134 @@
+import { signal, computed, untracked } from '@angular/core';
+
+class SignalMap {
+  constructor(values) {
+    this._map = signal(new Map(values));
+    this.value = this._map.asReadonly();
+    this.size = computed(() => this.value().size);
+    this.empty = computed(() => this.size() <= 0);
+  }
+  [Symbol.iterator]() {
+    return this.value()[Symbol.iterator]();
+  }
+  getCopy() {
+    return new Map(untracked(this.value));
+  }
+  //<editor-fold desc="Actions">
+  /**
+   * Remove all keys not in the whitelist
+   * @param whitelist - The keys to keep
+   */
+  filter(whitelist) {
+    const length = whitelist && "size" in whitelist ? whitelist.size : whitelist?.length;
+    if (!length) {
+      return this.clear();
+    }
+    const whitelistSet = whitelist instanceof Set ? whitelist : new Set(whitelist);
+    const map = this.getCopy();
+    for (let [key] of untracked(this.value)) {
+      if (whitelistSet.has(key)) continue;
+      map.delete(key);
+    }
+    if (untracked(this.size) !== map.size) {
+      this._map.set(map);
+      return true;
+    }
+    return false;
+  }
+  /** Clear the collection */
+  clear() {
+    if (!untracked(this.size)) return false;
+    this._map.set(/* @__PURE__ */ new Map());
+    return true;
+  }
+  /**
+   * 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, value) {
+    if (untracked(this.value).has(key)) return false;
+    const map = this.getCopy();
+    map.set(key, value);
+    this._map.set(map);
+    return true;
+  }
+  /**
+   * 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, value) {
+    const state = untracked(this.value);
+    if (state.has(key) && state.get(key) === value) return false;
+    const map = this.getCopy();
+    map.set(key, value);
+    this._map.set(map);
+    return true;
+  }
+  /**
+   * Remove a key from the collection
+   * @param key - The key to remove
+   * @return removed - True if an item was removed
+   */
+  delete(key) {
+    if (!untracked(this.value).has(key)) return false;
+    const map = this.getCopy();
+    map.delete(key);
+    this._map.set(map);
+    return true;
+  }
+  /**
+   * Remove keys from the collection
+   * @param values - The keys to remove
+   * @return removed - True if items were removed
+   */
+  deleteRange(values) {
+    const map = this.getCopy();
+    const size = map.size;
+    values.forEach((v) => map.delete(v));
+    if (map.size === size) return false;
+    this._map.set(map);
+    return true;
+  }
+  /**
+   * 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, value, state) {
+    if (untracked(this.value).has(key)) {
+      if (state === true) return void 0;
+      const map2 = this.getCopy();
+      map2.delete(key);
+      this._map.set(map2);
+      return false;
+    }
+    if (state === false) return void 0;
+    const map = this.getCopy();
+    map.set(key, value);
+    this._map.set(map);
+    return true;
+  }
+  /** Manually modify the inner collection */
+  modify(modify) {
+    const map = this.getCopy();
+    modify(map);
+    this._map.set(map);
+  }
+  /** @inheritDoc */
+  has(key) {
+    return computed(() => this.value().has(key));
+  }
+  /** @inheritDoc */
+  get(key) {
+    return computed(() => this.value().get(key));
+  }
+  //</editor-fold>
+}
+
+export { SignalMap };

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

@@ -0,0 +1,143 @@
+import { signal, computed, untracked } from '@angular/core';
+
+class SignalSet {
+  constructor(values) {
+    this._set = signal(new Set(values));
+    this.value = this._set.asReadonly();
+    this.size = computed(() => this.value().size);
+    this.empty = computed(() => this.size() <= 0);
+    this.array = computed(() => Array.from(this.value()));
+  }
+  /** @inheritDoc */
+  [Symbol.iterator]() {
+    return this.value()[Symbol.iterator]();
+  }
+  getCopy() {
+    return new Set(untracked(this.value));
+  }
+  //<editor-fold desc="Actions">
+  /**
+   * Remove all keys not in the whitelist
+   * @param whitelist - The keys to keep
+   */
+  filter(whitelist) {
+    const length = whitelist && "size" in whitelist ? whitelist.size : whitelist?.length;
+    if (!length) {
+      return this.clear();
+    }
+    const whitelistSet = whitelist instanceof Set ? whitelist : new Set(whitelist);
+    const set = this.getCopy();
+    for (let value of untracked(this.value)) {
+      if (whitelistSet.has(value)) continue;
+      set.delete(value);
+    }
+    if (untracked(this.size) !== set.size) {
+      this._set.set(set);
+      return true;
+    }
+    return false;
+  }
+  /** Clear the collection */
+  clear() {
+    if (!untracked(this.size)) return false;
+    this._set.set(/* @__PURE__ */ new Set());
+    return true;
+  }
+  /**
+   * Add a value to the collection is not already present
+   * @param value - The value to add
+   * @return added - Returns true if the value was added
+   */
+  add(value) {
+    if (untracked(this.value).has(value)) return false;
+    const set = this.getCopy();
+    set.add(value);
+    this._set.set(set);
+    return true;
+  }
+  /**
+   * Add a list of values to the collection is not already present
+   * @param values - The values to add
+   * @return added - Returns true if any value was added
+   */
+  addRange(values) {
+    const set = this.getCopy();
+    const size = set.size;
+    values.forEach((v) => set.add(v));
+    if (set.size === size) return false;
+    this._set.set(set);
+    return true;
+  }
+  /**
+   * Reset the values in the collection to the provided list
+   * @param values - The values to set
+   * @return changed - Returns true if the collection changed
+   */
+  set(values = []) {
+    if (!values.length && !this.size) return false;
+    if (values.length === untracked(this.size)) {
+      const same = values.every((x) => this.has(x));
+      if (same) return false;
+    }
+    this._set.set(new Set(values));
+    return true;
+  }
+  /**
+   * Remove a value from the collection
+   * @param value - The key to remove
+   * @return removed - True if the value existed
+   */
+  delete(value) {
+    if (!untracked(this.value).has(value)) return false;
+    const set = this.getCopy();
+    set.delete(value);
+    this._set.set(set);
+    return true;
+  }
+  /**
+   * Remove values from the collection
+   * @param values - The values to remove
+   * @return removed - True if any values were removed
+   */
+  deleteRange(values) {
+    const set = this.getCopy();
+    const size = set.size;
+    values.forEach((v) => set.delete(v));
+    if (set.size === size) return false;
+    this._set.set(set);
+    return true;
+  }
+  /**
+   * Toggle a value in the set
+   * @param value - The value to toggle
+   * @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(value, state) {
+    if (untracked(this.value).has(value)) {
+      if (state === true) return void 0;
+      const set2 = this.getCopy();
+      set2.delete(value);
+      this._set.set(set2);
+      return false;
+    }
+    if (state === false) return void 0;
+    const set = this.getCopy();
+    set.add(value);
+    this._set.set(set);
+    return true;
+  }
+  /** Manually modify the inner collection */
+  modify(modify) {
+    const set = this.getCopy();
+    modify(set);
+    this._set.set(set);
+  }
+  /** @inheritDoc */
+  has(value) {
+    return computed(() => this.value().has(value));
+  }
+  //</editor-fold>
+}
+
+export { SignalSet };

package/dist/index.d.ts

@@ -0,0 +1,287 @@
+import { Signal, Injector } from '@angular/core';
+import { BehaviorSubject, Subject, Subscribable } 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>;
+
+/** @category Loading Signal */
+type LoadingSignal<T> = Signal<T | undefined> & {
+    /** 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;
+};
+/**
+ * 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 Set where the state and values are accessible as signals
+ * @category Signal Collections
+ */
+declare class SignalSet<T> implements ReadonlySignalSet<T> {
+    private readonly _set;
+    /** @inheritDoc */
+    readonly value: Signal<ReadonlySet<T>>;
+    /** @inheritDoc */
+    readonly size: Signal<number>;
+    /** @inheritDoc */
+    readonly empty: Signal<boolean>;
+    /** @inheritDoc */
+    readonly array: Signal<T[]>;
+    constructor(values?: T[]);
+    /** @inheritDoc */
+    [Symbol.iterator](): IterableIterator<T>;
+    private getCopy;
+    /**
+     * Remove all keys not in the whitelist
+     * @param whitelist - The keys to keep
+     */
+    filter(whitelist: T[] | ReadonlySet<T> | undefined): boolean;
+    /** Clear the collection */
+    clear(): boolean;
+    /**
+     * Add a value to the collection is not already present
+     * @param value - The value to add
+     * @return added - Returns true if the value was added
+     */
+    add(value: T): boolean;
+    /**
+     * Add a list of values to the collection is not already present
+     * @param values - The values to add
+     * @return added - Returns true if any value was added
+     */
+    addRange(values: T[]): boolean;
+    /**
+     * Reset the values in the collection to the provided list
+     * @param values - The values to set
+     * @return changed - Returns true if the collection changed
+     */
+    set(values?: T[]): boolean;
+    /**
+     * Remove a value from the collection
+     * @param value - The key to remove
+     * @return removed - True if the value existed
+     */
+    delete(value: T): boolean;
+    /**
+     * Remove values from the collection
+     * @param values - The values to remove
+     * @return removed - True if any values were removed
+     */
+    deleteRange(values: T[]): boolean;
+    /**
+     * Toggle a value in the set
+     * @param value - The value to toggle
+     * @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(value: T, state?: boolean): boolean | undefined;
+    /** Manually modify the inner collection */
+    modify(modify: (set: Set<T>) => void): void;
+    /** @inheritDoc */
+    has(value: T): Signal<boolean>;
+}
+/**
+ * An immutable Set where the state and values are accessible as signals
+ * @category Signal Collections
+ */
+interface ReadonlySignalSet<T> extends Iterable<T> {
+    /** 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 Set */
+    readonly value: Signal<ReadonlySet<T>>;
+    /** A signal emitting the values of the set as an array */
+    readonly array: Signal<ReadonlyArray<T>>;
+    /** Create a signal emitting true if a key exists in the collection */
+    has(key: T): Signal<boolean>;
+}
+
+/**
+ * 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>;
+}
+
+export { type CreateLoadingSignalOptions, type LoadingSignal, type LoadingSignalOptions, type ReadonlySignalMap, type ReadonlySignalSet, SignalMap, SignalSet, debouncedSignal, debouncedThrottledSignal, loadingSignal, searchSignal, subjectToSignal, throttledSignal, toLoadingSignal };

package/dist/index.js

@@ -0,0 +1,5 @@
+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';

package/dist/interop.js

@@ -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.js

@@ -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/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@juulsgaard/signal-tools",
+  "version": "18.0.0",
+  "description": "Tools for working with Angular signals",
+  "repository": "git@github.com:Juulsgaard/signal-tools.git",
+  "homepage": "https://juulsgaard.github.io/signal-tools/",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "author": "Frederik Sørensen",
+  "license": "MIT",
+  "files": [
+    "dist/**"
+  ],
+  "peerDependencies": {
+    "@angular/core": "^18.2.5",
+    "@juulsgaard/ts-tools": "^1.6.4",
+    "@juulsgaard/rxjs-tools": "^1.7.4",
+    "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",
+    "jest": "^29.7.0",
+    "rollup": "^4.19.1",
+    "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",
+    "typescript": "~5.5.4",
+    "tslib": "2.7.0"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "test": "jest --config jestconfig.json",
+    "prepublishOnly": "rollup -c"
+  },
+  "packageManager": "pnpm@9.11.0"
+}