@vegajs/vortex/dist/core/reactive/reactive.d.ts

🌀 A next-gen, lightweight state management library for JavaScript and TypeScript.

import type { Mutation, MutationOptions, MutationState, Query, QueryData, QueryOptions } from '../../types';
import { type RetryOptions } from '../../utils';
export declare class Effect<T = unknown> {
    fn: () => T;
    private stopFn;
    constructor(fn: () => T);
    run(): T;
    start(): T;
    stop(): void;
}
export declare class Reactive<T = unknown> {
    currentValue: T;
    type: string;
    private signal;
    private setter;
    constructor(currentValue: T);
    get value(): T;
    set value(value: T);
    subscribe(callback: (value: T) => void): () => void;
}
export declare class Computed<T = unknown> {
    getter: () => T;
    type: string;
    private computed;
    constructor(getter: () => T);
    get value(): T;
    subscribe(callback: (value: T) => void): () => void;
}
export declare class QueryHandler<Data, TError = unknown, TOptions = void> implements Query<Data, TError, TOptions> {
    #private;
    private readonly asyncFn;
    private readonly options?;
    type: "$$query";
    private pollingTimer;
    private unifiedPromise?;
    constructor(asyncFn: (options: TOptions) => Promise<Data>, options?: (QueryOptions<Data, TError> & {
        retry?: RetryOptions;
    }) | undefined);
    get value(): QueryData<Data, TError>;
    set value(value: QueryData<Data, TError>);
    subscribe: (callback: (value: QueryData<Data, TError>) => void) => () => void;
    run: (runOptions: TOptions) => Promise<Data>;
    reset: () => void;
    update: (value: Data | ((value: Data | undefined) => Data)) => void;
    refetch: () => Promise<Data>;
    startPolling(interval: number, immediately?: boolean): void;
    stopPolling(): void;
    private setLoading;
    private setSuccess;
    private setError;
}
export declare class MutationHandler<Data, TError = unknown, TOptions = void> implements Mutation<Data, TError, TOptions> {
    #private;
    private readonly asyncFn;
    private readonly options?;
    type: "$$mutation";
    constructor(asyncFn: (options: TOptions) => Promise<Data>, options?: MutationOptions<Data, TError, TOptions> | undefined);
    get state(): MutationState<TError>;
    get value(): MutationState<TError>;
    subscribe: (callback: (value: MutationState<TError>) => void) => () => void;
    runSync: (options: TOptions) => void;
    runAsync: (options: TOptions) => Promise<Data | undefined>;
    reset: () => void;
    private setLoading;
    private setSuccess;
    private setError;
}
type UnknownReactivity = object | unknown[];
declare class DeepReactive<T = unknown | UnknownReactivity> {
    readonly type = "$$reactive";
    private reactive;
    private reactiveCache;
    constructor(initialValue: T);
    private makeReactive;
    private isPrimitive;
    private defineReactiveObject;
    private makeReactiveProperty;
    private update;
    get value(): T;
    set value(newValue: T);
    subscribe(callback: (value: T) => void): () => void;
}
/**
 * Creates a computed reactive value that updates when dependencies change.
 * @template T
 * @param {() => T} getter - Function that computes the value.
 * @returns {Computed<T>} A computed reactive value.
 */
export declare function computed<T>(getter: () => T): Computed<T>;
/**
 * Batches multiple state updates to optimize reactivity processing.
 * @param {() => void} cb - Callback function containing batched updates.
 */
export declare function batch(cb: () => void): void;
/**
 * Creates a reactive state container.
 * @template T
 * @param {T} [oldValue] - Initial value for the reactive state.
 * @returns {Reactive<T | undefined>} A reactive object.
 */
export declare function reactive<T>(): Reactive<T | undefined>;
export declare function reactive<T>(oldValue: T): Reactive<T>;
/**
 * Runs an effect function that reacts to changes in reactive dependencies.
 * @template T
 * @param {() => T} fn - Effect function that runs reactively.
 * @returns {() => void} A function to stop the effect.
 */
export declare function effect<T>(fn: () => T): () => void;
export declare function deepReactive<T>(): DeepReactive<T | undefined>;
export declare function deepReactive<T>(oldValue: T): DeepReactive<T>;
/**
 * Creates a reactive query that fetches data asynchronously and tracks its state.
 * @template Data
 * @template TError
 * @template TOptions
 * @param {(options: TOptions) => Promise<Data>} asyncFn - Async function that fetches data.
 * @param {QueryOptions<Data, TError> & { retry?: RetryOptions }} [options] - Query options.
 * @returns {QueryHandler<Data, TError, TOptions>} A reactive query handler.
 */
export declare function query<Data, TError = unknown, TOptions = void>(asyncFn: (options: TOptions) => Promise<Data>, options?: QueryOptions<Data, TError> & {
    retry?: RetryOptions;
}): QueryHandler<Data, TError, TOptions>;
/**
 * Creates a reactive mutation handler for managing async state changes.
 * @template Data
 * @template TError
 * @template TOptions
 * @param {(options: TOptions) => Promise<Data>} asyncFn - Async function that performs the mutation.
 * @param {MutationOptions<Data, TError, TOptions>} [options] - Mutation options.
 * @returns {MutationHandler<Data, TError, TOptions>} A reactive mutation handler.
 */
export declare function mutation<Data, TError = unknown, TOptions = void>(asyncFn: (options: TOptions) => Promise<Data>, options?: MutationOptions<Data, TError, TOptions>): MutationHandler<Data, TError, TOptions>;
export {};