jotai-composer/dist/index.d.ts

Jotai enhancers for composing atoms

import * as jotai from 'jotai';
import { Atom, Getter, Setter, WritableAtom } from 'jotai';

/** @format */

type AtomEnhancerRead<TLastState extends object, TResult extends object = object> = (get: Getter, { last }: StateTracking<TLastState>) => TResult;
type AtomEnhancerWrite<TLastState extends object, TParameter extends object> = (get: Getter, set: Setter, update: TParameter, { last }: StateTracking<TLastState>) => Promise<{
    shouldAbortNextSetter?: boolean;
}> | {
    shouldAbortNextSetter?: boolean;
};
type DispatcherAction<T extends string = string, TPayload = unknown> = {
    type: T;
    payload?: TPayload;
};
type ComposableAtom<TState extends object = object, TParamter extends object = object> = WritableAtom<TState, [
    update: TParamter
], Promise<void | {
    shouldAbortNextSetter?: boolean;
} | {
    shouldAbortNextSetter?: boolean;
}>>;
type InferState<TAtom> = TAtom extends WritableAtom<infer TState, any, any> ? TState : never;
type InferParameter<TAtom> = TAtom extends WritableAtom<any, [update: infer TParamter], any> ? TParamter : never;
type StateTracking<TLastState> = {
    last: TLastState;
};
type ComposableAtomReaderWithLastState<TLastState extends object, TResult extends object = object> = (state: StateTracking<TLastState>) => TResult | Atom<TResult>;
type AtomHelpers = {
    get: Getter;
    set: Setter;
};
type ComposableAtomWriterWithLastState<TLastState extends object, TParameter extends object> = (param: {
    stateHelper: StateTracking<TLastState> & AtomHelpers;
    update: TParameter;
}) => Promise<{
    shouldAbortNextSetter?: boolean;
}> | {
    shouldAbortNextSetter?: boolean;
};
type AtomEnhancer<TLastState extends object, TParameter extends object, TResult extends object> = {
    read?: ComposableAtomReaderWithLastState<TLastState, TResult>;
    write?: ComposableAtomWriterWithLastState<TLastState, TParameter>;
};

declare const enhanceWith: <TLastState extends object, TParameterExtended extends object = never, TResult extends object = never>({ read, write, }: AtomEnhancer<TLastState, TParameterExtended, TResult>) => <TState extends TLastState, TParameter extends object = never>(lastAtom?: ComposableAtom<TState, TParameter>, fallbackAtom?: ComposableAtom<any, TParameter>) => jotai.WritableAtom<TState & TResult, [update: TParameterExtended | TParameter], Promise<void | {
    shouldAbortNextSetter?: boolean;
}>>;
type Enhancer<TLastState extends object = object, TParameterExtended extends object = object, TResult extends object = object> = ReturnType<typeof enhanceWith<TLastState, TParameterExtended, TResult>>;

declare function atomEnhancer<TLastState extends object, TParameter extends object, TResult extends object = object>(read: AtomEnhancerRead<TLastState, TResult>, write?: AtomEnhancerWrite<TLastState, TParameter>, fallbackEnhancer?: ReturnType<Enhancer<TLastState, TParameter, TResult>>): (last: ComposableAtom<TLastState, object> | undefined) => jotai.WritableAtom<TLastState & TResult, [update: object | TParameter], Promise<void | {
    shouldAbortNextSetter?: boolean;
}>>;

export { type AtomEnhancer, type AtomEnhancerRead, type AtomEnhancerWrite, type ComposableAtom, type DispatcherAction, type Enhancer, type InferParameter, type InferState, atomEnhancer, enhanceWith };