storken/dist/index.d.ts

🚀 5KB LLM-native state management for React 18+ with TypeScript, universal API, and plugin system

import { Dispatch, SetStateAction } from 'react';

type StorkenKey = string | symbol;
type StorkenArgs = unknown[];
type StorkenPlugin<T = any> = (storken: IStorken<T>, ...config: unknown[]) => unknown;
type StorkenPlugins = {
    [key: string]: StorkenPlugin | [StorkenPlugin, ...unknown[]];
};
type StorkenGetter<T = any> = (storken: IStorken<T>, ...args: unknown[]) => T | Promise<T>;
type StorkenSetter<T = any> = (storken: IStorken<T>, value: T, ...args: unknown[]) => void | Promise<void> | T | Promise<T>;
type StorkenGetters = {
    [key: StorkenKey]: StorkenGetter;
};
type StorkenSetters = {
    [key: StorkenKey]: StorkenSetter;
};
interface StorkenOptions<T = any> {
    key: StorkenKey;
    args?: StorkenArgs;
    plugins?: StorkenPlugins;
    initialValue?: T;
    namespace?: string;
    getter?: StorkenGetter<T>;
    setter?: StorkenSetter<T>;
    disableGetterOnLoading?: boolean;
    disableSetterOnGetter?: boolean;
    disableAutoGetter?: boolean;
    getOnce?: boolean;
    setWithSetter?: boolean;
    loading?: boolean;
    getOnlyOnMount?: boolean;
}
interface StorkenConfig<T = unknown> {
    plugins?: StorkenPlugins;
    getters?: StorkenGetters;
    setters?: StorkenSetters;
    options?: Partial<StorkenOptions<T>>;
    storkenOptions?: {
        [key: StorkenKey]: Partial<StorkenOptions<T>>;
    };
    initialValues?: {
        [key: StorkenKey]: T;
    };
}
type StorkenHookReturn<T = unknown> = [
    value: T,
    setValue: (value: T | ((prev: T) => T), options?: {
        disableSetter?: boolean;
        force?: boolean;
    }) => Promise<void>,
    reset: () => Promise<void>,
    loading: boolean,
    update: (...args: unknown[]) => Promise<T | undefined>,
    plugins?: Record<string, unknown>
] & {
    value: T;
    set: (value: T | ((prev: T) => T), options?: {
        disableSetter?: boolean;
        force?: boolean;
    }) => Promise<void>;
    reset: () => Promise<void>;
    loading: boolean;
    update: (...args: unknown[]) => Promise<T | undefined>;
    plugins?: Record<string, unknown>;
};
type ReactState<T> = [T, Dispatch<SetStateAction<T>>];
type StorkenEventListener = (...args: unknown[]) => void | Promise<void>;
type StorkenEventListeners = {
    [eventName: string]: StorkenEventListener[];
};
interface IStorken<T = unknown> {
    id: number;
    key: StorkenKey;
    opts: StorkenOptions<T>;
    args: StorkenArgs;
    value: T;
    Store: ISky;
    namespace: string;
    listeners: Dispatch<SetStateAction<T>>[];
    loadingListeners: Dispatch<SetStateAction<boolean>>[];
    eventListeners?: StorkenEventListeners;
    plugins?: Record<string, unknown>;
    loading?: boolean;
    getted?: boolean;
    on(name: string, func: StorkenEventListener): void;
    dispatchEvent(name: string, ...args: unknown[]): Promise<void>;
    loadPlugins(returnPack: unknown[]): Record<string, unknown> | undefined;
    setFromGetter(...args: unknown[]): Promise<T | undefined>;
    update(...args: unknown[]): Promise<T | undefined>;
    set(value: T | ((prev: T) => T), options?: {
        disableSetter?: boolean;
        force?: boolean;
    }): Promise<void>;
    reset(): Promise<void>;
    listen(state: ReactState<T>, loadingState: ReactState<boolean>, args: StorkenArgs): () => void;
    updateListeners(value: T): void;
    updateLoadingListeners(loading: boolean): void;
    load(loading: boolean): Promise<boolean>;
}
interface ISky {
    bundles: Record<StorkenKey, IStorken<any>>;
    config: StorkenConfig;
    create<T = any>(key: StorkenKey, ...args: StorkenArgs): IStorken<T>;
    get<T = any>(key: StorkenKey, args?: StorkenArgs, obj?: boolean): T | IStorken<T>;
    getStorken<T = any>(key: StorkenKey, ...args: StorkenArgs): IStorken<T>;
    getPlugin<T = any>(key: StorkenKey, plugin: StorkenKey): unknown;
    set<T = any>(key: StorkenKey, value: T, ...args: StorkenArgs): void;
    remove(key: StorkenKey, reset?: boolean): Promise<void>;
    multiRemove(...keys: StorkenKey[]): Promise<void>;
    destroy(key: StorkenKey, value: unknown): Promise<void>;
    multiDestroy(...keyValPairs: Array<{
        key: StorkenKey;
        value: unknown;
    }>): Promise<void>;
    restore(dump: Record<StorkenKey, unknown>): void;
    dump(): Record<StorkenKey, unknown>;
}
type CreateReturn = readonly [
    useStorken: <T = unknown>(key: StorkenKey, ...args: StorkenArgs) => StorkenHookReturn<T>,
    get: <T = any>(key: StorkenKey, args?: StorkenArgs, obj?: boolean) => T | IStorken<T>,
    set: <T = any>(key: StorkenKey, value: T, ...args: StorkenArgs) => void,
    Sky: ISky
];
type TPlugin = StorkenPlugin;
type TKey = StorkenKey;
type TUseStorken = (key: StorkenKey, ...args: StorkenArgs) => StorkenHookReturn;

declare class Storken<T = unknown> implements IStorken<T> {
    readonly id: number;
    readonly key: StorkenKey;
    opts: StorkenOptions<T>;
    args: StorkenArgs;
    value: T;
    Store: ISky;
    namespace: string;
    listeners: Dispatch<SetStateAction<T>>[];
    loadingListeners: Dispatch<SetStateAction<boolean>>[];
    eventListeners?: StorkenEventListeners;
    plugins?: Record<string, unknown>;
    loading?: boolean;
    getted?: boolean;
    constructor(options: StorkenOptions<T>, Sky: ISky);
    on: (name: string, func: StorkenEventListener) => void;
    dispatchEvent: (name: string, ...args: unknown[]) => Promise<void>;
    loadPlugins: (returnPack?: unknown[]) => Record<string, unknown> | undefined;
    setFromGetter: (...args: unknown[]) => Promise<T | undefined>;
    update: (...args: unknown[]) => Promise<T | undefined>;
    listen: (state: ReactState<T>, loadingState: ReactState<boolean>, args: StorkenArgs) => (() => void);
    updateListeners: (val: T) => void;
    updateLoadingListeners: (val: boolean) => void;
    set: (newValue: T | ((prev: T) => T), opts?: {
        disableSetter?: boolean;
        force?: boolean;
    }) => Promise<void>;
    load: (loadingState: boolean | null) => Promise<boolean>;
    reset: () => Promise<void>;
}
declare class Sky implements ISky {
    readonly bundles: Record<StorkenKey, IStorken<any>>;
    readonly config: StorkenConfig;
    constructor(config?: StorkenConfig);
    create: <T = any>(key: StorkenKey, ...args: StorkenArgs) => IStorken<T>;
    get: <T = any>(key: StorkenKey, args?: StorkenArgs, obj?: boolean) => T | IStorken<T>;
    getStorken: <T = any>(key: StorkenKey, ...args: StorkenArgs) => IStorken<T>;
    getPlugin: <T = any>(key: StorkenKey, plugin: StorkenKey) => unknown;
    set: <T = any>(key: StorkenKey, value: T, ...args: StorkenArgs) => void;
    remove: (key: StorkenKey, reset?: boolean) => Promise<void>;
    multiRemove: (...keys: StorkenKey[]) => Promise<void>;
    destroy: (key: StorkenKey, value: unknown) => Promise<void>;
    multiDestroy: (...keyValPairs: Array<{
        key: StorkenKey;
        value: unknown;
    }>) => Promise<void>;
    restore: (dump: Record<StorkenKey, unknown>) => void;
    dump: () => Record<StorkenKey, unknown>;
}
declare const create: (storkenConfig?: StorkenConfig) => CreateReturn;

/**
 * Hook creator for Storken v3.0 with React 18 useSyncExternalStore support
 * @param Sky - Wrapper object which will be used to create and orchestrate for Storkens
 * @returns useStorken - Hook function with full type safety
 */
declare const createHook: (Sky: ISky) => <T = unknown>(key: StorkenKey, ...args: StorkenArgs) => StorkenHookReturn<T>;

export { type CreateReturn, type ISky, type IStorken, type ReactState, Sky, Storken, type StorkenArgs, type StorkenConfig, type StorkenEventListener, type StorkenEventListeners, type StorkenGetter, type StorkenGetters, type StorkenHookReturn, type StorkenKey, type StorkenOptions, type StorkenPlugin, type StorkenPlugins, type StorkenSetter, type StorkenSetters, type TKey, type TPlugin, type TUseStorken, create, createHook, create as default };