react-mtquery/dist/utils.d.ts

FOR REACT HOOK QUERIES and HOOKS HELPER

export declare enum MQUERY_STATUS {
    LOADING = 1,
    LOADED = 2,
    ERROR = 3
}
interface MTConfig {
    duration: number;
    type: 'flatten' | 'audit' | 'debounce' | 'batch' | 'interval';
}
export declare function flattenSequencer(duration: number): () => MTConfig;
export declare function auditSequencer(duration: number): () => MTConfig;
export declare function debounceSequencer(duration: number): () => MTConfig;
export declare function batchSequencer(duration: number): () => MTConfig;
export declare function intervalSequencer(duration: number): () => MTConfig;
export declare function waitFor(defaultValue?: number): {
    wait: (duration?: number) => Promise<Boolean>;
    kill: () => void;
};
export declare const useWaitFor: (defaultValue?: number) => {
    wait: (duration?: number) => Promise<Boolean>;
    kill: () => void;
};
export declare function useMFu(): {
    time: number;
    update: () => void;
};
export declare function useMState<X>(defaultValue?: X): {
    value: X;
    time: number;
    setValue: (nv: X | ((pre: X) => X)) => void;
    reset: () => void;
};
export declare function useQState<X>(defaultValue?: X, delay?: number): {
    value: X;
    time: number;
    setValue: (nv: X | ((pre: X) => X)) => void;
    reset: () => void;
};
export declare function useMVar<X>(value?: X): {
    value: X;
    setValue: (nv: X | ((pre: X) => X)) => void;
};
export interface MTimeShiftStatus {
    pending: boolean;
    running: boolean;
    completed: boolean;
    stopped: boolean;
}
type MTimeShiftStatusListen = (value: MTimeShiftStatus) => void;
type MTimeShiftTimeListen = (value: number) => void;
export declare const useMTimeShift: () => {
    timems: number;
    timesec: number;
    timemin: number;
    pending: boolean;
    running: boolean;
    completed: boolean;
    stopped: boolean;
    start: (sec: number, type?: "up" | "down") => void;
    stop: () => void;
    pause: () => void;
    play: () => void;
    addStatusListener: (cb: MTimeShiftStatusListen) => () => void;
    addTimeListener: (cb: MTimeShiftTimeListen) => () => void;
};
type MFSKey = string | number;
type MFSPutFun<X> = X | ((pre: X | null) => X);
type MFSKeyExt = ((value: any, index: number) => MFSKey) | string;
type MFSValAcc<X> = (value: any, index: number) => X;
export declare function useMFSVar<X>(value?: any): Readonly<{
    time: number;
    items: X[];
    put: (key: MFSKey, value: MFSPutFun<X>) => boolean;
    get: (key: MFSKey) => X;
    rm: (key: MFSKey) => boolean;
    clr: () => boolean;
    size: () => number;
    keys: () => string[];
    values: () => X[];
    exist: (key: MFSKey) => boolean;
    item: (value: X) => boolean;
    key: (value: X) => string;
    fromArr: (arr: any[], keyExt: MFSKeyExt, valExt?: MFSValAcc<X>) => void;
}>;
export declare function useMFS<X>(value?: any): Readonly<{
    time: number;
    items: X[];
    put: (key: MFSKey, value: MFSPutFun<X>) => boolean;
    get: (key: MFSKey) => X;
    rm: (key: MFSKey) => boolean;
    clr: () => boolean;
    size: () => number;
    keys: () => string[];
    values: () => X[];
    exist: (key: MFSKey) => boolean;
    item: (value: X) => boolean;
    key: (value: X) => string;
    fromArr: (arr: any[], keyExt: MFSKeyExt, valExt?: MFSValAcc<X>) => void;
}>;
export declare function useQFS<X>(value?: any): Readonly<{
    time: number;
    items: X[];
    put: (key: MFSKey, value: MFSPutFun<X>) => boolean;
    get: (key: MFSKey) => X;
    rm: (key: MFSKey) => boolean;
    clr: () => boolean;
    size: () => number;
    keys: () => string[];
    values: () => X[];
    exist: (key: MFSKey) => boolean;
    item: (value: X) => boolean;
    key: (value: X) => string;
    fromArr: (arr: any[], keyExt: MFSKeyExt, valExt?: MFSValAcc<X>) => void;
}>;
export declare function useMEffect(deep: {
    [key: string]: null | undefined | number | boolean | string | Array<any> | Object;
} | Array<any>, cb: () => void): void;
export declare function useMLayout(deep: {
    [key: string]: null | undefined | number | boolean | string | Array<any> | Object;
} | Array<any>, cb: () => void): void;
export declare function useMCalc<T>(deep: {
    [key: string]: null | undefined | number | boolean | string | Array<any> | Object;
} | Array<any>, cb: () => T): T;
export declare function useQCalc<T>(deep: {
    [key: string]: null | undefined | number | boolean | string | Array<any> | Object;
} | Array<any>, cb: () => T, delay?: number): {
    running: boolean;
    value?: T;
    time: number;
};
export declare function useMRun<T>(deep: {
    [key: string]: null | undefined | number | boolean | string | Array<any> | Object;
} | Array<any>, cb: () => T | Promise<T>, delay?: number): {
    running: boolean;
    time: number;
};
interface SAlp {
    [key: string]: null | undefined | number | boolean | string | Array<any> | Object;
}
export declare function useMSearch<T extends any[], K extends SAlp>(deep: K, items: T, delay: number, onSearch: (params: K, items: T) => T): {
    value: T;
    update: number;
    isSearching: boolean;
};
declare class MLoader<B> {
    private _loading;
    private _loaded;
    private _error;
    private _lmp;
    private _final;
    private loader;
    constructor(cb: (_loading: () => void, _loaded: (data: B) => void, _error: (error: any) => void, _lmp: (data: B) => B, _final: () => void) => void);
    loading(loading: () => void): this;
    loaded(loaded: (data: B) => void): this;
    error(error: (error: any) => void): this;
    lmp(lmp: (data: B) => B): this;
    final(final: () => void): this;
    go(): void;
}
export interface MQueryReturn<T> {
    status: MQUERY_STATUS;
    data: T;
    loading: boolean;
    loaded: boolean;
    error: boolean;
}
export declare function useMQuery<T extends any[], B extends any>(func: (...args: T) => Promise<B>, defaultValue?: B, amd?: (data: B) => B): Readonly<{
    updateTime: number;
    loadTime: number;
    status: MQUERY_STATUS;
    data: B;
    loading: boolean;
    loaded: boolean;
    error: any;
    load: (...args: T) => MLoader<B>;
    loadPromise: (...args: T) => Promise<B>;
    reload: () => MLoader<B>;
    reloadPromise: () => Promise<B>;
    loadHidden: (...args: T) => MLoader<B>;
    reloadHidden: () => MLoader<B>;
    reset: () => void;
    setLoading: () => void;
    setLoaded: (data?: B) => void;
    setError: (error?: any) => void;
    setValue: (nv: B | ((value: B) => B)) => void;
}>;
declare class MRtLoader<T extends any[], B extends unknown> {
    private _loading;
    private _loaded;
    private _error;
    private _lmp;
    private _final;
    private loader;
    constructor(cb: (_loading: () => void, _loaded: (data: B) => void, _error: (error: any) => void, _lmp: (data: B) => B, _final: () => void, ...params: T) => void);
    loading(loading: () => void): this;
    loaded(loaded: (data: B) => void): this;
    error(error: (error: any) => void): this;
    lmp(lmp: (data: B) => B): this;
    final(final: () => void): this;
    go(...params: T): void;
}
export interface MQueryRtReturn<T> {
    status: MQUERY_STATUS;
    data: T;
    loading: boolean;
    loaded: boolean;
    error: boolean;
}
export declare function useMRQuery<T>(defaultvalue?: T): Readonly<{
    updateTime: number;
    loadTime: number;
    status: MQUERY_STATUS;
    data: any;
    loading: boolean;
    loaded: boolean;
    error: any;
    setValue: (nv?: T | ((value: T) => T)) => void;
    load: <T_1 extends any[], B extends unknown>(func: (...params: T_1) => B | Promise<B>) => MRtLoader<T_1, B>;
    loadHidden: <T_2 extends any[], B_1 extends unknown>(func: (...params: T_2) => B_1 | Promise<B_1>) => MRtLoader<T_2, B_1>;
}>;
declare class Seq<PR, R> {
    _head: Seq<any, any>;
    _parent: Seq<any, any>;
    private _loading;
    private _loaded;
    private _error;
    private _func;
    constructor(head: Seq<any, any>);
    parent(parent: Seq<any, any>): void;
    func(func: (preV: PR) => Promise<R> | R): this;
    loading(loading: () => void): this;
    loaded(loaded: (data: R) => void): this;
    error(error: (error: any) => void): this;
    next(): Seqhelp<R>;
    run(preV: PR): Promise<R>;
}
interface SeqReturnType<B> {
    loading: (loading: () => void) => SeqReturnType<B>;
    loaded: (loaded: (data: B) => void) => SeqReturnType<B>;
    error: (error: (error: any) => void) => SeqReturnType<B>;
    next: () => Seqhelp<B>;
}
declare class Seqhelp<P extends unknown> {
    private _head;
    private _parent;
    constructor(head?: Seq<any, any>, parent?: Seq<any, any>);
    private run;
    go(): Promise<any>;
    add<B>(func: (preV: P) => Promise<B> | B): SeqReturnType<B>;
}
export declare function useMSQuery<T>(defaultvalue?: T): Readonly<{
    updateTime: number;
    loadTime: number;
    data: T;
    status: MQUERY_STATUS;
    loading: boolean;
    loaded: boolean;
    error: any;
    setValue: (nv?: T | ((value: T) => T)) => void;
    new: () => Seqhelp<any>;
    load: () => Seqhelp<any>;
    go: () => Promise<void>;
    goHidden: () => Promise<void>;
}>;
export declare function allSettled<T>(promises: Promise<unknown>[]): Promise<({
    status: "fulfilled";
    value: T;
} | {
    status: "rejected";
    reason: any;
})[]>;
export declare enum UPLOAD_STATUS {
    READY = "READY",
    WAITING = "WAITING",
    SENDING = "SENDING",
    UPLOADED = "UPLOADED",
    ERROR = "ERROR",
    CANCELED = "CANCELED",
    COMPLETED = "COMPLETED",
    PAUSED = "PAUSED"
}
declare class MtFile {
    _file: File;
    _id: string;
    _path: string;
    _name: string;
    _size: number;
    _type: string;
    _mb: number;
    _kb: number;
    _time: number;
    constructor(file: File);
    static new(file: File, name?: string): MtFile;
    info(): {
        id: string;
        name: string;
        size: number;
        type: string;
        path: string;
        kb: number;
        mb: number;
        time: number;
    };
}
export declare class FileUplader {
    private upload;
    private listen;
    constructor();
    static new(): FileUplader;
    get status(): UPLOAD_STATUS;
    get percent(): number;
    preview(): string;
    info(): {
        id: string;
        name: string;
        size: number;
        type: string;
        path: string;
        kb: number;
        mb: number;
        time: number;
    };
    file(file: File, name?: string): FileUplader;
    url(url: string): FileUplader;
    header(headers?: Record<string, any>): FileUplader;
    idle(percent: number, status: number): FileUplader;
    listener(): {
        status: (cb: (status: UPLOAD_STATUS) => void) => () => void;
        percent: (cb: (percent: number) => void) => () => void;
        next: () => FileUplader;
    };
    start(): FileUplader | null | string | boolean;
    stop(): FileUplader | null | string | boolean;
}
export declare const upHelper: {
    byW3i: (input: string) => File;
    byName: (name: string) => File;
    byElement: (el: HTMLElement) => File;
    fileInfo: (file: File) => MtFile;
};
export declare function useFileUplader(): FileUplader;
export declare function safePromise<R, E = Error>(callback: Promise<R>): Promise<[R, null] | [null, E]>;
export {};