@ardium-pl/devkit 8.3.2

package/lib/http-service/index.d.ts

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

package/lib/infinite-scroll/index.d.ts

@@ -0,0 +1,3 @@
+export * from './infinite-scroll.defaults';
+export * from './infinite-scroll.directive';
+export * from './infinite-scroll.module';

package/lib/infinite-scroll/infinite-scroll.defaults.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { ArdInfScrollTarget } from './infinite-scroll.directive';
+export interface ArdInfiniteScrollDefaults {
+    threshold: number;
+    target: ArdInfScrollTarget;
+}
+export declare const ARD_INFINITE_SCROLL_DEFAULTS: InjectionToken<ArdInfiniteScrollDefaults>;
+export declare function provideInfiniteScrollDefaults(config: Partial<ArdInfiniteScrollDefaults>): Provider;

package/lib/infinite-scroll/infinite-scroll.directive.d.ts

@@ -0,0 +1,24 @@
+import * as i0 from "@angular/core";
+export declare const ArdInfScrollTarget: {
+    readonly Host: "host";
+    readonly HTML: "html";
+};
+export type ArdInfScrollTarget = (typeof ArdInfScrollTarget)[keyof typeof ArdInfScrollTarget];
+export declare class ArdiumInfiniteScrollDirective {
+    private readonly elementRef;
+    protected readonly _DEFAULTS: import("@ardium-pl/devkit").ArdInfiniteScrollDefaults;
+    readonly ardInfScrollReachThreshold: import("@angular/core").OutputEmitterRef<void>;
+    private _getElementRect;
+    private _getElementScrollTop;
+    private _getElementScrollHeight;
+    constructor();
+    readonly ardInfScrollThreshold: import("@angular/core").InputSignalWithTransform<number, any>;
+    readonly ardInfScrollActive: import("@angular/core").ModelSignal<boolean>;
+    readonly ardInfScrollTarget: import("@angular/core").InputSignal<ArdInfScrollTarget>;
+    onHostScroll(): void;
+    onWindowScroll(): void;
+    private _detectHostReachThreshold;
+    private _detectWindowReachThreshold;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumInfiniteScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumInfiniteScrollDirective, "[ardInfScroll]", never, { "ardInfScrollThreshold": { "alias": "ardInfScrollThreshold"; "required": false; "isSignal": true; }; "ardInfScrollActive": { "alias": "ardInfScrollActive"; "required": false; "isSignal": true; }; "ardInfScrollTarget": { "alias": "ardInfScrollTarget"; "required": false; "isSignal": true; }; }, { "ardInfScrollReachThreshold": "ardInfScrollReachThreshold"; "ardInfScrollActive": "ardInfScrollActiveChange"; }, never, never, false, never>;
+}

package/lib/infinite-scroll/infinite-scroll.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./infinite-scroll.directive";
+import * as i2 from "@angular/common";
+export declare class ArdiumInfiniteScrollModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumInfiniteScrollModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumInfiniteScrollModule, [typeof i1.ArdiumInfiniteScrollDirective], [typeof i2.CommonModule], [typeof i1.ArdiumInfiniteScrollDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumInfiniteScrollModule>;
+}

package/lib/keyboard/index.d.ts

@@ -0,0 +1,2 @@
+export * from './keyboard.service';
+export * from './keyboard.types';

package/lib/keyboard/keyboard.service.d.ts

@@ -0,0 +1,60 @@
+import { OnDestroy } from '@angular/core';
+import { ɵDomRendererFactory2 } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { KeyboardKey, KeyboardKeyState, KeyboardShortcut } from './keyboard.types';
+import * as i0 from "@angular/core";
+export declare class KeyboardService implements OnDestroy {
+    private renderer;
+    private removeListenFuncKeydown;
+    private removeListenFuncKeyup;
+    private removeListenFuncWindowblur;
+    constructor(rendererFactory: ɵDomRendererFactory2);
+    ngOnDestroy(): void;
+    private _resetAllKeys;
+    private readonly _isLeftCtrlHeld;
+    private readonly _isRightCtrlHeld;
+    readonly isLeftCtrlHeld: import("@angular/core").Signal<boolean>;
+    readonly isRightCtrlHeld: import("@angular/core").Signal<boolean>;
+    readonly isCtrlHeld: import("@angular/core").Signal<boolean>;
+    private readonly _isLeftAltHeld;
+    private readonly _isRightAltHeld;
+    readonly isAltHeld: import("@angular/core").Signal<boolean>;
+    readonly isAltGraphHeld: import("@angular/core").Signal<boolean>;
+    private readonly _isLeftShiftHeld;
+    private readonly _isRightShiftHeld;
+    readonly isLeftShiftHeld: import("@angular/core").Signal<boolean>;
+    readonly isRightShiftHeld: import("@angular/core").Signal<boolean>;
+    readonly isShiftHeld: import("@angular/core").Signal<boolean>;
+    private readonly _isLeftMetaHeld;
+    private readonly _isRightMetaHeld;
+    readonly isLeftMetaHeld: import("@angular/core").Signal<boolean>;
+    readonly isRightMetaHeld: import("@angular/core").Signal<boolean>;
+    readonly isMetaHeld: import("@angular/core").Signal<boolean>;
+    private readonly isAnyModifierKeyHeld;
+    private readonly _capsLockState;
+    readonly capsLockState: import("@angular/core").Signal<boolean | undefined>;
+    private readonly _numLockState;
+    readonly numLockState: import("@angular/core").Signal<boolean | undefined>;
+    private readonly _scrollLockState;
+    readonly scrollLockState: import("@angular/core").Signal<boolean | undefined>;
+    private readonly _shortcutSubject$;
+    readonly anyShortcut$: Observable<KeyboardShortcut>;
+    private readonly _keySubject$;
+    readonly anyKeyPress$: Observable<KeyboardKey>;
+    private readonly _keyStateSubject$;
+    readonly anyKeyState$: Observable<KeyboardKeyState>;
+    private _demapKeyCode;
+    private _emitShortcut;
+    private _emitKeydown;
+    private _emitKeyStateDown;
+    private _emitKeyStateUp;
+    listenToShortcut(toMatch: string[], treatAltGraphAsAltPlusCtrl?: boolean): Observable<KeyboardShortcut>;
+    listenToKey(code: string): Observable<KeyboardKey>;
+    listenToKeyState(code: string): Observable<KeyboardKeyState>;
+    private readonly _KEY_CODE_SIGNALS_MAP;
+    private _onKeydown;
+    private _updateLockKeyStates;
+    private _onKeyup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KeyboardService>;
+}

package/lib/keyboard/keyboard.types.d.ts

@@ -0,0 +1,13 @@
+export type KeyboardShortcut = {
+    keys: string[];
+    event: KeyboardEvent;
+};
+export type KeyboardKey = {
+    key: string;
+    event: KeyboardEvent;
+};
+export type KeyboardKeyState = {
+    key: string;
+    isHeld: boolean;
+    event: KeyboardEvent;
+};

package/lib/keyboard/types-internal.d.ts

@@ -0,0 +1,20 @@
+import { KeyboardShortcut } from "./keyboard.types";
+export type _LeftRight = {
+    left: boolean;
+    right: boolean;
+};
+export type _KeyboardShortcutInternal = {
+    ctrl: _LeftRight;
+    alt: _LeftRight;
+    shift: _LeftRight;
+    meta: _LeftRight;
+    key: string;
+    publicData: KeyboardShortcut;
+};
+export declare const _ExpectedModifierKeySide: {
+    readonly None: "none";
+    readonly Left: "left";
+    readonly Right: "right";
+    readonly Any: "any";
+};
+export type _ExpectedModifierKeySide = typeof _ExpectedModifierKeySide[keyof typeof _ExpectedModifierKeySide];

package/lib/keyboard/utils.d.ts

@@ -0,0 +1,3 @@
+import { _ExpectedModifierKeySide, _LeftRight } from './types-internal';
+export declare function trySettingModifierKey(modifierKeyName: string, keyCode: string, rawKeyCode: string, previouslyFoundKeyCode: string | null, currentKeyState: _ExpectedModifierKeySide): [_ExpectedModifierKeySide, string | null, boolean];
+export declare function isModifierKeyInWrongState(state: _LeftRight, expectedState: _ExpectedModifierKeySide): boolean;

package/lib/relative-pos/index.d.ts

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

package/lib/relative-pos/relative-pos.d.ts

@@ -0,0 +1,24 @@
+import { ElementRef } from '@angular/core';
+export declare class EventRelativePos<T extends HTMLElement> {
+    readonly target: T;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+    readonly overflowsTop: boolean;
+    readonly overflowsRight: boolean;
+    readonly overflowsBottom: boolean;
+    readonly overflowsLeft: boolean;
+    readonly overflows: boolean;
+    constructor(target: T, top: number, right: number, bottom: number, left: number);
+    valueOf(): {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    toJSON(): string;
+    toString(): string;
+    static fromEvent<T extends HTMLElement>(event: MouseEvent | TouchEvent | Touch, el: T | ElementRef<T>): EventRelativePos<T>;
+}
+export declare function getEventRelativePos<T extends HTMLElement>(event: MouseEvent | TouchEvent | Touch, el: T | ElementRef<T>): EventRelativePos<T>;

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

@@ -0,0 +1,123 @@
+import { Signal, WritableSignal } from '@angular/core';
+/**
+ * A read-only array signal with non-mutating methods.
+ */
+export interface ArraySignal<T> extends Signal<T[]> {
+    /**
+     * A computed signal that returns `true` if the array is empty.
+     */
+    readonly isEmpty: Signal<boolean>;
+}
+/**
+ * A writable array signal with mutating and non-mutating methods.
+ */
+export interface WritableArraySignal<T> extends WritableSignal<T[]>, ArraySignal<T> {
+    /**
+     * Returns a read-only version of the array signal.
+     */
+    asReadonly(): ArraySignal<T>;
+    /**
+     * Fills all the elements of the array signal from a start index to an end index with a static value.
+     * @param value - The value to fill the array with.
+     * @param start - The start index (inclusive). Defaults to 0.
+     * @param end - The end index (exclusive). Defaults to array length.
+     */
+    fill(value: T, start?: number, end?: number): void;
+    /**
+     * Filters the array based on a predicate function and updates the signal with the filtered result.
+     * @param predicate - Function to test each element of the array.
+     */
+    filter(predicate: (value: T, index: number, array: T[]) => boolean): void;
+    /**
+     * Applies a mapping function to each element in the array and updates the signal with the result.
+     * @param mapFn - Function that produces an element of the new array.
+     */
+    map(mapFn: (value: T, index: number, array: T[]) => T): void;
+    /**
+     * Removes the last element from the array and returns it.
+     * Updates the signal.
+     * @returns The removed element, or undefined if the array was empty.
+     */
+    pop(): T | undefined;
+    /**
+     * Appends new elements to the end of the array and returns the new length.
+     * Updates the signal.
+     * @param items - The elements to add.
+     * @returns The new length of the array.
+     */
+    push(...items: T[]): number;
+    /**
+     * Reverses the order of the elements in the array and updates the signal.
+     */
+    reverse(): void;
+    /**
+     * Replaces the entire array with a new array value.
+     * @param value - The new array value.
+     */
+    set(value: T[]): void;
+    /**
+     * Replaces the item at the given index with the new item.
+     * @param index - The index where the item should be replaced.
+     * @param newItem - The new item to be set at the given index.
+     */
+    setAt(index: number, newItem: T): void;
+    /**
+     * Removes the first element from the array and returns it.
+     * Updates the signal.
+     * @returns The removed element, or undefined if the array was empty.
+     */
+    shift(): T | undefined;
+    /**
+     * Sorts the elements of the array in place and updates the signal.
+     * @param compareFn - Specifies a function that defines the sort order.
+     */
+    sort(compareFn?: (a: T, b: T) => number): void;
+    /**
+     * Changes the contents of the array by removing or replacing existing elements and/or adding new elements.
+     * Updates the signal.
+     * @param start - The index at which to start changing the array.
+     * @param deleteCount - The number of elements to remove.
+     * @param items - Elements to add to the array.
+     * @returns An array containing the deleted elements.
+     */
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    /**
+     * Adds one or more elements to the beginning of the array and returns the new length.
+     * Updates the signal.
+     * @param items - The elements to add.
+     * @returns The new length of the array.
+     */
+    unshift(...items: T[]): number;
+    /**
+     * Updates the array signal based on a provided update function.
+     * @param updateFn - A function that receives the current array and returns the updated array.
+     */
+    update(updateFn: (value: T[]) => T[]): void;
+    /**
+     * Updates the item at the given index by applying the update function.
+     * @param index - The index where the item should be updated.
+     * @param updateFn - The function that will update the current item at the given index.
+     */
+    updateAt(index: number, updateFn: (current: T) => T): void;
+}
+/**
+ * Creates a writable, reactive array signal with convenient, immutable array manipulation methods.
+ *
+ * This helper returns a signal that wraps an array and exposes a full suite of mutating and non-mutating array methods,
+ * all of which will automatically trigger Angular reactivity.
+ *
+ * All mutator methods (such as `push`, `pop`, `splice`, `setAt`, `updateAt`, etc) return a new array value, preserving
+ * immutability for optimal signal reactivity. Do not depend on reference equality between updates.
+ *
+ * @template T The type of items stored in the array.
+ * @param {T[]} [initialValue=[]] Optional initial value for the array.
+ * @returns {WritableArraySignal<T>} A writable array signal with both native and array-specific helpers.
+ *
+ * @example
+ * const numbers = arraySignal([1, 2, 3]);
+ * numbers.push(4);          // [1, 2, 3, 4]
+ * numbers.pop();            // returns 4, numbers() === [1, 2, 3]
+ * numbers.setAt(1, 99);     // [1, 99, 3]
+ * numbers.filter(x => x>1); // [99, 3]
+ */
+export declare function arraySignal<T>(initialValue?: T[]): WritableArraySignal<T>;

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

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

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

@@ -0,0 +1,67 @@
+import { Signal, WritableSignal } from '@angular/core';
+/**
+ * A read-only counter signal with computed helpers.
+ */
+export interface CounterSignal extends Signal<number> {
+    /**
+     * Returns true if the counter's value was not changed after resetting.
+     */
+    readonly isReset: Signal<boolean>;
+    /**
+     * Returns the current counter value (alias for signal()).
+     */
+    value(): number;
+}
+/**
+ * A writable counter signal with mutation helpers and computed queries.
+ */
+export interface WritableCounterSignal extends WritableSignal<number>, CounterSignal {
+    /**
+     * Returns a read-only version of the counter signal.
+     */
+    asReadonly(): CounterSignal;
+    /**
+     * Increments the counter by a specified value (default: 1).
+     * @param amount The value to increment by. Default is 1.
+     */
+    increment(amount?: number): void;
+    /**
+     * Decrements the counter by a specified value (default: 1).
+     * @param amount The value to decrement by. Default is 1.
+     */
+    decrement(amount?: number): void;
+    /**
+     * Sets the counter to a specific value.
+     * @param value The value to set the counter to.
+     */
+    set(value: number): void;
+    /**
+     * Updates the counter using an updater function.
+     * @param updater A function that receives the current value and returns the new value.
+     */
+    update(updater: (current: number) => number): void;
+    /**
+     * Resets the counter to its base (initial) value.
+     *
+     * Base value is the initial value by default, and can be changed using {@link setBaseValue}.
+     */
+    reset(): void;
+    /**
+     * Sets the base value to be used when resetting the counter.
+     */
+    setBaseValue(value: number): void;
+}
+/**
+ * Creates a writable, reactive counter signal with convenient helpers and computed queries.
+ *
+ * @param {number} [initial=0] The initial value of the counter.
+ * @returns {WritableCounterSignal} A writable counter signal instance.
+ *
+ * @example
+ * const count = counterSignal(10);
+ * count.inc();     // 11
+ * count.dec(2);    // 9
+ * count.reset();   // 10
+ * count.isReset(); // true
+ */
+export declare function counterSignal(initial?: number): WritableCounterSignal;

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

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

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

@@ -0,0 +1,15 @@
+import { WritableSignal } from '@angular/core';
+/**
+ * A DebouncedSignal interface that extends WritableSignal<T> and includes debouncing behavior.
+ */
+export interface DebouncedSignal<T> extends WritableSignal<T> {
+    readonly debounceTime: number;
+}
+/**
+ * Creates a `WritableSignal` that delays updates to its value until there's a pause in updates, based on the debounce time specified.
+ *
+ * @param initialValue - The initial value of the signal.
+ * @param debounceTime - The delay in milliseconds after the last update before applying the signal update.
+ * @returns A `WritableSignal<T>` that debounces value updates based on the specified debounce time.
+ */
+export declare function debouncedSignal<T>(initialValue: T, debounceTime: number): DebouncedSignal<T>;

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

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

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

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

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

@@ -0,0 +1,97 @@
+import { Signal, WritableSignal } from '@angular/core';
+/**
+ * A read-only map signal with non-mutating methods.
+ */
+export interface MapSignal<K, V> extends Signal<Map<K, V>> {
+    /**
+     * Computed signal that returns `true` if the map is empty.
+     */
+    readonly isEmpty: Signal<boolean>;
+    /**
+     * Computed signal for map size.
+     */
+    readonly size: Signal<number>;
+    /**
+     * Gets the value for a key, or undefined.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Checks if a key exists in the map.
+     */
+    has(key: K): boolean;
+    /**
+     * Computed signal that returns an array of [key, value] entries.
+     */
+    readonly entriesArray: Signal<[K, V][]>;
+    /**
+     * Computed signal that returns an array of keys.
+     */
+    readonly keysArray: Signal<K[]>;
+    /**
+     * Computed signal that returns an array of values.
+     */
+    readonly valuesArray: Signal<V[]>;
+}
+/**
+ * A writable map signal with mutating and non-mutating methods.
+ */
+export interface WritableMapSignal<K, V> extends WritableSignal<Map<K, V>>, MapSignal<K, V> {
+    /**
+     * Returns a read-only version of the map signal.
+     */
+    asReadonly(): MapSignal<K, V>;
+    /**
+     * Sets a value for the key.
+     */
+    setKey(key: K, value: V): void;
+    /**
+     * Deletes a key from the map.
+     * Returns true if a value was removed.
+     */
+    delete(key: K): boolean;
+    /**
+     * Clears the map.
+     */
+    clear(): void;
+    /**
+     * Replaces the map with a new map.
+     */
+    setMap(value: Map<K, V>): void;
+    /**
+     * Replaces the map with a new map. Alias of the method `setMap()`.
+     */
+    set(value: Map<K, V>): void;
+    /**
+     * Updates the map using an update function.
+     */
+    update(updateFn: (current: Map<K, V>) => Map<K, V>): void;
+    /**
+     * Updates the value for a key using the provided update function if the key exists.
+     */
+    updateAt(key: K, updateFn: (current: V) => V): void;
+}
+/**
+ * Creates a writable, reactive Map signal with full Map-like API and helpers.
+ *
+ * This factory returns a signal wrapping a JavaScript `Map`, exposing both non-mutating and mutating methods
+ * for convenient and fully reactive manipulation of key-value pairs.
+ *
+ * All mutator methods (`setKey`, `delete`, `clear`, `setMap`, etc.) always replace the Map with a cloned version,
+ * ensuring immutability for predictable reactivity.
+ *
+ * The signal also provides computed signals for common queries (such as `isEmpty`, `size`, `entriesArray`, `keysArray`, `valuesArray`),
+ * and offers a type-safe, readonly view via `.asReadonly()`.
+ *
+ * @template K The type of keys.
+ * @template V The type of values.
+ * @param {Iterable<[K, V]>} [initialValue=[]] Optional initial map contents, as entries or another Map.
+ * @returns {WritableMapSignal<K, V>} A writable Map signal instance with both native and Map-specific helpers.
+ *
+ * @example
+ * const map = mapSignal<string, number>([['a', 1], ['b', 2]]);
+ * map.setKey('c', 3);        // Adds key 'c'
+ * map.delete('a');           // Removes key 'a'
+ * map.update(m => { m.set('d', 4); return m; });
+ * map.entriesArray();        // [['b', 2], ['c', 3], ['d', 4]]
+ */
+export declare function mapSignal<K, V>(initialValue?: Iterable<[K, V]>): WritableMapSignal<K, V>;

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

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

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

@@ -0,0 +1,106 @@
+import { Signal, WritableSignal } from '@angular/core';
+export interface PersistentSignalNonNullable<T> extends Signal<T> {
+    readonly method: PersistentStorageMethod;
+    readonly key: string;
+    readonly serialized: Signal<string | null>;
+}
+export interface PersistentSignal<T> extends PersistentSignalNonNullable<T | null> {
+}
+/**
+ * A `PersistentSignal` is a specialized type of `WritableSignal` that automatically persists its value using a specified storage method (localStorage, sessionStorage, or cookies). It extends the standard `WritableSignal` interface by including additional properties to define the persistence mechanism and key used for storage. The `PersistentSignal` ensures that any changes to its value are saved to the chosen storage method, and it initializes its value from storage if available when created.
+ */
+export interface WritablePersistentSignalNonNullable<T> extends WritableSignal<T>, PersistentSignalNonNullable<T> {
+    asReadonly(): PersistentSignalNonNullable<T>;
+}
+export interface WritablePersistentSignal<T> extends WritablePersistentSignalNonNullable<T | null> {
+    clear(): void;
+    asReadonly(): PersistentSignal<T>;
+}
+/**
+ * Defines the available persistent storage methods for the `persistentSignal`. Each method corresponds to a different browser storage mechanism:
+ * - `PersistentStorageMethod.LocalStorage`: Uses the browser's localStorage to persist the value across sessions.
+ * - `PersistentStorageMethod.SessionStorage`: Uses the browser's sessionStorage to persist the value for the duration of the page session.
+ * - `PersistentStorageMethod.Cookies`: Uses browser cookies to persist the value, allowing for additional options like expiration and path.
+ */
+export declare const PersistentStorageMethod: {
+    readonly Cookies: "cookies";
+    readonly LocalStorage: "local-storage";
+    readonly SessionStorage: "session-storage";
+};
+/**
+ * Defines the available persistent storage methods for the `persistentSignal`. Each method corresponds to a different browser storage mechanism:
+ * - `PersistentStorageMethod.LocalStorage`: Uses the browser's localStorage to persist the value across sessions.
+ * - `PersistentStorageMethod.SessionStorage`: Uses the browser's sessionStorage to persist the value for the duration of the page session.
+ * - `PersistentStorageMethod.Cookies`: Uses browser cookies to persist the value, allowing for additional options like expiration and path.
+ */
+export type PersistentStorageMethod = (typeof PersistentStorageMethod)[keyof typeof PersistentStorageMethod];
+interface _PersistentSignalOptionsBase<T> {
+    /**
+     * The persistent storage method to use for storing the signal value. Options include:
+     * - `PersistentStorageMethod.LocalStorage`: Uses the browser's localStorage to persist the value across sessions.
+     * - `PersistentStorageMethod.SessionStorage`: Uses the browser's sessionStorage to persist the value for the duration of the page session.
+     * - `PersistentStorageMethod.Cookies`: Uses browser cookies to persist the value, allowing for additional options like expiration and path.
+     */
+    method: PersistentStorageMethod;
+    /**
+     * Cookie-specific option: Defines the expiration date of the cookie. Can be a `Date` object or a string in UTC format. If not specified, the cookie will be a session cookie and will expire when the browser is closed.
+     */
+    expires?: Date | string;
+    /**
+     * Cookie-specific option: Defines the maximum age of the cookie in seconds. If both `expires` and `maxAge` are specified, `maxAge` takes precedence. If not specified, the cookie will be a session cookie and will expire when the browser is closed.
+     */
+    maxAge?: number;
+    /**
+     * Cookie-specific option: Defines the path for which the cookie is valid. Defaults to `'/'`, making the cookie accessible across the entire site. If set to a specific path, the cookie will only be sent to the server for requests matching that path.
+     */
+    path?: string;
+    /**
+     * Optional serialization function to convert the signal value into a string for storage. This is required if the signal value is not a string or if you want to customize the serialization format. The function should return a string representation of the value, or `null` if the value is `null`.
+     * @param value The value to serialize, which can be of type `T` or `null`.
+     * @returns A string representation of the value for storage, or `null` if the value is `null`.
+     */
+    serialize?: (value: T | null) => string | null;
+    /**
+     * Optional deserialization function to convert the stored string value back into the original type `T`. This is required if a custom `serialize` function is provided, or if the initial value is not a string and serialization options are not defined. The function should return the deserialized value of type `T`, or `null` if the input value is `null`.
+     * @param value The string value retrieved from storage that needs to be deserialized back into the original type `T`. This function is required if a custom `serialize` function is provided, or if the initial value is not a string and serialization options are not defined. The function should return the deserialized value of type `T`, or `null` if the input value is `null`.
+     * @returns The deserialized value of type `T`, or `null` if the input value is `null`.
+     */
+    deserialize?: (value: string) => T | null;
+    /**
+     * If true, creates a non-nullable persistent signal interface.
+     */
+    nonNullable?: boolean;
+}
+interface _PersistentSignalOptionsDeprecated<T> extends _PersistentSignalOptionsBase<T> {
+    /**
+     * @deprecated Use `key` instead. The name/key used to store the signal value in the chosen storage method.
+     */
+    name: string;
+}
+interface _PersistentSignalOptions<T> extends _PersistentSignalOptionsBase<T> {
+    /**
+     * The name/key used to store the signal value in the chosen storage method.
+     */
+    key: string;
+}
+/**
+ * Options for persisting the signal value.
+ */
+export type PersistentSignalOptions<T> = _PersistentSignalOptionsDeprecated<T> | _PersistentSignalOptions<T>;
+/**
+ * Creates a `WritableSignal` that persists its value using the specified storage method,
+ * with custom serialization and deserialization.
+ *
+ * @param initialValue - The initial value of the signal if no stored value is found.
+ * @param options - An object containing the storage method and custom serialization/deserialization functions.
+ * @param options.name - The key used to store the signal value.
+ * @param options.method - The persistent storage method (localStorage, sessionStorage, or cookies).
+ * @param options.serialize - A function to serialize the value into a string for storage.
+ * @param options.deserialize - A function to deserialize the stored string value back into the original type.
+ * @returns A `WritableSignal<T>` that persists its value using the specified storage method.
+ */
+export declare function persistentSignal<T>(initialValue: T, options: PersistentSignalOptions<T> & {
+    nonNullable: true;
+}): WritablePersistentSignalNonNullable<T>;
+export declare function persistentSignal<T>(initialValue: T | null, options: PersistentSignalOptions<T>): WritablePersistentSignal<T>;
+export {};

package/lib/signals/query-param/index.d.ts

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

package/lib/signals/query-param/query-param-signal.d.ts

@@ -0,0 +1,35 @@
+import { Signal, WritableSignal } from '@angular/core';
+export interface QueryParamSignalNonNullable<T> extends Signal<T> {
+    readonly paramName: string;
+    readonly serialized: Signal<string | null>;
+}
+export interface QueryParamSignal<T> extends QueryParamSignalNonNullable<T | null> {
+}
+export interface WritableQueryParamSignalNonNullable<T> extends WritableSignal<T>, QueryParamSignalNonNullable<T> {
+    asReadonly(): QueryParamSignalNonNullable<T>;
+}
+export interface WritableQueryParamSignal<T> extends WritableQueryParamSignalNonNullable<T | null>, QueryParamSignal<T> {
+    clear(): void;
+    asReadonly(): QueryParamSignal<T>;
+}
+export interface QueryParamSignalOptions<T> {
+    paramName: string;
+    serialize?: (value: T | null) => string | null;
+    deserialize?: (value: string) => T | null;
+    nonNullable?: boolean;
+}
+/**
+ * Creates a `WritableSignal` that persists its value in a URL query parameter with both serialization and deserialization.
+ *
+ * @param initialValue - The initial value of the signal if no value is found in the query param.
+ * @param options - An object containing the query parameter name, and custom serialization/deserialization functions.
+ * @param options.paramName - The name of the query parameter used to store the signal value.
+ * @param options.serialize - A function to serialize the value into a string for the query parameter.
+ * @param options.deserialize - A function to deserialize the value from a string back to the original type.
+ * @param options.nonNullable - If true, returns a non-nullable signal interface.
+ * @returns A `WritableSignal<T | null>` that persists its value using the specified query parameter.
+ */
+export declare function queryParamSignal<T>(initialValue: T, options: QueryParamSignalOptions<T> & {
+    nonNullable: true;
+}): WritableQueryParamSignalNonNullable<T>;
+export declare function queryParamSignal<T>(initialValue: T | null, optionsOrParam: string | QueryParamSignalOptions<T>): WritableQueryParamSignal<T>;

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

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