@tempots/dom 33.1.1 → 34.1.0

package/std/disposal-scope.d.ts

@@ -1,97 +0,0 @@
-import { AnySignal, Computed, ListenerOptions, Prop } from './signal';
-import { Value } from './value';
-import { ValueTypes } from '../types/domain';
-/**
- * A DisposalScope tracks signals created during its lifetime and disposes them when the scope ends.
- * This enables automatic signal disposal without manual OnDispose() calls.
- *
- * @public
- */
-export declare class DisposalScope {
-    private _signals;
-    private _callbacks;
-    private _disposed;
-    /**
-     * Register a signal with this scope for automatic disposal.
-     *
-     * @param signal - The signal to track
-     * @throws Error if the scope has already been disposed
-     * @throws Error if the signal has already been disposed
-     * @public
-     */
-    track(signal: AnySignal): void;
-    /**
-     * Register a disposal callback to be called when this scope is disposed.
-     * Callbacks are called before signals are disposed.
-     * Use this for cleanup that doesn't need the `removeTree` parameter.
-     *
-     * @param callback - The callback to call on disposal
-     * @throws Error if the scope has already been disposed
-     * @public
-     */
-    onDispose(callback: () => void): void;
-    /**
-     * Dispose all signals tracked by this scope.
-     * This method is idempotent - calling it multiple times is safe.
-     *
-     * @public
-     */
-    dispose(): void;
-    /**
-     * Check if this scope has been disposed.
-     *
-     * @returns true if the scope has been disposed
-     * @public
-     */
-    get disposed(): boolean;
-    /**
-     * Creates a prop signal and tracks it in this scope.
-     * Use this method in async contexts where automatic tracking doesn't work.
-     *
-     * @param value - The initial value
-     * @param equals - Optional equality function
-     * @returns A tracked Prop signal
-     * @public
-     */
-    prop<T>(value: T, equals?: (a: T, b: T) => boolean): Prop<T>;
-    /**
-     * Creates a computed signal and tracks it in this scope.
-     * Use this method in async contexts where automatic tracking doesn't work.
-     *
-     * @param fn - The computation function
-     * @param dependencies - Array of signals this computed depends on
-     * @param equals - Optional equality function
-     * @returns A tracked Computed signal
-     * @public
-     */
-    computed<T>(fn: () => T, dependencies: Array<AnySignal>, equals?: (a: T, b: T) => boolean): Computed<T>;
-    /**
-     * Creates an effect and tracks it in this scope.
-     * Use this method in async contexts where automatic tracking doesn't work.
-     *
-     * @param fn - The effect function
-     * @param signals - Array of signals to listen to
-     * @param options - Optional listener options
-     * @returns A clear function (the effect itself is tracked in the scope)
-     * @public
-     */
-    effect(fn: () => void, signals: Array<AnySignal>, options?: ListenerOptions): () => void;
-    /**
-     * Creates a computed signal with curried signature and tracks it in this scope.
-     * Use this method in async contexts where automatic tracking doesn't work.
-     *
-     * @param args - Values or signals to compute from
-     * @returns A function that takes the computation function and returns a tracked Computed signal
-     * @public
-     */
-    computedOf<T extends Value<unknown>[]>(...args: T): <O>(fn: (...args: ValueTypes<T>) => O, equals?: (a: O, b: O) => boolean) => Computed<O>;
-    /**
-     * Creates an effect with curried signature and tracks it in this scope.
-     * Use this method in async contexts where automatic tracking doesn't work.
-     *
-     * @param args - Values or signals to listen to
-     * @returns A function that takes the effect function and returns a clear function
-     * @public
-     */
-    effectOf<T extends Value<unknown>[]>(...args: T): (fn: (...args: ValueTypes<T>) => void, options?: ListenerOptions) => (() => void);
-}

package/std/element-position.d.ts

@@ -1,64 +0,0 @@
-import { Signal } from './signal';
-/**
- * Represents the position of an element in a collection.
- *
- * @public
- */
-export declare class ElementPosition {
-    #private;
-    /**
-     * The index of the element.
-     */
-    readonly index: number;
-    /**
-     * The total number of elements in the collection.
-     */
-    readonly total: Signal<number>;
-    /**
-     * The counter of the element starting from 1.
-     */
-    readonly counter: number;
-    /**
-     * Checks if the element is the first element in the collection.
-     * @returns `true` if the element is the first element, `false` otherwise.
-     */
-    readonly isFirst: boolean;
-    /**
-     * Checks if the counter of the element is even.
-     * @returns `true` if the counter is even, `false` otherwise.
-     */
-    readonly isEven: boolean;
-    /**
-     * Checks if the counter of the element is odd.
-     * @returns `true` if the counter is odd, `false` otherwise.
-     */
-    readonly isOdd: boolean;
-    /**
-     * Creates a new instance of `ElementPosition`.
-     * @param index - The index of the element.
-     * @param total - The total number of elements in the collection.
-     */
-    constructor(
-    /**
-     * The index of the element.
-     */
-    index: number, 
-    /**
-     * The total number of elements in the collection.
-     */
-    total: Signal<number>);
-    /**
-     * Checks if the element is the last element in the collection.
-     * @returns `true` if the element is the last element, `false` otherwise.
-     */
-    get isLast(): Signal<boolean>;
-    /**
-     * Disposes the internal signal created by `isLast`.
-     *
-     * **Note:** With automatic signal disposal, this method is now a no-op when used within
-     * a disposal scope (e.g., inside a renderable). The signal created by `isLast` is
-     * automatically tracked and disposed when the scope ends. This method is kept for
-     * backward compatibility and for cases where ElementPosition is used outside a scope.
-     */
-    readonly dispose: () => void;
-}

package/std/interpolate.d.ts

@@ -1,56 +0,0 @@
-/**
- * Represents a function that interpolates between two values.
- *
- * @typeParam T - The type of the values being interpolated.
- * @param start - The starting value.
- * @param end - The ending value.
- * @param delta - The interpolation factor between 0 and 1.
- * @returns The interpolated value.
- * @public
- */
-export type Interpolate<T> = (start: T, end: T, delta: number) => T;
-/**
- * Interpolates a number between a start and end value based on a delta.
- *
- * @param start - The starting value.
- * @param end - The ending value.
- * @param delta - The delta value between 0 and 1.
- * @returns The interpolated number.
- * @public
- */
-export declare const interpolateNumber: Interpolate<number>;
-/**
- * Interpolates between two strings based on a delta value.
- *
- * @param start - The starting string.
- * @param end - The ending string.
- * @param delta - The delta value between 0 and 1.
- * @returns The interpolated string.
- * @public
- */
-export declare const interpolateString: Interpolate<string>;
-/**
- * Interpolates between two dates based on a delta value.
- *
- * @param start - The starting date.
- * @param end - The ending date.
- * @param delta - The delta value between 0 and 1.
- * @returns The interpolated date.
- * @public
- */
-export declare const interpolateDate: Interpolate<Date>;
-/**
- * A fake interpolate function that always returns the end value.
- *
- * @public
- */
-export declare const endInterpolate: <T>(_start: T, end: T) => T;
-/**
- * Returns an interpolation function based on the type of the value.
- *
- * @typeParam T - The type of the value.
- * @param value - The value to be interpolated.
- * @returns An interpolation function that takes a start value, an end value, and a delta, and returns an interpolated value.
- * @public
- */
-export declare const guessInterpolate: <T>(value: T) => Interpolate<T>;

package/std/scope-stack.d.ts

@@ -1,76 +0,0 @@
-import { DisposalScope } from './disposal-scope';
-/**
- * Global scope stack for tracking active disposal scopes.
- * The last element in the array is the current scope.
- *
- * @internal
- */
-export declare const scopeStack: DisposalScope[];
-/**
- * Push a scope onto the stack, making it the current scope.
- *
- * @param scope - The scope to push
- * @internal
- */
-export declare const pushScope: (scope: DisposalScope) => void;
-/**
- * Pop the current scope from the stack.
- *
- * @throws Error if the stack is empty
- * @internal
- */
-export declare const popScope: () => void;
-/**
- * Get the current active scope.
- *
- * @returns The current scope, or null if no scope is active
- * @public
- */
-export declare const getCurrentScope: () => DisposalScope | null;
-/**
- * Get the full scope stack.
- * Useful for debugging scope hierarchy.
- *
- * @advanced Most users don't need this. Use getCurrentScope() instead.
- * @returns Read-only array of active scopes
- * @public
- */
-export declare const getScopeStack: () => readonly DisposalScope[];
-/**
- * Get the parent scope of the current scope.
- *
- * @advanced Most users don't need this. Accessing parent scopes can lead to
- * unexpected behavior. Only use this for debugging or advanced use cases.
- * @returns The parent scope or null if no parent exists
- * @public
- */
-export declare const getParentScope: () => DisposalScope | null;
-/**
- * Execute a function within a scope context.
- * The scope is pushed before the function executes and popped after.
- * The scope is NOT disposed - the caller is responsible for disposal.
- *
- * @param scope - The scope to use
- * @param fn - The function to execute
- * @returns The result of the function
- * @public
- */
-export declare const withScope: <T>(scope: DisposalScope, fn: () => T) => T;
-/**
- * Execute a function in a new scope and dispose the scope immediately after.
- * Useful for one-off scoped operations.
- *
- * @param fn - The function to execute, receives the scope as parameter
- * @returns The result of the function
- * @public
- */
-export declare const scoped: <T>(fn: (scope: DisposalScope) => T) => T;
-/**
- * Execute a function without any scope tracking.
- * Signals created inside will NOT be automatically tracked.
- *
- * @param fn - The function to execute
- * @returns The result of the function
- * @public
- */
-export declare const untracked: <T>(fn: () => T) => T;

package/std/signal-utils.d.ts

@@ -1,301 +0,0 @@
-import { ValueType, RemoveSignals, Values } from '../types/domain';
-import { AnySignal, Computed, Prop, Signal } from './signal';
-import { Value } from './value';
-/**
- * Represents a memory store that stores key-value pairs.
- *
- * @public
- */
-export declare class MemoryStore {
-    private readonly _store;
-    /**
-     * Retrieves the value associated with the specified key from the memory store.
-     * @param key - The key to retrieve the value for.
-     * @returns The value associated with the key, or `null` if the key is not found.
-     */
-    readonly getItem: (key: string) => string | null;
-    /**
-     * Sets the value associated with the specified key in the memory store.
-     * @param key - The key to set the value for.
-     * @param value - The value to set.
-     */
-    readonly setItem: (key: string, value: string) => void;
-}
-/**
- * Represents the properties required for storing and retrieving a value of type `T`.
- *
- * @typeParam T - The type of the value to be stored.
- * @public
- */
-export type StoredPropOptions<T> = {
-    /**
-     * The key to use for storing and retrieving the value.
-     * Can be a static string or a reactive signal that changes over time.
-     */
-    key: Value<string>;
-    /**
-     * The default value to use if the value is not found in the store.
-     * This can be a value of type `T` or a function that returns a value of type `T`.
-     * If a function is provided, it will be called to get the default value.
-     */
-    defaultValue: T | (() => T);
-    /**
-     * The store to use for storing and retrieving the value.
-     */
-    store: {
-        /**
-         * Retrieves the value associated with the specified key from the store.
-         * @param key - The key to retrieve the value for.
-         * @returns The value associated with the key, or `null` if the key is not found.
-         */
-        getItem: (key: string) => string | null;
-        /**
-         * Sets the value associated with the specified key in the store.
-         * @param key - The key to set the value for.
-         * @param value - The value to set.
-         */
-        setItem: (key: string, value: string) => void;
-    };
-    /**
-     * A function that serializes a value of type `T` to a string.
-     * The default implementation uses `JSON.stringify`.
-     */
-    serialize?: (v: T) => string;
-    /**
-     * A function that deserializes a string to a value of type `T`.
-     * The default implementation uses `JSON.parse`.
-     */
-    deserialize?: (v: string) => T;
-    /**
-     * A function that compares two values of type `T` for equality.
-     * The default implementation uses strict equality (`===`).
-     */
-    equals?: (a: T, b: T) => boolean;
-    /**
-     * A function that is called when a value is loaded from the store.
-     * The default implementation returns the value as is.
-     */
-    onLoad?: (value: T) => T;
-    /**
-     * Whether to sync the value across tabs. Defaults to `true`.
-     */
-    syncTabs?: boolean;
-    /**
-     * Strategy for handling key changes when using a reactive key.
-     * - 'load' (default): Load value from new key, the current state is already stored at this point
-     * - 'migrate': Move current value to new key and continue with current value
-     * - 'keep': Keep current value without loading from new key
-     */
-    onKeyChange?: 'load' | 'migrate' | 'keep';
-};
-/**
- * Creates a stored property that persists its value in a storage mechanism.
- *
- * @typeParam T - The type of the property value.
- * @param options - The options for creating the stored property.
- * @returns - The created stored property.
- * @public
- */
-export declare const storedProp: <T>({ key, defaultValue, store, serialize, deserialize, equals, onLoad, syncTabs, onKeyChange, }: StoredPropOptions<T>) => Prop<T>;
-/**
- * Represents the properties required for storing and retrieving a value of type `T`.
- *
- * @typeParam T - The type of the value to be stored.
- * @public
- */
-export type StorageOptions<T> = {
-    /**
-     * The key to use for storing and retrieving the value.
-     * Can be a static string or a reactive signal that changes over time.
-     */
-    key: Value<string>;
-    /**
-     * The default value to use if the value is not found in the store.
-     * This can be a value of type `T` or a function that returns a value of type `T`.
-     * If a function is provided, it will be called to get the default value.
-     */
-    defaultValue: T | (() => T);
-    /**
-     * A function that serializes a value of type `T` to a string.
-     * The default implementation uses `JSON.stringify`.
-     */
-    serialize?: (v: T) => string;
-    /**
-     * A function that deserializes a string to a value of type `T`.
-     * The default implementation uses `JSON.parse`.
-     */
-    deserialize?: (v: string) => T;
-    /**
-     * A function that compares two values of type `T` for equality.
-     * The default implementation uses strict equality (`===`).
-     */
-    equals?: (a: T, b: T) => boolean;
-    /**
-     * A function that is called when a value is loaded from the store.
-     * The default implementation returns the value as is.
-     */
-    onLoad?: (value: T) => T;
-    /**
-     * Whether to sync the value across tabs. Defaults to `true`.
-     */
-    syncTabs?: boolean;
-    /**
-     * Strategy for handling key changes when using a reactive key.
-     * - 'load' (default): Load value from new key, the current state is already stored at this point
-     * - 'migrate': Move current value to new key and continue with current value
-     * - 'keep': Keep current value without loading from new key
-     */
-    onKeyChange?: 'load' | 'migrate' | 'keep';
-};
-/**
- * Creates a prop that is backed by the localStorage or a MemoryStore.
- *
- * @param options - The options for creating the prop.
- * @returns The created prop.
- * @public
- */
-export declare const localStorageProp: <T>(options: StorageOptions<T>) => Prop<T>;
-/**
- * Creates a prop that stores its value in the session storage.
- *
- * @param options - The options for the storage prop.
- * @returns A prop that stores its value in the session storage.
- * @public
- */
-export declare const sessionStorageProp: <T>(options: StorageOptions<T>) => Prop<T>;
-/**
- * Options for animating signals.
- *
- * @typeParam T - The type of the signal values.
- * @public
- */
-export type AnimateSignalsOptions<T> = {
-    /**
-     * The function that interpolates between two values.
-     */
-    interpolate?: (start: T, end: T, delta: number) => T;
-    /**
-     * The duration of the animation in milliseconds.
-     */
-    duration?: Value<number>;
-    /**
-     * The easing function for the animation.
-     */
-    easing?: (t: number) => number;
-    /**
-     * The function that compares two values for equality.
-     */
-    equals?: (a: T, b: T) => boolean;
-};
-/**
- * Animates signals based on the provided options.
- *
- * @typeParam T - The type of the animated value.
- * @param initialValue - The initial value of the animation.
- * @param fn - A function that returns the end value of the animation.
- * @param dependencies - An array of signals that the animation depends on.
- * @param options - Optional options for the animation.
- * @returns - The animated value as Prop<T>
- * @public
- */
-export declare const animateSignals: <T>(initialValue: T, fn: () => T, dependencies: Array<AnySignal>, options?: AnimateSignalsOptions<T>) => Prop<T>;
-/**
- * Represents the configuration options for animating a signal.
- *
- * @typeParam T - The type of the signal value.
- * @public
- */
-export type AnimateSignal<T> = {
-    /**
-     * The initial value for the animation. If not provided, the current value of the input signal will be used.
-     */
-    initialValue?: T;
-    /**
-     * The interpolation function to use for calculating intermediate values during the animation.
-     */
-    interpolate?: (start: T, end: T, delta: number) => T;
-    /**
-     * The duration of the animation in milliseconds.
-     */
-    duration?: number;
-    /**
-     * The easing function to use for controlling the animation progress.
-     */
-    easing?: (t: number) => number;
-    /**
-     * The equality function to use for comparing signal values.
-     */
-    equals?: (a: T, b: T) => boolean;
-};
-/**
- * Animates a signal by creating a new signal that transitions from an initial value to the current value of the input signal.
- *
- * @typeParam T - The type of the signal value.
- * @param signal - The input signal to animate.
- * @param options - The animation options.
- * @returns - The animated signal.
- * @public
- */
-export declare const animateSignal: <T>(signal: Signal<T>, options?: AnimateSignal<T>) => Prop<T>;
-/**
- * Computes a value based on a record of signals and literals.
- *
- * @typeParam T - The type of the record containing signals and literals.
- * @typeParam O - The type of the computed value.
- * @param record - The record containing signals and literals.
- * @param fn - The function to compute the value based on the literals.
- * @returns - The computed value as a signal.
- * @public
- */
-export declare const computedRecord: <T extends Record<string, Value<unknown>>, O>(record: T, fn: (value: RemoveSignals<T>) => O) => Computed<O>;
-/**
- * Merges a record of signals and literals into a single signal.
- *
- * @typeParam T - The type of the record containing signals and literals.
- * @param options - The record containing signals and literals.
- * @returns - The merged signal.
- * @public
- */
-export declare const merge: <T extends Record<string, Value<unknown>>>(options: T) => Signal<{ [K in keyof T]: ValueType<T[K]>; }>;
-/**
- * Delays the value of a signal by a specified amount of time.
- *
- * @typeParam T - The type of the signal value.
- * @param signal - The signal to delay.
- * @param ms - The amount of time to delay the signal in milliseconds.
- * @returns - The delayed signal.
- * @public
- */
-export declare const delaySignal: <T>(signal: Signal<T>, ms: number | ((value: T) => number)) => Signal<T>;
-/**
- * Creates a signal that emits the previous value of the input signal.
- *
- * @typeParam T - The type of the signal value.
- * @param signal - The input signal.
- * @returns - The signal that emits the previous value of the input signal.
- * @public
- */
-export declare const previousSignal: <T>(signal: Signal<T>) => Signal<T | undefined>;
-/**
- * Creates a signal that emits a sliding window of values from the input signal.
- *
- * @typeParam T - The type of the signal value.
- * @param options - The options for the sliding window.
- * @returns - The signal that emits the sliding window of values.
- * @public
- */
-export declare const slidingWindowSignal: <T>({ size, signal, }: {
-    size: number | undefined;
-    signal: Signal<T>;
-}) => Computed<T[]>;
-/**
- * Binds a function or signal of a function to a set of signals and literals.
- *
- * @typeParam FN - The type of the function to bind.
- * @typeParam R - The return type of the function.
- * @param fn - The function to bind.
- * @returns - A function that takes a set of signals and literals and returns a computed signal.
- * @public
- */
-export declare const bind: <FN extends (...args: any[]) => R, R = ReturnType<FN>>(fn: Value<FN>) => (...args: Values<Parameters<FN>>) => Computed<R>;
-export declare function coalesce<L>(...args: readonly [...unknown[], L]): Computed<ValueType<L>>;