@juulsgaard/signal-tools 18.0.0 → 18.0.2

package/dist/async.mjs

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

@@ -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-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-queue.mjs

@@ -0,0 +1,115 @@
+import { signal, computed, untracked } from '@angular/core';
+import { pairwiseSignal } from '../operators.mjs';
+
+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-set.mjs

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