@legendapp/state 3.0.0-alpha.1 → 3.0.0-alpha.3

package/react.d.ts

@@ -1,21 +1,157 @@
-export * from './src/react/Computed';
-export * from './src/react/For';
-export { usePauseProvider } from './src/react/usePauseProvider';
-export * from './src/react/Memo';
-export { Reactive, configureReactive } from './src/react/Reactive';
-export type { IReactive } from './src/react/Reactive';
-export * from './src/react/Show';
-export * from './src/react/Switch';
-export * from './src/react/reactInterfaces';
-export * from './src/react/reactive-observer';
-export * from './src/react/useComputed';
-export * from './src/react/useEffectOnce';
-export * from './src/react/useIsMounted';
-export * from './src/react/useMount';
-export * from './src/react/useObservable';
-export * from './src/react/useObservableReducer';
-export * from './src/react/useObserve';
-export * from './src/react/useObserveEffect';
-export * from './src/react/useSelector';
-export * from './src/react/useUnmount';
-export * from './src/react/useWhen';
+import * as react from 'react';
+import { ReactNode, ReactElement, FC, LegacyRef, ComponentClass, ReducerWithoutAction, ReducerStateWithoutAction, DispatchWithoutAction, Reducer, ReducerState, Dispatch, ReducerAction } from 'react';
+import { ObservableParam, Observable, ObservableBoolean, Selector, RecursiveValueOrFunction, ObserveEvent, ObserveOptions, ObserveEventCallback } from '@legendapp/state';
+
+declare function Computed({ children }: {
+    children: ObservableParam | (() => ReactNode);
+}): ReactElement;
+
+type ForItemProps<T, TProps = {}> = {
+    item$: Observable<T>;
+    id?: string;
+} & TProps;
+declare function For<T, TProps>({ each, optimized: isOptimized, item, itemProps, sortValues, children, }: {
+    each?: ObservableParam<T[] | Record<any, T> | Map<any, T>>;
+    optimized?: boolean;
+    item?: FC<ForItemProps<T, TProps>>;
+    itemProps?: TProps;
+    sortValues?: (A: T, B: T, AKey: string, BKey: string) => number;
+    children?: (value: Observable<T>, id: string | undefined) => ReactElement;
+}): ReactElement | null;
+
+declare function usePauseProvider(): {
+    PauseProvider: ({ children }: {
+        children: ReactNode;
+    }) => react.FunctionComponentElement<react.ProviderProps<ObservableBoolean>>;
+    isPaused$: ObservableBoolean;
+};
+
+declare const Memo: react.MemoExoticComponent<typeof Computed>;
+
+type ShapeWithNew$<T> = Partial<Omit<T, 'children'>> & {
+    [K in keyof T as K extends `$${string & K}` ? K : `$${string & K}`]?: Selector<T[K]>;
+} & {
+    children?: Selector<ReactNode>;
+};
+interface BindKey<P> {
+    handler?: keyof P;
+    getValue?: (e: any) => any;
+    defaultValue?: any;
+    selector?: (propsOut: Record<string, any>, p: Observable<any>) => any;
+}
+type BindKeys<P = any> = Record<keyof P, BindKey<P>>;
+type FCReactiveObject<T> = {
+    [K in keyof T]: FC<ShapeWithNew$<T[K]>>;
+};
+type FCReactive<P, P2> = P & FC<ShapeWithNew$<P2> & {
+    ref?: LegacyRef<P> | undefined;
+}>;
+interface UseSelectorOptions {
+    suspense?: boolean;
+    skipCheck?: boolean;
+}
+
+interface IReactive {
+}
+declare const Reactive: IReactive;
+declare function configureReactive({ components, binders, }: {
+    components?: Record<string, FC | ComponentClass<any>>;
+    binders?: Record<string, BindKeys>;
+}): void;
+
+interface PropsIf<T> {
+    if: Selector<T>;
+    ifReady?: never;
+}
+interface PropsIfReady<T> {
+    if?: never;
+    ifReady: Selector<T>;
+}
+interface PropsBase<T> {
+    else?: ReactNode | (() => ReactNode);
+    wrap?: FC;
+    children: ReactNode | ((value?: T) => ReactNode);
+}
+type Props<T> = PropsBase<T> & (PropsIf<T> | PropsIfReady<T>);
+declare function Show<T>(props: Props<T>): ReactElement;
+
+declare function Switch<T extends object>({ value, children, }: {
+    value?: Selector<T>;
+    children: Partial<Record<keyof T | 'null' | 'undefined' | 'default', () => ReactNode>>;
+}): ReactElement | null;
+declare function Switch<T extends string | number | symbol>({ value, children, }: {
+    value?: Selector<T>;
+    children: Partial<Record<T | 'null' | 'undefined' | 'default', () => ReactNode>>;
+}): ReactElement | null;
+declare function Switch<T extends boolean>({ value, children, }: {
+    value?: Selector<T>;
+    children: Partial<Record<'false' | 'true' | 'null' | 'undefined' | 'default', () => ReactNode>>;
+}): ReactElement | null;
+declare function Switch<T>({ value, children, }: {
+    value?: Selector<T>;
+    children: Partial<Record<'undefined' | 'default', () => ReactNode>>;
+}): ReactElement | null;
+
+type ShapeWithPick$<T, T2 extends keyof T = keyof T> = Partial<T> & {
+    [K in T2 as K extends `$${string & K}` ? K : `$${string & K}`]?: Selector<T[K]>;
+};
+type ShapeWith$<T> = Partial<T> & {
+    [K in keyof T as K extends `$${string & K}` ? K : `$${string & K}`]?: Selector<T[K]>;
+};
+type ObjectShapeWith$<T> = {
+    [K in keyof T]: T[K] extends FC<infer P> ? FC<ShapeWith$<P>> : T[K];
+};
+type ExtractFCPropsType<T> = T extends FC<infer P> ? P : never;
+declare const hasSymbol: false | ((key: string) => symbol);
+declare function observer<P extends FC<any>>(component: P): P;
+declare function reactive<T extends FC<any>>(component: T, bindKeys?: BindKeys<ExtractFCPropsType<T>>): T | FC<ShapeWith$<ExtractFCPropsType<T>>>;
+declare function reactive<T extends FC<any>, T2 extends keyof ExtractFCPropsType<T>>(component: T, bindKeys?: BindKeys<ExtractFCPropsType<T>>): T | FC<ShapeWithPick$<ExtractFCPropsType<T>, T2>>;
+declare function reactiveObserver<T extends FC<any>>(component: T, bindKeys?: BindKeys<ExtractFCPropsType<T>>): T | FC<ShapeWith$<ExtractFCPropsType<T>>>;
+declare function reactiveObserver<T extends FC<any>, T2 extends keyof ExtractFCPropsType<T>>(component: T, bindKeys?: BindKeys<ExtractFCPropsType<T>>): T | FC<ShapeWithPick$<ExtractFCPropsType<T>, T2>>;
+declare function reactiveComponents<P extends Record<string, FC>>(components: P): ObjectShapeWith$<P>;
+
+declare function useComputed<T>(compute: () => T | Promise<T>): Observable<T>;
+declare function useComputed<T>(compute: () => T | Promise<T>, deps: any[]): Observable<T>;
+declare function useComputed<T, T2 = T>(compute: (() => T | Promise<T>) | ObservableParam<T>, set: (value: T2) => void): Observable<T>;
+declare function useComputed<T, T2 = T>(compute: (() => T | Promise<T>) | ObservableParam<T>, set: (value: T2) => void, deps: any[]): Observable<T>;
+
+declare const useEffectOnce: (effect: () => void | (() => void), deps: any[]) => void;
+
+declare function useIsMounted(): Observable<boolean>;
+
+declare function useMount(fn: () => (void | (() => void)) | Promise<void>): void;
+declare const useMountOnce: typeof useMount;
+
+/**
+ * A React hook that creates a new observable
+ *
+ * @param initialValue The initial value of the observable or a function that returns the initial value
+ *
+ * @see https://www.legendapp.com/dev/state/react/#useObservable
+ */
+declare function useObservable<T>(): Observable<T | undefined>;
+declare function useObservable<T>(value: Promise<RecursiveValueOrFunction<T>> | (() => RecursiveValueOrFunction<T>) | RecursiveValueOrFunction<T>): Observable<T>;
+declare function useObservable<T>(value: T): Observable<T>;
+declare function useObservable<T>(value?: T): Observable<any>;
+
+declare function useObservableReducer<R extends ReducerWithoutAction<any>, I>(reducer: R, initializerArg: I, initializer: (arg: I) => ReducerStateWithoutAction<R>): [Observable<ReducerStateWithoutAction<R>>, DispatchWithoutAction];
+declare function useObservableReducer<R extends ReducerWithoutAction<any>>(reducer: R, initializerArg: ReducerStateWithoutAction<R>, initializer?: undefined): [Observable<ReducerStateWithoutAction<R>>, DispatchWithoutAction];
+declare function useObservableReducer<R extends Reducer<any, any>, I>(reducer: R, initializerArg: I & ReducerState<R>, initializer: (arg: I & ReducerState<R>) => ReducerState<R>): [Observable<ReducerState<R>>, Dispatch<ReducerAction<R>>];
+declare function useObservableReducer<R extends Reducer<any, any>, I>(reducer: R, initializerArg: I, initializer: (arg: I) => ReducerState<R>): [Observable<ReducerState<R>>, Dispatch<ReducerAction<R>>];
+declare function useObservableReducer<R extends Reducer<any, any>>(reducer: R, initialState: ReducerState<R>, initializer?: undefined): [Observable<ReducerState<R>>, Dispatch<ReducerAction<R>>];
+
+declare function useObserve<T>(run: (e: ObserveEvent<T>) => T | void, options?: ObserveOptions): () => void;
+declare function useObserve<T>(selector: Selector<T>, reaction?: (e: ObserveEventCallback<T>) => any, options?: ObserveOptions): () => void;
+
+declare function useObserveEffect<T>(run: (e: ObserveEvent<T>) => T | void, options?: ObserveOptions): void;
+declare function useObserveEffect<T>(selector: Selector<T>, reaction?: (e: ObserveEventCallback<T>) => any, options?: ObserveOptions): void;
+
+declare function useSelector<T>(selector: Selector<T>, options?: UseSelectorOptions): T;
+
+declare function useUnmount(fn: () => void): void;
+declare const useUnmountOnce: typeof useUnmount;
+
+declare function useWhen<T>(predicate: Selector<T>, effect: (value: T) => any | (() => any)): Promise<any>;
+declare function useWhenReady<T>(predicate: Selector<T>, effect: (value: T) => any | (() => any)): Promise<any>;
+
+export { type BindKey, type BindKeys, Computed, type ExtractFCPropsType, type FCReactive, type FCReactiveObject, For, type IReactive, Memo, type ObjectShapeWith$, Reactive, type ShapeWith$, type ShapeWithNew$, type ShapeWithPick$, Show, Switch, type UseSelectorOptions, configureReactive, hasSymbol, observer, reactive, reactiveComponents, reactiveObserver, useComputed, useEffectOnce, useIsMounted, useMount, useMountOnce, useObservable, useObservableReducer, useObserve, useObserveEffect, usePauseProvider, useSelector, useUnmount, useUnmountOnce, useWhen, useWhenReady };