@native-router/core 1.9.0 → 1.9.1

package/README.md

@@ -141,6 +141,8 @@ const router = create(
 
 - No `params` schema → behavior unchanged: the raw string map flows through
 - The parse runs per level (shallow → deep): a level's schema validates the params merged up to it; a deeper schema sees the (possibly coerced) output of the shallower ones
+- A `redirect` level skips its params schema entirely — the level's guard never runs, so there is nothing to hand coerced params to; the same asymmetry the search schema has (`redirect` wins over `beforeLoad`). Hanging a params schema on a redirect level is inert, it cannot fail the navigation
+- A same-name param on both a parent and a child segment (`/users/:id/files/:id`): the deep-over-shallow merge operates on the **raw** strings, so the child segment's value overwrites the parent's coerced one — a child guard sees the raw string again. Declare the coercing schema on (or below) the deepest level that reads the param — a deeper schema validates the whole merged map anyway — or avoid reusing a param name across levels
 - A rejected validation fails the resolution through the `errorHandler` channel with a `ParamsError` (a `NativeRouterError`) carrying the raw `params` and the reported `issues` — the same route a search-schema failure takes
 - `parseParams`/`parseParamsSync` are exported for custom `resolveView` implementations (the async/sync flavors mirror `parseSearch`/`parseSearchSync`)
 

package/dist/index.cjs

@@ -528,11 +528,16 @@ async function resolveEntry(router, location, opts) {
         ...matched[i].params
       };
       // The level's params schema runs before its guard, so the guard
-      // sees the coerced output. A validation failure fails the
-      // resolution through the task's errorHandler channel — the same
-      // route a search-schema failure takes — instead of rejecting this
-      // entry, which preload consumers share.
-      if (route.params) {
+      // sees the coerced output. A redirect level never runs its guard,
+      // so its schema is skipped — the same asymmetry the level's
+      // search schema already has(`redirect` wins over `beforeLoad`):
+      // hanging a params schema on a redirect level must not be able to
+      // fail the navigation, its only observable effect would be the
+      // failure. A validation failure fails the resolution through the
+      // task's errorHandler channel — the same route a search-schema
+      // failure takes — instead of rejecting this entry, which preload
+      // consumers share.
+      if (route.params && !route.redirect) {
         try {
           // eslint-disable-next-line no-await-in-loop -- guards must run in declaration order, sequentially
           params = await parseParams(route.params, params);

package/dist/index.mjs

@@ -526,11 +526,16 @@ async function resolveEntry(router, location, opts) {
         ...matched[i].params
       };
       // The level's params schema runs before its guard, so the guard
-      // sees the coerced output. A validation failure fails the
-      // resolution through the task's errorHandler channel — the same
-      // route a search-schema failure takes — instead of rejecting this
-      // entry, which preload consumers share.
-      if (route.params) {
+      // sees the coerced output. A redirect level never runs its guard,
+      // so its schema is skipped — the same asymmetry the level's
+      // search schema already has(`redirect` wins over `beforeLoad`):
+      // hanging a params schema on a redirect level must not be able to
+      // fail the navigation, its only observable effect would be the
+      // failure. A validation failure fails the resolution through the
+      // task's errorHandler channel — the same route a search-schema
+      // failure takes — instead of rejecting this entry, which preload
+      // consumers share.
+      if (route.params && !route.redirect) {
         try {
           // eslint-disable-next-line no-await-in-loop -- guards must run in declaration order, sequentially
           params = await parseParams(route.params, params);

package/dist/types/types.d.ts

@@ -142,8 +142,16 @@ export type ExtractPathParams<P extends string> = P extends `${infer Head}/${inf
  * Context passed to a route guard({@link BaseRoute.beforeLoad beforeLoad}).
  * `params` are accumulated from the root level down to the level that
  * owns the guard, so a guard only sees params of itself and its parents.
+ *
+ * Type arguments: `S` types {@link GuardContext.search search}(schema
+ * output, or the degraded input without a schema), `P` types
+ * {@link GuardContext.params params}. Both default to what a
+ * schema-less route produces — `search: unknown`, `params: the raw
+ * string map` — so plain guards keep compiling unchanged; thread a
+ * params schema's coerced output through `P` to type what the guard
+ * actually receives at runtime.
  */
-export type GuardContext<R extends BaseRoute = BaseRoute, S = unknown> = {
+export type GuardContext<R extends BaseRoute = BaseRoute, S = unknown, P = Record<string, string>> = {
     router: RouterInstance<R>;
     location: Location;
     /**
@@ -151,9 +159,13 @@ export type GuardContext<R extends BaseRoute = BaseRoute, S = unknown> = {
      * declares a {@link BaseRoute.params params schema}, the merged raw
      * params are parsed through the deepest matching schema before the
      * guard runs; without schemas the raw string map the matcher
-     * extracted.
+     * extracted. The loose default models the raw map; give the third
+     * type argument the schema's output(`GuardContext<R, S, {id: number}>`
+     * for a `z.coerce.number()` id) — the runtime value is the parse
+     * result, which a coercing schema makes anything but
+     * `Record<string, string>`.
      */
-    params: Record<string, string>;
+    params: P;
     /**
      * The search the guard sees: the route's {@link BaseRoute.search search
      * schema} output(parsed and validated before the guard runs), or the
@@ -193,7 +205,9 @@ export type BaseRoute<T = any> = {
      * runs it in {@link resolveEntry} after matching and before the level's
      * `beforeLoad`, so guards and loaders see coerced params(e.g. `:id`
      * as a number) instead of raw strings; a validation failure fails the
-     * resolve like any other navigation error(via `ParamsError`).
+     * resolve like any other navigation error(via `ParamsError`). A level
+     * with a {@link BaseRoute.redirect redirect} skips the schema — the
+     * guard never runs there, so the schema would have no consumer.
      *
      * Omit it and the params stay the raw `Record<string, string>` the
      * matcher extracted — behavior is unchanged.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@native-router/core",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -34,7 +34,8 @@
     "lint": "eslint --fix src test *.js",
     "doc:gen": "typedoc",
     "deploy": "npm run doc:gen && gh-pages -d dist",
-    "test": "vitest run"
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit"
   },
   "repository": {
     "type": "git",