clear-react-router 1.7.9 → 1.8.1

package/dist/instance.d.ts

@@ -0,0 +1 @@
+export declare const router: import("./types").RouterType;

package/dist/runtime/invalidate.d.ts

@@ -1,6 +1,2 @@
-type Options = {
-    withChildren?: boolean;
-};
-export declare function invalidate(path?: string[]): Promise<void>;
-export declare function invalidate(path?: string, options?: Options): Promise<void>;
-export {};
+import { type InvalidateOptions, RevalidateCache, RouterState } from '../types';
+export declare const createInvalidate: ({ routeItemDataState, loaderStateRef, timestampMap, currentLoaderState, contextState }: RouterState, revalidateCache: RevalidateCache) => (pathList?: string | string[], options?: InvalidateOptions) => Promise<void>;

package/dist/runtime/navigate.d.ts

@@ -1,2 +1,2 @@
-import { Location } from '../types/global';
-export declare const navigate: (nextLocation: Location) => Promise<void>;
+import { Location, RevalidateCache, RouterState } from '../types';
+export declare const createNavigate: (routerState: RouterState, revalidateCache: RevalidateCache) => (nextLocation: Location) => Promise<void>;

package/dist/runtime/prefetch.d.ts

@@ -1 +1,2 @@
-export declare const prefetch: (pathname: string) => Promise<void>;
+import { RevalidateCache } from '../types';
+export declare const createPrefetch: (revalidateCache: RevalidateCache) => (pathname: string) => Promise<void>;

package/dist/{types/global.d.ts → types.d.ts}

@@ -1,4 +1,6 @@
 import type { ComponentType, Dispatch, ReactElement, ReactNode, SetStateAction } from 'react';
+import { Store, useGlobalState } from './create';
+import { Cell } from './cell';
 export type LazyComponent = () => Promise<{
     default: ComponentType<unknown>;
 }>;
@@ -9,11 +11,6 @@ export type BeforeLoad = (arg: {
     params: Record<string, string>;
     setContext: Dispatch<SetStateAction<Record<string, unknown>>>;
 }) => Promise<unknown> | undefined | void;
-export type AfterLoad = (arg: {
-    context: Record<string, unknown>;
-    params: Record<string, string>;
-    setContext: Dispatch<SetStateAction<Record<string, unknown>>>;
-}) => Promise<void>;
 export type ClientRouteItem = {
     path: string;
     element: RenderElement | LazyComponent;
@@ -27,6 +24,7 @@ export type ClientRouteItem = {
     fallback?: RenderElement;
     children?: ClientRouteItem[];
     staleTime?: number;
+    retry?: Retry;
     beforeLoad?: BeforeLoad;
     afterLoad?: (arg: {
         context: Record<string, unknown>;
@@ -63,7 +61,7 @@ export type LoaderState<T = unknown> = {
     loaderError: Error | null;
     beforeLoadError: Error | null;
 };
-export type AdapterType<T> = {
+export type Adapter<T> = {
     parse: (params: string[]) => T;
     serialize?: (params: T) => string | string[];
 };
@@ -71,12 +69,18 @@ export type RouteItemData = {
     location: Location;
     routeItem: RouteItem | undefined;
 };
+type ObjectRetry = {
+    count: number;
+    delay: number;
+};
+export type Retry = number | ObjectRetry | undefined;
 export type RouterProps = {
     routes: RouteItem[];
     isAnimated?: boolean;
     animationDuration?: number;
     spinner?: boolean;
     preserveScroll?: boolean;
+    defaultRetry?: Retry;
     defaultLoaderFallback?: RenderElement;
     defaultErrorElement?: RenderElement;
     showFallbackOnAnimation?: boolean;
@@ -89,3 +93,55 @@ export type RouterProps = {
     afterLoad?: ClientRouteItem['afterLoad'];
     context?: Record<string, unknown>;
 };
+export type RouterState = {
+    isLoadingState: Store<boolean>;
+    loaderFallbackState: Store<RouteItem['loaderFallback']>;
+    routeItemDataState: Store<RouteItemData>;
+    currentLoaderState: Store<LoaderState>;
+    scrollMapState: Store<Record<string, number>>;
+    contextState: Store<Record<string, unknown>>;
+    blockedRouteState: Store<{
+        from: string;
+        to: string;
+    }>;
+    loaderStateRef: Cell<LoaderState>;
+    prevPathnameRef: Cell<string>;
+    timestampMap: Map<string, number>;
+};
+export type RouterType = {
+    state: Omit<RouterState, 'loaderStateRef' | 'timestampMap'>;
+    runtime: {
+        navigate(arg: Location): Promise<void>;
+        invalidate(pathList?: string | string[], options?: InvalidateOptions): Promise<void>;
+        prefetch(pathname: string): Promise<void>;
+    };
+    hooks: {
+        useIsLoading: () => ReturnType<typeof useGlobalState<boolean>>;
+        useBlockedRoute: () => ReturnType<typeof useGlobalState<{
+            from: string;
+            to: string;
+        }>>;
+        useLoaderFallback: () => ReturnType<typeof useGlobalState<RenderElement | undefined>>;
+        useRouteItemData: () => ReturnType<typeof useGlobalState<RouteItemData>>;
+        useCurrentLoaderState: () => ReturnType<typeof useGlobalState<LoaderState>>;
+        useScrollMap: () => ReturnType<typeof useGlobalState<Record<string, number>>>;
+        useContextState: () => ReturnType<typeof useGlobalState<Record<string, unknown>>>;
+        useParams: <T>() => T;
+        useNavigate: () => (arg: Location | string | -1) => Promise<void>;
+        useGetAction: (actionKey: string) => {
+            currentAction: (arg: FormData) => Promise<unknown> | Promise<void> | void | unknown;
+            invalidate: (pathList?: string | string[], options?: InvalidateOptions) => Promise<void>;
+        };
+        useRestoreScroll: () => () => void;
+        useAction: (action: string, options?: Options) => (arg: FormData) => Promise<void>;
+    };
+};
+export type InvalidateOptions = {
+    withChildren?: boolean;
+};
+export type RevalidateCache = ({ routeItem, pathname }: RevalidateCacheArgs) => Promise<unknown> | undefined;
+export type Options = Partial<{
+    onSuccess: (args: unknown) => void;
+    onError: (args: unknown) => void;
+}> | undefined;
+export {};

package/dist/utils/adapter.d.ts

@@ -1,4 +1,4 @@
-import { AdapterType } from '../types/global';
+import { Adapter } from '../types';
 type ZodInterface<T> = {
     safeParse(input: unknown): {
         success: true;
@@ -46,6 +46,6 @@ export declare const adapter: {
         parse: (params: string[]) => Date[];
         serialize: (args: Date[]) => string[];
     };
-    zodSchema: <T>(schema: ZodInterface<T>) => AdapterType<T>;
+    zodSchema: <T>(schema: ZodInterface<T>) => Adapter<T>;
 };
 export {};

package/dist/utils/commitNavigation.d.ts

@@ -1,2 +1,3 @@
-import { Location, RouteItem } from '../types/global';
-export declare const commitNavigation: (nextLocation: Location, routeItem: RouteItem | undefined) => void;
+import { Cell } from '../cell';
+import { Location, RouteItem } from '../types';
+export declare const createCommitNavigation: (navigationExecutor: (arg: Location, routeItem: RouteItem | undefined) => void, prevPathnameRef: Cell<string>) => (nextLocation: Location, routeItem: RouteItem | undefined) => void;

package/dist/utils/commitState.d.ts

@@ -1,2 +1,2 @@
-import { Location, RouteItem } from '../types/global';
-export declare const commitState: (nextLocation: Location, routeItem: RouteItem | undefined) => void;
+import { Location, RouteItem, RouterState } from '../types';
+export declare const createCommitState: ({ isLoadingState, routeItemDataState, loaderFallbackState, currentLoaderState, prevPathnameRef, loaderStateRef, }: RouterState) => (nextLocation: Location, routeItem: RouteItem | undefined) => void;

package/dist/utils/createRouterInstance.d.ts

@@ -0,0 +1,2 @@
+import { RouterType } from '../types';
+export declare const createRouterInstance: () => RouterType;

package/dist/utils/findRoute.d.ts

@@ -1,2 +1,2 @@
-export declare const ALL_LOCATIONS = "*";
+export declare const ALL_LOCATIONS = "/*";
 export declare const findRoute: (pathname: string, includeAll?: boolean) => import("..").RouteItem | undefined;

package/dist/utils/isCacheItemFresh.d.ts

@@ -1,5 +1,5 @@
-import type { RouteItem } from '../types/global';
-export declare const isCacheItemFresh: ({ routeItem, pathname }: {
+import type { RouteItem } from '../types';
+export declare const createIsCacheItemFresh: (timestampMap: Map<string, number>) => ({ routeItem, pathname }: {
     routeItem?: RouteItem;
     pathname: string;
 }) => boolean;

package/dist/utils/renderElement.d.ts

@@ -1,2 +1,2 @@
-import { RenderElement } from '../types/global';
+import { RenderElement } from '../types';
 export declare const renderElement: (Component?: RenderElement) => import("react/jsx-runtime").JSX.Element | null;

package/dist/utils/revalidateCache.d.ts

@@ -1,3 +1,2 @@
-import type { RevalidateCacheArgs } from '../types/global';
-declare const revalidateCache: ({ routeItem, pathname }: RevalidateCacheArgs) => Promise<unknown> | undefined;
-export { revalidateCache };
+import { RevalidateCacheArgs, RouterState } from '../types';
+export declare const createRevalidateCache: (routerState: RouterState) => ({ routeItem, pathname }: RevalidateCacheArgs, retried?: number) => Promise<any>;

package/dist/utils/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ClientRouteItem, Location, RouteItem } from '../types/global';
+import { ClientRouteItem, Location, RouteItem } from '../types';
 export declare const createRouter: (clientList: ClientRouteItem[]) => RouteItem[];
 export declare const getParamsObject: ({ params, pathname }: {
     params?: RouteItem["params"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clear-react-router",
-  "version": "1.7.9",
+  "version": "1.8.1",
   "description": "A lightweight, type-safe routing library for React applications",
   "author": "Andrew Bubnov",
   "scripts": {

package/dist/hooks/useGetAction.d.ts

@@ -1,4 +0,0 @@
-export declare const useGetAction: (actionKey: string) => {
-    currentAction: (arg: FormData) => Promise<unknown> | Promise<void> | void | unknown;
-    invalidate: typeof import("../runtime/invalidate").invalidate;
-};

package/dist/state/state.d.ts

@@ -1,50 +0,0 @@
-import { LoaderState, RouteItemData } from '../types/global';
-export declare const isLoadingState: {
-    subscribe: (listener: (state: boolean, prevState: boolean) => void) => () => void;
-    getState: () => boolean;
-    setState: (action: boolean | ((prevState: boolean) => boolean)) => void;
-};
-export declare const useIsLoading: () => readonly [boolean, (action: boolean | ((prevState: boolean) => boolean)) => void];
-export declare const useBlockedRoute: () => readonly [{
-    from: string;
-    to: string;
-}, (action: {
-    from: string;
-    to: string;
-} | ((prevState: {
-    from: string;
-    to: string;
-}) => {
-    from: string;
-    to: string;
-})) => void];
-export declare const loaderFallbackState: {
-    subscribe: (listener: (state: import("../types/global").RenderElement | undefined, prevState: import("../types/global").RenderElement | undefined) => void) => () => void;
-    getState: () => import("../types/global").RenderElement | undefined;
-    setState: (action: import("../types/global").RenderElement | ((prevState: import("../types/global").RenderElement | undefined) => import("../types/global").RenderElement | undefined) | undefined) => void;
-};
-export declare const useLoaderFallback: () => readonly [import("../types/global").RenderElement | undefined, (action: import("../types/global").RenderElement | ((prevState: import("../types/global").RenderElement | undefined) => import("../types/global").RenderElement | undefined) | undefined) => void];
-export declare const routeItemDataState: {
-    subscribe: (listener: (state: RouteItemData, prevState: RouteItemData) => void) => () => void;
-    getState: () => RouteItemData;
-    setState: (action: RouteItemData | ((prevState: RouteItemData) => RouteItemData)) => void;
-};
-export declare const useRouteItemData: () => readonly [RouteItemData, (action: RouteItemData | ((prevState: RouteItemData) => RouteItemData)) => void];
-export declare const currentLoaderState: {
-    subscribe: (listener: (state: LoaderState, prevState: LoaderState) => void) => () => void;
-    getState: () => LoaderState;
-    setState: (action: LoaderState | ((prevState: LoaderState) => LoaderState)) => void;
-};
-export declare const useCurrentLoaderState: () => readonly [LoaderState, (action: LoaderState | ((prevState: LoaderState) => LoaderState)) => void];
-export declare const scrollMapState: {
-    subscribe: (listener: (state: Record<string, number>, prevState: Record<string, number>) => void) => () => void;
-    getState: () => Record<string, number>;
-    setState: (action: Record<string, number> | ((prevState: Record<string, number>) => Record<string, number>)) => void;
-};
-export declare const useScrollMap: () => readonly [Record<string, number>, (action: Record<string, number> | ((prevState: Record<string, number>) => Record<string, number>)) => void];
-export declare const contextState: {
-    subscribe: (listener: (state: Record<string, unknown>, prevState: Record<string, unknown>) => void) => () => void;
-    getState: () => Record<string, unknown>;
-    setState: (action: Record<string, unknown> | ((prevState: Record<string, unknown>) => Record<string, unknown>)) => void;
-};
-export declare const useContextState: () => readonly [Record<string, unknown>, (action: Record<string, unknown> | ((prevState: Record<string, unknown>) => Record<string, unknown>)) => void];

package/dist/utils/getContext.d.ts

@@ -1,4 +0,0 @@
-export declare const getContext: () => {
-    context: Record<string, unknown>;
-    setContext: (action: Record<string, unknown> | ((prevState: Record<string, unknown>) => Record<string, unknown>)) => void;
-};