next-generate-path 0.0.1

package/README.md

@@ -0,0 +1,138 @@
+# next-generate-path
+
+Type-safe `generatePath()` for Next.js. Autocomplete for every route, params enforced at compile time.
+
+Next.js [typed routes](https://nextjs.org/docs/app/api-reference/config/next-config-js/typedRoutes) give you type safety on `<Link href>`, `redirect()`, etc. — but dynamic routes like `/blog/[slug]` don't appear in autocomplete. You have to know the pattern and manually write template literals.
+
+`next-generate-path` fixes this. It gives you a single `generatePath` function with full autocomplete for **all** your routes and compile-time enforcement of the correct params.
+
+```tsx
+import { generatePath } from "next-generate-path";
+
+generatePath("/blog/[slug]", { slug: "hello-world" });
+// => "/blog/hello-world" — full autocomplete, params required
+
+generatePath("/about");
+// => "/about" — no params needed
+
+generatePath("/blog/[slug]");
+// TS error: missing required params
+```
+
+The return type is compatible with Next.js's `RouteImpl`, so it works directly with `<Link>`, `redirect()`, and `router.push()` — no casts needed.
+
+## Setup
+
+### 1. Install
+
+```bash
+npm install next-generate-path
+```
+
+### 2. Wrap your Next.js config
+
+```js
+// next.config.js
+import { withTypedRoutes } from "next-generate-path/next";
+
+const nextConfig = {};
+
+export default withTypedRoutes(nextConfig);
+```
+
+That's it. `withTypedRoutes` enables `typedRoutes` and generates a declaration file that wires your app's routes into `generatePath` automatically.
+
+### 3. Use it
+
+```tsx
+import Link from "next/link";
+import { generatePath } from "next-generate-path";
+
+export default function Page() {
+  return (
+    <Link href={generatePath("/blog/[slug]", { slug: "hello-world" })}>
+      Read post
+    </Link>
+  );
+}
+```
+
+## Supported route types
+
+### Static routes
+
+```tsx
+generatePath("/about");
+// => "/about"
+```
+
+### Dynamic routes
+
+```tsx
+generatePath("/blog/[slug]", { slug: "hello-world" });
+// => "/blog/hello-world"
+```
+
+### Nested dynamic routes
+
+```tsx
+generatePath("/products/[id]/reviews", { id: "42" });
+// => "/products/42/reviews"
+```
+
+### Catch-all routes
+
+Catch-all params accept `string[]` — segments are joined with `/`.
+
+```tsx
+generatePath("/docs/[...segments]", { segments: ["guides", "routing"] });
+// => "/docs/guides/routing"
+```
+
+### Route groups
+
+Route groups like `(marketing)` don't affect URLs. A page at `app/(marketing)/pricing/page.tsx` is just `/pricing`:
+
+```tsx
+generatePath("/pricing");
+// => "/pricing"
+```
+
+## How it works
+
+Next.js with `typedRoutes: true` generates a `ParamMap` interface in `.next/types/routes.d.ts` that maps every route pattern to its params:
+
+```ts
+interface ParamMap {
+  "/": {}
+  "/about": {}
+  "/blog/[slug]": { slug: string }
+  "/docs/[...segments]": { segments: string[] }
+}
+```
+
+`withTypedRoutes()` generates a small declaration file in `.next/types/` that merges this `ParamMap` into the package via [module augmentation](https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation). Since `.next/types/**/*.ts` is already in your tsconfig's `include`, TypeScript picks it up automatically — no manual wiring needed.
+
+The `generatePath` function uses conditional tuple types to require params only when the route has them, and returns a template literal type (e.g. `` `/blog/${string}` ``) that Next.js's `RouteImpl` accepts.
+
+## `createGeneratePath` factory
+
+If you're not using Next.js, or want to provide your own param map, use the factory:
+
+```ts
+import { createGeneratePath } from "next-generate-path";
+
+type MyRoutes = {
+  "/": {};
+  "/users/[id]": { id: string };
+};
+
+const generatePath = createGeneratePath<MyRoutes>();
+
+generatePath("/users/[id]", { id: "123" });
+// => "/users/123"
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+type HasParams<T> = keyof T extends never ? false : true;
+type ResolveRoute<R extends string> = R extends `${infer Before}[${string}]${infer After}` ? `${Before}${string}${ResolveRoute<After>}` : R;
+type ParamValue = string | string[];
+interface TypedRoutesParamMap {
+}
+declare function generatePath<R extends keyof TypedRoutesParamMap & string>(...args: HasParams<TypedRoutesParamMap[R]> extends true ? [route: R, params: TypedRoutesParamMap[R]] : [route: R]): ResolveRoute<R>;
+declare function createGeneratePath<PM extends {
+    [K in keyof PM]: Record<string, ParamValue>;
+}>(): <R extends keyof PM & string>(...args: HasParams<PM[R]> extends true ? [route: R, params: PM[R]] : [route: R]) => ResolveRoute<R>;
+
+export { type TypedRoutesParamMap, createGeneratePath, generatePath };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+type HasParams<T> = keyof T extends never ? false : true;
+type ResolveRoute<R extends string> = R extends `${infer Before}[${string}]${infer After}` ? `${Before}${string}${ResolveRoute<After>}` : R;
+type ParamValue = string | string[];
+interface TypedRoutesParamMap {
+}
+declare function generatePath<R extends keyof TypedRoutesParamMap & string>(...args: HasParams<TypedRoutesParamMap[R]> extends true ? [route: R, params: TypedRoutesParamMap[R]] : [route: R]): ResolveRoute<R>;
+declare function createGeneratePath<PM extends {
+    [K in keyof PM]: Record<string, ParamValue>;
+}>(): <R extends keyof PM & string>(...args: HasParams<PM[R]> extends true ? [route: R, params: PM[R]] : [route: R]) => ResolveRoute<R>;
+
+export { type TypedRoutesParamMap, createGeneratePath, generatePath };

package/dist/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createGeneratePath: () => createGeneratePath,
+  generatePath: () => generatePath
+});
+module.exports = __toCommonJS(index_exports);
+function replaceParams(route, params) {
+  return route.replace(/\[(?:\.\.\.)?([^\]]+)\]/g, (_, key) => {
+    const value = params[key];
+    if (value === void 0) {
+      throw new Error(`Missing param "${key}" for route "${route}"`);
+    }
+    if (Array.isArray(value)) {
+      return value.map(encodeURIComponent).join("/");
+    }
+    return encodeURIComponent(value);
+  });
+}
+function generatePath(...args) {
+  const [route, params] = args;
+  if (!params) return route;
+  return replaceParams(route, params);
+}
+function createGeneratePath() {
+  return function generatePath2(...args) {
+    const [route, params] = args;
+    if (!params) return route;
+    return replaceParams(route, params);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGeneratePath,
+  generatePath
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// Checks whether a type has any keys at all.\n// Used to distinguish \"/blog/[slug]\" (has params) from \"/\" (no params).\n//   HasParams<{ slug: string }> → true\n//   HasParams<{}>               → false\ntype HasParams<T> = keyof T extends never ? false : true;\n\n// Recursively turns a route pattern into the shape of its resolved URL,\n// so Next.js's Link/redirect/router.push accept it as a valid route.\n//   ResolveRoute<\"/blog/[slug]\">                      → `/blog/${string}`\n//   ResolveRoute<\"/blog/[slug]/comments/[commentId]\"> → `/blog/${string}/comments/${string}`\n//   ResolveRoute<\"/docs/[...segments]\">               → `/docs/${string}`\n//   ResolveRoute<\"/\">                                 → \"/\"\ntype ResolveRoute<R extends string> =\n  R extends `${infer Before}[${string}]${infer After}`\n    ? `${Before}${string}${ResolveRoute<After>}`\n    : R;\n\n// Param values can be strings (regular params) or string arrays (catch-all params like [...slug]).\ntype ParamValue = string | string[];\n\n// Replaces [param] and [...param] segments with their values.\n// Catch-all params (string[]) are joined with \"/\".\nfunction replaceParams(route: string, params: Record<string, ParamValue>): string {\n  return route.replace(/\\[(?:\\.\\.\\.)?([^\\]]+)\\]/g, (_, key: string) => {\n    const value = params[key];\n    if (value === undefined) {\n      throw new Error(`Missing param \"${key}\" for route \"${route}\"`);\n    }\n    if (Array.isArray(value)) {\n      return value.map(encodeURIComponent).join(\"/\");\n    }\n    return encodeURIComponent(value);\n  });\n}\n\n// Augmentable interface — `withTypedRoutes()` in next.config.js auto-generates\n// a declaration file that merges Next.js's `ParamMap` into this interface.\n// This is what makes `generatePath` know about your app's routes without\n// any manual wiring.\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface TypedRoutesParamMap {}\n\n// Ready-to-use generatePath, typed against TypedRoutesParamMap.\n// When used with `withTypedRoutes()` in next.config.js, this automatically\n// knows all your app's routes. No factory or manual setup needed.\nexport function generatePath<\n  R extends keyof TypedRoutesParamMap & string,\n>(\n  ...args: HasParams<TypedRoutesParamMap[R]> extends true\n    ? [route: R, params: TypedRoutesParamMap[R]]\n    : [route: R]\n): ResolveRoute<R> {\n  const [route, params] = args as [string, Record<string, ParamValue>?];\n\n  if (!params) return route as ResolveRoute<R>;\n\n  return replaceParams(route, params) as ResolveRoute<R>;\n}\n\n// Factory for non-Next.js consumers or custom ParamMap types.\n// Produces the same generatePath function but with an explicit type parameter.\nexport function createGeneratePath<\n  // Self-referential constraint: each value must be a Record<string, string | string[]>.\n  // Written this way (instead of Record<string, ...>) because TS interfaces\n  // (like Next.js's ParamMap) don't satisfy index-signature constraints.\n  PM extends { [K in keyof PM]: Record<string, ParamValue> },\n>() {\n  return function generatePath<R extends keyof PM & string>(\n    // Conditional args tuple:\n    //   - routes WITH params  → two args required: (route, params)\n    //   - routes WITHOUT params → single arg:      (route)\n    // This makes `generatePath(\"/\")` valid but `generatePath(\"/blog/[slug]\")` a TS error.\n    ...args: HasParams<PM[R]> extends true\n      ? [route: R, params: PM[R]]\n      : [route: R]\n  ): ResolveRoute<R> {\n    const [route, params] = args as [string, Record<string, ParamValue>?];\n\n    if (!params) return route as ResolveRoute<R>;\n\n    return replaceParams(route, params) as ResolveRoute<R>;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,SAAS,cAAc,OAAe,QAA4C;AAChF,SAAO,MAAM,QAAQ,4BAA4B,CAAC,GAAG,QAAgB;AACnE,UAAM,QAAQ,OAAO,GAAG;AACxB,QAAI,UAAU,QAAW;AACvB,YAAM,IAAI,MAAM,kBAAkB,GAAG,gBAAgB,KAAK,GAAG;AAAA,IAC/D;AACA,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,aAAO,MAAM,IAAI,kBAAkB,EAAE,KAAK,GAAG;AAAA,IAC/C;AACA,WAAO,mBAAmB,KAAK;AAAA,EACjC,CAAC;AACH;AAYO,SAAS,gBAGX,MAGc;AACjB,QAAM,CAAC,OAAO,MAAM,IAAI;AAExB,MAAI,CAAC,OAAQ,QAAO;AAEpB,SAAO,cAAc,OAAO,MAAM;AACpC;AAIO,SAAS,qBAKZ;AACF,SAAO,SAASA,iBAKX,MAGc;AACjB,UAAM,CAAC,OAAO,MAAM,IAAI;AAExB,QAAI,CAAC,OAAQ,QAAO;AAEpB,WAAO,cAAc,OAAO,MAAM;AAAA,EACpC;AACF;","names":["generatePath"]}

package/dist/index.mjs

@@ -0,0 +1,30 @@
+// src/index.ts
+function replaceParams(route, params) {
+  return route.replace(/\[(?:\.\.\.)?([^\]]+)\]/g, (_, key) => {
+    const value = params[key];
+    if (value === void 0) {
+      throw new Error(`Missing param "${key}" for route "${route}"`);
+    }
+    if (Array.isArray(value)) {
+      return value.map(encodeURIComponent).join("/");
+    }
+    return encodeURIComponent(value);
+  });
+}
+function generatePath(...args) {
+  const [route, params] = args;
+  if (!params) return route;
+  return replaceParams(route, params);
+}
+function createGeneratePath() {
+  return function generatePath2(...args) {
+    const [route, params] = args;
+    if (!params) return route;
+    return replaceParams(route, params);
+  };
+}
+export {
+  createGeneratePath,
+  generatePath
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// Checks whether a type has any keys at all.\n// Used to distinguish \"/blog/[slug]\" (has params) from \"/\" (no params).\n//   HasParams<{ slug: string }> → true\n//   HasParams<{}>               → false\ntype HasParams<T> = keyof T extends never ? false : true;\n\n// Recursively turns a route pattern into the shape of its resolved URL,\n// so Next.js's Link/redirect/router.push accept it as a valid route.\n//   ResolveRoute<\"/blog/[slug]\">                      → `/blog/${string}`\n//   ResolveRoute<\"/blog/[slug]/comments/[commentId]\"> → `/blog/${string}/comments/${string}`\n//   ResolveRoute<\"/docs/[...segments]\">               → `/docs/${string}`\n//   ResolveRoute<\"/\">                                 → \"/\"\ntype ResolveRoute<R extends string> =\n  R extends `${infer Before}[${string}]${infer After}`\n    ? `${Before}${string}${ResolveRoute<After>}`\n    : R;\n\n// Param values can be strings (regular params) or string arrays (catch-all params like [...slug]).\ntype ParamValue = string | string[];\n\n// Replaces [param] and [...param] segments with their values.\n// Catch-all params (string[]) are joined with \"/\".\nfunction replaceParams(route: string, params: Record<string, ParamValue>): string {\n  return route.replace(/\\[(?:\\.\\.\\.)?([^\\]]+)\\]/g, (_, key: string) => {\n    const value = params[key];\n    if (value === undefined) {\n      throw new Error(`Missing param \"${key}\" for route \"${route}\"`);\n    }\n    if (Array.isArray(value)) {\n      return value.map(encodeURIComponent).join(\"/\");\n    }\n    return encodeURIComponent(value);\n  });\n}\n\n// Augmentable interface — `withTypedRoutes()` in next.config.js auto-generates\n// a declaration file that merges Next.js's `ParamMap` into this interface.\n// This is what makes `generatePath` know about your app's routes without\n// any manual wiring.\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface TypedRoutesParamMap {}\n\n// Ready-to-use generatePath, typed against TypedRoutesParamMap.\n// When used with `withTypedRoutes()` in next.config.js, this automatically\n// knows all your app's routes. No factory or manual setup needed.\nexport function generatePath<\n  R extends keyof TypedRoutesParamMap & string,\n>(\n  ...args: HasParams<TypedRoutesParamMap[R]> extends true\n    ? [route: R, params: TypedRoutesParamMap[R]]\n    : [route: R]\n): ResolveRoute<R> {\n  const [route, params] = args as [string, Record<string, ParamValue>?];\n\n  if (!params) return route as ResolveRoute<R>;\n\n  return replaceParams(route, params) as ResolveRoute<R>;\n}\n\n// Factory for non-Next.js consumers or custom ParamMap types.\n// Produces the same generatePath function but with an explicit type parameter.\nexport function createGeneratePath<\n  // Self-referential constraint: each value must be a Record<string, string | string[]>.\n  // Written this way (instead of Record<string, ...>) because TS interfaces\n  // (like Next.js's ParamMap) don't satisfy index-signature constraints.\n  PM extends { [K in keyof PM]: Record<string, ParamValue> },\n>() {\n  return function generatePath<R extends keyof PM & string>(\n    // Conditional args tuple:\n    //   - routes WITH params  → two args required: (route, params)\n    //   - routes WITHOUT params → single arg:      (route)\n    // This makes `generatePath(\"/\")` valid but `generatePath(\"/blog/[slug]\")` a TS error.\n    ...args: HasParams<PM[R]> extends true\n      ? [route: R, params: PM[R]]\n      : [route: R]\n  ): ResolveRoute<R> {\n    const [route, params] = args as [string, Record<string, ParamValue>?];\n\n    if (!params) return route as ResolveRoute<R>;\n\n    return replaceParams(route, params) as ResolveRoute<R>;\n  };\n}\n"],"mappings":";AAsBA,SAAS,cAAc,OAAe,QAA4C;AAChF,SAAO,MAAM,QAAQ,4BAA4B,CAAC,GAAG,QAAgB;AACnE,UAAM,QAAQ,OAAO,GAAG;AACxB,QAAI,UAAU,QAAW;AACvB,YAAM,IAAI,MAAM,kBAAkB,GAAG,gBAAgB,KAAK,GAAG;AAAA,IAC/D;AACA,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,aAAO,MAAM,IAAI,kBAAkB,EAAE,KAAK,GAAG;AAAA,IAC/C;AACA,WAAO,mBAAmB,KAAK;AAAA,EACjC,CAAC;AACH;AAYO,SAAS,gBAGX,MAGc;AACjB,QAAM,CAAC,OAAO,MAAM,IAAI;AAExB,MAAI,CAAC,OAAQ,QAAO;AAEpB,SAAO,cAAc,OAAO,MAAM;AACpC;AAIO,SAAS,qBAKZ;AACF,SAAO,SAASA,iBAKX,MAGc;AACjB,UAAM,CAAC,OAAO,MAAM,IAAI;AAExB,QAAI,CAAC,OAAQ,QAAO;AAEpB,WAAO,cAAc,OAAO,MAAM;AAAA,EACpC;AACF;","names":["generatePath"]}

package/dist/next.d.mts

@@ -0,0 +1,5 @@
+import { NextConfig } from 'next';
+
+declare function withTypedRoutes(config: NextConfig): NextConfig;
+
+export { withTypedRoutes };

package/dist/next.d.ts

@@ -0,0 +1,5 @@
+import { NextConfig } from 'next';
+
+declare function withTypedRoutes(config: NextConfig): NextConfig;
+
+export { withTypedRoutes };

package/dist/next.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next.ts
+var next_exports = {};
+__export(next_exports, {
+  withTypedRoutes: () => withTypedRoutes
+});
+module.exports = __toCommonJS(next_exports);
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var GENERATED_DTS = `// Auto-generated by next-generate-path \u2014 do not edit
+import type { ParamMap } from "./routes";
+import "next-generate-path";
+
+declare module "next-generate-path" {
+  interface TypedRoutesParamMap extends ParamMap {}
+}
+`;
+function withTypedRoutes(config) {
+  const typesDir = (0, import_node_path.join)(process.cwd(), ".next", "types");
+  (0, import_node_fs.mkdirSync)(typesDir, { recursive: true });
+  (0, import_node_fs.writeFileSync)((0, import_node_path.join)(typesDir, "typed-routes.d.ts"), GENERATED_DTS);
+  return {
+    ...config,
+    typedRoutes: true
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withTypedRoutes
+});
+//# sourceMappingURL=next.js.map

package/dist/next.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/next.ts"],"sourcesContent":["import type { NextConfig } from \"next\";\nimport { writeFileSync, mkdirSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nconst GENERATED_DTS = `// Auto-generated by next-generate-path — do not edit\nimport type { ParamMap } from \"./routes\";\nimport \"next-generate-path\";\n\ndeclare module \"next-generate-path\" {\n  interface TypedRoutesParamMap extends ParamMap {}\n}\n`;\n\n// Wraps your Next.js config to enable direct `generatePath` imports.\n// Generates a .d.ts file in .next/types/ that bridges Next.js's ParamMap\n// into the package's TypedRoutesParamMap via module augmentation.\nexport function withTypedRoutes(config: NextConfig): NextConfig {\n  const typesDir = join(process.cwd(), \".next\", \"types\");\n  mkdirSync(typesDir, { recursive: true });\n  writeFileSync(join(typesDir, \"typed-routes.d.ts\"), GENERATED_DTS);\n\n  return {\n    ...config,\n    typedRoutes: true,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,qBAAyC;AACzC,uBAAqB;AAErB,IAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYf,SAAS,gBAAgB,QAAgC;AAC9D,QAAM,eAAW,uBAAK,QAAQ,IAAI,GAAG,SAAS,OAAO;AACrD,gCAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AACvC,wCAAc,uBAAK,UAAU,mBAAmB,GAAG,aAAa;AAEhE,SAAO;AAAA,IACL,GAAG;AAAA,IACH,aAAa;AAAA,EACf;AACF;","names":[]}

package/dist/next.mjs

@@ -0,0 +1,24 @@
+// src/next.ts
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+var GENERATED_DTS = `// Auto-generated by next-generate-path \u2014 do not edit
+import type { ParamMap } from "./routes";
+import "next-generate-path";
+
+declare module "next-generate-path" {
+  interface TypedRoutesParamMap extends ParamMap {}
+}
+`;
+function withTypedRoutes(config) {
+  const typesDir = join(process.cwd(), ".next", "types");
+  mkdirSync(typesDir, { recursive: true });
+  writeFileSync(join(typesDir, "typed-routes.d.ts"), GENERATED_DTS);
+  return {
+    ...config,
+    typedRoutes: true
+  };
+}
+export {
+  withTypedRoutes
+};
+//# sourceMappingURL=next.mjs.map

package/dist/next.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/next.ts"],"sourcesContent":["import type { NextConfig } from \"next\";\nimport { writeFileSync, mkdirSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nconst GENERATED_DTS = `// Auto-generated by next-generate-path — do not edit\nimport type { ParamMap } from \"./routes\";\nimport \"next-generate-path\";\n\ndeclare module \"next-generate-path\" {\n  interface TypedRoutesParamMap extends ParamMap {}\n}\n`;\n\n// Wraps your Next.js config to enable direct `generatePath` imports.\n// Generates a .d.ts file in .next/types/ that bridges Next.js's ParamMap\n// into the package's TypedRoutesParamMap via module augmentation.\nexport function withTypedRoutes(config: NextConfig): NextConfig {\n  const typesDir = join(process.cwd(), \".next\", \"types\");\n  mkdirSync(typesDir, { recursive: true });\n  writeFileSync(join(typesDir, \"typed-routes.d.ts\"), GENERATED_DTS);\n\n  return {\n    ...config,\n    typedRoutes: true,\n  };\n}\n"],"mappings":";AACA,SAAS,eAAe,iBAAiB;AACzC,SAAS,YAAY;AAErB,IAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYf,SAAS,gBAAgB,QAAgC;AAC9D,QAAM,WAAW,KAAK,QAAQ,IAAI,GAAG,SAAS,OAAO;AACrD,YAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AACvC,gBAAc,KAAK,UAAU,mBAAmB,GAAG,aAAa;AAEhE,SAAO;AAAA,IACL,GAAG;AAAA,IACH,aAAa;AAAA,EACf;AACF;","names":[]}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "next-generate-path",
+  "version": "0.0.1",
+  "description": "Type-safe route path generation for Next.js typed routes",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": "./dist/index.js"
+    },
+    "./next": {
+      "types": "./dist/next.d.ts",
+      "import": {
+        "types": "./dist/next.d.mts",
+        "default": "./dist/next.mjs"
+      },
+      "require": "./dist/next.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint . --max-warnings 0",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "nextjs",
+    "typed-routes",
+    "generate-path",
+    "type-safe",
+    "routing"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/twenty9-labs/next-generate-path.git"
+  },
+  "bugs": {
+    "url": "https://github.com/twenty9-labs/next-generate-path/issues"
+  },
+  "homepage": "https://github.com/twenty9-labs/next-generate-path#readme",
+  "peerDependencies": {
+    "next": ">=14"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "workspace:*",
+    "@repo/typescript-config": "workspace:*",
+    "@types/node": "^22.15.3",
+    "eslint": "^9.39.1",
+    "next": "16.1.5",
+    "tsup": "^8.5.1",
+    "typescript": "5.9.2",
+    "vitest": "^4.0.18"
+  }
+}