next-generate-path 0.0.2 → 0.0.4

package/README.md

@@ -1,10 +1,12 @@
 # next-generate-path
 
+[![npm](https://img.shields.io/npm/v/next-generate-path)](https://www.npmjs.com/package/next-generate-path)
+
 Type-safe `generatePath()` for Next.js. Autocomplete for every route, params enforced at compile time.
 
 ## The problem
 
-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. There's no way to discover what routes exist or what params they need.
+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. However, dynamic routes like `/blog/[slug]` don't appear in autocomplete. You have to know the pattern and manually write template literals. There's no way to discover what routes exist or what params they need.
 
 ## The solution
 
@@ -17,13 +19,13 @@ generatePath("/blog/[slug]", { slug: "hello-world" });
 //            ^ autocomplete shows all routes     ^ params are required and type-checked
 
 generatePath("/about");
-// => "/about" — static routes need no params
+// => "/about" (static routes need no params)
 
 generatePath("/blog/[slug]");
 // TS error: expected 2 arguments, got 1
 ```
 
-The return type is compatible with Next.js's `RouteImpl`, so it works directly with `<Link>`, `redirect()`, and `router.push()` — no casts needed.
+The return type is compatible with Next.js's `RouteImpl`, so it works directly with `<Link>`, `redirect()`, and `router.push()` without any casts.
 
 ```tsx
 // All of these are fully type-safe
@@ -79,7 +81,7 @@ generatePath("/about");
 // => "/about"
 ```
 
-### Dynamic routes — `[param]`
+### Dynamic routes (`[param]`)
 
 ```tsx
 generatePath("/blog/[slug]", { slug: "hello-world" });
@@ -95,9 +97,9 @@ generatePath("/products/[id]/reviews", { id: "42" });
 // => "/products/42/reviews"
 ```
 
-### Catch-all routes — `[...param]`
+### Catch-all routes (`[...param]`)
 
-Catch-all params accept `string[]` — segments are joined with `/`:
+Catch-all params accept `string[]`. Segments are joined with `/`:
 
 ```tsx
 generatePath("/docs/[...segments]", { segments: ["guides", "routing"] });
@@ -107,7 +109,25 @@ generatePath("/docs/[...segments]", { segments: ["getting-started"] });
 // => "/docs/getting-started"
 ```
 
-### Route groups — `(folder)`
+### API routes (`route.ts`)
+
+API route handlers are included in the `ParamMap` too, so `generatePath` works for building API URLs:
+
+```tsx
+generatePath("/api/health");
+// => "/api/health"
+
+generatePath("/api/products/[id]", { id: "42" });
+// => "/api/products/42"
+```
+
+This is useful for `fetch` calls where you want type-safe API paths:
+
+```tsx
+const res = await fetch(generatePath("/api/products/[id]", { id: productId }));
+```
+
+### Route groups (`(folder)`)
 
 Route groups don't affect URLs. A page at `app/(marketing)/pricing/page.tsx` is just `/pricing`:
 
@@ -125,6 +145,8 @@ Next.js with `typedRoutes: true` generates a `ParamMap` interface in `.next/type
 interface ParamMap {
   "/": {}
   "/about": {}
+  "/api/health": {}
+  "/api/products/[id]": { id: string }
   "/blog/[slug]": { slug: string }
   "/products/[id]": { id: string }
   "/products/[id]/reviews": { id: string }
@@ -144,9 +166,9 @@ declare module "next-generate-path" {
 }
 ```
 
-Since `.next/types/**/*.ts` is already in your tsconfig's `include`, TypeScript picks it up automatically — no manual wiring needed.
+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 — so the result works directly with `<Link>`, `redirect()`, and `router.push()`.
+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. This means the result works directly with `<Link>`, `redirect()`, and `router.push()`.
 
 ## API
 
@@ -158,9 +180,9 @@ import { generatePath } from "next-generate-path";
 
 Returns the resolved URL string. Params are required for dynamic routes and omitted for static routes.
 
-- **`route`** — A route pattern string (autocompleted from your app's routes)
-- **`params`** — An object of param values (required when the route has dynamic segments)
-- **Returns** — The resolved URL, typed as a template literal compatible with Next.js's `RouteImpl`
+- **`route`** - A route pattern string (autocompleted from your app's routes)
+- **`params`** - An object of param values (required when the route has dynamic segments)
+- **Returns** - The resolved URL, typed as a template literal compatible with Next.js's `RouteImpl`
 
 Param values are URI-encoded. Catch-all params (`string[]`) are joined with `/`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-generate-path",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Type-safe route path generation for Next.js typed routes",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",