@vlian/router 0.1.0

package/dist/adapters/create-app-router.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get createAppRouter(){return createAppRouter},get defineRoutes(){return defineRoutes}});const _reactrouterdom=require("react-router-dom");const _normalizeroutes=require("../core/normalize/normalize-routes");const _createnavigationpatcher=require("../core/patcher/create-navigation-patcher");const _routeregistry=require("../core/runtime/route-registry");const defineRoutes=routes=>routes;const createAppRouter=options=>{const normalizedRoutes=(0,_normalizeroutes.normalizeRoutes)(options.routes,{authorization:options.authorization,source:"static"});const routeRegistry=new _routeregistry.RouteRegistry(normalizedRoutes);let router;const sharedRouterOptions={basename:options.basename,future:options.future,hydrationData:options.hydrationData,dataStrategy:options.dataStrategy,getContext:options.getContext,patchRoutesOnNavigation:options.dynamic?(0,_createnavigationpatcher.createNavigationPatcher)({dynamic:options.dynamic,authorization:options.authorization,registry:routeRegistry,getRouter:()=>router,onError:options.onError}):undefined};switch(options.mode){case"hash":router=(0,_reactrouterdom.createHashRouter)(normalizedRoutes,{...sharedRouterOptions,window:options.window});return router;case"memory":router=(0,_reactrouterdom.createMemoryRouter)(normalizedRoutes,{...sharedRouterOptions,initialEntries:options.initialEntries,initialIndex:options.initialIndex});return router;case"browser":default:router=(0,_reactrouterdom.createBrowserRouter)(normalizedRoutes,{...sharedRouterOptions,window:options.window});return router}};

package/dist/adapters/create-app-router.d.ts

@@ -0,0 +1,4 @@
+import { type DataRouter } from "react-router-dom";
+import type { DefaultRouteMeta, RouteExtraFields, RouterPluginOptions, StaticRouteConfig } from "../types";
+export declare const defineRoutes: <Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields>(routes: StaticRouteConfig<Meta, Extra>[]) => StaticRouteConfig<Meta, Extra>[];
+export declare const createAppRouter: <Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields>(options: RouterPluginOptions<Meta, Extra>) => DataRouter;

package/dist/adapters/create-app-router.js

@@ -0,0 +1 @@
+import{createBrowserRouter,createHashRouter,createMemoryRouter}from"react-router-dom";import{normalizeRoutes}from"../core/normalize/normalize-routes";import{createNavigationPatcher}from"../core/patcher/create-navigation-patcher";import{RouteRegistry}from"../core/runtime/route-registry";export const defineRoutes=routes=>routes;export const createAppRouter=options=>{const normalizedRoutes=normalizeRoutes(options.routes,{authorization:options.authorization,source:"static"});const routeRegistry=new RouteRegistry(normalizedRoutes);let router;const sharedRouterOptions={basename:options.basename,future:options.future,hydrationData:options.hydrationData,dataStrategy:options.dataStrategy,getContext:options.getContext,patchRoutesOnNavigation:options.dynamic?createNavigationPatcher({dynamic:options.dynamic,authorization:options.authorization,registry:routeRegistry,getRouter:()=>router,onError:options.onError}):undefined};switch(options.mode){case"hash":router=createHashRouter(normalizedRoutes,{...sharedRouterOptions,window:options.window});return router;case"memory":router=createMemoryRouter(normalizedRoutes,{...sharedRouterOptions,initialEntries:options.initialEntries,initialIndex:options.initialIndex});return router;case"browser":default:router=createBrowserRouter(normalizedRoutes,{...sharedRouterOptions,window:options.window});return router}};

package/dist/adapters/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get createAppRouter(){return _createapprouter.createAppRouter},get defineRoutes(){return _createapprouter.defineRoutes}});const _createapprouter=require("./create-app-router");

package/dist/adapters/index.d.ts

@@ -0,0 +1 @@
+export { createAppRouter, defineRoutes } from "./create-app-router";

package/dist/adapters/index.js

@@ -0,0 +1 @@
+export{createAppRouter,defineRoutes}from"./create-app-router";

package/dist/core/guards/route-shell.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"createRouteShellComponent",{enumerable:true,get:function(){return createRouteShellComponent}});const _react=require("react");const _reactrouterdom=require("react-router-dom");const resolveLayoutDescriptor=layout=>typeof layout==="function"?{component:layout}:layout;const renderAuthorizationFallback=(route,auth,authorization)=>{const{renderDenied}=authorization;if(!renderDenied){return null}if(typeof renderDenied==="function"){return(0,_react.createElement)(renderDenied,{route,auth})}return renderDenied};const resolveUnauthorizedRedirect=(auth,authorization)=>{if(auth&&typeof auth==="object"&&typeof auth.redirectTo==="string"){return auth.redirectTo}if(typeof authorization?.redirectTo==="string"){return authorization.redirectTo}return null};const renderRouteContent=(route,config)=>{if(config.redirect){return React.createElement(_reactrouterdom.Navigate,{replace:config.redirect.replace??true,state:config.redirect.state,to:config.redirect.to})}if(config.component){return(0,_react.createElement)(config.component)}if(config.element!==undefined){return config.element}if(route.children?.length){return React.createElement(_reactrouterdom.Outlet,null)}return null};const createRouteShellComponent=config=>{const RouteShell=()=>{if(config.auth&&config.authorization){const isAllowed=config.authorization.resolve({route:config.route,auth:config.auth});if(!isAllowed){const redirectTo=resolveUnauthorizedRedirect(config.auth,config.authorization);if(redirectTo){return React.createElement(_reactrouterdom.Navigate,{replace:true,to:redirectTo})}return renderAuthorizationFallback(config.route,config.auth,config.authorization)}}const content=renderRouteContent(config.route,config);if(!config.layout){return content}const layoutDescriptor=resolveLayoutDescriptor(config.layout);return(0,_react.createElement)(layoutDescriptor.component,{...layoutDescriptor.props,route:config.route},content)};RouteShell.displayName=`RouteShell(${config.route.id})`;return RouteShell};

package/dist/core/guards/route-shell.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+import type { AppRouteObject, DefaultRouteMeta, RedirectRouteConfig, RouteAuthConfig, RouteAuthorizationOptions, RouteComponent, RouteExtraFields, RouteLayout } from "../../types";
+type RouteShellConfig<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> = {
+    route: AppRouteObject<Meta, Extra>;
+    redirect?: RedirectRouteConfig;
+    auth?: RouteAuthConfig;
+    authorization?: RouteAuthorizationOptions<Meta, Extra>;
+    layout?: RouteLayout<Meta, Extra>;
+    component?: RouteComponent;
+    element?: ReactNode;
+};
+export declare const createRouteShellComponent: <Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields>(config: RouteShellConfig<Meta, Extra>) => RouteComponent;
+export {};

package/dist/core/guards/route-shell.js

@@ -0,0 +1 @@
+import{createElement}from"react";import{Navigate,Outlet}from"react-router-dom";const resolveLayoutDescriptor=layout=>typeof layout==="function"?{component:layout}:layout;const renderAuthorizationFallback=(route,auth,authorization)=>{const{renderDenied}=authorization;if(!renderDenied){return null}if(typeof renderDenied==="function"){return createElement(renderDenied,{route,auth})}return renderDenied};const resolveUnauthorizedRedirect=(auth,authorization)=>{if(auth&&typeof auth==="object"&&typeof auth.redirectTo==="string"){return auth.redirectTo}if(typeof authorization?.redirectTo==="string"){return authorization.redirectTo}return null};const renderRouteContent=(route,config)=>{if(config.redirect){return React.createElement(Navigate,{replace:config.redirect.replace??true,state:config.redirect.state,to:config.redirect.to})}if(config.component){return createElement(config.component)}if(config.element!==undefined){return config.element}if(route.children?.length){return React.createElement(Outlet,null)}return null};export const createRouteShellComponent=config=>{const RouteShell=()=>{if(config.auth&&config.authorization){const isAllowed=config.authorization.resolve({route:config.route,auth:config.auth});if(!isAllowed){const redirectTo=resolveUnauthorizedRedirect(config.auth,config.authorization);if(redirectTo){return React.createElement(Navigate,{replace:true,to:redirectTo})}return renderAuthorizationFallback(config.route,config.auth,config.authorization)}}const content=renderRouteContent(config.route,config);if(!config.layout){return content}const layoutDescriptor=resolveLayoutDescriptor(config.layout);return createElement(layoutDescriptor.component,{...layoutDescriptor.props,route:config.route},content)};RouteShell.displayName=`RouteShell(${config.route.id})`;return RouteShell};

package/dist/core/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get RouteRegistry(){return _routeregistry.RouteRegistry},get createNavigationPatcher(){return _createnavigationpatcher.createNavigationPatcher},get normalizeRoutes(){return _normalizeroutes.normalizeRoutes}});const _normalizeroutes=require("./normalize/normalize-routes");const _createnavigationpatcher=require("./patcher/create-navigation-patcher");const _routeregistry=require("./runtime/route-registry");

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export { normalizeRoutes } from "./normalize/normalize-routes";
+export { createNavigationPatcher } from "./patcher/create-navigation-patcher";
+export { RouteRegistry } from "./runtime/route-registry";

package/dist/core/index.js

@@ -0,0 +1 @@
+export{normalizeRoutes}from"./normalize/normalize-routes";export{createNavigationPatcher}from"./patcher/create-navigation-patcher";export{RouteRegistry}from"./runtime/route-registry";

package/dist/core/normalize/normalize-routes.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"normalizeRoutes",{enumerable:true,get:function(){return normalizeRoutes}});const _routeshell=require("../guards/route-shell");const _routeid=require("./route-id");const RESERVED_ROUTE_KEYS=new Set(["id","path","index","caseSensitive","component","Component","element","lazy","loader","action","shouldRevalidate","errorElement","ErrorBoundary","hydrateFallbackElement","HydrateFallback","handle","meta","layout","auth","redirect","children"]);const isRecord=value=>typeof value==="object"&&value!==null&&!Array.isArray(value);const mergeHandle=(handle,meta,auth,source)=>{const baseHandle=isRecord(handle)?handle:{};return{...baseHandle,meta,auth,source}};const pickExtraFields=route=>{const extraEntries=Object.entries(route).filter(([key])=>!RESERVED_ROUTE_KEYS.has(key));return Object.fromEntries(extraEntries)};const normalizeRedirect=redirect=>{if(!redirect){return undefined}if(typeof redirect==="string"){return{to:redirect,replace:true}}return{replace:true,...redirect}};const needsRouteShell=(route,normalizedRedirect,authorization)=>Boolean(normalizedRedirect||route.layout||route.auth&&authorization||route.component||route.Component&&(route.layout||route.auth)||route.element!==undefined&&(route.layout||route.auth));const wrapLazyRoute=(lazy,routeRef,route,normalizedRedirect,authorization)=>{return async()=>{const resolved=await lazy();const component=resolved.Component??route.Component??route.component;const element=resolved.element??route.element;if(!needsRouteShell({...route,Component:component,element},normalizedRedirect,authorization)){return resolved}return{...resolved,Component:(0,_routeshell.createRouteShellComponent)({route:routeRef,redirect:normalizedRedirect,auth:route.auth,authorization,layout:route.layout,component,element}),element:undefined}}};const normalizeRoute=(route,index,parentId,options)=>{const routeId=(0,_routeid.createRouteId)(route,parentId,index);const normalizedRedirect=normalizeRedirect(route.redirect);const handle=mergeHandle(route.handle,route.meta,route.auth,options.source);const normalizedRoute={id:routeId,path:route.path,index:route.index,caseSensitive:route.caseSensitive,loader:route.loader,action:route.action,shouldRevalidate:route.shouldRevalidate,errorElement:route.errorElement,ErrorBoundary:route.ErrorBoundary,hydrateFallbackElement:route.hydrateFallbackElement,HydrateFallback:route.HydrateFallback,handle,__extra:pickExtraFields(route)};if(route.children?.length){normalizedRoute.children=route.children.map((child,childIndex)=>normalizeRoute(child,childIndex,routeId,options))}if(route.lazy){normalizedRoute.lazy=wrapLazyRoute(route.lazy,normalizedRoute,route,normalizedRedirect,options.authorization);return normalizedRoute}const component=route.Component??route.component;const element=route.element;if(needsRouteShell(route,normalizedRedirect,options.authorization)){normalizedRoute.Component=(0,_routeshell.createRouteShellComponent)({route:normalizedRoute,redirect:normalizedRedirect,auth:route.auth,authorization:options.authorization,layout:route.layout,component,element});return normalizedRoute}if(component){normalizedRoute.Component=component}if(element!==undefined){normalizedRoute.element=element}return normalizedRoute};const normalizeRoutes=(routes,options)=>routes.map((route,index)=>normalizeRoute(route,index,options.parentId??null,options));

package/dist/core/normalize/normalize-routes.d.ts

@@ -0,0 +1,8 @@
+import type { AppRouteObject, DefaultRouteMeta, RouteAuthorizationOptions, RouteExtraFields, StaticRouteConfig } from "../../types";
+interface NormalizeRoutesOptions<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    authorization?: RouteAuthorizationOptions<Meta, Extra>;
+    parentId?: string | null;
+    source: "static" | "dynamic";
+}
+export declare const normalizeRoutes: <Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields>(routes: StaticRouteConfig<Meta, Extra>[], options: NormalizeRoutesOptions<Meta, Extra>) => AppRouteObject<Meta, Extra>[];
+export {};

package/dist/core/normalize/normalize-routes.js

@@ -0,0 +1 @@
+import{createRouteShellComponent}from"../guards/route-shell";import{createRouteId}from"./route-id";const RESERVED_ROUTE_KEYS=new Set(["id","path","index","caseSensitive","component","Component","element","lazy","loader","action","shouldRevalidate","errorElement","ErrorBoundary","hydrateFallbackElement","HydrateFallback","handle","meta","layout","auth","redirect","children"]);const isRecord=value=>typeof value==="object"&&value!==null&&!Array.isArray(value);const mergeHandle=(handle,meta,auth,source)=>{const baseHandle=isRecord(handle)?handle:{};return{...baseHandle,meta,auth,source}};const pickExtraFields=route=>{const extraEntries=Object.entries(route).filter(([key])=>!RESERVED_ROUTE_KEYS.has(key));return Object.fromEntries(extraEntries)};const normalizeRedirect=redirect=>{if(!redirect){return undefined}if(typeof redirect==="string"){return{to:redirect,replace:true}}return{replace:true,...redirect}};const needsRouteShell=(route,normalizedRedirect,authorization)=>Boolean(normalizedRedirect||route.layout||route.auth&&authorization||route.component||route.Component&&(route.layout||route.auth)||route.element!==undefined&&(route.layout||route.auth));const wrapLazyRoute=(lazy,routeRef,route,normalizedRedirect,authorization)=>{return async()=>{const resolved=await lazy();const component=resolved.Component??route.Component??route.component;const element=resolved.element??route.element;if(!needsRouteShell({...route,Component:component,element},normalizedRedirect,authorization)){return resolved}return{...resolved,Component:createRouteShellComponent({route:routeRef,redirect:normalizedRedirect,auth:route.auth,authorization,layout:route.layout,component,element}),element:undefined}}};const normalizeRoute=(route,index,parentId,options)=>{const routeId=createRouteId(route,parentId,index);const normalizedRedirect=normalizeRedirect(route.redirect);const handle=mergeHandle(route.handle,route.meta,route.auth,options.source);const normalizedRoute={id:routeId,path:route.path,index:route.index,caseSensitive:route.caseSensitive,loader:route.loader,action:route.action,shouldRevalidate:route.shouldRevalidate,errorElement:route.errorElement,ErrorBoundary:route.ErrorBoundary,hydrateFallbackElement:route.hydrateFallbackElement,HydrateFallback:route.HydrateFallback,handle,__extra:pickExtraFields(route)};if(route.children?.length){normalizedRoute.children=route.children.map((child,childIndex)=>normalizeRoute(child,childIndex,routeId,options))}if(route.lazy){normalizedRoute.lazy=wrapLazyRoute(route.lazy,normalizedRoute,route,normalizedRedirect,options.authorization);return normalizedRoute}const component=route.Component??route.component;const element=route.element;if(needsRouteShell(route,normalizedRedirect,options.authorization)){normalizedRoute.Component=createRouteShellComponent({route:normalizedRoute,redirect:normalizedRedirect,auth:route.auth,authorization:options.authorization,layout:route.layout,component,element});return normalizedRoute}if(component){normalizedRoute.Component=component}if(element!==undefined){normalizedRoute.element=element}return normalizedRoute};export const normalizeRoutes=(routes,options)=>routes.map((route,index)=>normalizeRoute(route,index,options.parentId??null,options));

package/dist/core/normalize/route-id.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"createRouteId",{enumerable:true,get:function(){return createRouteId}});const normalizeSegment=segment=>segment.trim().toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-+|-+$/g,"")||"route";const normalizePathToId=(path,index)=>{if(index){return"index"}if(!path||path==="/"){return"root"}return path.split("/").filter(Boolean).map(normalizeSegment).join(".")};const createRouteId=(route,parentId,position)=>{const explicitId=typeof route.id==="string"?route.id.trim():"";if(explicitId){return explicitId}const selfId=normalizePathToId(route.path,route.index);return parentId?`${parentId}.${selfId}.${position}`:`${selfId}.${position}`};

package/dist/core/normalize/route-id.d.ts

@@ -0,0 +1,2 @@
+import type { DefaultRouteMeta, RouteExtraFields, StaticRouteConfig } from "../../types";
+export declare const createRouteId: <Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields>(route: StaticRouteConfig<Meta, Extra>, parentId: string | null, position: number) => string;

package/dist/core/normalize/route-id.js

@@ -0,0 +1 @@
+const normalizeSegment=segment=>segment.trim().toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-+|-+$/g,"")||"route";const normalizePathToId=(path,index)=>{if(index){return"index"}if(!path||path==="/"){return"root"}return path.split("/").filter(Boolean).map(normalizeSegment).join(".")};export const createRouteId=(route,parentId,position)=>{const explicitId=typeof route.id==="string"?route.id.trim():"";if(explicitId){return explicitId}const selfId=normalizePathToId(route.path,route.index);return parentId?`${parentId}.${selfId}.${position}`:`${selfId}.${position}`};

package/dist/core/patcher/create-navigation-patcher.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"createNavigationPatcher",{enumerable:true,get:function(){return createNavigationPatcher}});const _normalizeroutes=require("../normalize/normalize-routes");const isDynamicPatch=value=>typeof value==="object"&&value!==null&&Array.isArray(value.routes);const toDynamicPatches=(result,defaultParentId)=>{if(!result){return[]}if(Array.isArray(result)){if(result.every(item=>isDynamicPatch(item))){return result}return[{parentId:defaultParentId,routes:result}]}if(isDynamicPatch(result)){return[result]}return[]};const createNavigationPatcher=options=>{const resolvedCacheKeys=new Set;const inFlightLoads=new Map;return async({matches,patch,path,signal})=>{const router=options.getRouter();const context={path,signal,matches:matches,router,knownRouteIds:options.registry.snapshot()};const navigationCacheKey=options.dynamic.getNavigationCacheKey?.(context)??path;if(navigationCacheKey&&resolvedCacheKeys.has(navigationCacheKey)){return}const inFlightKey=navigationCacheKey===false?`pending:${path}:${Date.now()}`:navigationCacheKey;const currentInFlight=inFlightLoads.get(inFlightKey);if(currentInFlight){await currentInFlight;return}const loadingTask=(async()=>{try{const loadResult=await options.dynamic.loader(context);const patches=toDynamicPatches(loadResult,options.dynamic.defaultParentId);for(const patchEntry of patches){const resolvedParentId=patchEntry.parentId??options.dynamic.defaultParentId??null;const normalizedRoutes=(0,_normalizeroutes.normalizeRoutes)(patchEntry.routes,{authorization:options.authorization,parentId:resolvedParentId,source:"dynamic"});const unregisteredRoutes=options.registry.filterUnregistered(normalizedRoutes);if(!unregisteredRoutes.length){continue}patch(resolvedParentId,unregisteredRoutes);options.registry.register(unregisteredRoutes);if(patchEntry.cacheKey){resolvedCacheKeys.add(patchEntry.cacheKey)}}if(navigationCacheKey){resolvedCacheKeys.add(navigationCacheKey)}}catch(error){const errorContext={...context,error,phase:"dynamic-route-loading"};await options.onError?.(errorContext);if(options.dynamic.errorMode==="throw"){throw error}}finally{inFlightLoads.delete(inFlightKey)}})();inFlightLoads.set(inFlightKey,loadingTask);await loadingTask}};

package/dist/core/patcher/create-navigation-patcher.d.ts

@@ -0,0 +1,12 @@
+import type { DataRouter, PatchRoutesOnNavigationFunction } from "react-router-dom";
+import { RouteRegistry } from "../runtime/route-registry";
+import type { DefaultRouteMeta, DynamicRoutingOptions, RouteAuthorizationOptions, RouteExtraFields, RouterErrorHandler } from "../../types";
+interface CreateNavigationPatcherOptions<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    dynamic: DynamicRoutingOptions<Meta, Extra>;
+    authorization?: RouteAuthorizationOptions<Meta, Extra>;
+    registry: RouteRegistry<Meta, Extra>;
+    getRouter: () => DataRouter;
+    onError?: RouterErrorHandler<Meta, Extra>;
+}
+export declare const createNavigationPatcher: <Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields>(options: CreateNavigationPatcherOptions<Meta, Extra>) => PatchRoutesOnNavigationFunction;
+export {};

package/dist/core/patcher/create-navigation-patcher.js

@@ -0,0 +1 @@
+import{normalizeRoutes}from"../normalize/normalize-routes";const isDynamicPatch=value=>typeof value==="object"&&value!==null&&Array.isArray(value.routes);const toDynamicPatches=(result,defaultParentId)=>{if(!result){return[]}if(Array.isArray(result)){if(result.every(item=>isDynamicPatch(item))){return result}return[{parentId:defaultParentId,routes:result}]}if(isDynamicPatch(result)){return[result]}return[]};export const createNavigationPatcher=options=>{const resolvedCacheKeys=new Set;const inFlightLoads=new Map;return async({matches,patch,path,signal})=>{const router=options.getRouter();const context={path,signal,matches:matches,router,knownRouteIds:options.registry.snapshot()};const navigationCacheKey=options.dynamic.getNavigationCacheKey?.(context)??path;if(navigationCacheKey&&resolvedCacheKeys.has(navigationCacheKey)){return}const inFlightKey=navigationCacheKey===false?`pending:${path}:${Date.now()}`:navigationCacheKey;const currentInFlight=inFlightLoads.get(inFlightKey);if(currentInFlight){await currentInFlight;return}const loadingTask=(async()=>{try{const loadResult=await options.dynamic.loader(context);const patches=toDynamicPatches(loadResult,options.dynamic.defaultParentId);for(const patchEntry of patches){const resolvedParentId=patchEntry.parentId??options.dynamic.defaultParentId??null;const normalizedRoutes=normalizeRoutes(patchEntry.routes,{authorization:options.authorization,parentId:resolvedParentId,source:"dynamic"});const unregisteredRoutes=options.registry.filterUnregistered(normalizedRoutes);if(!unregisteredRoutes.length){continue}patch(resolvedParentId,unregisteredRoutes);options.registry.register(unregisteredRoutes);if(patchEntry.cacheKey){resolvedCacheKeys.add(patchEntry.cacheKey)}}if(navigationCacheKey){resolvedCacheKeys.add(navigationCacheKey)}}catch(error){const errorContext={...context,error,phase:"dynamic-route-loading"};await options.onError?.(errorContext);if(options.dynamic.errorMode==="throw"){throw error}}finally{inFlightLoads.delete(inFlightKey)}})();inFlightLoads.set(inFlightKey,loadingTask);await loadingTask}};

package/dist/core/runtime/route-registry.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"RouteRegistry",{enumerable:true,get:function(){return RouteRegistry}});function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}const collectRouteIds=(routes,collector)=>{for(const route of routes){collector.add(route.id);if(route.children?.length){collectRouteIds(route.children,collector)}}};let RouteRegistry=class RouteRegistry{isRegistered(routeId){return this.registeredIds.has(routeId)}register(routes){collectRouteIds(routes,this.registeredIds)}filterUnregistered(routes){return routes.filter(route=>!this.isRegistered(route.id))}snapshot(){return new Set(this.registeredIds)}constructor(routes=[]){_define_property(this,"registeredIds",new Set);this.register(routes)}};

package/dist/core/runtime/route-registry.d.ts

@@ -0,0 +1,9 @@
+import type { AppRouteObject, DefaultRouteMeta, RouteExtraFields } from "../../types";
+export declare class RouteRegistry<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    private readonly registeredIds;
+    constructor(routes?: AppRouteObject<Meta, Extra>[]);
+    isRegistered(routeId: string): boolean;
+    register(routes: AppRouteObject<Meta, Extra>[]): void;
+    filterUnregistered(routes: AppRouteObject<Meta, Extra>[]): AppRouteObject<Meta, Extra>[];
+    snapshot(): Set<string>;
+}

package/dist/core/runtime/route-registry.js

@@ -0,0 +1 @@
+function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}const collectRouteIds=(routes,collector)=>{for(const route of routes){collector.add(route.id);if(route.children?.length){collectRouteIds(route.children,collector)}}};export class RouteRegistry{isRegistered(routeId){return this.registeredIds.has(routeId)}register(routes){collectRouteIds(routes,this.registeredIds)}filterUnregistered(routes){return routes.filter(route=>!this.isRegistered(route.id))}snapshot(){return new Set(this.registeredIds)}constructor(routes=[]){_define_property(this,"registeredIds",new Set);this.register(routes)}}

package/dist/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get createAppRouter(){return _adapters.createAppRouter},get defineRoutes(){return _adapters.defineRoutes}});const _adapters=require("./adapters");

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createAppRouter, defineRoutes } from "./adapters";
+export type { AppRouterProviderProps } from "./runtime";
+export type { AppRouteHandle, AppRouteObject, AppRoutePatchFunction, AppRouterMode, DefaultRouteMeta, DynamicRouteLoader, DynamicRouteLoaderContext, DynamicRouteLoadResult, DynamicRoutePatch, DynamicRoutingOptions, RedirectRouteConfig, RouteAuthConfig, RouteAuthorizationContext, RouteAuthorizationFallbackProps, RouteAuthorizationOptions, RouteExtraFields, RouteLayout, RouteLayoutDescriptor, RouteLayoutProps, RouteLazyLoader, RouteRedirect, RouterErrorHandler, RouterErrorHandlerContext, RouterPluginOptions, StaticRouteConfig, } from "./types";

package/dist/index.js

@@ -0,0 +1 @@
+export{createAppRouter,defineRoutes}from"./adapters";

package/dist/runtime/AppRouterProvider.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"AppRouterProvider",{enumerable:true,get:function(){return AppRouterProvider}});const _react=require("react");const _reactrouterdom=require("react-router-dom");const _createapprouter=require("../adapters/create-app-router");const AppRouterProvider=({options,...providerProps})=>{const router=(0,_react.useMemo)(()=>(0,_createapprouter.createAppRouter)(options),[options]);return React.createElement(_reactrouterdom.RouterProvider,{router:router,...providerProps})};

package/dist/runtime/AppRouterProvider.d.ts

@@ -0,0 +1,6 @@
+import { type RouterProviderProps } from "react-router-dom";
+import type { DefaultRouteMeta, RouteExtraFields, RouterPluginOptions } from "../types";
+export interface AppRouterProviderProps<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> extends Omit<RouterProviderProps, "router"> {
+    options: RouterPluginOptions<Meta, Extra>;
+}
+export declare const AppRouterProvider: <Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields>({ options, ...providerProps }: AppRouterProviderProps<Meta, Extra>) => import("react/jsx-runtime").JSX.Element;

package/dist/runtime/AppRouterProvider.js

@@ -0,0 +1 @@
+import{useMemo}from"react";import{RouterProvider}from"react-router-dom";import{createAppRouter}from"../adapters/create-app-router";export const AppRouterProvider=({options,...providerProps})=>{const router=useMemo(()=>createAppRouter(options),[options]);return React.createElement(RouterProvider,{router:router,...providerProps})};

package/dist/runtime/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"AppRouterProvider",{enumerable:true,get:function(){return _AppRouterProvider.AppRouterProvider}});const _AppRouterProvider=require("./AppRouterProvider");

package/dist/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export { AppRouterProvider } from "./AppRouterProvider";
+export type { AppRouterProviderProps } from "./AppRouterProvider";

package/dist/runtime/index.js

@@ -0,0 +1 @@
+export{AppRouterProvider}from"./AppRouterProvider";

package/dist/types/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export type { AppRouteHandle, AppRouteObject, AppRoutePatchFunction, AppRouterMode, DefaultRouteMeta, DynamicRouteLoader, DynamicRouteLoaderContext, DynamicRouteLoadResult, DynamicRoutePatch, DynamicRoutingOptions, MaybePromise, RedirectRouteConfig, RouteAuthConfig, RouteAuthorizationContext, RouteAuthorizationFallbackProps, RouteAuthorizationOptions, RouteComponent, RouteExtraFields, RouteLayout, RouteLayoutDescriptor, RouteLayoutProps, RouteLazyLoader, RouteRedirect, RouterErrorHandler, RouterErrorHandlerContext, RouterPluginOptions, StaticRouteConfig, } from "./route";

package/dist/types/index.js

@@ -0,0 +1 @@
+export{};

package/dist/types/route.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});

package/dist/types/route.d.ts

@@ -0,0 +1,116 @@
+import type { ComponentType, ReactNode } from "react";
+import type { DataRouter, LazyRouteFunction, MemoryRouterOpts, PatchRoutesOnNavigationFunction, RouteMatch, RouteObject } from "react-router-dom";
+export type MaybePromise<T> = T | Promise<T>;
+export type AppRouterMode = "browser" | "hash" | "memory";
+export type DefaultRouteMeta = Record<string, unknown>;
+export type RouteExtraFields = Record<string, unknown>;
+export interface RedirectRouteConfig {
+    to: string;
+    replace?: boolean;
+    state?: unknown;
+}
+export type RouteRedirect = string | RedirectRouteConfig;
+export type RouteAuthConfig = boolean | {
+    required?: boolean;
+    redirectTo?: string;
+    [key: string]: unknown;
+};
+export interface AppRouteHandle<Meta = DefaultRouteMeta> extends Record<string, unknown> {
+    meta?: Meta;
+    auth?: RouteAuthConfig;
+    source?: "static" | "dynamic";
+}
+export type AppRouteObject<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> = RouteObject & {
+    id: string;
+    children?: AppRouteObject<Meta, Extra>[];
+    handle?: AppRouteHandle<Meta>;
+    __extra?: Extra;
+};
+export interface RouteLayoutProps<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    children?: ReactNode;
+    route: AppRouteObject<Meta, Extra>;
+}
+export interface RouteLayoutDescriptor<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    component: ComponentType<RouteLayoutProps<Meta, Extra>>;
+    props?: Record<string, unknown>;
+}
+export type RouteLayout<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> = ComponentType<RouteLayoutProps<Meta, Extra>> | RouteLayoutDescriptor<Meta, Extra>;
+export type RouteComponent = Exclude<RouteObject["Component"], undefined>;
+export type RouteLazyLoader = LazyRouteFunction<RouteObject>;
+interface StaticRouteConfigBase<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    id?: string;
+    path?: string;
+    index?: boolean;
+    caseSensitive?: boolean;
+    component?: RouteComponent;
+    Component?: RouteComponent;
+    element?: ReactNode;
+    lazy?: RouteLazyLoader;
+    loader?: RouteObject["loader"];
+    action?: RouteObject["action"];
+    shouldRevalidate?: RouteObject["shouldRevalidate"];
+    errorElement?: ReactNode;
+    ErrorBoundary?: RouteObject["ErrorBoundary"];
+    hydrateFallbackElement?: ReactNode;
+    HydrateFallback?: RouteObject["HydrateFallback"];
+    handle?: RouteObject["handle"];
+    meta?: Meta;
+    layout?: RouteLayout<Meta, Extra>;
+    auth?: RouteAuthConfig;
+    redirect?: RouteRedirect;
+    children?: StaticRouteConfig<Meta, Extra>[];
+}
+export type StaticRouteConfig<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> = StaticRouteConfigBase<Meta, Extra> & Extra;
+export interface RouteAuthorizationContext<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    route: AppRouteObject<Meta, Extra>;
+    auth: RouteAuthConfig;
+}
+export interface RouteAuthorizationFallbackProps<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> extends RouteAuthorizationContext<Meta, Extra> {
+}
+export interface RouteAuthorizationOptions<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    resolve: (context: RouteAuthorizationContext<Meta, Extra>) => boolean;
+    redirectTo?: string;
+    renderDenied?: ReactNode | ComponentType<RouteAuthorizationFallbackProps<Meta, Extra>>;
+}
+export interface DynamicRouteLoaderContext<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    path: string;
+    signal: AbortSignal;
+    matches: RouteMatch<string, AppRouteObject<Meta, Extra>>[];
+    router: DataRouter;
+    knownRouteIds: Set<string>;
+}
+export interface DynamicRoutePatch<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    parentId?: string | null;
+    routes: StaticRouteConfig<Meta, Extra>[];
+    cacheKey?: string | false;
+}
+export type DynamicRouteLoadResult<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> = void | StaticRouteConfig<Meta, Extra>[] | DynamicRoutePatch<Meta, Extra> | DynamicRoutePatch<Meta, Extra>[];
+export type DynamicRouteLoader<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> = (context: DynamicRouteLoaderContext<Meta, Extra>) => MaybePromise<DynamicRouteLoadResult<Meta, Extra>>;
+export interface DynamicRoutingOptions<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    loader: DynamicRouteLoader<Meta, Extra>;
+    defaultParentId?: string | null;
+    getNavigationCacheKey?: (context: DynamicRouteLoaderContext<Meta, Extra>) => string | false;
+    errorMode?: "silent" | "throw";
+}
+export interface RouterErrorHandlerContext<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> extends DynamicRouteLoaderContext<Meta, Extra> {
+    error: unknown;
+    phase: "dynamic-route-loading";
+}
+export type RouterErrorHandler<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> = (context: RouterErrorHandlerContext<Meta, Extra>) => MaybePromise<void>;
+export interface RouterPluginOptions<Meta = DefaultRouteMeta, Extra extends RouteExtraFields = RouteExtraFields> {
+    routes: StaticRouteConfig<Meta, Extra>[];
+    mode?: AppRouterMode;
+    basename?: string;
+    future?: MemoryRouterOpts["future"];
+    hydrationData?: MemoryRouterOpts["hydrationData"];
+    getContext?: MemoryRouterOpts["getContext"];
+    dataStrategy?: MemoryRouterOpts["dataStrategy"];
+    initialEntries?: MemoryRouterOpts["initialEntries"];
+    initialIndex?: MemoryRouterOpts["initialIndex"];
+    window?: Window;
+    dynamic?: DynamicRoutingOptions<Meta, Extra>;
+    authorization?: RouteAuthorizationOptions<Meta, Extra>;
+    onError?: RouterErrorHandler<Meta, Extra>;
+}
+export type AppRoutePatchFunction = PatchRoutesOnNavigationFunction;
+export {};

package/dist/types/route.js

@@ -0,0 +1 @@
+export{};

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@vlian/router",
+  "version": "0.1.0",
+  "description": "Business-friendly router wrapper built on react-router-dom",
+  "license": "Apache-2.0",
+  "author": "Secra Framework Contributors",
+  "packageManager": "pnpm@10.6.0",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js",
+      "require": "./dist/core/index.cjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js",
+      "require": "./dist/runtime/index.cjs"
+    },
+    "./provider": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js",
+      "require": "./dist/runtime/index.cjs"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js",
+      "require": "./dist/types/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "core": [
+        "dist/core/index.d.ts"
+      ],
+      "runtime": [
+        "dist/runtime/index.d.ts"
+      ],
+      "provider": [
+        "dist/runtime/index.d.ts"
+      ],
+      "types": [
+        "dist/types/index.d.ts"
+      ],
+      "*": [
+        "dist/*.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npm run clean && npm run build:types && npm run build:esm && npm run build:cjs",
+    "build:types": "tsc --emitDeclarationOnly --declarationMap false --sourceMap false",
+    "build:esm": "swc src -d dist --strip-leading-paths --config-file .swcrc",
+    "build:cjs": "swc src -d dist-temp --strip-leading-paths --config-file .swcrc.cjs && node scripts/rename-cjs.js && rm -rf dist-temp",
+    "clean": "rm -rf dist dist-temp",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-router-dom": "^7.0.0"
+  },
+  "devDependencies": {
+    "@swc/cli": "^0.7.3",
+    "@swc/core": "^1.13.5",
+    "@types/react": "^19.2.5",
+    "@types/react-dom": "^19.2.3",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-router-dom": "^7.13.1",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}