@biglogic/rgs 3.9.7 → 3.9.8

package/core/ssr.d.ts

@@ -0,0 +1,73 @@
+import type { IStore, StoreConfig } from "./types";
+export declare const isServerSide: () => boolean;
+export declare const isClientSide: () => boolean;
+export interface SSRStoreConfig<S extends Record<string, unknown>> extends StoreConfig<S> {
+    deferHydration?: boolean;
+    initialState?: S;
+    ssrSafe?: boolean;
+}
+export declare const createSSRStore: <S extends Record<string, unknown>>(config?: SSRStoreConfig<S>) => IStore<S> & {
+    hydrate: () => Promise<void>;
+    getSerializedState: () => string | null;
+    isHydrated: () => boolean;
+};
+export declare const hydrateOnClient: (store: IStore<Record<string, unknown>>) => Promise<void>;
+export declare const dehydrateStore: (store: IStore<Record<string, unknown>>) => string;
+export declare const rehydrateStore: (store: IStore<Record<string, unknown>>, serializedState: string) => void;
+export declare const useHydrated: () => boolean;
+export declare const useHydrationStatus: () => {
+    isHydrated: boolean;
+    isHydrating: boolean;
+};
+export declare const useDeferredStore: <S extends Record<string, unknown>>(store: IStore<S> & {
+    isHydrated?: () => boolean;
+}) => IStore<S>;
+export declare const createNextStore: <S extends Record<string, unknown>>(config?: SSRStoreConfig<S>) => IStore<S> & {
+    hydrate: () => Promise<void>;
+    getSerializedState: () => string | null;
+    isHydrated: () => boolean;
+} & {
+    useHydrated: () => boolean;
+    useHydrationStatus: () => {
+        isHydrated: boolean;
+        isHydrating: boolean;
+    };
+    useDeferredStore: <K extends keyof S>(key: K) => unknown;
+};
+export declare const getSSRInitialState: (store: IStore<Record<string, unknown>>) => Record<string, unknown>;
+export declare const initializeFromSSR: (store: IStore<Record<string, unknown>>, initialState: Record<string, unknown>) => void;
+declare const _default: {
+    isServerSide: () => boolean;
+    isClientSide: () => boolean;
+    createSSRStore: <S extends Record<string, unknown>>(config?: SSRStoreConfig<S>) => IStore<S> & {
+        hydrate: () => Promise<void>;
+        getSerializedState: () => string | null;
+        isHydrated: () => boolean;
+    };
+    hydrateOnClient: (store: IStore<Record<string, unknown>>) => Promise<void>;
+    dehydrateStore: (store: IStore<Record<string, unknown>>) => string;
+    rehydrateStore: (store: IStore<Record<string, unknown>>, serializedState: string) => void;
+    useHydrated: () => boolean;
+    useHydrationStatus: () => {
+        isHydrated: boolean;
+        isHydrating: boolean;
+    };
+    useDeferredStore: <S extends Record<string, unknown>>(store: IStore<S> & {
+        isHydrated?: () => boolean;
+    }) => IStore<S>;
+    createNextStore: <S extends Record<string, unknown>>(config?: SSRStoreConfig<S>) => IStore<S> & {
+        hydrate: () => Promise<void>;
+        getSerializedState: () => string | null;
+        isHydrated: () => boolean;
+    } & {
+        useHydrated: () => boolean;
+        useHydrationStatus: () => {
+            isHydrated: boolean;
+            isHydrating: boolean;
+        };
+        useDeferredStore: <K extends keyof S>(key: K) => unknown;
+    };
+    getSSRInitialState: (store: IStore<Record<string, unknown>>) => Record<string, unknown>;
+    initializeFromSSR: (store: IStore<Record<string, unknown>>, initialState: Record<string, unknown>) => void;
+};
+export default _default;

package/core/thunk.d.ts

@@ -0,0 +1,75 @@
+import type { IStore } from "./types";
+export type ThunkAction<R = void, S extends Record<string, unknown> = Record<string, unknown>> = (dispatch: ThunkDispatch<S>, getState: () => S, extraArgument?: unknown) => Promise<R> | R;
+export type ThunkDispatch<S extends Record<string, unknown> = Record<string, unknown>> = <R>(action: ThunkAction<R, S> | ThunkActionPayload<S>) => Promise<R>;
+export interface ThunkActionPayload<_S extends Record<string, unknown> = Record<string, unknown>> {
+    type: string;
+    payload?: unknown;
+    meta?: Record<string, unknown>;
+}
+export interface ThunkMiddlewareConfig {
+    extraArgument?: unknown;
+    dispatchKey?: string;
+}
+export declare const createThunkStore: <S extends Record<string, unknown>>(store: IStore<S>, config?: ThunkMiddlewareConfig) => IStore<S> & {
+    dispatch: ThunkDispatch<S>;
+};
+export declare const createActions: <S extends Record<string, unknown>, T extends Record<string, unknown>>(store: IStore<S>, creators: T) => T & {
+    dispatch: ThunkDispatch<S>;
+};
+export declare const createAsyncAction: <T>(key: string, fetcher: () => Promise<T>) => ThunkAction<T, Record<string, {
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+}>>;
+export declare const createAsyncActions: <S extends Record<string, unknown>>(store: IStore<S>, actions: Record<string, () => Promise<unknown>>) => Record<string, ThunkAction<unknown, S>>;
+export type Effect = {
+    type: 'call';
+    fn: () => Promise<unknown>;
+    args?: unknown[];
+} | {
+    type: 'put';
+    action: ThunkActionPayload<Record<string, unknown>>;
+} | {
+    type: 'select';
+    selector: (state: Record<string, unknown>) => unknown;
+} | {
+    type: 'take';
+    pattern: string | ((action: ThunkActionPayload) => boolean);
+} | {
+    type: 'all';
+    effects: Effect[];
+} | {
+    type: 'race';
+    effects: Record<string, Effect>;
+};
+export declare const call: (fn: () => Promise<unknown>, ...args: unknown[]) => Effect;
+export declare const put: (action: ThunkActionPayload<Record<string, unknown>>) => Effect;
+export declare const select: (selector: (state: Record<string, unknown>) => unknown) => Effect;
+export declare const take: (pattern: string | ((action: ThunkActionPayload) => boolean)) => Effect;
+export declare const all: (effects: Effect[]) => Effect;
+export declare const race: (effects: Record<string, Effect>) => Effect;
+export declare const createSaga: <S extends Record<string, unknown>>(generator: Generator<Effect, void, unknown>) => ((dispatch: ThunkDispatch<S>, getState: () => S, extraArgument?: unknown) => Promise<void>);
+export declare const runSaga: <S extends Record<string, unknown>>(store: IStore<S>, saga: ThunkAction<void, S>) => (() => void);
+declare const _default: {
+    createThunkStore: <S extends Record<string, unknown>>(store: IStore<S>, config?: ThunkMiddlewareConfig) => IStore<S> & {
+        dispatch: ThunkDispatch<S>;
+    };
+    createActions: <S extends Record<string, unknown>, T extends Record<string, unknown>>(store: IStore<S>, creators: T) => T & {
+        dispatch: ThunkDispatch<S>;
+    };
+    createAsyncAction: <T>(key: string, fetcher: () => Promise<T>) => ThunkAction<T, Record<string, {
+        data: T | null;
+        loading: boolean;
+        error: Error | null;
+    }>>;
+    createAsyncActions: <S extends Record<string, unknown>>(store: IStore<S>, actions: Record<string, () => Promise<unknown>>) => Record<string, ThunkAction<unknown, S>>;
+    call: (fn: () => Promise<unknown>, ...args: unknown[]) => Effect;
+    put: (action: ThunkActionPayload<Record<string, unknown>>) => Effect;
+    select: (selector: (state: Record<string, unknown>) => unknown) => Effect;
+    take: (pattern: string | ((action: ThunkActionPayload) => boolean)) => Effect;
+    all: (effects: Effect[]) => Effect;
+    race: (effects: Record<string, Effect>) => Effect;
+    createSaga: <S extends Record<string, unknown>>(generator: Generator<Effect, void, unknown>) => ((dispatch: ThunkDispatch<S>, getState: () => S, extraArgument?: unknown) => Promise<void>);
+    runSaga: <S extends Record<string, unknown>>(store: IStore<S>, saga: ThunkAction<void, S>) => (() => void);
+};
+export default _default;