path-router-red 0.4.0

package/README.md

@@ -0,0 +1,427 @@
+# PathRouter
+
+A small, type-safe routing layer built on top of `react-router-dom` that adds:
+
+- A **declarative config** for pages and modals (`setPage` / `setModal`).
+- A **factory** (`createPathRouter`) that binds your config to fully-typed router pieces — no manual generics on every call site.
+- A **single React context** exposing the current page, the current modal and the search params, with imperative helpers (`navigate`, `open`, `close`, `set`, `change`, `delete`, `clear`).
+- **URL-driven modals**: a modal is represented as a segment after `/modal/` inside the path, so it survives reloads, deep links and back/forward navigation.
+- An optional **`ModalWrapper`** plugin (e.g. an animated popup) that can intercept the close action via a forwarded ref.
+
+---
+
+## File layout
+
+```text
+PathRouter/
+├── index.ts                 # Public API (factory + builders + types)
+├── createPathRouter.tsx     # The factory itself
+├── types.ts                 # All public types
+├── Container/
+│   ├── RouterContainer.tsx  # Renders <Routes> for pages + <ModalsContainer>
+│   ├── ModalsContainer.tsx  # Renders the currently open modal
+│   └── index.ts
+├── Provider/
+│   ├── PathProvider.tsx     # BrowserRouter + PathContext provider
+│   ├── context.ts           # React context object
+│   ├── usePath.ts           # Internal hook (factory wraps it for users)
+│   └── index.ts
+├── NavLink/
+│   ├── NavLink.tsx          # Internal NavLink (factory wraps it for users)
+│   └── index.ts
+└── utils/
+    ├── setters.ts           # setPage / setModal helpers
+    ├── createRoute.ts       # Flattens the nested page config
+    ├── clearSlash.ts        # Path normalization
+    ├── parseSearch.ts       # Search-params merge helper
+    └── index.ts
+```
+
+---
+
+## Quick start
+
+```ts
+// src/config/route.ts
+import { setPage, setModal } from "@/modules/PathRouter";
+import { HomePage, AddPage, NotFoundPage } from "@/Pages";
+import { TestModal } from "@/Modals/Test";
+
+export const route = {
+  pages: {
+    home:  setPage({ component: HomePage }),
+    add:   setPage({ component: AddPage }),
+    "*":   setPage({ component: NotFoundPage }),
+  },
+  modals: {
+    test: setModal({ component: TestModal }),
+  },
+} as const;
+```
+
+```ts
+// src/containers/Router/PathProvider.tsx
+import { route } from "@/config";
+import { createPathRouter } from "@/modules/PathRouter";
+
+export const {
+  PathProvider,
+  PathRouterContainer,
+  usePath,
+  NavLink,
+  getPath,
+  getModal,
+} = createPathRouter(route);
+```
+
+```tsx
+// somewhere near the root
+import { PathProvider, PathRouterContainer } from "@/containers/Router";
+
+<PathProvider>
+  <PathRouterContainer fallback={<Spinner />} />
+</PathProvider>;
+```
+
+```tsx
+// any component
+import { usePath, NavLink } from "@/containers/Router";
+
+const Foo = () => {
+  const { page, modal } = usePath();   // no <typeof config> generic needed!
+  page.navigate("add");                 // ✓ autocompleted
+  modal.open("test");                   // ✓ autocompleted
+  return <NavLink to="home" modal="test">Open</NavLink>;
+};
+```
+
+---
+
+## How it works
+
+### 1. Configuration via `setPage` / `setModal`
+
+The config is a plain object with two sections — `pages` and `modals`:
+
+```ts
+import { setPage, setModal } from "@/modules/PathRouter";
+
+export const route = {
+  pages: {
+    "/":   setPage({ component: HomePage }),
+    add:   setPage({ component: AddItemPage }),
+    users: {
+      "/":   setPage({ component: UsersListPage }),
+      ":id": setPage({ component: UserPage }),
+    },
+    modules: {
+      ...setPage({ component: ModulesIndexPage }), // page at /modules
+      routing: setPage({ component: RoutingPage }), // page at /modules/routing
+      "*":     setPage({ component: RoutingPage }), // page at /modules/*
+    },
+    "*":   setPage({ component: NotFoundPage }),
+  },
+  modals: {
+    test:    setModal({ component: TestModal }),
+    confirm: setModal({ component: ConfirmModal }),
+  },
+} as const;
+```
+
+- `setPage({ component, redirect? })` wraps the value as `{ data: {...} }`. The `data` field marks the node as a renderable page, but **does not stop** the route builder from descending — children of the same node are still discovered.
+- Pages can be **nested** as plain objects — `createRoute` walks the tree and produces a flat `[{ pathName, data }]` list (see `utils/createRoute.ts`).
+- A node may **simultaneously be a page and a container** for child routes. Spread the result of `setPage` into the node to attach a component at that path while keeping nested keys:
+
+  ```ts
+  modules: {
+    ...setPage({ component: ModulesIndexPage }), // /modules
+    routing: setPage({ component: RoutingPage }), // /modules/routing
+    "*":     setPage({ component: RoutingPage }), // /modules/*
+  }
+  ```
+
+  This is what enables breadcrumb-style hierarchies where each ancestor segment is itself a page.
+- Recursion into a node stops only when the node itself carries `component` or `redirect` at its top level (i.e. it is a bare leaf, not a `setPage(...)` result). `setPage` puts those fields under `data`, so spreading it never blocks descent.
+- A page with `redirect` (or no `component`) becomes a `<Navigate to={redirect || "/"} replace />`.
+- `setModal({ component })` is just an identity helper that preserves literal types for inference.
+- `as const` is **required** — without it TS widens string keys to `string` and you lose autocompletion.
+
+### 2. The `createPathRouter` factory
+
+`createPathRouter(route)` captures your config once and returns everything pre-bound:
+
+```ts
+const {
+  PathProvider,            // BrowserRouter + context
+  PathRouterContainer,     // renders pages + modals (config injected)
+  usePath,                 // typed hook  — no <typeof config> needed
+  NavLink,                 // typed link  — no <typeof config> needed
+  getPath,                 // identity helper: <P extends PathNamesOf<C>>(p: P) => p
+  getModal,                // identity helper: <M extends ModalNamesOf<C>>(m: M) => m
+  config,                  // the original config, re-exported
+} = createPathRouter(route);
+```
+
+Why re-exports rather than direct imports?
+
+- TypeScript cannot infer generics from a literal `typeof route` _unless_ you pass it explicitly each time. The factory passes it once for you.
+- Every consumer of the returned API gets autocompletion of routes / modal names with **zero ceremony**.
+- The package itself stays generic and reusable; the binding lives in your app code.
+
+> The factory return values are not re-exported from `@/modules/PathRouter`. The only way to obtain `PathProvider`, `PathRouterContainer`, `usePath`, `NavLink`, `getPath`, `getModal` is via `createPathRouter(config)`.
+
+### 3. Mounting
+
+```tsx
+import { PathProvider, PathRouterContainer } from "@/containers/Router";
+
+<PathProvider>
+  <PathRouterContainer
+    ModalWrapper={MyModalWrapper}   // optional
+    fallback={<Spinner />}          // optional Suspense fallback
+  />
+</PathProvider>;
+```
+
+- `PathProvider` mounts a `BrowserRouter` and an inner provider that derives the page path, the modal state and the search params from `useLocation()` (`Provider/PathProvider.tsx`).
+- `PathRouterContainer` renders the pages inside `<Suspense>` and, if a modal is open, mounts `ModalsContainer` next to the page tree. `config` is already injected by the factory — you only pass `ModalWrapper` / `fallback`.
+
+### 4. URL shape
+
+A URL is split on the literal **`/modal/`** separator:
+
+```text
+/users/42/modal/confirm/extra-crumb?tab=info
+└── page path ──┘     └─ modal ──┘
+```
+
+In `PathProvider`:
+
+```ts
+const [rawPagePath, modalPath] = location.pathname.split("/modal/");
+const segments = (modalPath || "").split("/").filter(Boolean);
+const name        = segments[0];       // "confirm"
+const breadCrumbs = segments.slice(1); // ["extra-crumb"]
+```
+
+So:
+
+- `page.path` always points to the page route the user is on, regardless of whether a modal is open.
+- `modal.name` is the first segment after `/modal/`.
+- `modal.breadCrumbs` are additional path segments that the modal can use for its own internal navigation/steps.
+- `modal.isOpen` is `true` iff `modal.name` is set.
+
+This means modals are **bookmarkable and shareable** out of the box and the browser back button closes the modal naturally.
+
+### 5. The `usePath` hook (from the factory)
+
+```ts
+import { usePath } from "@/containers/Router";
+
+const { page, modal, searchParams } = usePath();   // already typed!
+
+page.path;                 // current page pathname (no /modal/... suffix)
+page.navigate("add");      // ✓ typed against config.pages
+page.isHavePrevHistory;    // true if history.key !== "default"
+
+modal.isOpen;
+modal.name;                // current modal key
+modal.breadCrumbs;         // string[] after the modal name
+modal.path;                // "<name>/<crumb1>/<crumb2>"
+modal.open("confirm", ["step-2"]); // ✓ typed against config.modals
+modal.close();
+
+searchParams.params;       // Record<string, string[]>
+searchParams.change({ tab: "info" });           // merge (string=set, string[]=append)
+searchParams.set({ tab: ["a", "b"] });          // replace per-key
+searchParams.delete("tab");
+searchParams.clear();
+```
+
+### 6. `getPath` / `getModal` — typed identity helpers
+
+When you need a typed path or modal-name literal somewhere outside JSX (e.g. inside a side-effect, a redux thunk, a `redirect` field of another page), use the identity helpers returned by the factory:
+
+```ts
+import { getPath, getModal } from "@/containers/Router";
+
+const target = getPath("home");      // type: "home"
+const which  = getModal("test");     // type: "test"
+
+// Compile-time error: argument is not assignable to PathNamesOf<typeof route>
+const bad = getPath("does-not-exist");
+```
+
+These replace the previous `export type PathNames = NestedKeyOf<typeof routes, "data">` pattern that is impossible to express from inside an isolated package.
+
+If you really need the type itself (e.g. as a function parameter), it is still available via `typeof getPath`:
+
+```ts
+type PathNames = Parameters<typeof getPath>[0];
+type ModalNames = Parameters<typeof getModal>[0];
+```
+
+…or use the package-level generics with an explicit config:
+
+```ts
+import type { PathNamesOf, ModalNamesOf } from "@/modules/PathRouter";
+import type { route } from "@/config";
+
+type PathNames  = PathNamesOf<typeof route>;
+type ModalNames = ModalNamesOf<typeof route>;
+```
+
+### 7. `NavLink` (from the factory)
+
+```tsx
+import { NavLink } from "@/containers/Router";
+
+<NavLink to="home">Home</NavLink>
+<NavLink modal="test">Open test modal</NavLink>
+<NavLink to="users" modal="confirm" modalBreadCrumbs={["step-2"]}>
+  Users + confirm at step 2
+</NavLink>
+```
+
+- Renders a real `<a href>` (right-click / “open in new tab” / SSR work as expected).
+- Intercepts the primary-button click and routes through `page.navigate(...)`.
+- Adds `aria-current="page"` and `data-active` when active; you can override the active class via `activeClassName`.
+
+### 8. Page rendering (`RouterContainer.tsx`)
+
+- Calls `createRoute(config)` once (memoised) to flatten the page tree.
+- Renders a single `<Routes>` switch with one `<Route>` per leaf.
+- If a leaf has no `component` or has a `redirect`, the element becomes `<Navigate to={redirect || "/"} replace />`.
+- The whole switch is wrapped in `<Suspense fallback={fallback}>` so lazy components work transparently.
+- Modals are rendered as a **sibling** of `<Routes>`, only when `modal.isOpen` — they overlay the current page rather than replacing it.
+
+### 9. Modal rendering (`ModalsContainer.tsx`)
+
+- Builds a virtual location `"<pagePath>/<modalName>"` (normalized via `clearSlash`) and feeds it to a dedicated `<Routes location={routesLocation}>`. This is what makes the modal aware of the current page path.
+- Each modal route is registered at `"<pagePath>/<modalName>"`, so modals can be **page-scoped** if needed.
+- If the URL contains a modal name that does not exist in the config (no matching component), the container calls `modal.close()` automatically — broken/stale modal links self-heal.
+- If a `ModalWrapper` is provided, it is rendered with `{ modalName, isOpen, onClose, children }` and a forwarded ref. When the user triggers close, the container prefers `ref.current.handleCloseWithAnimation()` (so the wrapper can run an exit animation), and only falls back to the raw `close()` if that method is not exposed.
+
+The `ModalWrapper` contract:
+
+```ts
+interface ModalWrapperRef {
+  handleCloseWithAnimation: () => void;
+}
+
+interface ModalWrapperProps {
+  modalName?: string;
+  isOpen: boolean;
+  onClose: () => void;
+  children?: ReactNode;
+}
+
+type ModalWrapperComponent = ForwardRefExoticComponent<
+  ModalWrapperProps & RefAttributes<ModalWrapperRef>
+>;
+```
+
+Modal components themselves receive `ModalProps` (`{ onClose: () => void }`):
+
+```tsx
+import type { FC } from "react";
+import type { ModalProps } from "@/modules/PathRouter";
+
+export const TestModal: FC<ModalProps> = ({ onClose }) => (
+  <button onClick={onClose}>Close</button>
+);
+```
+
+### 10. Path normalization (`clearSlash`)
+
+All internal `navigate(...)` calls go through `clearSlash`:
+
+- collapses repeated slashes (`a//b` → `a/b`);
+- guarantees a single leading slash;
+- strips trailing slashes (root `/` stays as `/`).
+
+This keeps the URL canonical regardless of how the caller composed it.
+
+### 11. Search params
+
+`PathProvider` derives `searchParams` from `location.search` and exposes four helpers:
+
+| Method   | Behaviour                                                                 |
+| -------- | ------------------------------------------------------------------------- |
+| `change` | Merge: `string` value → set the key; `string[]` value → append values.    |
+| `set`    | Replace each provided key: deletes existing values, then writes new ones. |
+| `delete` | Removes a key entirely.                                                   |
+| `clear`  | Removes every search param.                                               |
+
+All mutations preserve `location.hash`.
+
+---
+
+## Public API of `@/modules/PathRouter`
+
+The package exposes only what cannot depend on a concrete config:
+
+### Builders / factory / utilities
+
+- `setPage`, `setModal` — config builders.
+- `createPathRouter(config)` — returns `{ PathProvider, PathRouterContainer, usePath, NavLink, getPath, getModal, config }`.
+- `clearSlash` — path normalizer.
+
+### Types — config-independent
+
+- `RouterConfig`, `PageData`, `ModalData`
+- `ModalProps` — props passed to a modal component.
+- `ModalState`, `SearchParams`, `SearchParamsState`
+- `ModalWrapperComponent`, `ModalWrapperProps`, `ModalWrapperRef`
+- `BoundPathRouterContainerProps`, `BoundNavLinkProps<C>`, `PathRouter<C>`
+
+### Types — config-dependent (must be parametrised)
+
+- `PathNamesOf<C>` — must be used as `PathNamesOf<typeof route>`.
+- `ModalNamesOf<C>` — must be used as `ModalNamesOf<typeof route>`.
+
+> `PathProvider`, `PathRouterContainer`, `usePath`, `NavLink`, `getPath`, `getModal` are **deliberately not exported** from the package — obtain them from `createPathRouter(config)`.
+> `PathContextType` is also not re-exported; the typed shape is available via the return type of the factory's `usePath`.
+
+---
+
+## Minimal end-to-end example
+
+```tsx
+import { setPage, setModal, createPathRouter } from "@/modules/PathRouter";
+
+const route = {
+  pages: {
+    "/":  setPage({ component: HomePage }),
+    add:  setPage({ component: AddItemPage }),
+    "*":  setPage({ redirect: "/" }),
+  },
+  modals: {
+    confirm: setModal({ component: ConfirmModal }),
+  },
+} as const;
+
+export const {
+  PathProvider,
+  PathRouterContainer,
+  usePath,
+  NavLink,
+  getPath,
+  getModal,
+} = createPathRouter(route);
+
+export const App = () => (
+  <PathProvider>
+    <PathRouterContainer />
+  </PathProvider>
+);
+
+const SomeButton = () => {
+  const { page, modal } = usePath();
+  return (
+    <button onClick={() => modal.open("confirm")}>
+      Open confirm (current page stays: {page.path})
+    </button>
+  );
+};
+```

package/dist/PathRouter/Container/ModalsContainer.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import type { ModalData, ModalWrapperComponent } from "../types";
+export interface ModalContainerProps {
+    paths: {
+        pathName: string;
+        data: ModalData;
+    }[];
+    /**
+     * Optional wrapper around the modal contents (e.g. an animated popup).
+     * If omitted, the modal component is rendered directly.
+     */
+    ModalWrapper?: ModalWrapperComponent;
+    /** Fallback shown by `Suspense` while a lazy modal is loading. */
+    fallback?: React.ReactNode;
+}
+export declare const ModalsContainer: React.FC<ModalContainerProps>;
+//# sourceMappingURL=ModalsContainer.d.ts.map

package/dist/PathRouter/Container/ModalsContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModalsContainer.d.ts","sourceRoot":"","sources":["../../../src/PathRouter/Container/ModalsContainer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAgD,MAAM,OAAO,CAAC;AAKrE,OAAO,KAAK,EACV,SAAS,EACT,qBAAqB,EAEtB,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,CAAA;KAAE,EAAE,CAAC;IAC/C;;;OAGG;IACH,YAAY,CAAC,EAAE,qBAAqB,CAAC;IACrC,kEAAkE;IAClE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAqEzD,CAAC"}

package/dist/PathRouter/Container/ModalsContainer.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalsContainer = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_router_dom_1 = require("react-router-dom");
+const usePath_1 = require("../Provider/usePath");
+const clearSlash_1 = require("../utils/clearSlash");
+const ModalsContainer = ({ paths, ModalWrapper, fallback = null, }) => {
+    const { page, modal } = (0, usePath_1.usePath)();
+    const { name: modalName, isOpen, close } = modal;
+    const modalRef = (0, react_1.useRef)(null);
+    const hasMatchingComponent = !!modalName &&
+        paths.some(({ pathName, data }) => pathName === modalName && !!data.component);
+    (0, react_1.useEffect)(() => {
+        if (isOpen && !hasMatchingComponent) {
+            close();
+        }
+    }, [isOpen, hasMatchingComponent, close]);
+    if (!modalName)
+        return null;
+    const routesLocation = (0, clearSlash_1.clearSlash)(`${page.path}/${modalName}`);
+    const handleClose = () => modalRef.current?.handleCloseWithAnimation
+        ? modalRef.current.handleCloseWithAnimation()
+        : close();
+    const content = ((0, jsx_runtime_1.jsx)(react_1.Suspense, { fallback: fallback, children: (0, jsx_runtime_1.jsx)(react_router_dom_1.Routes, { location: routesLocation, children: paths.map(({ pathName, data }, i) => {
+                const { component: Component } = data;
+                if (!Component) {
+                    return ((0, jsx_runtime_1.jsx)(react_router_dom_1.Route, { path: (0, clearSlash_1.clearSlash)(`${page.path}/${pathName}`), element: (0, jsx_runtime_1.jsx)(react_router_dom_1.Navigate, { to: "/", replace: true }) }, `modals/${pathName}_${i}`));
+                }
+                return ((0, jsx_runtime_1.jsx)(react_router_dom_1.Route, { path: (0, clearSlash_1.clearSlash)(`${page.path}/${pathName}`), element: (0, jsx_runtime_1.jsx)(Component, { onClose: handleClose }) }, `modals/${pathName}_${i}`));
+            }) }) }));
+    if (!ModalWrapper) {
+        return isOpen ? (0, jsx_runtime_1.jsx)(react_1.Fragment, { children: content }) : null;
+    }
+    return ((0, jsx_runtime_1.jsx)(ModalWrapper, { ref: modalRef, modalName: modalName, isOpen: isOpen, onClose: close, children: content }));
+};
+exports.ModalsContainer = ModalsContainer;
+//# sourceMappingURL=ModalsContainer.js.map

package/dist/PathRouter/Container/ModalsContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModalsContainer.js","sourceRoot":"","sources":["../../../src/PathRouter/Container/ModalsContainer.tsx"],"names":[],"mappings":";;;;AAAA,iCAAqE;AACrE,uDAA2D;AAE3D,iDAA8C;AAC9C,oDAAiD;AAkB1C,MAAM,eAAe,GAAkC,CAAC,EAC7D,KAAK,EACL,YAAY,EACZ,QAAQ,GAAG,IAAI,GAChB,EAAE,EAAE;IACH,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAA,iBAAO,GAAE,CAAC;IAClC,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IACjD,MAAM,QAAQ,GAAG,IAAA,cAAM,EAAyB,IAAI,CAAC,CAAC;IAEtD,MAAM,oBAAoB,GACxB,CAAC,CAAC,SAAS;QACX,KAAK,CAAC,IAAI,CACR,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,CACnE,CAAC;IAEJ,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,IAAI,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;YACpC,KAAK,EAAE,CAAC;QACV,CAAC;IACH,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,EAAE,KAAK,CAAC,CAAC,CAAC;IAE1C,IAAI,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAE5B,MAAM,cAAc,GAAG,IAAA,uBAAU,EAAC,GAAG,IAAI,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC,CAAC;IAE/D,MAAM,WAAW,GAAG,GAAG,EAAE,CACvB,QAAQ,CAAC,OAAO,EAAE,wBAAwB;QACxC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,wBAAwB,EAAE;QAC7C,CAAC,CAAC,KAAK,EAAE,CAAC;IAEd,MAAM,OAAO,GAAG,CACd,uBAAC,gBAAQ,IAAC,QAAQ,EAAE,QAAQ,YAC1B,uBAAC,yBAAM,IAAC,QAAQ,EAAE,cAAc,YAC7B,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,EAAE;gBACnC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;gBACtC,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,OAAO,CACL,uBAAC,wBAAK,IAEJ,IAAI,EAAE,IAAA,uBAAU,EAAC,GAAG,IAAI,CAAC,IAAI,IAAI,QAAQ,EAAE,CAAC,EAC5C,OAAO,EAAE,uBAAC,2BAAQ,IAAC,EAAE,EAAC,GAAG,EAAC,OAAO,SAAG,IAF/B,UAAU,QAAQ,IAAI,CAAC,EAAE,CAG9B,CACH,CAAC;gBACJ,CAAC;gBACD,OAAO,CACL,uBAAC,wBAAK,IAEJ,IAAI,EAAE,IAAA,uBAAU,EAAC,GAAG,IAAI,CAAC,IAAI,IAAI,QAAQ,EAAE,CAAC,EAC5C,OAAO,EAAE,uBAAC,SAAS,IAAC,OAAO,EAAE,WAAW,GAAI,IAFvC,UAAU,QAAQ,IAAI,CAAC,EAAE,CAG9B,CACH,CAAC;YACJ,CAAC,CAAC,GACK,GACA,CACZ,CAAC;IAEF,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,OAAO,MAAM,CAAC,CAAC,CAAC,uBAAC,gBAAQ,cAAE,OAAO,GAAY,CAAC,CAAC,CAAC,IAAI,CAAC;IACxD,CAAC;IAED,OAAO,CACL,uBAAC,YAAY,IACX,GAAG,EAAE,QAAQ,EACb,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,KAAK,YACb,OAAO,GACK,CAChB,CAAC;AACJ,CAAC,CAAC;AArEW,QAAA,eAAe,mBAqE1B"}

package/dist/PathRouter/Container/RouterContainer.d.ts

@@ -0,0 +1,16 @@
+import React, { type ReactNode } from "react";
+import type { ModalWrapperComponent, RouterConfig } from "../types";
+export interface PathRouterProps<C extends RouterConfig<any, any>> {
+    /** Pages + modals tree built with `setPage` / `setModal`. */
+    config: C;
+    /**
+     * Optional component used to wrap modal content (animated popup, etc.).
+     * The package will pass it `{ modalName, isOpen, onClose, children }`
+     * and read `handleCloseWithAnimation()` from its forwarded ref.
+     */
+    ModalWrapper?: ModalWrapperComponent;
+    /** Suspense fallback shown while pages / modals are loading. */
+    fallback?: ReactNode;
+}
+export declare const PathRouterContainer: <C extends RouterConfig<any, any>>({ config, ModalWrapper, fallback, }: PathRouterProps<C>) => React.JSX.Element;
+//# sourceMappingURL=RouterContainer.d.ts.map

package/dist/PathRouter/Container/RouterContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterContainer.d.ts","sourceRoot":"","sources":["../../../src/PathRouter/Container/RouterContainer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAC;AAOjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEpE,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC;IAC/D,6DAA6D;IAC7D,MAAM,EAAE,CAAC,CAAC;IACV;;;;OAIG;IACH,YAAY,CAAC,EAAE,qBAAqB,CAAC;IACrC,gEAAgE;IAChE,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,qCAInE,eAAe,CAAC,CAAC,CAAC,sBAuCpB,CAAC"}

package/dist/PathRouter/Container/RouterContainer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathRouterContainer = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_router_dom_1 = require("react-router-dom");
+const usePath_1 = require("../Provider/usePath");
+const createRoute_1 = require("../utils/createRoute");
+const ModalsContainer_1 = require("./ModalsContainer");
+const PathRouterContainer = ({ config, ModalWrapper, fallback = null, }) => {
+    const { modal } = (0, usePath_1.usePath)();
+    const { pages, modals } = (0, react_1.useMemo)(() => (0, createRoute_1.createRoute)(config), [config]);
+    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(react_1.Suspense, { fallback: fallback, children: (0, jsx_runtime_1.jsx)(react_router_dom_1.Routes, { children: pages.map(({ pathName, data }, i) => {
+                        const { component: Component, redirect } = data;
+                        const isRedirect = Boolean(!Component || redirect);
+                        return ((0, jsx_runtime_1.jsx)(react_router_dom_1.Route, { path: pathName, element: !isRedirect && Component ? ((0, jsx_runtime_1.jsx)(Component, {})) : ((0, jsx_runtime_1.jsx)(react_router_dom_1.Navigate, { to: redirect || "/", replace: true })) }, `routes/${pathName}_${i}`));
+                    }) }) }), modal.isOpen && ((0, jsx_runtime_1.jsx)(ModalsContainer_1.ModalsContainer, { paths: modals, ModalWrapper: ModalWrapper, fallback: fallback }))] }));
+};
+exports.PathRouterContainer = PathRouterContainer;
+//# sourceMappingURL=RouterContainer.js.map

package/dist/PathRouter/Container/RouterContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterContainer.js","sourceRoot":"","sources":["../../../src/PathRouter/Container/RouterContainer.tsx"],"names":[],"mappings":";;;;AAAA,iCAAiE;AACjE,uDAAqE;AAErE,iDAA8C;AAC9C,sDAAmD;AAEnD,uDAAoD;AAgB7C,MAAM,mBAAmB,GAAG,CAAmC,EACpE,MAAM,EACN,YAAY,EACZ,QAAQ,GAAG,IAAI,GACI,EAAE,EAAE;IACvB,MAAM,EAAE,KAAK,EAAE,GAAG,IAAA,iBAAO,GAAE,CAAC;IAE5B,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAA,eAAO,EAAC,GAAG,EAAE,CAAC,IAAA,yBAAW,EAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvE,OAAO,CACL,6DACE,uBAAC,gBAAQ,IAAC,QAAQ,EAAE,QAAQ,YAC1B,uBAAC,yBAAM,cACJ,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,EAAE;wBACnC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;wBAChD,MAAM,UAAU,GAAG,OAAO,CAAC,CAAC,SAAS,IAAI,QAAQ,CAAC,CAAC;wBAEnD,OAAO,CACL,uBAAC,wBAAK,IAEJ,IAAI,EAAE,QAAQ,EACd,OAAO,EACL,CAAC,UAAU,IAAI,SAAS,CAAC,CAAC,CAAC,CACzB,uBAAC,SAAS,KAAG,CACd,CAAC,CAAC,CAAC,CACF,uBAAC,2BAAQ,IAAC,EAAE,EAAE,QAAQ,IAAI,GAAG,EAAE,OAAO,SAAG,CAC1C,IAPE,UAAU,QAAQ,IAAI,CAAC,EAAE,CAS9B,CACH,CAAC;oBACJ,CAAC,CAAC,GACK,GACA,EAEV,KAAK,CAAC,MAAM,IAAI,CACf,uBAAC,iCAAe,IACd,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,QAAQ,GAClB,CACH,IACA,CACJ,CAAC;AACJ,CAAC,CAAC;AA3CW,QAAA,mBAAmB,uBA2C9B"}

package/dist/PathRouter/Container/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./RouterContainer";
+//# sourceMappingURL=index.d.ts.map

package/dist/PathRouter/Container/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/PathRouter/Container/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/PathRouter/Container/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RouterContainer"), exports);
+//# sourceMappingURL=index.js.map

package/dist/PathRouter/Container/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/PathRouter/Container/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC"}

package/dist/PathRouter/NavLink/NavLink.d.ts

@@ -0,0 +1,40 @@
+import React, { type AnchorHTMLAttributes, type ReactNode, type Ref } from "react";
+import type { NavigateOptions } from "react-router-dom";
+import type { ModalNamesOf, PathNamesOf, RouterConfig } from "../types";
+export interface NavLinkProps<C extends RouterConfig<any, any> = RouterConfig<any, any>> extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+    /**
+     * Target page path. If omitted, the current page is preserved
+     * (useful when you only want to open a modal).
+     */
+    to?: PathNamesOf<C>;
+    /** Modal to open on click. */
+    modal?: ModalNamesOf<C>;
+    /** Extra path segments appended after the modal name. */
+    modalBreadCrumbs?: string[];
+    /** Replace history entry instead of pushing a new one. */
+    replace?: boolean;
+    /** Extra options forwarded to the underlying `navigate`. */
+    navigateOptions?: NavigateOptions;
+    /** Class applied when this link matches the current location. */
+    activeClassName?: string;
+    children?: ReactNode;
+}
+/**
+ * Router-aware anchor.
+ *
+ * Renders a real `<a href>` (so right-click / "open in new tab" / SSR work)
+ * and intercepts the primary-button click to call `page.navigate` /
+ * open a modal through the `PathRouter` context.
+ *
+ * ```tsx
+ * <NavLink<typeof config> to="add">Add item</NavLink>
+ * <NavLink<typeof config> modal="confirm">Open confirm</NavLink>
+ * <NavLink<typeof config> to="users" modal="confirm" modalBreadCrumbs={["step-2"]}>
+ *   Go to users + open confirm at step 2
+ * </NavLink>
+ * ```
+ */
+export declare const NavLink: <C extends RouterConfig<any, any> = RouterConfig<any, any>>(props: NavLinkProps<C> & {
+    ref?: Ref<HTMLAnchorElement>;
+}) => React.ReactElement | null;
+//# sourceMappingURL=NavLink.d.ts.map

package/dist/PathRouter/NavLink/NavLink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavLink.d.ts","sourceRoot":"","sources":["../../../src/PathRouter/NavLink/NavLink.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAEZ,KAAK,oBAAoB,EAEzB,KAAK,SAAS,EACd,KAAK,GAAG,EACT,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAIxD,OAAO,KAAK,EACV,YAAY,EACZ,WAAW,EACX,YAAY,EACb,MAAM,UAAU,CAAC;AAKlB,MAAM,WAAW,YAAY,CAC3B,CAAC,SAAS,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CACzD,SAAQ,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC7D;;;OAGG;IACH,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACpB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACxB,yDAAyD;IACzD,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,0DAA0D;IAC1D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,4DAA4D;IAC5D,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,iEAAiE;IACjE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAuFD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,OAAO,EAAmB,CACrC,CAAC,SAAS,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,EAEzD,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG;IAAE,GAAG,CAAC,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAA;CAAE,KACtD,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC"}