@genesislcap/foundation-react-utils 14.496.2-alpha-2c4a633.0 → 14.498.0

package/dist/custom-elements.json

@@ -263,6 +263,251 @@
           }
         }
       ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/router/index.ts",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "ProtectedRoute",
+          "declaration": {
+            "name": "ProtectedRoute",
+            "module": "./protected-route"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "createProtectedRoute",
+          "declaration": {
+            "name": "createProtectedRoute",
+            "module": "./protected-route"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ProtectedRouteProps",
+          "declaration": {
+            "name": "ProtectedRouteProps",
+            "module": "./protected-route"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "BoundProtectedRouteProps",
+          "declaration": {
+            "name": "BoundProtectedRouteProps",
+            "module": "./protected-route"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "CreateProtectedRouteOptions",
+          "declaration": {
+            "name": "CreateProtectedRouteOptions",
+            "module": "./protected-route"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "buildPostLoginRedirect",
+          "declaration": {
+            "name": "buildPostLoginRedirect",
+            "module": "./post-login-redirect"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "RedirectableLocationState",
+          "declaration": {
+            "name": "RedirectableLocationState",
+            "module": "./post-login-redirect"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "readInitialParam",
+          "declaration": {
+            "name": "readInitialParam",
+            "module": "./single-component"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "createComponentRegistry",
+          "declaration": {
+            "name": "createComponentRegistry",
+            "module": "./single-component"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "SingleComponentOutlet",
+          "declaration": {
+            "name": "SingleComponentOutlet",
+            "module": "./single-component"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ComponentRegistry",
+          "declaration": {
+            "name": "ComponentRegistry",
+            "module": "./single-component"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "SingleComponentOutletProps",
+          "declaration": {
+            "name": "SingleComponentOutletProps",
+            "module": "./single-component"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "renderAppRoutes",
+          "declaration": {
+            "name": "renderAppRoutes",
+            "module": "./app-routes"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AppRouteConfig",
+          "declaration": {
+            "name": "AppRouteConfig",
+            "module": "./app-routes"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "RouteRedirect",
+          "declaration": {
+            "name": "RouteRedirect",
+            "module": "./app-routes"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "RenderAppRoutesOptions",
+          "declaration": {
+            "name": "RenderAppRoutesOptions",
+            "module": "./app-routes"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "mergePbcRoutes",
+          "declaration": {
+            "name": "mergePbcRoutes",
+            "module": "./pbc-routes"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "PbcRouteInput",
+          "declaration": {
+            "name": "PbcRouteInput",
+            "module": "./pbc-routes"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "MergePbcRoutesOptions",
+          "declaration": {
+            "name": "MergePbcRoutesOptions",
+            "module": "./pbc-routes"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/router/pbc-routes.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "mergePbcRoutes",
+          "return": {
+            "type": {
+              "text": "AppRouteConfig[]"
+            }
+          },
+          "parameters": [
+            {
+              "name": "staticRoutes",
+              "type": {
+                "text": "AppRouteConfig[]"
+              }
+            },
+            {
+              "name": "pbcRoutes",
+              "type": {
+                "text": "PbcRouteInput[]"
+              }
+            },
+            {
+              "name": "{ renderPbc }",
+              "type": {
+                "text": "MergePbcRoutesOptions"
+              }
+            }
+          ],
+          "description": "Merge a static route table with PBC routes (e.g. from `getApp().routes`) into\none AppRouteConfig array. PBC routes are guarded, in-layout, and carry\ntheir element/tag + navItems through `data` so downstream consumers (a PBC\ncontainer, nav-item derivation) can read them — matching the `data` shape the\nhand-rolled version produced."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "mergePbcRoutes",
+          "declaration": {
+            "name": "mergePbcRoutes",
+            "module": "src/router/pbc-routes.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/router/post-login-redirect.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "buildPostLoginRedirect",
+          "return": {
+            "type": {
+              "text": "string"
+            }
+          },
+          "parameters": [
+            {
+              "name": "location",
+              "type": {
+                "text": "{ state?: RedirectableLocationState | null }"
+              },
+              "description": "The current router location (needs only `state.from`)."
+            },
+            {
+              "name": "defaultPath",
+              "default": "'/'",
+              "description": "Where to land when nothing was stashed. Defaults to `/`."
+            }
+          ],
+          "description": "Build the post-login redirect target from a router location's `state.from`,\npreserving the query string and hash so deep-link params (e.g.\n`?component=<name>`) survive the login bounce. Falls back to `defaultPath`\nwhen there is no stashed origin."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "buildPostLoginRedirect",
+          "declaration": {
+            "name": "buildPostLoginRedirect",
+            "module": "src/router/post-login-redirect.ts"
+          }
+        }
+      ]
     }
   ]
 }

package/dist/dts/router/app-routes.d.ts

@@ -0,0 +1,69 @@
+import type { ComponentType, ReactElement, ReactNode } from 'react';
+import type { BoundProtectedRouteProps } from './protected-route';
+/**
+ * Declarative description of one app route. The `element` is rendered when the
+ * path matches; guarding, layout nesting, and permission are derived from the
+ * flags below so the app doesn't hand-write the `<Route>`/`<ProtectedRoute>`
+ * boilerplate per route.
+ */
+export interface AppRouteConfig {
+    path: string;
+    element: ReactNode;
+    /** Skip the auth guard (e.g. login, not-permitted). Default `false`. */
+    public?: boolean;
+    /** Render outside the shared layout. Default `false` (guarded routes sit in the layout). */
+    noLayout?: boolean;
+    /** Permission code handed to the guard's optional permission check. */
+    permissionCode?: string;
+    /**
+     * Nested child routes rendered inside this route's `element` (which must
+     * render an `<Outlet />`). Children use paths relative to this route and
+     * inherit its guard — they are rendered as plain routes, not re-guarded.
+     */
+    children?: AppRouteConfig[];
+    /** Arbitrary metadata preserved for other consumers (nav items, PBC info, ...). */
+    data?: Record<string, any>;
+}
+/** A simple `from → to` redirect. */
+export interface RouteRedirect {
+    from: string;
+    to: string;
+}
+/**
+ * Options for {@link renderAppRoutes}.
+ */
+export interface RenderAppRoutesOptions {
+    /** The full route table (static + any merged PBC routes). */
+    routes: AppRouteConfig[];
+    /**
+     * Guard component (typically from `createProtectedRoute`) wrapping every
+     * non-public route; receives each route's `permissionCode`.
+     */
+    ProtectedRoute: ComponentType<BoundProtectedRouteProps>;
+    /**
+     * Layout route element (rendering an `<Outlet />`) that wraps in-layout
+     * routes. Omit to render every route at the top level.
+     */
+    layout?: ReactElement;
+    /** `from → to` redirects rendered before the routes. */
+    redirects?: RouteRedirect[];
+    /** Element for unmatched paths (`*`). */
+    notFound?: ReactNode;
+    /**
+     * When `name` is truthy, short-circuit to single-component mode: render only
+     * the public routes (so login / session-restore still work) plus a catch-all
+     * rendering `element` behind the guard. See the single-component deep-link.
+     */
+    singleComponent?: {
+        name: string | null | undefined;
+        element: ReactNode;
+    };
+}
+/**
+ * Build the app's `<Routes>` tree from a declarative route table, applying the
+ * auth guard, layout nesting, redirects, not-found, and the single-component
+ * short-circuit — so a consuming app configures routes instead of hand-writing
+ * repetitive `<Route element={<ProtectedRoute>…}>` markup.
+ */
+export declare function renderAppRoutes({ routes, ProtectedRoute, layout, redirects, notFound, singleComponent, }: RenderAppRoutesOptions): ReactElement;
+//# sourceMappingURL=app-routes.d.ts.map

package/dist/dts/router/app-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-routes.d.ts","sourceRoot":"","sources":["../../../src/router/app-routes.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAElE;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,CAAC;IACnB,wEAAwE;IACxE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uEAAuE;IACvE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;IAC5B,mFAAmF;IACnF,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5B;AAED,qCAAqC;AACrC,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,6DAA6D;IAC7D,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB;;;OAGG;IACH,cAAc,EAAE,aAAa,CAAC,wBAAwB,CAAC,CAAC;IACxD;;;OAGG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,wDAAwD;IACxD,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;IAC5B,yCAAyC;IACzC,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;OAIG;IACH,eAAe,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;QAAC,OAAO,EAAE,SAAS,CAAA;KAAE,CAAC;CAC3E;AAKD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAC9B,MAAM,EACN,cAAc,EACd,MAAM,EACN,SAAc,EACd,QAAQ,EACR,eAAe,GAChB,EAAE,sBAAsB,GAAG,YAAY,CA6DvC"}

package/dist/dts/router/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `@genesislcap/foundation-react-utils/router`
+ *
+ * Reusable `react-router-dom` primitives for Genesis Foundation React apps, so
+ * the app-shell routing logic doesn't have to be reimplemented per app.
+ *
+ * Exposed as a subpath (`/router`) rather than from the package root so that
+ * consumers which don't route (and don't depend on `react-router-dom`) are
+ * unaffected.
+ *
+ * Key exports:
+ * - `ProtectedRoute` / `createProtectedRoute` — auth + permission gate that
+ *   stashes the full origin location (incl. `search` + `hash`) for post-login
+ *   restore, and redirects to a not-permitted path when authorized-but-blocked.
+ * - `buildPostLoginRedirect` — rebuild the return URL preserving query + hash.
+ * - `readInitialParam` / `createComponentRegistry` / `SingleComponentOutlet` —
+ *   render a single registered component full-screen from a `?param=<name>`
+ *   deep-link captured before the shell strips the query string.
+ * - `renderAppRoutes` — build the app's `<Routes>` from a declarative route
+ *   table (guarding, layout nesting, redirects, not-found, single-component).
+ * - `mergePbcRoutes` — merge static routes with shell/PBC routes into one table.
+ */
+export { ProtectedRoute, createProtectedRoute } from './protected-route';
+export type { ProtectedRouteProps, BoundProtectedRouteProps, CreateProtectedRouteOptions, } from './protected-route';
+export { buildPostLoginRedirect } from './post-login-redirect';
+export type { RedirectableLocationState } from './post-login-redirect';
+export { readInitialParam, createComponentRegistry, SingleComponentOutlet, } from './single-component';
+export type { ComponentRegistry, SingleComponentOutletProps } from './single-component';
+export { renderAppRoutes } from './app-routes';
+export type { AppRouteConfig, RouteRedirect, RenderAppRoutesOptions } from './app-routes';
+export { mergePbcRoutes } from './pbc-routes';
+export type { PbcRouteInput, MergePbcRoutesOptions } from './pbc-routes';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/router/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzE,YAAY,EACV,mBAAmB,EACnB,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,YAAY,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AACxF,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC"}

package/dist/dts/router/pbc-routes.d.ts

@@ -0,0 +1,36 @@
+import type { ReactNode } from 'react';
+import type { AppRouteConfig } from './app-routes';
+/**
+ * Minimal shape of a PBC route as provided by the shell (e.g. `getApp().routes`).
+ * Kept as an input type — rather than importing `foundation-shell` — so this
+ * helper stays dependency-free and the `/router` subpath doesn't pull the shell
+ * into apps that don't use PBCs.
+ */
+export interface PbcRouteInput {
+    path: string;
+    title?: string;
+    /** The PBC element (module/loader) the container will mount. */
+    element?: unknown;
+    /** Explicit custom-element tag, if the container shouldn't derive one. */
+    elementTag?: string;
+    /** Nav items contributed by this PBC. */
+    navItems?: unknown;
+    /** Extra per-route settings (e.g. `permissionCode`), spread into `data`. */
+    settings?: Record<string, unknown>;
+}
+/**
+ * Options for {@link mergePbcRoutes}.
+ */
+export interface MergePbcRoutesOptions {
+    /** Render the element for a PBC route (typically `() => <PBCContainer />`). */
+    renderPbc: (pbc: PbcRouteInput) => ReactNode;
+}
+/**
+ * Merge a static route table with PBC routes (e.g. from `getApp().routes`) into
+ * one {@link AppRouteConfig} array. PBC routes are guarded, in-layout, and carry
+ * their element/tag + navItems through `data` so downstream consumers (a PBC
+ * container, nav-item derivation) can read them — matching the `data` shape the
+ * hand-rolled version produced.
+ */
+export declare function mergePbcRoutes(staticRoutes: AppRouteConfig[], pbcRoutes: PbcRouteInput[], { renderPbc }: MergePbcRoutesOptions): AppRouteConfig[];
+//# sourceMappingURL=pbc-routes.d.ts.map

package/dist/dts/router/pbc-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbc-routes.d.ts","sourceRoot":"","sources":["../../../src/router/pbc-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,SAAS,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,SAAS,CAAC;CAC9C;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,YAAY,EAAE,cAAc,EAAE,EAC9B,SAAS,EAAE,aAAa,EAAE,EAC1B,EAAE,SAAS,EAAE,EAAE,qBAAqB,GACnC,cAAc,EAAE,CAclB"}

package/dist/dts/router/post-login-redirect.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shape of the router location `state` that a route guard stashes before
+ * redirecting to login. Structural, so it works with `react-router-dom`'s
+ * `Location` without importing it here.
+ */
+export interface RedirectableLocationState {
+    from?: {
+        pathname: string;
+        search?: string;
+        hash?: string;
+    };
+}
+/**
+ * Build the post-login redirect target from a router location's `state.from`,
+ * preserving the query string and hash so deep-link params (e.g.
+ * `?component=<name>`) survive the login bounce. Falls back to `defaultPath`
+ * when there is no stashed origin.
+ *
+ * @param location - The current router location (needs only `state.from`).
+ * @param defaultPath - Where to land when nothing was stashed. Defaults to `/`.
+ */
+export declare function buildPostLoginRedirect(location: {
+    state?: RedirectableLocationState | null;
+}, defaultPath?: string): string;
+//# sourceMappingURL=post-login-redirect.d.ts.map

package/dist/dts/router/post-login-redirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-login-redirect.d.ts","sourceRoot":"","sources":["../../../src/router/post-login-redirect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,IAAI,CAAC,EAAE;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;CACH;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE;IAAE,KAAK,CAAC,EAAE,yBAAyB,GAAG,IAAI,CAAA;CAAE,EACtD,WAAW,SAAM,GAChB,MAAM,CAGR"}

package/dist/dts/router/protected-route.d.ts

@@ -0,0 +1,80 @@
+import type { ReactNode } from 'react';
+/**
+ * Props for {@link ProtectedRoute}.
+ */
+export interface ProtectedRouteProps {
+    /** Whether the current user is authenticated. */
+    isAuthenticated: boolean;
+    /**
+     * Whether the current user may view this route. When `false` (and
+     * authenticated), redirects to `notPermittedPath` instead of rendering.
+     * Defaults to `true`.
+     */
+    hasPermission?: boolean;
+    /** Path to redirect to when unauthenticated. Defaults to `/login`. */
+    loginPath?: string;
+    /** Path to redirect to when authenticated but not permitted. Defaults to `/not-permitted`. */
+    notPermittedPath?: string;
+    children: ReactNode;
+}
+/**
+ * Route guard. In order:
+ * - not authenticated → redirect to `loginPath`, stashing the full current
+ *   location in `state.from` (incl. `search` + `hash`) so the login flow can
+ *   restore the original deep-link via {@link buildPostLoginRedirect};
+ * - authenticated but `hasPermission === false` → redirect to `notPermittedPath`;
+ * - otherwise → render `children`.
+ *
+ * Deliberately decoupled from any auth package — pass the booleans in (or use
+ * {@link createProtectedRoute} to bind the checks once).
+ */
+export declare function ProtectedRoute({ isAuthenticated, hasPermission, loginPath, notPermittedPath, children, }: ProtectedRouteProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props of the component returned by {@link createProtectedRoute}. `permissionCode`
+ * is forwarded to the bound `hasPermission` check (e.g. by {@link renderAppRoutes}).
+ */
+export interface BoundProtectedRouteProps {
+    children: ReactNode;
+    /** Route permission code handed to the bound `hasPermission` check. */
+    permissionCode?: string;
+}
+/**
+ * Options for {@link createProtectedRoute}.
+ */
+export interface CreateProtectedRouteOptions {
+    /**
+     * Called at render time to determine auth state. Kept as a function (not a
+     * boolean) so it is re-evaluated on every render and the util stays free of
+     * any specific auth dependency.
+     */
+    getIsAuthenticated: () => boolean;
+    /**
+     * Optional per-route permission check, called at render time with the route's
+     * `permissionCode`. Absent → every authenticated user is permitted.
+     */
+    hasPermission?: (permissionCode: string | undefined) => boolean;
+    /** Path to redirect to when unauthenticated. Defaults to `/login`. */
+    loginPath?: string;
+    /** Path to redirect to when authenticated but not permitted. Defaults to `/not-permitted`. */
+    notPermittedPath?: string;
+}
+/**
+ * Bind auth (and optionally permission) checks once and get an ergonomic
+ * `<ProtectedRoute>` that only needs `children` (plus an optional
+ * `permissionCode`) — ideal when a route table wraps many elements.
+ *
+ * **Call this at module scope, never inside a component's render.** It returns a
+ * new component type each call; invoking it during render recreates that type
+ * every render, forcing React to unmount and remount the entire protected
+ * subtree (flicker + lost state).
+ *
+ * @example
+ * ```tsx
+ * const ProtectedRoute = createProtectedRoute({
+ *   getIsAuthenticated: () => getUser().isAuthenticated,
+ *   hasPermission: (code) => !code || canView(getUser(), code),
+ * });
+ * ```
+ */
+export declare function createProtectedRoute({ getIsAuthenticated, hasPermission, loginPath, notPermittedPath, }: CreateProtectedRouteOptions): ({ children, permissionCode }: BoundProtectedRouteProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=protected-route.d.ts.map

package/dist/dts/router/protected-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protected-route.d.ts","sourceRoot":"","sources":["../../../src/router/protected-route.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,eAAe,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,EAC7B,eAAe,EACf,aAAoB,EACpB,SAAoB,EACpB,gBAAmC,EACnC,QAAQ,GACT,EAAE,mBAAmB,2CAYrB;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,SAAS,CAAC;IACpB,uEAAuE;IACvE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,kBAAkB,EAAE,MAAM,OAAO,CAAC;IAClC;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;IAChE,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,kBAAkB,EAClB,aAAa,EACb,SAAS,EACT,gBAAgB,GACjB,EAAE,2BAA2B,IACQ,8BAA8B,wBAAwB,6CAY3F"}

package/dist/dts/router/router.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=router.test.d.ts.map

package/dist/dts/router/router.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.test.d.ts","sourceRoot":"","sources":["../../../src/router/router.test.ts"],"names":[],"mappings":""}

package/dist/dts/router/single-component.d.ts

@@ -0,0 +1,52 @@
+import type { ComponentType, ReactNode } from 'react';
+/**
+ * Read a query-string parameter from the current URL.
+ *
+ * Call this at **module-evaluation time** in your app (i.e. as a top-level
+ * `const`), before the app shell's async bootstrap rewrites the URL and drops
+ * the query string, and store the result. That way a deep-link param such as
+ * `?component=<name>` survives even though it is gone by the time the router
+ * mounts.
+ */
+export declare function readInitialParam(key: string): string | null;
+/**
+ * A name → component registry with tolerant lookup. Create one with
+ * {@link createComponentRegistry}.
+ */
+export interface ComponentRegistry {
+    /** The underlying name → component map. */
+    entries: Record<string, ComponentType<any>>;
+    /** All registered names, for help/error output. */
+    available(): string[];
+    /** Resolve a registered component by name, tolerant of case and separators. */
+    resolve(name: string | null | undefined): ComponentType<any> | undefined;
+}
+/**
+ * Create a name → component registry whose `resolve` is case- and
+ * separator-insensitive (`LimitDistributionChart` === `limit-distribution-chart`).
+ */
+export declare function createComponentRegistry(entries: Record<string, ComponentType<any>>): ComponentRegistry;
+/**
+ * Props for {@link SingleComponentOutlet}.
+ */
+export interface SingleComponentOutletProps {
+    /** The requested component name (typically captured via {@link readInitialParam}). */
+    name: string | null | undefined;
+    /** Registry to resolve the name against. */
+    registry: ComponentRegistry;
+    /**
+     * Render when no component matches. Defaults to a plain, unstyled
+     * "Unknown component" message; pass your own to theme it.
+     */
+    renderUnknown?: (name: string | null | undefined, available: string[]) => ReactNode;
+}
+/**
+ * Resolve `name` against `registry` and render the matching component, or a
+ * fallback when unmatched.
+ *
+ * Theming/provider chrome is intentionally left to the caller — wrap this outlet
+ * in your app's design-system provider so the standalone component is themed
+ * identically to how it appears in-app.
+ */
+export declare function SingleComponentOutlet({ name, registry, renderUnknown, }: SingleComponentOutletProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=single-component.d.ts.map

package/dist/dts/router/single-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-component.d.ts","sourceRoot":"","sources":["../../../src/router/single-component.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEtD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG3D;AAKD;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,mDAAmD;IACnD,SAAS,IAAI,MAAM,EAAE,CAAC;IACtB,+EAA+E;IAC/E,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;CAC1E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,GAC1C,iBAAiB,CAiBnB;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,sFAAsF;IACtF,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAChC,4CAA4C;IAC5C,QAAQ,EAAE,iBAAiB,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,SAAS,CAAC;CACrF;AAQD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,IAAI,EACJ,QAAQ,EACR,aAA8B,GAC/B,EAAE,0BAA0B,2CAG5B"}

package/dist/esm/router/app-routes.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Navigate, Route, Routes } from 'react-router-dom';
+const resolvePermissionCode = (route) => { var _a, _b; return (_a = route.permissionCode) !== null && _a !== void 0 ? _a : (_b = route.data) === null || _b === void 0 ? void 0 : _b.permissionCode; };
+/**
+ * Build the app's `<Routes>` tree from a declarative route table, applying the
+ * auth guard, layout nesting, redirects, not-found, and the single-component
+ * short-circuit — so a consuming app configures routes instead of hand-writing
+ * repetitive `<Route element={<ProtectedRoute>…}>` markup.
+ */
+export function renderAppRoutes({ routes, ProtectedRoute, layout, redirects = [], notFound, singleComponent, }) {
+    const publicRoutes = routes.filter((r) => r.public);
+    // Single-component mode: keep public routes reachable (login / session
+    // restore) and gate everything else behind the guard rendering the component.
+    if (singleComponent === null || singleComponent === void 0 ? void 0 : singleComponent.name) {
+        return (_jsxs(Routes, { children: [publicRoutes.map((r) => (_jsx(Route, { path: r.path, element: r.element }, r.path))), _jsx(Route, { path: "*", element: _jsx(ProtectedRoute, { children: singleComponent.element }) })] }));
+    }
+    const guarded = routes.filter((r) => !r.public);
+    const inLayout = guarded.filter((r) => !r.noLayout);
+    const topLevelGuarded = guarded.filter((r) => r.noLayout);
+    // Nested children render as plain relative routes inside the parent's
+    // `<Outlet />`; they inherit the parent's guard, so they are not re-wrapped.
+    const renderChild = (c) => {
+        var _a;
+        return ((_a = c.children) === null || _a === void 0 ? void 0 : _a.length) ? (_jsx(Route, { path: c.path, element: c.element, children: c.children.map(renderChild) }, c.path)) : (_jsx(Route, { path: c.path, element: c.element }, c.path));
+    };
+    const renderGuarded = (r) => {
+        var _a;
+        const element = (_jsx(ProtectedRoute, { permissionCode: resolvePermissionCode(r), children: r.element }));
+        return ((_a = r.children) === null || _a === void 0 ? void 0 : _a.length) ? (_jsx(Route, { path: r.path, element: element, children: r.children.map(renderChild) }, r.path)) : (_jsx(Route, { path: r.path, element: element }, r.path));
+    };
+    return (_jsxs(Routes, { children: [redirects.map((r) => (_jsx(Route, { path: r.from, element: _jsx(Navigate, { to: r.to, replace: true }) }, `redirect:${r.from}`))), publicRoutes.map((r) => (_jsx(Route, { path: r.path, element: r.element }, r.path))), topLevelGuarded.map(renderGuarded), layout ? (_jsx(Route, { element: layout, children: inLayout.map(renderGuarded) })) : (inLayout.map(renderGuarded)), notFound ? _jsx(Route, { path: "*", element: notFound }) : null] }));
+}

package/dist/esm/router/index.js

@@ -0,0 +1,27 @@
+/**
+ * `@genesislcap/foundation-react-utils/router`
+ *
+ * Reusable `react-router-dom` primitives for Genesis Foundation React apps, so
+ * the app-shell routing logic doesn't have to be reimplemented per app.
+ *
+ * Exposed as a subpath (`/router`) rather than from the package root so that
+ * consumers which don't route (and don't depend on `react-router-dom`) are
+ * unaffected.
+ *
+ * Key exports:
+ * - `ProtectedRoute` / `createProtectedRoute` — auth + permission gate that
+ *   stashes the full origin location (incl. `search` + `hash`) for post-login
+ *   restore, and redirects to a not-permitted path when authorized-but-blocked.
+ * - `buildPostLoginRedirect` — rebuild the return URL preserving query + hash.
+ * - `readInitialParam` / `createComponentRegistry` / `SingleComponentOutlet` —
+ *   render a single registered component full-screen from a `?param=<name>`
+ *   deep-link captured before the shell strips the query string.
+ * - `renderAppRoutes` — build the app's `<Routes>` from a declarative route
+ *   table (guarding, layout nesting, redirects, not-found, single-component).
+ * - `mergePbcRoutes` — merge static routes with shell/PBC routes into one table.
+ */
+export { ProtectedRoute, createProtectedRoute } from './protected-route';
+export { buildPostLoginRedirect } from './post-login-redirect';
+export { readInitialParam, createComponentRegistry, SingleComponentOutlet, } from './single-component';
+export { renderAppRoutes } from './app-routes';
+export { mergePbcRoutes } from './pbc-routes';