clear-react-router 1.0.2 → 1.0.5

package/dist/components/Link.d.ts

@@ -1,4 +1,4 @@
-import { ReactElement, MouseEvent, CSSProperties } from 'react';
+import { type ReactElement, type MouseEvent, type CSSProperties } from 'react';
 type LinkProps = {
     to: string;
     children: ReactElement<{

package/dist/components/Router.d.ts

@@ -1,4 +1,4 @@
-import { RouteItem } from '../types/global.ts';
+import type { RouteItem } from '../types/global.ts';
 type RouterProps = {
     routeList: RouteItem[];
     context?: Record<string, unknown>;

package/dist/context/RouterContext.d.ts

@@ -1,4 +1,4 @@
-import { BlockerState, Location, UpdateBlockedRouteProps } from '../types/global.ts';
+import type { BlockerState, Location, UpdateBlockedRouteProps } from '../types/global';
 export type NavigationContextValue = {
     location: Location;
     params: Record<string, string>;
@@ -11,9 +11,9 @@ export type ActionsContextValue = {
     setContext(arg: object): void;
 };
 export type DataContextValue = {
-    loaderCache: Record<string, unknown>;
+    loaderCache: unknown;
     context: Record<string, unknown>;
 };
-export declare const ActionsContext: import('react').Context<ActionsContextValue>;
-export declare const DataContext: import('react').Context<DataContextValue>;
-export declare const NavigationContext: import('react').Context<NavigationContextValue>;
+export declare const ActionsContext: import("react").Context<ActionsContextValue>;
+export declare const DataContext: import("react").Context<DataContextValue>;
+export declare const NavigationContext: import("react").Context<NavigationContextValue>;

package/dist/hooks/useBlocker.d.ts

@@ -1,4 +1,4 @@
-import { BlockerState } from '../types/global.ts';
+import type { BlockerState } from '../types/global.ts';
 type UseBlockerReturnValue = {
     state: BlockerState;
     process(): void;

package/dist/hooks/useHandleNavigation.d.ts

@@ -1,4 +1,4 @@
-import { BlockerState, Location, RouteItem, UpdateBlockedRouteProps } from '../types/global.ts';
+import type { BlockerState, Location, RouteItem, UpdateBlockedRouteProps } from '../types/global.ts';
 type UseHandleNavigation = {
     routeList: RouteItem[];
     setLocation: (arg: Location) => void;

package/dist/hooks/useLatest.d.ts

@@ -1 +1 @@
-export declare const useLatest: <T>(value: T) => import('react').RefObject<T>;
+export declare const useLatest: <T>(value: T) => import("react").RefObject<T>;

package/dist/hooks/useLoader.d.ts

@@ -1,8 +1,8 @@
-import { RouteItem } from '../types/global.ts';
+import type { RouteItem } from '../types/global.ts';
 export declare const useLoader: (routeList: RouteItem[]) => {
-    loaderCache: Record<string, unknown>;
+    loaderCache: unknown;
     loaderError: boolean;
     prefetchLoader: (pathname: string) => Promise<void>;
     revalidateCache: (routeItem?: RouteItem) => Promise<void>;
-    isLoadingMap: Record<string, boolean>;
+    isLoading: boolean;
 };

package/dist/hooks/useLocation.d.ts

@@ -1 +1 @@
-export declare const useLocation: () => import('..').Location;
+export declare const useLocation: () => import("../types/global").Location;

package/dist/hooks/useNavigate.d.ts

@@ -1,2 +1,2 @@
-import { Location } from '../types/global.ts';
+import type { Location } from '../types/global.ts';
 export declare const useNavigate: () => (arg: Location | -1) => Promise<void>;

package/dist/hooks/useServiceContext.d.ts

@@ -1,3 +1,3 @@
-export declare const useNavigationState: () => import('../context/RouterContext').NavigationContextValue;
-export declare const useRouterActions: () => import('../context/RouterContext').ActionsContextValue;
-export declare const useRouterData: () => import('../context/RouterContext').DataContextValue;
+export declare const useNavigationState: () => import("../context/RouterContext").NavigationContextValue;
+export declare const useRouterActions: () => import("../context/RouterContext").ActionsContextValue;
+export declare const useRouterData: () => import("../context/RouterContext").DataContextValue;

package/dist/index.d.ts

@@ -7,6 +7,5 @@ export { useLoaderState } from './hooks/useLoaderState';
 export { useBlocker } from './hooks/useBlocker';
 export { useBeforeUnload } from './hooks/useBeforeUnload';
 export { useRouterContext } from './hooks/useRouterContext';
-export { createRouter, parseWindowLocation, comparePaths } from './utils/utils';
+export { createRouter } from './utils/utils';
 export { redirect } from './utils/redirect';
-export type { ClientRouteItem, RouteItem, Location, BlockerState } from './types/global';

package/dist/index.js

@@ -279,15 +279,15 @@ var l = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t
 		})) : await f.current(e);
 	}, [l.from, f]);
 	return a(() => {
-		let t = async (t) => {
-			let n = C(t.target.location);
+		let e = async (e) => {
+			let t = C(e.target.location);
 			d.current === l.from ? (u({
 				from: d.current,
-				to: n.pathname
-			}), history.replaceState(null, "", d.current)) : e(n);
+				to: t.pathname
+			}), history.replaceState(null, "", d.current)) : f.current(t);
 		};
-		return window.addEventListener("popstate", t), () => window.removeEventListener("popstate", t);
-	}, [l.from, e]), a(() => {
+		return window.addEventListener("popstate", e), () => window.removeEventListener("popstate", e);
+	}, [l.from, f]), a(() => {
 		let e = C(window.location);
 		f.current(e), d.current = e.pathname;
 	}, [f]), {
@@ -296,16 +296,16 @@ var l = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t
 		updateBlockedRoute: p
 	};
 }, k = (e) => {
-	let [t, n] = c({}), [i, a] = c({}), [o, s] = c(!1), [l, u] = c({}), d = r(({ key: e, value: t }) => n((n) => ({
+	let [t, n] = c({}), [i, a] = c(!1), [o, l] = c({}), u = s({}), d = r(({ key: e, value: t }) => n((n) => ({
 		...n,
 		[e]: t
 	})), []), f = r((e) => {
 		if (!e) return !0;
-		let t = i[e.path];
+		let t = u.current[e.path];
 		return !!(t && Date.now() - t < (e.staleTime || 0));
-	}, [i]), p = r(async (e) => {
+	}, []), p = r(async (e) => {
 		if (e?.loader && !f(e)) {
-			u((t) => ({
+			l((t) => ({
 				...t,
 				[e.path]: !0
 			})), n((t) => Object.keys(t).filter((t) => t !== e.path).reduce((e, n) => ({
@@ -313,37 +313,37 @@ var l = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t
 				[n]: t[n]
 			}), {}));
 			try {
-				s(!1);
+				a(!1);
 				let t = await e?.loader();
-				a((t) => ({
-					...t,
+				u.current = {
+					...u.current,
 					[e.path]: Date.now()
-				})), d({
+				}, d({
 					key: e.path,
 					value: t
 				});
 			} catch {
-				s(!0);
+				a(!0);
 			} finally {
-				u((t) => ({
+				l((t) => ({
 					...t,
 					[e.path]: !1
 				}));
 			}
 		}
-	}, [f, d]);
+	}, [f, d]), m = r(async (t) => {
+		let n = e.find((e) => w(e, t));
+		n && await p(n);
+	}, [p, e]);
 	return {
-		loaderCache: t,
-		loaderError: o,
-		prefetchLoader: r(async (t) => {
-			let n = e.find((e) => w(e, t));
-			n && await p(n);
-		}, [p, e]),
+		loaderCache: t[window.location.pathname],
+		loaderError: i,
+		prefetchLoader: m,
 		revalidateCache: p,
-		isLoadingMap: l
+		isLoading: o[window.location.pathname]
 	};
 }, A = (e) => e ? typeof e == "function" ? /* @__PURE__ */ (0, g.jsx)(e, {}) : e : null, j = "error 404. Page not found", M = "*", N = ({ routeList: e, context: t = {} }) => {
-	let [n, r] = c(C(window.location)), [i, a] = c(t), s = o(() => e.find((e) => e.path === M || w(e, n.pathname)), [n.pathname, e]), { loaderError: l, loaderCache: u, prefetchLoader: d, revalidateCache: f, isLoadingMap: p } = k(e), { blockerState: m, updateLocation: h, updateBlockedRoute: v } = O({
+	let [n, r] = c(C(window.location)), [i, a] = c(t), s = o(() => e.find((e) => e.path === M || w(e, n.pathname)), [n.pathname, e]), { loaderError: l, loaderCache: u, prefetchLoader: d, revalidateCache: f, isLoading: p } = k(e), { blockerState: m, updateLocation: h, updateBlockedRoute: v } = O({
 		setLocation: r,
 		routeList: e,
 		context: i,
@@ -368,7 +368,7 @@ var l = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t
 		v,
 		h
 	]);
-	return s?.loader && !l && p[n.pathname] ? /* @__PURE__ */ (0, g.jsx)(_, {
+	return s?.loader && !l && p ? /* @__PURE__ */ (0, g.jsx)(_, {
 		...b,
 		children: A(s?.loaderFallback)
 	}) : l ? /* @__PURE__ */ (0, g.jsx)(_, {
@@ -406,7 +406,7 @@ var l = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t
 	return e;
 }, B = () => P().location, V = () => {
 	let { loaderCache: e } = I();
-	return e[window.location.pathname];
+	return e;
 }, H = (e) => {
 	let { location: { pathname: t }, blockerState: n } = P(), { updateBlockedRoute: r } = F(), i = e();
 	return a(() => r(i ? {
@@ -436,4 +436,4 @@ var l = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t
 	};
 };
 //#endregion
-export { R as Link, N as Router, w as comparePaths, x as createRouter, C as parseWindowLocation, E as redirect, U as useBeforeUnload, H as useBlocker, V as useLoaderState, B as useLocation, L as useNavigate, z as useParams, W as useRouterContext };
+export { R as Link, N as Router, x as createRouter, E as redirect, U as useBeforeUnload, H as useBlocker, V as useLoaderState, B as useLocation, L as useNavigate, z as useParams, W as useRouterContext };

package/dist/provider/RouterProvider.d.ts

@@ -1,5 +1,5 @@
-import { ReactNode } from 'react';
-import { ActionsContextValue, DataContextValue, NavigationContextValue } from '../context/RouterContext';
+import { type ReactNode } from 'react';
+import { type ActionsContextValue, type DataContextValue, type NavigationContextValue } from '../context/RouterContext';
 type RouterProviderProps = NavigationContextValue & ActionsContextValue & DataContextValue & {
     children: ReactNode;
 };

package/dist/types/global.d.ts

@@ -1,4 +1,4 @@
-import { ComponentType, ReactElement } from 'react';
+import type { ComponentType, ReactElement } from 'react';
 export type LazyComponent = () => Promise<{
     default: ComponentType<unknown>;
 }>;

package/dist/utils/createLazyComponent.d.ts

@@ -1,4 +1,4 @@
-import { ComponentType, ReactElement } from 'react';
+import { type ComponentType, type ReactElement } from 'react';
 export declare const createLazyComponent: (importFn: () => Promise<{
     default: ComponentType<unknown>;
 }>, fallback?: ReactElement | (() => ReactElement)) => (() => ReactElement);

package/dist/utils/renderElement.d.ts

@@ -1,2 +1,2 @@
-import { ReactElement } from 'react';
+import { type ReactElement } from 'react';
 export declare const renderElement: (Component?: (() => ReactElement) | ReactElement) => import("react").JSX.Element | null;

package/dist/utils/utils.d.ts

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

package/package.json

@@ -1,32 +1,13 @@
 {
   "name": "clear-react-router",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "A lightweight, type-safe routing library for React applications",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/AndrewBubnov/clear-react-router"
-  },
-  "sideEffects": false,
-  "type": "module",
+  "author": "Andrew Bubnov",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist"
-  ],
   "scripts": {
-    "build": "vite build"
-  },
-  "peerDependencies": {
-    "react": ">=16.8.0",
-    "react-dom": ">=16.8.0"
+    "build": "vite build && tsc --emitDeclarationOnly"
   },
   "keywords": [
     "react",
@@ -36,15 +17,33 @@
     "spa",
     "nested-routes"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AndrewBubnov/clear-react-router"
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
+  },
+  "files": [
+    "dist"
+  ],
   "license": "MIT",
-  "author": "Andrew Bubnov",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
   "devDependencies": {
     "@types/react": "^19.2.17",
     "@vitejs/plugin-react": "^6.0.2",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "typescript": "^6.0.3",
-    "vite": "^8.0.16",
-    "vite-plugin-dts": "^5.0.2"
+    "vite": "^8.0.16"
   }
 }

package/README.md

@@ -1,169 +0,0 @@
-A lightweight, type-safe routing library for React applications with nested routes, data loading, navigation blocking, and prefetching.
-
-## Features
-
-- 🧩 **Nested Routes** - Organize your UI with nested layouts and routes
-- ⚡ **Data Loading** - Built-in loaders with caching and stale-while-revalidate strategy
-- 🔒 **Navigation Blocking** - Prevent accidental navigation with `useBlocker`
-- 🎯 **Type-safe Redirects** - Redirect from loaders and beforeLoad hooks
-- 📦 **Prefetching** - Preload data on hover for instant navigation
-- 🚀 **Lazy Loading** - Code-split your routes with dynamic imports for optimal performance
-- 🎨 **Flexible API** - Use components or hooks as you prefer
-- 📱 **Browser History** - Full support for browser back/forward buttons
-- 🧠 **Context-aware** - Pass and update context through routes
-
-## API
-
-### `Router`
-
-Main component that renders the application based on current URL.
-
-| Prop | Type | Description |
-|------|------|-------------|
-| `routeList` | `RouteItem[]` | Array of route configurations |
-| `context` | `object` | Optional initial context (user, theme, etc.) |
-
-### `createRouter(routes)`
-
-Normalizes route configuration. Handles wildcard `*` routes, extracts dynamic params, builds nested paths.
-
-### `redirect(url, search?)`
-
-Redirects from `beforeLoad`.
-```
-beforeLoad: context => {
-					if (!context.isAuthorized) return redirect('/');
-				}
-```
-
-### `Link`
-
-Component for client-side navigation with prefetch support.
-
-| Prop | Type | Default |
-|------|------|---------|
-| `to` | `string` | required |
-| `prefetch` | `boolean` | `true` |
-| `children` | `ReactElement` | required |
-
-## Hooks
-
-### `useNavigate()`
-
-Returns function to navigate programmatically:
-
-- `navigate({ pathname: '/about' })` - navigate to path
-- `navigate({ pathname: '/user/123', state: { fromDashboard: true } })` - navigate with state
-- `navigate(-1)` - go back
-
-**Note:** Navigation state can be accessed via `useLocation()`:
-
-```
-const navigate = useNavigate();
-navigate({ pathname: '/profile', state: { userId: 123 } });
-
-// In Profile component
-const { state } = useLocation();
-console.log(state); // { userId: 123 }
-```
-
-### `useParams<T>()`
-
-Returns route parameters object.
-
-const params = useParams<{ userId: string }>();
-// URL: /user/123 → params.userId === '123'
-
-### `useLocation()`
-
-Returns current location `{ pathname, search, state }`.
-```
-const { pathname, search, state } = useLocation();
-```
-
-### `useLoaderState()`
-
-Returns loaderState from current route's loader.
-
-### `useBlocker(callback)`
-
-Blocks navigation when callback returns `true`.
-
-**Returns:**
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `state` | `'unblocked' \| 'charged' \| 'blocked'` | Current blocker state |
-| `process()` | `() => void` | Confirm navigation and proceed |
-| `reset()` | `() => void` | Cancel navigation |
-
-```
-const { state, process, reset } = useBlocker(() => hasUnsavedChanges);
-
-useEffect(() => {
-  if (state === 'blocked') {
-    // Show your custom modal
-    if (confirm('Leave without saving?')) {
-      process();
-    } else {
-      reset();
-    }
-  }
-}, [state, process, reset]);
-```
-
-### `useBeforeUnload(callback?)`
-
-Executes a callback when the page is about to be closed or reloaded. Perfect for auto-saving data at the last moment.
-
-**Parameters:**
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `callback` | `() => void | undefined` | Function to execute before page unload (e.g., auto-save) |
-
-**Note:** This hook does not show a browser confirmation dialog. It silently executes the callback, allowing you to save user data in the background before the page closes.
-
-```
-const [text, setText] = useState('');
-const onSave = useCallback(() => {
-  localStorage.setItem('draft', text);
-}, [text]);
-
-// Auto-save when user tries to close/reload the page
-useBeforeUnload(text ? onSave : undefined);
-```
-## Route Configuration
-
-### `RouteItem`
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `path` | `string` | Route path, e.g., `/user/:userId` |
-| `element` | `ReactElement \| () => ReactElement \| LazyComponent` | Component to render |
-| `loader` | `() => Promise<unknown>` | Fetch data |
-| `beforeLoad` | `(context) => Promise<void>` | Auth checks, redirects |
-| `afterLoad` | `(context) => Promise<void>` | Analytics, side effects |
-| `fallback` | `ReactElement \| () => ReactElement` | Loading fallback (for lazy loading) |
-| `loaderFallback` | `ReactElement \| () => ReactElement` | Loading fallback (for loader) |
-| `errorElement` | `ReactElement \| () => ReactElement` | Error fallback |
-| `staleTime` | `number` | Cache duration in ms for loader data |
-| `children` | `RouteItem[]` | Nested routes |
-
-## Lazy Loading
-
-Clear Router supports code-splitting out of the box. Simply pass a function that returns a dynamic import:
-```
-{
-  path: '/heavy-page',
-  element: () => import('./pages/HeavyComponent'),
-  fallback: () => <div>Loading...</div>,
-}
-```
-
-## Requirements
-- React 16.6+ (for React.lazy and Suspense)
-- Use `default` export for your lazy-loaded components
-
- ## License
- MIT

package/dist/vite.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import('vite').UserConfig;
-export default _default;