@hairy/react-lib 1.47.0 → 1.50.0

package/dist/index.d.ts

@@ -1,374 +0,0 @@
-import { AnyFn, BooleanLike, Deferred, PromiseFn, PromiseType } from '@hairy/utils';
-import * as react from 'react';
-import { JSX, ReactNode, PropsWithChildren, ReactElement, FC, ComponentClass, useCallback, useEffect, useInsertionEffect, useReducer, useRef, useState, DetailedHTMLProps, HTMLAttributes } from 'react';
-import * as valtio from 'valtio';
-
-type Value = string | boolean | undefined | null;
-type Mapping = Record<string, any>;
-interface ArgumentArray extends Array<Argument> {
-}
-interface ReadonlyArgumentArray extends ReadonlyArray<Argument> {
-}
-type Argument = Value | Mapping | ArgumentArray | ReadonlyArgumentArray;
-/**
- * A simple JavaScript utility for conditionally joining classNames together.
- */
-declare function cls(...args: ArgumentArray): string;
-declare namespace cls {
-    var parse: (arg: any) => string;
-    var append: (value: any, newClass: any) => any;
-}
-
-/**
- * @requires `Trigger` component to be mounted in the tree.
- *
- * @example
- * ```tsx
- * // Obtain externally
- * import { track } from '@hairy/lib-react'
- * const context = await track(() => useContext(YourContext))
- * console.log(context) // { ... }
- */
-declare function track<T extends AnyFn>(fn: T, ...args: Parameters<T>): Promise<ReturnType<T>>;
-
-type WrapperTag = keyof JSX.IntrinsicElements | Function;
-type WrapperProps<As extends keyof JSX.IntrinsicElements | React.FC | unknown> = {
-    /** @deprecated use `as` instead */
-    tag?: As;
-    as?: As;
-} & (As extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[As] : unknown) & (As extends React.FC<infer P> ? P : unknown);
-declare function wrapper(asChild: any, props: unknown, children?: React.ReactNode): react.ReactNode;
-
-type CaseProps<Kag> = WrapperProps<Kag> & {
-    cond?: BooleanLike;
-    children?: ReactNode;
-};
-declare function Case<Tag extends WrapperTag>(props: CaseProps<Tag>): ReactNode;
-
-type DefaultProps<Tag> = WrapperProps<Tag> & {
-    children?: ReactNode;
-};
-declare function Default<Tag extends WrapperTag>(props: DefaultProps<Tag>): ReactNode;
-
-type IfProps<Kag> = WrapperProps<Kag> & {
-    cond?: BooleanLike;
-    then?: ReactNode;
-    else?: ReactNode;
-    children?: ReactNode;
-};
-declare function If<K extends WrapperTag>(props: IfProps<K>): ReactNode;
-
-type ElseProps<Tag> = IfProps<Tag>;
-declare function Else<Tag extends WrapperTag>(props: ElseProps<Tag>): react.ReactNode;
-
-interface SwitchProps extends PropsWithChildren {
-    value?: BooleanLike;
-}
-declare function Switch(props: SwitchProps): ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
-
-type ThenProps<Tag> = IfProps<Tag>;
-declare function Then<Tag extends WrapperTag>(props: ThenProps<Tag>): react.ReactNode;
-
-type UnlessProps<Tag> = WrapperProps<Tag> & {
-    cond?: BooleanLike;
-    then?: ReactNode;
-    else?: ReactNode;
-    children?: ReactNode;
-};
-declare function Unless<Tag extends WrapperTag>(props: UnlessProps<Tag>): ReactNode;
-
-interface InjectComponent<P> {
-    component: FC<P> | ComponentClass<P>;
-    props?: P;
-}
-interface InjectorProps {
-    install: (FC<any> | InjectComponent<any> | ComponentClass<any>)[];
-    children?: ReactNode;
-}
-declare function Injector(props: InjectorProps): ReactNode;
-
-interface Exposer {
-    deferred: Deferred<any>;
-    args: any[];
-    fn: AnyFn;
-    id: number;
-}
-/**
- * @example
- * ```tsx
- * import { Trigger } from '@hairy/lib-react'
- *
- * // Use triggers to capture context
- * function App() {
- *  return (
- *   <YourContext.Provider>
- *    <Trigger />
- *   </YourContext.Provider>
- *  )
- * }
- *
- * // Obtain externally
- * import { track } from '@hairy/lib-react'
- * const context = await track(() => useContext(YourContext))
- * console.log(context) // { ... }
- * ```
- */
-declare function Trigger(): ReactNode[];
-declare namespace Trigger {
-    var id: number;
-    var tasks: Map<number, Exposer> & {
-        $$valtioSnapshot: Omit<Map<number, Exposer>, "clear" | "set" | "delete">;
-    };
-}
-
-declare const tryUseCallback: typeof useCallback;
-
-declare const tryUseEffect: typeof useEffect;
-
-declare const tryUseInsertionEffect: typeof useInsertionEffect;
-
-declare const tryUseReducer: typeof useReducer;
-
-declare const tryUseRef: typeof useRef;
-
-declare const tryUseState: typeof useState;
-
-declare function tryUseUpdate(): () => void;
-
-declare function useAsyncCallback<T extends PromiseFn>(fun: T): readonly [boolean, T, Error | undefined];
-
-type AsyncState<T> = {
-    loading: boolean;
-    error?: undefined;
-    value?: undefined;
-} | {
-    loading: true;
-    error?: Error | undefined;
-    value?: T;
-} | {
-    loading: false;
-    error: Error;
-    value?: undefined;
-} | {
-    loading: false;
-    error?: undefined;
-    value: T;
-};
-type StateFromFnReturningPromise<T extends PromiseFn = PromiseFn> = AsyncState<PromiseType<ReturnType<T>>>;
-declare type AsyncStateReturn<T extends PromiseFn = PromiseFn> = [
-    StateFromFnReturningPromise<T>,
-    T
-];
-
-type UseAsyncStateOptions<T extends AnyFn> = {
-    immediate?: boolean;
-    initial?: PromiseType<ReturnType<T>>;
-    deps?: any[];
-} | {
-    immediate?: boolean;
-    initial: PromiseType<ReturnType<T>>;
-    deps?: any[];
-};
-declare function useAsyncState<T extends PromiseFn>(fun: T, deps?: any[], options?: UseAsyncStateOptions<T>): AsyncStateReturn<T>;
-
-declare function useDebounce<T>(value: T, delay: number): T;
-
-interface EventBusListener<T = any> {
-    (event: T): void;
-}
-declare function useEventBus<T>(key: string): {
-    on: (listener: EventBusListener<T>) => void;
-    emit: (event?: T) => void;
-    off: (listener: EventBusListener) => void;
-};
-
-interface FetchResponseInterceptCallback {
-    (response: Response, init: RequestInit | undefined): Response | Promise<Response>;
-}
-interface FetchRequestInterceptCallback {
-    (fetch: typeof window.fetch, input: RequestInfo | URL, init?: RequestInit | undefined): Response | Promise<Response>;
-}
-declare function useFetchResponseIntercept(intercept: FetchResponseInterceptCallback): void;
-declare function useFetchRequestIntercept(intercept: FetchRequestInterceptCallback): void;
-
-declare function useMounted(): boolean;
-
-interface UseOffsetPaginationOptions {
-    total?: number;
-    page?: number;
-    pageSize?: number;
-    onChange?: (pagination: Pagination) => void;
-    onPageSizeChange?: (pagination: Pagination) => void;
-    onPageCountChange?: (pagination: Pagination) => void;
-}
-interface Pagination {
-    pageSizeChange: (limit: number) => void;
-    pageChange: (page: number) => void;
-    next: () => void;
-    prev: () => void;
-    page: number;
-    pageSize: number;
-    isFirstPage: boolean;
-    isLastPage: boolean;
-    pageCount: number;
-    total: number;
-}
-declare function useOffsetPagination(options: UseOffsetPaginationOptions): Pagination;
-
-declare function useUpdate(): () => void;
-
-interface UseWatchCallback<T = any> {
-    (value: T, oldValue: T): void;
-}
-interface UseWatchOptions {
-    immediate?: boolean;
-}
-declare function useWatch<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options?: UseWatchOptions): void;
-declare function useWatch<T>(source: T, callback: UseWatchCallback<T>, options?: UseWatchOptions): void;
-
-declare function useWhenever<T>(source: T, cb: UseWatchCallback<Exclude<T, null | undefined>>, options?: UseWatchOptions): void;
-
-interface PersistantOptions {
-    id: string;
-    storage?: Storage;
-    pick?: string[];
-}
-/**
- *
- * @deprecated please use `valtio-define`
- */
-declare function proxyWithPersistant<T extends object>(key: string, initialObject?: T, options?: Omit<PersistantOptions, 'key'>): T;
-declare function proxyWithPersistant<T extends object>(options: PersistantOptions, initialObject?: T): T;
-
-type Actions<S> = Record<string, (this: S, ...args: any) => any>;
-type Getters<S> = Record<string, (this: S) => any>;
-type ActionsOmitThisParameter<A extends Actions<any>> = {
-    [K in keyof A]: (...args: Parameters<A[K]>) => ReturnType<A[K]>;
-};
-interface Status {
-    finished: boolean;
-    loading: boolean;
-    error: Error | null;
-}
-type ActionsStatus<A extends Actions<any>> = Status & {
-    [K in keyof A]: Status;
-};
-type GettersReturnType<G extends Getters<any>> = {
-    [K in keyof G]: ReturnType<G[K]>;
-};
-interface StoreDefine<S extends object, A extends Actions<S>, G extends Getters<S>> {
-    state: (() => S) | S;
-    actions?: A;
-    getters?: G;
-}
-interface StoreOptions {
-    persist?: string | PersistantOptions;
-}
-interface StoreSignal<S, A extends Actions<S>, G extends Getters<S>> {
-    <T>(fn: (state: S & GettersReturnType<G>) => T): T;
-    status: <T>(fn: (status: ActionsStatus<A>) => T) => T;
-}
-interface StoreSubscribe<S, A extends Actions<S>, G extends Getters<S>> {
-    (listener: (state: S & GettersReturnType<G>) => void): () => void;
-    status: (listener: (status: ActionsStatus<A>) => void) => () => void;
-}
-interface StorePatch<S, G extends Getters<S>> {
-    (patch: Partial<S> | ((state: S & GettersReturnType<G>) => void)): void;
-}
-type Store<S, A extends Actions<S>, G extends Getters<S>> = {
-    $subscribe: StoreSubscribe<S, A, G>;
-    $patch: StorePatch<S, G>;
-    $state: S & GettersReturnType<G> & ActionsOmitThisParameter<A>;
-    $actions: ActionsOmitThisParameter<A>;
-    $getters: GettersReturnType<G>;
-    $status: ActionsStatus<A>;
-    $signal: StoreSignal<S, A, G>;
-} & ActionsOmitThisParameter<A>;
-
-/**
- * @description Define a store
- * @deprecated please use `valtio-define`
- * @example
- * ```tsx
- * const store = defineStore({
- *   state: () => ({ count: 0 }),
- *   actions: {
- *     increment() {
- *       this.count++
- *     },
- *   },
- * })
- *
- * store.increment()
- * console.log(store.$state.count) // 1
- *
- * function Component() {
- *   const store = useStore(store)
- *   return (
- *     <div>
- *       <button onClick={store.increment}>Increment</button>
- *       <div>{store.count}</div>
- *     </div>
- *   )
- * }
- *
- * ```
- */
-declare function defineStore<S extends object, A extends Actions<S>, G extends Getters<S>>(store: StoreDefine<S, A, G>, options?: StoreOptions): Store<S, A, G>;
-
-type StoreAsyncInitial<T extends AnyFn> = ReturnType<T> extends Promise<infer U> ? U : ReturnType<T>;
-interface StoreAsyncOptions<T extends AnyFn> {
-    initial?: StoreAsyncInitial<T>;
-    persist?: string | Omit<PersistantOptions, 'pick'> | undefined;
-    immediate?: boolean;
-}
-interface StoreAsyncInitialOptions<T extends AnyFn> extends StoreAsyncOptions<T> {
-    initial: StoreAsyncInitial<T>;
-}
-type StoreAsync<T extends AnyFn, Initial = StoreAsyncInitial<T> | undefined> = Store<{
-    value: Initial;
-    error: Error | null | undefined;
-    loading: boolean;
-    finished: boolean;
-}, {
-    refetch: (...args: Parameters<T>) => ReturnType<T>;
-    reset: (value?: StoreAsyncInitial<T>) => void;
-}, {}>;
-/**
- * @description Define a store async
- * @deprecated please use `valtio-define`
- * @example
- * ```tsx
- * const store = defineStoreAsync(
- *   () => fetch('https://api.example.com/data').then(response => response.json()),
- *   {
- *     initial: [],
- *     // data will be obtained immediately upon defining the store
- *     immediate: true,
- *   },
- * )
- * ```
- */
-declare function defineStoreAsync<T extends AnyFn>(fetch: T, options: StoreAsyncInitialOptions<T>): StoreAsync<T, StoreAsyncInitial<T>>;
-declare function defineStoreAsync<T extends AnyFn>(fetch: T, options?: StoreAsyncOptions<T>): StoreAsync<T>;
-/**
- * @deprecated
- * use defineStoreAsync instead
- */
-declare const defienAsyncStore: typeof defineStoreAsync;
-
-/**
- *
- * @deprecated please use `valtio-define`
- */
-declare function useStatus<S extends object, A extends Actions<S>, G extends Getters<S>>(store: Store<S, A, G>): valtio.Snapshot<ActionsStatus<A>>;
-
-/**
- *
- * @deprecated please use `valtio-define`
- */
-declare function useStore<S extends object, A extends Actions<S>, G extends Getters<S>>(store: Store<S, A, G>): valtio.Snapshot<S & GettersReturnType<G> & ActionsOmitThisParameter<A>>;
-
-type PropsWithDetailedHTML<T = HTMLDivElement> = DetailedHTMLProps<HTMLAttributes<T>, T>;
-
-export { type Argument, type ArgumentArray, Case, type CaseProps, Default, type DefaultProps, Else, type ElseProps, type EventBusListener, type Exposer, type FetchRequestInterceptCallback, type FetchResponseInterceptCallback, If, type IfProps, type InjectComponent, Injector, type InjectorProps, type Mapping, type Pagination, type PersistantOptions, type PropsWithDetailedHTML, type ReadonlyArgumentArray, type StoreAsync, type StoreAsyncInitial, type StoreAsyncInitialOptions, type StoreAsyncOptions, Switch, type SwitchProps, Then, type ThenProps, Trigger, Unless, type UnlessProps, type UseAsyncStateOptions, type UseOffsetPaginationOptions, type UseWatchCallback, type UseWatchOptions, type Value, type WrapperProps, type WrapperTag, cls, defienAsyncStore, defineStore, defineStoreAsync, proxyWithPersistant, track, tryUseCallback, tryUseEffect, tryUseInsertionEffect, tryUseReducer, tryUseRef, tryUseState, tryUseUpdate, useAsyncCallback, useAsyncState, useDebounce, useEventBus, useFetchRequestIntercept, useFetchResponseIntercept, useMounted, useOffsetPagination, useStatus, useStore, useUpdate, useWatch, useWhenever, wrapper };