@ardium-pl/devkit 8.3.2

package/lib/signals/queue/queue-signal.d.ts

@@ -0,0 +1,77 @@
+import { Signal, WritableSignal } from '@angular/core';
+/**
+ * A read-only queue signal, providing non-mutating helpers and computed properties.
+ * @template T The type of elements held in the queue.
+ */
+export interface QueueSignal<T> extends Signal<T[]> {
+    /**
+     * A signal that returns `true` if the queue is empty.
+     */
+    readonly isEmpty: Signal<boolean>;
+    /**
+     * A signal that returns the current number of items in the queue.
+     */
+    readonly size: Signal<number>;
+    /**
+     * A signal that returns the front (first) item of the queue, or `undefined` if the queue is empty. Does not remove it.
+     */
+    readonly front: Signal<T | undefined>;
+    /**
+     * A signal that returns a shallow copy of the queue as an array.
+     */
+    readonly asArray: Signal<T[]>;
+    /**
+     * Returns the front item in the queue, or `undefined` if the queue is empty. Does not remove it.
+     * @returns The front item or `undefined`.
+     */
+    peek(): T | undefined;
+}
+/**
+ * A writable queue signal, providing mutating and non-mutating helpers.
+ * @template T The type of elements held in the queue.
+ */
+export interface WritableQueueSignal<T> extends WritableSignal<T[]>, QueueSignal<T> {
+    /**
+     * Returns a read-only version of the queue signal.
+     * @returns A read-only {@link QueueSignal} instance.
+     */
+    asReadonly(): QueueSignal<T>;
+    /**
+     * Adds one or more items to the end of the queue.
+     * @param items - The elements to enqueue.
+     */
+    enqueue(...items: T[]): void;
+    /**
+     * Removes and returns the front item of the queue. If the queue is empty, returns `undefined`.
+     * @returns The dequeued item, or `undefined` if the queue was empty.
+     */
+    dequeue(): T | undefined;
+    /**
+     * Clears all items from the queue.
+     */
+    clear(): void;
+    /**
+     * Replaces the queue with a new array of items.
+     * @param value - The new array to set as the queue.
+     */
+    set(value: T[]): void;
+    /**
+     * Updates the queue using the provided update function.
+     * @param updateFn - Function that receives the current queue and returns a new queue.
+     */
+    update(updateFn: (current: T[]) => T[]): void;
+}
+/**
+ * Creates a writable queue signal, which is a reactive queue data structure.
+ *
+ * @template T The type of elements held in the queue.
+ * @param {T[]} [initialValue=[]] Optional initial items in the queue.
+ * @returns {WritableQueueSignal<T>} The writable queue signal instance.
+ *
+ * @example
+ * const queue = queueSignal<number>([1, 2, 3]);
+ * queue.enqueue(4);              // new value: [1, 2, 3, 4]
+ * const value = queue.dequeue(); // 1    new value: [2, 3, 4]
+ * queue.clear();                 // new value: []
+ */
+export declare function queueSignal<T>(initialValue?: T[]): WritableQueueSignal<T>;

package/lib/signals/set/index.d.ts

@@ -0,0 +1 @@
+export * from './set-signal';

package/lib/signals/set/set-signal.d.ts

@@ -0,0 +1,76 @@
+import { Signal, WritableSignal } from '@angular/core';
+/**
+ * A read-only set signal with non-mutating methods.
+ */
+export interface SetSignal<T> extends Signal<Set<T>> {
+    /**
+     * Computed signal that returns `true` if the set is empty.
+     */
+    readonly isEmpty: Signal<boolean>;
+    /**
+     * Computed signal for set size.
+     */
+    readonly size: Signal<number>;
+    /**
+     * Checks if a value exists in the set.
+     */
+    has(value: T): boolean;
+    /**
+     * Computed signal that returns a new array from the set.
+     */
+    readonly asArray: Signal<T[]>;
+}
+/**
+ * A writable set signal with mutating and non-mutating methods.
+ */
+export interface WritableSetSignal<T> extends WritableSignal<Set<T>>, SetSignal<T> {
+    /**
+     * Returns a read-only version of the set signal.
+     */
+    asReadonly(): SetSignal<T>;
+    /**
+     * Adds a value to the set.
+     */
+    add(value: T): void;
+    /**
+     * Deletes a value from the set.
+     * Returns true if a value was removed.
+     */
+    delete(value: T): boolean;
+    /**
+     * Clears the set.
+     */
+    clear(): void;
+    /**
+     * Replaces the set with a new set.
+     */
+    set(value: Set<T>): void;
+    /**
+     * Updates the set using an update function.
+     */
+    update(updateFn: (current: Set<T>) => Set<T>): void;
+}
+/**
+ * Creates a writable, reactive Set signal with convenient, immutable Set manipulation methods.
+ *
+ * This function returns a signal that wraps a JavaScript `Set` and exposes both non-mutating and mutating helpers,
+ * ensuring that all operations are fully reactive and immutably safe. All mutator methods (`add`, `delete`, `clear`, etc.)
+ * return a new Set value for robust signal reactivity.
+ *
+ * Also provides computed signals for queries such as `isEmpty`, `size`, and `asArray`, and offers a type-safe, read-only
+ * view via `.asReadonly()`.
+ *
+ * @template T The type of items stored in the set.
+ * @param {Iterable<T>} [initialValue=[]] Optional initial values for the set (can be another Set or any iterable).
+ * @returns {WritableSetSignal<T>} A writable Set signal instance with both native and Set-specific helpers.
+ *
+ * @example
+ * const ids = setSignal<number>([1, 2, 3]);
+ * ids.add(4);              // [1, 2, 3, 4]
+ * ids.delete(2);           // removes 2
+ * ids.has(3);              // true
+ * ids.asArray();           // [1, 3, 4]
+ * ids.clear();             // empty set
+ * ids.isEmpty();           // true
+ */
+export declare function setSignal<T>(initialValue?: Iterable<T>): WritableSetSignal<T>;

package/lib/signals/stack/index.d.ts

@@ -0,0 +1 @@
+export * from './stack-signal';

package/lib/signals/stack/stack-signal.d.ts

@@ -0,0 +1,77 @@
+import { Signal, WritableSignal } from '@angular/core';
+/**
+ * A read-only stack signal, providing non-mutating helpers and computed properties.
+ * @template T The type of elements held in the stack.
+ */
+export interface StackSignal<T> extends Signal<T[]> {
+    /**
+     * A signal that returns `true` if the stack is empty.
+     */
+    readonly isEmpty: Signal<boolean>;
+    /**
+     * A signal that returns the current number of items in the stack.
+     */
+    readonly size: Signal<number>;
+    /**
+     * A signal that returns the top (last) item of the stack, or `undefined` if the stack is empty. Does not remove it.
+     */
+    readonly top: Signal<T | undefined>;
+    /**
+     * A signal that returns a shallow copy of the stack as an array.
+     */
+    readonly asArray: Signal<T[]>;
+    /**
+     * Returns the top item in the stack, or `undefined` if the stack is empty. Does not remove it.
+     * @returns The top item or `undefined`.
+     */
+    peek(): T | undefined;
+}
+/**
+ * A writable stack signal, providing mutating and non-mutating helpers.
+ * @template T The type of elements held in the stack.
+ */
+export interface WritableStackSignal<T> extends WritableSignal<T[]>, StackSignal<T> {
+    /**
+     * Returns a read-only version of the stack signal.
+     * @returns A read-only {@link StackSignal} instance.
+     */
+    asReadonly(): StackSignal<T>;
+    /**
+     * Pushes one or more items onto the top of the stack.
+     * @param items - The elements to push onto the stack.
+     */
+    push(...items: T[]): void;
+    /**
+     * Removes and returns the top item of the stack. If the stack is empty, returns `undefined`.
+     * @returns The popped item, or `undefined` if the stack was empty.
+     */
+    pop(): T | undefined;
+    /**
+     * Clears all items from the stack.
+     */
+    clear(): void;
+    /**
+     * Replaces the stack with a new array of items.
+     * @param value - The new array to set as the stack.
+     */
+    set(value: T[]): void;
+    /**
+     * Updates the stack using the provided update function.
+     * @param updateFn - Function that receives the current stack and returns a new stack.
+     */
+    update(updateFn: (current: T[]) => T[]): void;
+}
+/**
+ * Creates a writable stack signal, which is a reactive stack data structure.
+ *
+ * @template T The type of elements held in the stack.
+ * @param {T[]} [initialValue=[]] Optional initial items in the stack.
+ * @returns {WritableStackSignal<T>} The writable stack signal instance.
+ *
+ * @example
+ * const stack = stackSignal<number>([1, 2, 3]);
+ * stack.push(4);             // [1, 2, 3, 4]
+ * const value = stack.pop(); // 4        [1, 2, 3]
+ * stack.clear();             // []
+ */
+export declare function stackSignal<T>(initialValue?: T[]): WritableStackSignal<T>;

package/lib/signals/throttled/index.d.ts

@@ -0,0 +1 @@
+export * from './throttled-signal';

package/lib/signals/throttled/throttled-signal.d.ts

@@ -0,0 +1,15 @@
+import { WritableSignal } from '@angular/core';
+/**
+ * A ThrottledSignal interface that extends WritableSignal<T> and includes throttling behavior.
+ */
+export interface ThrottledSignal<T> extends WritableSignal<T> {
+    readonly throttleTime: number;
+}
+/**
+ * Creates a `WritableSignal` that limits how often its value can be updated, using the throttle time specified.
+ *
+ * @param initialValue - The initial value of the signal.
+ * @param throttleTime - The minimum delay in milliseconds between signal updates.
+ * @returns A `WritableSignal<T>` that throttles value updates based on the specified throttle time.
+ */
+export declare function throttledSignal<T>(initialValue: T, throttleTime: number): ThrottledSignal<T>;

package/lib/signals/tuple/index.d.ts

@@ -0,0 +1 @@
+export * from './tuple-signal';

package/lib/signals/tuple/tuple-signal.d.ts

@@ -0,0 +1,60 @@
+import { Signal, WritableSignal } from '@angular/core';
+/**
+ * A read-only tuple signal.
+ */
+export interface TupleSignal<T extends readonly unknown[]> extends Signal<T> {
+    /**
+     * Computed signal that returns an array of tuple entries [index, value].
+     */
+    readonly entriesArray: Signal<{
+        [K in keyof T]: [K, T[K]];
+    }[number][]>;
+    /**
+     * Returns the value at a given index.
+     */
+    getAt<I extends keyof T>(index: I): T[I];
+}
+/**
+ * A writable tuple signal.
+ */
+export interface WritableTupleSignal<T extends readonly unknown[]> extends WritableSignal<T>, TupleSignal<T> {
+    /**
+     * Returns a read-only version of the tuple signal.
+     */
+    asReadonly(): TupleSignal<T>;
+    /**
+     * Sets the value at a given index.
+     */
+    setAt<I extends keyof T>(index: I, value: T[I]): void;
+    /**
+     * Updates the entire tuple with a function.
+     */
+    update(updateFn: (current: T) => T): void;
+    /**
+     * Updates the value at a given index with a function.
+     */
+    updateAt<I extends keyof T>(index: I, updateFn: (value: T[I]) => T[I]): void;
+}
+/**
+ * Creates a writable, reactive tuple signal of **fixed length**, with tuple-specific and array-like helpers.
+ *
+ * This function returns a signal wrapping a tuple (fixed-length array), exposing safe, type-aware mutation and update helpers
+ * as well as computed signals for common tuple queries.
+ *
+ * All mutating methods (`set`, `setAt`, `updateAt`, `update`) return a new tuple value,
+ * preserving immutability and optimal signal reactivity.
+ *
+ * Also provides `.asReadonly()` for read-only consumption and computed signals for empty/entries.
+ *
+ * @template T The tuple type (e.g. `[number, string, boolean]`).
+ * @param {T} initialValue The initial tuple value.
+ * @returns {WritableTupleSignal<T>} A writable tuple signal with all mutation, query, and computed helpers.
+ *
+ * @example
+ * const point = tupleSignal<[number, number]>([0, 1]);
+ * point.setAt(1, 99);          // [0, 99]
+ * point.updateAt(0, x => x+10);// [10, 99]
+ * point();                     // [10, 99]
+ * point.entriesArray();        // [[0, 10], [1, 99]]
+ */
+export declare function tupleSignal<T extends readonly unknown[]>(initialValue: T): WritableTupleSignal<T>;

package/lib/validators/index.d.ts

@@ -0,0 +1 @@
+export * from './validators';