react-routes-forge 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mostafa Abdelhamid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# react-routes-forge
+
+Type-safe route definitions with automatic path builders for React apps.
+
+## Why react-routes-forge?
+
+`react-routes-forge` eliminates the duplicate template/builder pattern used in route definitions. One source of truth defines:
+
+- static path templates for routing
+- dynamic path builders for navigation
+- typed params for safer runtime usage
+
+## Installation
+
+```bash
+npm install react-routes-forge
+```
+
+## Quick start
+
+```ts
+import { defineRoutes } from "react-routes-forge";
+
+export const PATHS = defineRoutes({
+  HOME: "/",
+  LOGIN: "/login",
+  USERS: {
+    ROOT: "/users",
+    ADD: "/users/add",
+    EDIT: "/users/edit/:id",
+    DETAILS: "/users/:id",
+  },
+  ROLES: {
+    PERMISSIONS: "/roles/permissions/:name",
+  },
+} as const);
+```
+
+## Usage
+
+### Router definitions
+
+Use route templates directly in route declarations.
+
+```tsx
+import { PATHS } from './paths';
+
+<Route path={PATHS.HOME} />
+<Route path={PATHS.USERS.EDIT} />
+<Route path={PATHS.ROLES.PERMISSIONS} />
+```
+
+### Navigation
+
+Build resolved paths from dynamic templates.
+
+```ts
+navigate(PATHS.USERS.EDIT.build({ id: 42 }));
+navigate(PATHS.ROLES.PERMISSIONS.build({ name: "admin" }));
+navigate(PATHS.HOME);
+```
+
+### Dynamic routes keep plain-string behavior
+
+Dynamic routes remain usable as strings while gaining helper methods.
+
+```ts
+PATHS.USERS.EDIT; // '/users/edit/:id'
+PATHS.USERS.EDIT.build({ id: 42 }); // '/users/edit/42'
+PATHS.USERS.EDIT.paramNames; // ['id']
+```
+
+## API
+
+### `defineRoutes(routeMap)`
+
+Create a typed route object from a nested route definition.
+
+- static routes remain plain strings
+- dynamic routes gain `.build(params)` and `.paramNames`
+
+### `build(template, params)`
+
+Resolve a route template without using `defineRoutes`.
+
+```ts
+import { build } from "react-routes-forge";
+
+build("/users/:id/posts/:postId", { id: 1, postId: 42 });
+// '/users/1/posts/42'
+```
+
+### `isActivePath(currentPath, template, options?)`
+
+Check whether a path matches a template.
+
+```ts
+import { isActivePath } from "react-routes-forge";
+
+isActivePath("/users/42", "/users/:id");
+isActivePath("/users/42/posts", "/users/:id");
+isActivePath("/users/42/posts", "/users/:id", { exact: false });
+```
+
+### `extractParamsFromPath(template, resolvedPath)`
+
+Extract path params from a resolved route.
+
+```ts
+import { extractParamsFromPath } from "react-routes-forge";
+
+extractParamsFromPath("/users/:id", "/users/42");
+// { id: '42' }
+```
+
+### `joinPaths(...segments)`
+
+Join path fragments and normalise slashes.
+
+```ts
+import { joinPaths } from "react-routes-forge";
+
+joinPaths("/api/", "/v1/", "/users");
+// '/api/v1/users'
+```
+
+### `getParamNames(template)`
+
+Return all parameter names from a template.
+
+```ts
+import { getParamNames } from "react-routes-forge";
+
+getParamNames("/users/:id/posts/:postId");
+// ['id', 'postId']
+```
+
+## React hooks
+
+Import only when using React Router.
+
+### `useRouteParams<T>()`
+
+Typed wrapper around React Router's `useParams`.
+
+```tsx
+import { useRouteParams } from "react-routes-forge";
+
+function EditUser() {
+  const { id } = useRouteParams<"/users/edit/:id">();
+  return <div>{id}</div>;
+}
+```
+
+### `useNavigateTo()`
+
+Thin, typed wrapper around React Router's `useNavigate()`.
+
+```tsx
+import { useNavigateTo } from "react-routes-forge";
+
+function Component() {
+  const navigateTo = useNavigateTo();
+  return (
+    <button onClick={() => navigateTo(PATHS.USERS.EDIT.build({ id: 42 }))}>
+      Edit
+    </button>
+  );
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,107 @@
+/**
+ * A static route string (template or resolved), e.g. '/users/:id' or '/users/42'
+ */
+type RoutePath = `/${string}`;
+/**
+ * A route builder function that accepts params and returns a resolved path.
+ */
+type RouteBuilder<TParams extends RouteParams = RouteParams> = (params: TParams) => RoutePath;
+/**
+ * Acceptable param value types for route builders.
+ */
+type RouteParam = string | number;
+type RouteParams = Record<string, RouteParam>;
+/**
+ * A leaf node in a route definition: either a static path or a builder function.
+ */
+type RouteLeaf = RoutePath | RouteBuilder;
+/**
+ * Recursively defines a route map: each key is either a leaf or a nested map.
+ */
+type RouteMap = {
+    [key: string]: RouteLeaf | RouteMap;
+};
+/**
+ * Extracts param names from a path template string.
+ * e.g. '/users/:id/posts/:postId' → 'id' | 'postId'
+ */
+type ExtractParams<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractParams<`/${Rest}`> : T extends `${string}:${infer Param}` ? Param : never;
+/**
+ * Builds a params object type from a path template.
+ * e.g. '/users/:id' → { id: RouteParam }
+ */
+type PathParams<T extends string> = ExtractParams<T> extends never ? never : {
+    [K in ExtractParams<T>]: RouteParam;
+};
+
+declare function buildPath(template: string, params: Record<string, RouteParam>): string;
+declare function extractParamNames(template: string): string[];
+declare function isDynamic(path: string): boolean;
+declare function isActivePath(currentPath: string, template: string, options?: {
+    exact?: boolean;
+}): boolean;
+declare function extractParamsFromPath(template: string, resolvedPath: string): Record<string, string>;
+declare function joinPaths(...segments: string[]): string;
+declare function build(template: string, params: Record<string, RouteParam>): string;
+declare function getParamNames(template: string): string[];
+
+type RouteInput = {
+    [key: string]: string | RouteInput;
+};
+type DynamicRoute<T extends string> = T extends `${string}:${string}` ? T & {
+    build(params: PathParams<T>): RoutePath;
+    paramNames: Array<ExtractParams<T>>;
+} : T;
+type ResolvedRoutes<T extends RouteInput> = {
+    [K in keyof T]: T[K] extends RouteInput ? ResolvedRoutes<T[K]> : T[K] extends string ? DynamicRoute<T[K]> : never;
+};
+declare function defineRoutes<T extends RouteInput>(routes: T): ResolvedRoutes<T>;
+
+/**
+ * React integration hooks for route-forge.
+ * These are thin wrappers — import only if you're using React Router.
+ */
+
+/**
+ * A typed wrapper around React Router's `useParams`.
+ *
+ * Pass the route's path template as a const generic to get a properly typed
+ * params object back — no casting needed.
+ *
+ * @example
+ * ```tsx
+ * // Route is defined as '/users/edit/:id'
+ * const { id } = useRouteParams<'/users/edit/:id'>();
+ * ```
+ */
+declare function useRouteParams<T extends string, K extends string = T extends `${string}:${infer P}/${infer R}` ? P | (R extends `${string}:${infer Q}` ? Q : never) : T extends `${string}:${infer P}` ? P : never>(): Record<K, string>;
+type NavigateOptions = {
+    replace?: boolean;
+    state?: unknown;
+};
+/**
+ * A typed `navigate` helper that accepts a resolved path (output of `.build()`)
+ * or a plain static path, with optional navigation options.
+ *
+ * @example
+ * ```tsx
+ * const navigateTo = useNavigateTo();
+ * navigateTo(PATHS.USERS.EDIT.build({ id: 42 }));
+ * navigateTo(PATHS.HOME, { replace: true });
+ * ```
+ */
+declare function useNavigateTo(): (path: string, options?: NavigateOptions) => void;
+/**
+ * Resolves a dynamic path template against params using React Router's
+ * `generatePath`, with proper typing.
+ *
+ * Useful when you need the resolved path string without navigating.
+ *
+ * @example
+ * ```tsx
+ * const path = useResolvedPath('/users/:id', { id: 42 }); // → '/users/42'
+ * ```
+ */
+declare function useResolvedPath(template: string, params: Record<string, RouteParam>): string;
+
+export { type ExtractParams, type PathParams, type RouteBuilder, type RouteLeaf, type RouteMap, type RouteParam, type RouteParams, type RoutePath, build, buildPath, defineRoutes, extractParamNames, extractParamsFromPath, getParamNames, isActivePath, isDynamic, joinPaths, useNavigateTo, useResolvedPath, useRouteParams };

package/dist/index.js

@@ -0,0 +1,2 @@
+var c=()=>/:([^/]+)/g,f=()=>/[.*+?^${}()|[\]\\]/g;function g(t){return t.replace(f(),"\\$&")}function R(t){return g(t).replace(c(),"([^/]+)")}function i(t,e){let r=a(t).reduce((u,s)=>{let p=e[s],x=p===void 0?`:${s}`:String(p);return u.replace(new RegExp(`:${g(s)}(?=/|$)`,"g"),x)},t);return globalThis.process?.env?.NODE_ENV!=="production"&&r.includes(":")&&console.warn(`[route-forge] Unresolved params in path "${r}". Check that all :param segments have matching keys.`),r}function a(t){return[...t.matchAll(c())].map(e=>e[1])}function m(t){return c().test(t)}function d(t,e,n={exact:!0}){let r=R(e);return(n.exact?new RegExp(`^${r}$`):new RegExp(`^${r}`)).test(t)}function l(t,e){let n=a(t),r=new RegExp(`^${R(t)}$`),o=e.match(r);return o?Object.fromEntries(n.map((u,s)=>[u,o[s+1]??""])):{}}function T(...t){return"/"+t.map(e=>e.replace(/^\/+|\/+$/g,"")).filter(Boolean).join("/")}function y(t,e){return i(t,e)}function h(t){return a(t)}var v=t=>typeof t=="object"&&t!==null;function $(t){let e=a(t),n=new String(t);return n.build=r=>i(t,r),n.paramNames=e,n}function P(t){let e={};for(let n in t){if(!Object.prototype.hasOwnProperty.call(t,n))continue;let r=t[n];typeof r=="string"?e[n]=m(r)?$(r):r:v(r)&&(e[n]=P(r))}return e}function b(t){return P(t)}import{useParams as N,useNavigate as E,generatePath as w}from"react-router-dom";function k(){return N()}function D(){let t=E();return(e,n)=>{t(e,n)}}function A(t,e){return w(t,Object.fromEntries(Object.entries(e).map(([n,r])=>[n,String(r)])))}export{y as build,i as buildPath,b as defineRoutes,a as extractParamNames,l as extractParamsFromPath,h as getParamNames,d as isActivePath,m as isDynamic,T as joinPaths,D as useNavigateTo,A as useResolvedPath,k as useRouteParams};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/utils.ts","../src/core/defineRoutes.ts","../src/hooks/index.ts"],"sourcesContent":["import type { RouteParam } from '../types';\n\n/** Returns a fresh RegExp each call — avoids shared `lastIndex` state on /g patterns. */\nconst PATH_PARAM_RE = () => /:([^/]+)/g;\nconst ESCAPE_RE = () => /[.*+?^${}()|[\\]\\\\]/g;\n\nfunction escapeRegex(value: string): string {\n  return value.replace(ESCAPE_RE(), '\\\\$&');\n}\n\nfunction createTemplatePattern(template: string): string {\n  return escapeRegex(template).replace(PATH_PARAM_RE(), '([^/]+)');\n}\n\nexport function buildPath(\n  template: string,\n  params: Record<string, RouteParam>\n): string {\n  const paramNames = extractParamNames(template);\n\n  const resolved = paramNames.reduce((path, name) => {\n    const value = params[name];\n    const replacement = value === undefined ? `:${name}` : String(value);\n    return path.replace(new RegExp(`:${escapeRegex(name)}(?=/|$)`, 'g'), replacement);\n  }, template);\n\n  const runtimeProcess = (globalThis as typeof globalThis & {\n    process?: {\n      env?: Record<string, string | undefined>;\n    };\n  }).process;\n\n  if (runtimeProcess?.env?.NODE_ENV !== 'production' && resolved.includes(':')) {\n    console.warn(\n      `[route-forge] Unresolved params in path \"${resolved}\". ` +\n        `Check that all :param segments have matching keys.`\n    );\n  }\n\n  return resolved;\n}\n\nexport function extractParamNames(template: string): string[] {\n  return [...template.matchAll(PATH_PARAM_RE())].map((match) => match[1] as string);\n}\n\nexport function isDynamic(path: string): boolean {\n  return PATH_PARAM_RE().test(path);\n}\n\nexport function isActivePath(\n  currentPath: string,\n  template: string,\n  options: { exact?: boolean } = { exact: true }\n): boolean {\n  const pattern = createTemplatePattern(template);\n  const regex = options.exact\n    ? new RegExp(`^${pattern}$`)\n    : new RegExp(`^${pattern}`);\n\n  return regex.test(currentPath);\n}\n\nexport function extractParamsFromPath(\n  template: string,\n  resolvedPath: string\n): Record<string, string> {\n  const paramNames = extractParamNames(template);\n  const regex = new RegExp(`^${createTemplatePattern(template)}$`);\n  const match = resolvedPath.match(regex);\n\n  if (!match) return {};\n\n  return Object.fromEntries(\n    paramNames.map((name, index) => [name, match[index + 1] ?? ''])\n  );\n}\n\nexport function joinPaths(...segments: string[]): string {\n  return (\n    '/' +\n    segments\n      .map((segment) => segment.replace(/^\\/+|\\/+$/g, ''))\n      .filter(Boolean)\n      .join('/')\n  );\n}\n\nexport function build(\n  template: string,\n  params: Record<string, RouteParam>\n): string {\n  return buildPath(template, params);\n}\n\nexport function getParamNames(template: string): string[] {\n  return extractParamNames(template);\n}\n","import { buildPath, extractParamNames, isDynamic } from './utils';\nimport type { ExtractParams, PathParams, RoutePath } from '../types';\n\n// Re-export so consumers that import from 'core/defineRoutes' get the full surface\nexport { buildPath, extractParamNames, isDynamic } from './utils';\n\ntype RouteInput = {\n  [key: string]: string | RouteInput;\n};\n\ntype DynamicRoute<T extends string> = T extends `${string}:${string}`\n  ? T & {\n      build(params: PathParams<T>): RoutePath;\n      paramNames: Array<ExtractParams<T>>;\n    }\n  : T;\n\ntype ResolvedRoutes<T extends RouteInput> = {\n  [K in keyof T]: T[K] extends RouteInput\n    ? ResolvedRoutes<T[K]>\n    : T[K] extends string\n    ? DynamicRoute<T[K]>\n    : never;\n};\n\nconst isRouteGroup = (value: unknown): value is RouteInput =>\n  typeof value === 'object' && value !== null;\n\nfunction wrapDynamicPath<T extends string>(template: T): DynamicRoute<T> {\n  const paramNames = extractParamNames(template);\n  const wrapped = new String(template) as unknown as DynamicRoute<T> & {\n    build: (params: PathParams<T>) => RoutePath;\n    paramNames: Array<ExtractParams<T>>;\n  };\n\n  wrapped.build = (params: PathParams<T>) => buildPath(template, params) as RoutePath;\n  wrapped.paramNames = paramNames as Array<ExtractParams<T>>;\n\n  return wrapped as unknown as DynamicRoute<T>;\n}\n\nfunction processRouteMap<T extends RouteInput>(routes: T): ResolvedRoutes<T> {\n  const result = {} as ResolvedRoutes<T>;\n\n  for (const key in routes) {\n    if (!Object.prototype.hasOwnProperty.call(routes, key)) continue;\n\n    const value = routes[key];\n\n    if (typeof value === 'string') {\n      result[key] = (isDynamic(value)\n        ? wrapDynamicPath(value)\n        : value) as ResolvedRoutes<T>[typeof key];\n    } else if (isRouteGroup(value)) {\n      result[key] = processRouteMap(value as RouteInput) as unknown as ResolvedRoutes<T>[typeof key];\n    }\n  }\n\n  return result;\n}\n\nexport function defineRoutes<T extends RouteInput>(routes: T): ResolvedRoutes<T> {\n  return processRouteMap(routes);\n}\n","/**\n * React integration hooks for route-forge.\n * These are thin wrappers — import only if you're using React Router.\n */\n\nimport { useParams, useNavigate, generatePath } from 'react-router-dom';\nimport type { RouteParam } from '../types';\n\n// ─── useRouteParams ──────────────────────────────────────────────────────────\n\n/**\n * A typed wrapper around React Router's `useParams`.\n *\n * Pass the route's path template as a const generic to get a properly typed\n * params object back — no casting needed.\n *\n * @example\n * ```tsx\n * // Route is defined as '/users/edit/:id'\n * const { id } = useRouteParams<'/users/edit/:id'>();\n * ```\n */\nexport function useRouteParams<\n  T extends string,\n  // Extracts ':id' → 'id', ':postId' → 'postId', etc.\n  K extends string = T extends `${string}:${infer P}/${infer R}`\n    ? P | (R extends `${string}:${infer Q}` ? Q : never)\n    : T extends `${string}:${infer P}`\n    ? P\n    : never,\n>(): Record<K, string> {\n  return useParams() as Record<K, string>;\n}\n\n// ─── useNavigateTo ──────────────────────────────────────────────────────────\n\ntype NavigateOptions = {\n  replace?: boolean;\n  state?: unknown;\n};\n\n/**\n * A typed `navigate` helper that accepts a resolved path (output of `.build()`)\n * or a plain static path, with optional navigation options.\n *\n * @example\n * ```tsx\n * const navigateTo = useNavigateTo();\n * navigateTo(PATHS.USERS.EDIT.build({ id: 42 }));\n * navigateTo(PATHS.HOME, { replace: true });\n * ```\n */\nexport function useNavigateTo() {\n  const navigate = useNavigate();\n\n  return (path: string, options?: NavigateOptions) => {\n    navigate(path, options);\n  };\n}\n\n// ─── useResolvedPath ─────────────────────────────────────────────────────────\n\n/**\n * Resolves a dynamic path template against params using React Router's\n * `generatePath`, with proper typing.\n *\n * Useful when you need the resolved path string without navigating.\n *\n * @example\n * ```tsx\n * const path = useResolvedPath('/users/:id', { id: 42 }); // → '/users/42'\n * ```\n */\nexport function useResolvedPath(\n  template: string,\n  params: Record<string, RouteParam>\n): string {\n  return generatePath(\n    template,\n    Object.fromEntries(Object.entries(params).map(([k, v]) => [k, String(v)]))\n  );\n}\n"],"mappings":"AAGA,IAAMA,EAAgB,IAAM,YACtBC,EAAY,IAAM,sBAExB,SAASC,EAAYC,EAAuB,CAC1C,OAAOA,EAAM,QAAQF,EAAU,EAAG,MAAM,CAC1C,CAEA,SAASG,EAAsBC,EAA0B,CACvD,OAAOH,EAAYG,CAAQ,EAAE,QAAQL,EAAc,EAAG,SAAS,CACjE,CAEO,SAASM,EACdD,EACAE,EACQ,CAGR,IAAMC,EAFaC,EAAkBJ,CAAQ,EAEjB,OAAO,CAACK,EAAMC,IAAS,CACjD,IAAMR,EAAQI,EAAOI,CAAI,EACnBC,EAAcT,IAAU,OAAY,IAAIQ,CAAI,GAAK,OAAOR,CAAK,EACnE,OAAOO,EAAK,QAAQ,IAAI,OAAO,IAAIR,EAAYS,CAAI,CAAC,UAAW,GAAG,EAAGC,CAAW,CAClF,EAAGP,CAAQ,EAQX,OANwB,WAIrB,SAEiB,KAAK,WAAa,cAAgBG,EAAS,SAAS,GAAG,GACzE,QAAQ,KACN,4CAA4CA,CAAQ,uDAEtD,EAGKA,CACT,CAEO,SAASC,EAAkBJ,EAA4B,CAC5D,MAAO,CAAC,GAAGA,EAAS,SAASL,EAAc,CAAC,CAAC,EAAE,IAAKa,GAAUA,EAAM,CAAC,CAAW,CAClF,CAEO,SAASC,EAAUJ,EAAuB,CAC/C,OAAOV,EAAc,EAAE,KAAKU,CAAI,CAClC,CAEO,SAASK,EACdC,EACAX,EACAY,EAA+B,CAAE,MAAO,EAAK,EACpC,CACT,IAAMC,EAAUd,EAAsBC,CAAQ,EAK9C,OAJcY,EAAQ,MAClB,IAAI,OAAO,IAAIC,CAAO,GAAG,EACzB,IAAI,OAAO,IAAIA,CAAO,EAAE,GAEf,KAAKF,CAAW,CAC/B,CAEO,SAASG,EACdd,EACAe,EACwB,CACxB,IAAMC,EAAaZ,EAAkBJ,CAAQ,EACvCiB,EAAQ,IAAI,OAAO,IAAIlB,EAAsBC,CAAQ,CAAC,GAAG,EACzDQ,EAAQO,EAAa,MAAME,CAAK,EAEtC,OAAKT,EAEE,OAAO,YACZQ,EAAW,IAAI,CAACV,EAAMY,IAAU,CAACZ,EAAME,EAAMU,EAAQ,CAAC,GAAK,EAAE,CAAC,CAChE,EAJmB,CAAC,CAKtB,CAEO,SAASC,KAAaC,EAA4B,CACvD,MACE,IACAA,EACG,IAAKC,GAAYA,EAAQ,QAAQ,aAAc,EAAE,CAAC,EAClD,OAAO,OAAO,EACd,KAAK,GAAG,CAEf,CAEO,SAASC,EACdtB,EACAE,EACQ,CACR,OAAOD,EAAUD,EAAUE,CAAM,CACnC,CAEO,SAASqB,EAAcvB,EAA4B,CACxD,OAAOI,EAAkBJ,CAAQ,CACnC,CCxEA,IAAMwB,EAAgBC,GACpB,OAAOA,GAAU,UAAYA,IAAU,KAEzC,SAASC,EAAkCC,EAA8B,CACvE,IAAMC,EAAaC,EAAkBF,CAAQ,EACvCG,EAAU,IAAI,OAAOH,CAAQ,EAKnC,OAAAG,EAAQ,MAASC,GAA0BC,EAAUL,EAAUI,CAAM,EACrED,EAAQ,WAAaF,EAEdE,CACT,CAEA,SAASG,EAAsCC,EAA8B,CAC3E,IAAMC,EAAS,CAAC,EAEhB,QAAWC,KAAOF,EAAQ,CACxB,GAAI,CAAC,OAAO,UAAU,eAAe,KAAKA,EAAQE,CAAG,EAAG,SAExD,IAAMX,EAAQS,EAAOE,CAAG,EAEpB,OAAOX,GAAU,SACnBU,EAAOC,CAAG,EAAKC,EAAUZ,CAAK,EAC1BC,EAAgBD,CAAK,EACrBA,EACKD,EAAaC,CAAK,IAC3BU,EAAOC,CAAG,EAAIH,EAAgBR,CAAmB,EAErD,CAEA,OAAOU,CACT,CAEO,SAASG,EAAmCJ,EAA8B,CAC/E,OAAOD,EAAgBC,CAAM,CAC/B,CC1DA,OAAS,aAAAK,EAAW,eAAAC,EAAa,gBAAAC,MAAoB,mBAiB9C,SAASC,GAQO,CACrB,OAAOH,EAAU,CACnB,CAoBO,SAASI,GAAgB,CAC9B,IAAMC,EAAWJ,EAAY,EAE7B,MAAO,CAACK,EAAcC,IAA8B,CAClDF,EAASC,EAAMC,CAAO,CACxB,CACF,CAeO,SAASC,EACdC,EACAC,EACQ,CACR,OAAOR,EACLO,EACA,OAAO,YAAY,OAAO,QAAQC,CAAM,EAAE,IAAI,CAAC,CAACC,EAAGC,CAAC,IAAM,CAACD,EAAG,OAAOC,CAAC,CAAC,CAAC,CAAC,CAC3E,CACF","names":["PATH_PARAM_RE","ESCAPE_RE","escapeRegex","value","createTemplatePattern","template","buildPath","params","resolved","extractParamNames","path","name","replacement","match","isDynamic","isActivePath","currentPath","options","pattern","extractParamsFromPath","resolvedPath","paramNames","regex","index","joinPaths","segments","segment","build","getParamNames","isRouteGroup","value","wrapDynamicPath","template","paramNames","extractParamNames","wrapped","params","buildPath","processRouteMap","routes","result","key","isDynamic","defineRoutes","useParams","useNavigate","generatePath","useRouteParams","useNavigateTo","navigate","path","options","useResolvedPath","template","params","k","v"]}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "react-routes-forge",
+  "version": "1.0.3",
+  "description": "Type-safe route definitions with automatic path builders for React apps",
+  "type": "module",
+  "author": {
+    "name": "Mostafa Abdelhamid",
+    "email": "mhsmustafa84@gmail.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mhsmustafa84/react-routes-forge.git"
+  },
+  "homepage": "https://github.com/mhsmustafa84/react-routes-forge#readme",
+  "bugs": "https://github.com/mhsmustafa84/react-routes-forge/issues",
+  "keywords": [
+    "react",
+    "router",
+    "routes",
+    "typescript",
+    "type-safe",
+    "react-router",
+    "path-builder"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --minify --sourcemap --clean",
+    "lint": "tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "prepare": "husky",
+    "prepublishOnly": "bun run test && bun run build",
+    "release": "standard-version"
+  },
+  "peerDependencies": {
+    "react": ">=17",
+    "react-router-dom": ">=6"
+  },
+  "peerDependenciesMeta": {
+    "react-router-dom": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "react-router-dom": "^6.0.0",
+    "@commitlint/cli": "^21.0.2",
+    "@commitlint/config-conventional": "^21.0.2",
+    "@types/node": "^26.1.1",
+    "@types/bun": "^1.3.14",
+    "husky": "^9.0.0",
+    "standard-version": "^9.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}