valtio/vanilla.d.ts

🧙 Valtio makes proxy-state simple for React and Vanilla

type AnyFunction = (...args: any[]) => any;
type ProxyObject = object;
type Path = (string | symbol)[];
type Op = [op: 'set', path: Path, value: unknown, prevValue: unknown] | [op: 'delete', path: Path, prevValue: unknown];
type Listener = (op: Op, nextVersion: number) => void;
export type INTERNAL_Op = Op;
type Primitive = string | number | boolean | null | undefined | symbol | bigint;
type SnapshotIgnore = Date | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Error | RegExp | AnyFunction | Primitive;
export type Snapshot<T> = T extends {
    $$valtioSnapshot: infer S;
} ? S : T extends SnapshotIgnore ? T : T extends object ? {
    readonly [K in keyof T]: Snapshot<T[K]>;
} : T;
type RemoveListener = () => void;
type AddListener = (listener: Listener) => RemoveListener;
type ProxyState = readonly [
    target: object,
    ensureVersion: (nextCheckVersion?: number) => number,
    addListener: AddListener
];
declare const canProxyDefault: (x: unknown) => boolean;
declare const createSnapshotDefault: <T extends object>(target: T, version: number) => T;
declare const createHandlerDefault: <T extends object>(isInitializing: () => boolean, addPropListener: (prop: string | symbol, propValue: unknown) => void, removePropListener: (prop: string | symbol) => void, notifyUpdate: (op: Op) => void) => ProxyHandler<T>;
declare const proxyStateMap: WeakMap<ProxyObject, ProxyState>;
declare const refSet: WeakSet<object>;
declare const snapCache: WeakMap<object, [version: number, snap: unknown]>;
declare const versionHolder: [number, number];
declare const proxyCache: WeakMap<object, ProxyObject>;
declare let objectIs: (a: unknown, b: unknown) => boolean;
declare let newProxy: <T extends object>(target: T, handler: ProxyHandler<T>) => T;
declare let canProxy: typeof canProxyDefault;
declare let createSnapshot: typeof createSnapshotDefault;
declare let createHandler: typeof createHandlerDefault;
export declare function proxy<T extends object>(baseObject?: T): T;
export declare function getVersion(proxyObject: unknown): number | undefined;
export declare function subscribe<T extends object>(proxyObject: T, callback: (unstable_ops: Op[]) => void, notifyInSync?: boolean): () => void;
export declare function snapshot<T extends object>(proxyObject: T): Snapshot<T>;
export declare function ref<T extends object>(obj: T): T & {
    $$valtioSnapshot: T;
};
export declare function unstable_getInternalStates(): {
    proxyStateMap: typeof proxyStateMap;
    refSet: typeof refSet;
    snapCache: typeof snapCache;
    versionHolder: typeof versionHolder;
    proxyCache: typeof proxyCache;
};
export declare function unstable_replaceInternalFunction(name: 'objectIs', fn: (prev: typeof objectIs) => typeof objectIs): void;
export declare function unstable_replaceInternalFunction(name: 'newProxy', fn: (prev: typeof newProxy) => typeof newProxy): void;
export declare function unstable_replaceInternalFunction(name: 'canProxy', fn: (prev: typeof canProxy) => typeof canProxy): void;
export declare function unstable_replaceInternalFunction(name: 'createSnapshot', fn: (prev: typeof createSnapshot) => typeof createSnapshot): void;
export declare function unstable_replaceInternalFunction(name: 'createHandler', fn: (prev: typeof createHandler) => typeof createHandler): void;
export {};