storestack/lib/index.d.ts

Simple store solution

declare global {
    interface Window {
        stores: StoreStack;
    }
}
export interface Observer<T> {
    update(subject: Store<T>): void;
}
export interface Subject<T> {
    readonly state: T;
    attach(observer: Observer<T>): void;
    detach(observer: Observer<T>): void;
    notify(): void;
    set(options: T): void;
    set(options: (prevState: T) => T): void;
}
export declare type Pointer = string;
export declare type AnyStore = Store<any>;
export declare class DuplicateObserverError extends Error {
    constructor();
}
export declare class UnknownObserverError extends Error {
    constructor();
}
export declare class MemoryAllocationError extends Error {
    constructor();
}
export declare class NullPointerError extends Error {
    constructor();
}
export declare class Store<T> implements Subject<T> {
    #private;
    get state(): T;
    get prevState(): T | null;
    static newPointer(): string;
    constructor(state: T);
    attach(observer: Observer<T>, skipOnExist?: boolean): void;
    detach(observer: Observer<T>): void;
    notify(): void;
    set(options: T | ((prevState: T) => T)): void;
}
export interface StoreOptions<T> {
    pointer?: Pointer;
    onChange?: (state: T) => void;
    observers?: Observer<T>[];
    override?: boolean;
    errorHandling?: StoreOptionsErrorHandling;
}
export interface StoreOptionsErrorHandling {
    verbose?: boolean;
    stopOnError?: boolean;
}
export declare function useStore<T>(state: T, options?: StoreOptions<T>): Pointer;
export declare class StoreObserver<T> implements Observer<T> {
    #private;
    constructor(callback: (currentState: T, previousState?: T | null) => void);
    update(subject: Store<T>): void;
}
export declare function useObserver<T = unknown>(callback: (currentState: T, prevState?: T | null) => void): StoreObserver<T>;
declare type SetterFunction<T = any> = (prevState: T) => T;
export declare class StoreStack {
    #private;
    static configure(): void;
    static attach<T>(globalObservers?: Observer<T>[]): StoreStack;
    private constructor();
    addGlobalObserver<T>(...globalObservers: Observer<T>[]): void;
    addStore(newItem: AnyStore): Pointer;
    addStoreAtPointer(newItem: AnyStore, pointer: Pointer, options?: {
        override?: boolean;
        verbose?: boolean;
    }): void;
    upsert<T>(defaultValue: T, pointer: Pointer, ...observers: Observer<T>[]): void;
    removeStore(ptr: Pointer, options?: {
        verbose?: boolean;
    }): void;
    get<T = any>(ptr: Pointer): Store<T> | undefined;
    useState<T = any>({ pointer, defaultValue, observers, useGlobalObserver, }: {
        pointer: Pointer;
        defaultValue: T;
        observers?: Observer<T>[];
        useGlobalObserver?: boolean;
    }): [() => T, (newState: T | SetterFunction<T>) => void];
}
export declare const Stores: StoreStack;
export {};