@plumile/router 0.1.14 → 0.1.18

package/README.md

@@ -37,9 +37,6 @@ import { Route, getResourcePage } from '@plumile/router';
 const routes: Route<any, any>[] = [
   {
     path: '/',
-
-  ## Advanced Hooks Deep Dive & Combined Examples
-
     resourcePage: getResourcePage('Home', () => import('./pages/Home')),
   },
   {
@@ -147,9 +144,6 @@ Navigation component that handles client-side routing.
 
 - `to`: string - Destination path
 - `exact?`: boolean - Exact path matching for active state
-
-### Combined Example: Products Listing Page
-
 - `activeClassName?`: string - CSS class when link is active
 - `className?`: string - Base CSS class
 - `preload?`: boolean - Preload route on hover
@@ -236,6 +230,50 @@ Type helper for strongly-typed route definitions.
 
 ## Advanced Usage
 
+### Per-Route Prepared Data & Typed Navigate
+
+Each route created with `r({...})` now preserves:
+
+- Prepared data type (return of `prepare`)
+- URL parameter type
+- Inferred typed query shape from its `query` schema
+
+This enables discriminated narrowing using `entry.route?.path` and compile-time validation of `navigate` query objects.
+
+```ts
+import { r, q, createRouter } from '@plumile/router';
+
+const plans = r({
+  path: '/plans',
+  query: { page: q.number() } as const,
+  prepare: ({ query }) => ({ page: query.page }),
+});
+const user = r<{ userId: string }, { id: string }>({
+  path: '/users/:id',
+  prepare: ({ variables }) => ({ userId: variables.id }),
+});
+const { context } = createRouter([plans, user] as const);
+
+const entry = context.get();
+if (entry.route?.path === '/plans') {
+  const prepared = context.getPrepared('/plans');
+  // prepared?.page inferred as number | undefined
+  const typed = context.getTypedQuery('/plans');
+  // typed?.page inferred
+}
+
+// Typed navigate – query validated against the route schema
+context.navigate({ pathname: '/plans', query: { page: 2 } });
+```
+
+APIs:
+
+- `context.getPrepared(path)` → prepared object for that matched path (if present).
+- `context.getTypedQuery(path)` → typed query for path.
+- `context.navigate({...})` → enforces schema shape when `pathname` matches a known literal path.
+
+If a path is dynamic or no schema exists, the untyped fallback remains available.
+
 ### Typed Query Parameters (DSL)
 
 The router provides a lightweight schema DSL for parsing, typing, normalizing and serializing query strings.
@@ -482,118 +520,64 @@ Extending: if you need more (e.g. trigger navigations) you can wrap `createRoute
 
 Production: the symbol is not defined; accessing it will yield `undefined`. Never ship logic depending on it; keep usage inside `if (process.env.NODE_ENV !== 'production')` blocks or guarded optional checks.
 
-### ESLint Rule: no-direct-window-location-search
-
-To encourage consistent usage of the query hooks, a custom rule is provided inside the router package to flag raw `window.location.search` access.
-
-Add to your flat ESLint config:
-
-````js
-import noDirectWindowLocationSearch from '@plumile/router/lib/eslint-rules/no-direct-window-location-search.js';
-
-export default [
-  {
-
-## Batched Navigation & Provisional typedQuery Contract
-
-The router supports two batching modes:
-
-- Manual batching: pass `batch: true` in successive `navigate` calls within the same microtask.
-- Auto batching: enable `createRouter(routes, { autoBatch: true })` and omit `immediate: true` to coalesce navigations scheduled in the same microtask.
-
-During a batched sequence, the final history update (a single `push`/`set`) is deferred to a queued microtask. Some code (tests, imperative flows) may need to synchronously observe the merged query state before the flush occurs. To support this, the router performs a provisional in‑memory update of the current route entry on each batched `navigate`:
-
-Guarantees (provisional phase):
-
-1. `context.get()` returns an entry whose `location.search`, `rawSearch`, `query` (raw parsed) and `typedQuery` reflect the merged state of all batched calls so far.
-2. Each additional batched call merges query keys (last write wins) and overwrites the entire filters object (they are considered atomic state) before recomputing `typedQuery`.
-3. The provisional `typedQuery` uses the deepest route schema of the eventual target pathname (if a batched navigation changes pathname, subsequent calls resolve the schema for that new path).
-4. Normalization (e.g. clamping `page < 1`) is only applied at the final flush listener step; the provisional `typedQuery` may briefly contain unnormalized values until flush.
-5. Subscribers (`context.subscribe`) are **not** notified until the actual history update fires (asynchronously). Reading inside the same tick requires using `context.get()` directly, not relying on subscription callbacks.
-
-Non‑guarantees / caveats:
+### Filter Schema & useFilters (Integration with @plumile/filter-query)
 
-- If you read `window.location.search` directly (discouraged) during a batch it will still show the pre‑batch URL; use the entry returned by `context.get()`.
-- If later batched calls change the pathname, earlier provisional `typedQuery` objects become stale; always re‑read after your final batched mutation if you need the merged result.
-- Filters batching (from `useFilters` helpers) coalesces multiple `set/patch/clear` calls in the same microtask via an internal microtask queue. These feed into the outer navigation batching so a burst of filter helper calls plus other `navigate` calls still produce a single history entry.
-
-Edge cases:
-
-- Calling `navigate({ immediate: true })` inside an active batch forces an immediate flush, bypassing batching for that specific call.
-- Interleaving manual `batch: true` and autoBatch calls: if autoBatch is enabled and you explicitly pass `batch: false`, that call flushes immediately; otherwise the presence of any manual `batch: true` call within the tick keeps coalescing active until flush.
-
-Recommended usage pattern inside effects or event handlers:
+The router can parse and serialize structured filter expressions using the `@plumile/filter-query` package. Define a `filterSchema` on the deepest route (same precedence rule as `query`). Each filter key is encoded as `field.operator=value`.
 
 ```ts
-// Multiple logical updates unified into 1 URL change
-context.navigate({ query: { page: 1 }, batch: true });
-context.navigate({ filters: { status: { in: ['active'] } }, filterSchema, batch: true });
-context.navigate({ query: { tag: 'green' }, batch: true });
-// Synchronous inspection (provisional)
-const merged = context.get().typedQuery; // already includes page=1, tag=green, status filter
-````
-
-Testing note: tests asserting final URL should poll or await a microtask / tick rather than expecting synchronous `window.location.search` updates when batching is involved.
-
-Future evolution: if normalization or additional query transformations grow more complex, the provisional recompute will remain a best‑effort mirror; code relying on _final_ normalized values should subscribe or await the flush boundary.
-
-Summary: Provisional batching gives synchronous, allocation‑minimal read access to the in‑flight merged query & typedQuery without sacrificing a single history entry – use `context.get()` for immediate reads, and rely on subscriptions or hooks for React render updates.
-
-## Route-Level Filter Schemas
+import { r, q, useFilters } from '@plumile/router';
+import { defineSchema, numberField, stringField } from '@plumile/filter-query';
 
-Attach a `filterSchema` to routes to progressively declare filterable fields along the hierarchy. Parent → child schemas are shallow merged; fields defined later override earlier ones by name.
-
-Example:
-
-```ts
-import { r, defineFilters, numberFilter, stringFilter } from '@plumile/router';
+const filterSchema = defineSchema({
+  price: numberField(), // operators: gt,gte,lt,lte,eq,neq,between,in,nin
+  name: stringField(), // operators: contains,sw,ew,eq,neq,in,nin
+});
 
-export const routes = [
+const routes = [
   r({
-    path: '/products',
-    filterSchema: defineFilters({
-      price: numberFilter({ operators: ['gte', 'lte'] }),
-    }),
-    children: [
-      r({
-        path: '/:id',
-        filterSchema: defineFilters({
-          name: stringFilter({ operators: ['contains'] }),
-        }),
-      }),
-    ],
+    path: '/items',
+    query: { page: q.default(q.number(), 1) },
+    filterSchema,
+    render: () => null,
   }),
 ];
+
+// Inside a component rendered under /items
+const [filters, actions] = useFilters();
+actions.set('price', 'gt', 10); // ?page=1&price.gt=10
+actions.set('price', 'eq', 15); // ?page=1&price.gt=10&price.eq=15
+actions.remove('price', 'gt'); // remove only that operator
+actions.clear(); // remove all filter segments
 ```
 
-Merged result for `/products/123` is `{ price, name }` definitions. Currently, implicit serialization of new filter values still requires passing `{ filters, filterSchema }` in a navigate/helper call; the route-level merged schema is used for parsing existing keys. This keeps mutations explicit. A future enhancement may allow omitting `filterSchema` when adding new filter values on a route that already declares one.
+`navigate({ filters })` is also available for programmatic changes alongside query updates. Serialization keeps query parameters first, then filter segments, both deterministically ordered.
 
-Rules:
+Diagnostics (unknown field/operator, invalid values, etc.) are accessible via `useFilterDiagnostics()` for debugging tooling or UI feedback.
 
-- Order: shallow override by field name.
-- No deep merge inside a field definition.
-- Omitted routes: ignored.
+### ESLint Rule: no-direct-window-location-search
 
-Limitations / current behavior:
+To encourage consistent usage of the query hooks, a custom rule is provided inside the router package to flag raw `window.location.search` access.
 
-- Initial merged schema is internal; helpers still need explicit schema to serialize new filter state.
-- Empty filters object with route-level schema is treated as “no change” (no extra keys added).
+Add to your flat ESLint config:
 
-Planned: implicit mode & devtools visualization of merged filter schema chain.
-plugins: {
-'@plumile-router/dx': {
-rules: {
-'no-direct-window-location-search': noDirectWindowLocationSearch,
-},
-},
-},
-rules: {
-'@plumile-router/dx/no-direct-window-location-search': 'warn',
-},
-},
-];
+```js
+import noDirectWindowLocationSearch from '@plumile/router/lib/eslint-rules/no-direct-window-location-search.js';
 
-````
+export default [
+  {
+    plugins: {
+      '@plumile-router/dx': {
+        rules: {
+          'no-direct-window-location-search': noDirectWindowLocationSearch,
+        },
+      },
+    },
+    rules: {
+      '@plumile-router/dx/no-direct-window-location-search': 'warn',
+    },
+  },
+];
+```
 
 Optional configuration:
 
@@ -605,7 +589,7 @@ rules: {
     { allowInFiles: ['legacy-entry.ts'] },
   ],
 },
-````
+```
 
 When triggered, replace patterns like:
 
@@ -663,242 +647,6 @@ Behavior:
 Options:
 `{ defaultValue?, omitIfDefault?: boolean = true, replace?: boolean, raw?: boolean }`
 
-### Filters DSL (Experimental Advanced Filtering)
-
-Structured multi‑operator filtering can be expressed via query keys using the pattern `field.operator`.
-
-1. Define a schema
-
-```ts
-import { defineFilters, numberFilter, stringFilter } from '@plumile/router';
-
-export const filters = defineFilters({
-  price: numberFilter(), // numeric: eq, neq, gt, gte, lt, lte, in, nin, between, exists
-  status: stringFilter({ operators: ['eq', 'in', 'nin'] }),
-  name: stringFilter({ operators: ['contains', 'starts', 'ends'] }),
-  // Provide default operator values to omit them from serialization when matched
-  availability: numberFilter({
-    operators: ['exists'],
-    defaults: { exists: true },
-  }),
-  priceRange: numberFilter({
-    operators: ['between'],
-    defaults: { between: [[0, 100]] },
-  }),
-});
-```
-
-2. Read & update filters
-
-```tsx
-import { useFilters } from '@plumile/router';
-
-function Products() {
-  const [f, { patch, clear }] = useFilters(filters);
-  // f.price.gt => number[] | undefined
-  // f.status.in => string[] | undefined
-  return (
-    <button
-      onClick={() => {
-        patch({ price: { gt: [10] } });
-      }}
-    >
-      Price &gt; 10
-    </button>
-  );
-}
-```
-
-3. Narrow to a single operator
-
-```tsx
-import { useFilterState } from '@plumile/router';
-
-function PriceGt() {
-  const [gt, setGt] = useFilterState(filters, 'price', 'gt');
-  return (
-    <input
-      value={gt?.[0] ?? ''}
-      onChange={(e) => setGt([Number(e.target.value)])}
-    />
-  );
-}
-```
-
-4. Supported operators
-
-| Kind   | Operators                                                                            |
-| ------ | ------------------------------------------------------------------------------------ |
-| number | eq, neq, gt, gte, lt, lte, in, nin, between (tuples), exists                         |
-| string | eq, neq, in, nin, between (tuples of strings), exists, contains, starts, ends, regex |
-
-`exists` expects a boolean; presence of key defaults to `true` if value unrecognized.
-
-5. Query string format
-
-```
-?price.gt=10&price.between=10&price.between=20&price.between=30&price.between=40&status.in=active&status.in=pending
-```
-
-6. Between operator
-
-Pairs of values create ranges: four values → two ranges. Odd final value is ignored.
-
-7. Clearing
-
-`clear()` → remove all filters. `clear(['price'])` → remove only price.\* keys.
-
-8. Patching
-
-`patch({ price: { gt: [20], between: [[10,20]] } })` merges at field level, replacing individual operator arrays.
-
-9. Serialization rules
-
-- Previous filter keys (`field.op`) are dropped before adding new ones.
-- Multiple values produce repeated keys (same as existing query arrays).
-- Boolean `exists` serialized as `1` / `0`.
-- Optional omission of default operator values: if a filter definition supplies a `defaults` object
-  (e.g. `{ defaults: { gt: [10] } }` or `{ defaults: { exists: true } }`), and the current operator
-  value is shallow‑equal to that default, the `field.operator` key is skipped during serialization.
-  Applies to array operators (exact ordered match) and `exists` boolean. `between` defaults compare
-  tuple pairs (`[[a,b]]`) element-wise.
-
-10. Type inference
-
-`InferFilters<typeof filters.schema>` gives `{ price: { gt?: number[]; between?: [number, number][]; ... } }`.
-
-11. Opt‑in / Backward Compatible
-
-No change to existing query parameter behavior. Filter keys are just additional query entries; legacy code reading raw `useQuery()` continues to function.
-
-12. Limitations / Future
-
-- Sorting deliberately excluded (would be separate DSL).
-- No date operator specialization yet.
-- Regex values are passed through verbatim (URL decoding handled upstream).
-- Default omission currently uses shallow equality (ordered array match). For number arrays
-  canonicalization (sorting + optional dedupe) happens prior to comparison, ensuring stable omission.
-
-Tests cover parsing (including multiple ranges) and building; extend as needed for your domain.
-
-### New Hooks (Phase 4)
-
-#### `useQueryObject(opts?)`
-
-High-level accessor returning the entire current query object (typed when the matched deepest route declares a `query` schema). It also returns a stable setter that merges partial updates.
-
-```tsx
-import { useQueryObject } from '@plumile/router';
-
-function Panel() {
-  const [query, setQuery] = useQueryObject({ omitDefaults: true });
-  // query: typed (if schema) else raw record
-  return (
-    <button
-      onClick={() => {
-        setQuery({ page: (query.page ?? 1) + 1 });
-      }}
-    >
-      Next page
-    </button>
-  );
-}
-```
-
-Options:
-
-- `raw?: boolean` Use aggregated raw query even if a schema exists.
-- `replace?: boolean` Default navigation mode for all subsequent `setQuery` calls.
-- `omitDefaults?: boolean` When true, schema keys whose value equals their declared default are omitted from the URL.
-
-Setter semantics:
-
-- Accepts an object or function `(prev) => next`.
-- Keys set to `undefined` are removed from the URL.
-- Partial objects are shallow‑merged with previous query state (post-merge omission rules are applied if `omitDefaults` is enabled).
-
-#### `useActiveFilters(filterSchema)`
-
-Returns a flat array of currently active filter operator entries derived from the structured filters state returned by `useFilters`.
-
-```tsx
-import { useActiveFilters } from '@plumile/router';
-import { filters } from './filters-schema';
-
-function ActiveChips() {
-  const active = useActiveFilters(filters);
-  return (
-    <ul>
-      {active.map((f) => (
-        <li key={f.field + f.operator}>
-          {f.field}.{f.operator}: {f.values.join(', ')}
-        </li>
-      ))}
-    </ul>
-  );
-}
-```
-
-Each entry: `{ field: string; operator: string; values: any[] }` where `values` is the already normalized array (for non‑array primitives a singleton array is produced). Empty arrays / undefined operators are skipped.
-
-#### `useNavigateWithQuery(opts?)`
-
-Convenience wrapper combining current query (typed if possible) with partial updates before invoking `navigate`.
-
-```tsx
-import { useNavigateWithQuery } from '@plumile/router';
-
-function Incrementer() {
-  const update = useNavigateWithQuery({ omitDefaults: true });
-  return (
-    <button
-      onClick={() => {
-        update((prev) => ({ page: (prev.page ?? 1) + 1 }));
-      }}
-    >
-      Next
-    </button>
-  );
-}
-```
-
-Behavior:
-
-- Reads existing (typed or raw) query as base.
-- Accepts object or functional update.
-- Keys set to `undefined` are removed.
-- `omitDefaults` removes schema-default valued keys.
-- `raw` forces ignoring the schema (raw aggregation base).
-- `replace` option (global or per call) controls history mode.
-
-#### `useStableRefEquality(value, areEqual?)`
-
-Utility hook that preserves the reference of the latest value (object or array) as long as shallow equality holds. When a new value is passed whose own enumerable keys (and their primitive or reference-equal values) match the previous one, the previous stable reference is returned. If they differ, the new value becomes the stored reference.
-
-Designed for niche interop cases (e.g. passing derived objects to dependency arrays of third-party hooks) where you can't or don't want the upstream producer to handle memoization. Most consumers of the router do NOT need this because `useQuery`, `useTypedQuery`, `useFilters` already return stable references.
-
-```ts
-import { useStableRefEquality } from '@plumile/router';
-
-function Chart({ data }) {
-  // Avoid re-renders in a heavy child when parent recreates equivalent arrays
-  const stableData = useStableRefEquality(data);
-  return <ExpensiveChart data={stableData} />;
-}
-```
-
-Custom comparator:
-
-```ts
-const value = useStableRefEquality(complex, (a, b) => deepCustomCompare(a, b));
-```
-
-Notes:
-
-- Only shallow by default (no deep traversal) for perf.
-- Non-object/array inputs are returned as-is (no caching layer needed).
-- Avoid overuse; prefer structuring code so sources themselves are stable.
-
 ### Data Preloading
 
 ```typescript
@@ -946,89 +694,6 @@ function MyComponent() {
 }
 ```
 
-### Navigation With Filters & Batching (Phase 5)
-
-You can atomically update query parameters and structured filters via the extended `navigate` API and related hooks.
-
-```tsx
-import {
-  useNavigate,
-  useFilters,
-  defineFilters,
-  numberFilter,
-} from '@plumile/router';
-
-const filterSchema = defineFilters({ price: numberFilter() });
-
-function PriceBump() {
-  const navigate = useNavigate();
-  const [filters, { patch }] = useFilters(filterSchema);
-  return (
-    <button
-      onClick={() => {
-        // Update both query & filters in a single URL change
-        navigate({
-          query: { page: 1 },
-          filters: { price: { gt: [10] } },
-          filterSchema,
-        });
-      }}
-    >
-      Apply
-    </button>
-  );
-}
-```
-
-Batch multiple navigations issued during the same micro‑task into _one_ history update by passing `batch: true`:
-
-```tsx
-function ComplexMutation() {
-  const navigate = useNavigate();
-  return (
-    <button
-      onClick={() => {
-        navigate({ query: { page: 1 }, batch: true });
-        navigate({
-          filters: { price: { gt: [20] } },
-          filterSchema,
-          batch: true,
-        });
-        navigate({
-          filters: { price: {} /* clear price */ },
-          filterSchema,
-          batch: true,
-        });
-        // All three coalesce into one push
-      }}
-    >
-      Run sequence
-    </button>
-  );
-}
-```
-
-Hooks `useQueryObject` and `useFilters` also accept a `batch` flag in their nav options:
-
-```tsx
-const [query, setQuery] = useQueryObject();
-const [f, { patch, clear }] = useFilters(filterSchema);
-
-// Coalesce three operations
-setQuery({ page: 2 }, { batch: true });
-patch({ price: { gt: [30] } }, { batch: true });
-clear(['price'], { batch: true });
-```
-
-Notes:
-
-- Batching is opt‑in: default behavior is immediate navigation (backward compatible).
-- The last non‑undefined `replace` flag wins inside a batch group.
-- The last provided `query` object and `filters` snapshot in the batch are used for serialization.
-- Provide `filterSchema` whenever you include `filters`.
-
-`buildSearch(query, schema, { filters, filterSchema })` merges filters deterministically with query keys (schema‑ordered keys first, then extras).
-
 ### Route Preloading
 
 ```tsx

package/lib/esm/builder.d.ts

@@ -1,13 +1,13 @@
 import { type MatchFunction, type ParamData } from 'path-to-regexp';
-import type { FlatRouteInput, Redirect, Route } from './types.js';
+import type { FlatRouteInput, Redirect, AnyRoute } from './types.js';
 export declare class FlatRoute<TParams extends ParamData> {
     path: string;
-    routes: Route<any, any>[];
+    routes: AnyRoute[];
     matchFunction: MatchFunction<TParams>;
     redirectTo?: string;
     constructor(input: FlatRouteInput<TParams>);
 }
-export declare function isRedirect(route: Route<any, any> | Redirect): route is Redirect;
-export declare function buildRoute(routeConfig: (Route<any, any> | Redirect)[], parentRoutes?: Route<any, any>[], prefix?: string): FlatRoute<any>[];
-export declare function buildRoutes(routeConfig: Route<any, any>[]): FlatRoute<any>[];
+export declare function isRedirect(route: AnyRoute | Redirect): route is Redirect;
+export declare function buildRoute(routeConfig: (AnyRoute | Redirect)[], parentRoutes?: AnyRoute[], prefix?: string): FlatRoute<ParamData>[];
+export declare function buildRoutes(routeConfig: AnyRoute[]): FlatRoute<ParamData>[];
 //# sourceMappingURL=builder.d.ts.map

package/lib/esm/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAQlE,qBAAa,SAAS,CAAC,OAAO,SAAS,SAAS;IAEvC,IAAI,EAAE,MAAM,CAAC;IAGb,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IAG1B,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAGtC,UAAU,CAAC,EAAE,MAAM,CAAC;gBAOR,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC;CAOlD;AAQD,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,QAAQ,GAChC,KAAK,IAAI,QAAQ,CAGnB;AAYD,wBAAgB,UAAU,CACxB,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,QAAQ,CAAC,EAAE,EAC3C,YAAY,GAAE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAAO,EACpC,MAAM,SAAK,GACV,SAAS,CAAC,GAAG,CAAC,EAAE,CA8DlB;AASD,wBAAgB,WAAW,CAAC,WAAW,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,SAAS,CAAC,GAAG,CAAC,EAAE,CAE5E"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAS,QAAQ,EAAE,MAAM,YAAY,CAAC;AAQ5E,qBAAa,SAAS,CAAC,OAAO,SAAS,SAAS;IAEvC,IAAI,EAAE,MAAM,CAAC;IAGb,MAAM,EAAE,QAAQ,EAAE,CAAC;IAGnB,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAGtC,UAAU,CAAC,EAAE,MAAM,CAAC;gBAOR,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC;CAOlD;AAQD,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAGxE;AAYD,wBAAgB,UAAU,CACxB,WAAW,EAAE,CAAC,QAAQ,GAAG,QAAQ,CAAC,EAAE,EACpC,YAAY,GAAE,QAAQ,EAAO,EAC7B,MAAM,SAAK,GACV,SAAS,CAAC,SAAS,CAAC,EAAE,CAkExB;AASD,wBAAgB,WAAW,CAAC,WAAW,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAC,SAAS,CAAC,EAAE,CAE3E"}

package/lib/esm/builder.js

@@ -68,4 +68,4 @@ export function buildRoute(routeConfig, parentRoutes = [], prefix = '') {
 export function buildRoutes(routeConfig) {
     return buildRoute(routeConfig);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../src/builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { match, type MatchFunction, type ParamData } from 'path-to-regexp';\n\nimport type { FlatRouteInput, Redirect, Route } from './types.js';\n\n/**\n * Represents a flattened route with a compiled match function.\n * This is an internal representation used by the router to efficiently match URLs.\n *\n * @template TParams - Route parameter types extracted from the URL path\n */\nexport class FlatRoute<TParams extends ParamData> {\n  /** The URL path pattern for this route */\n  public path: string;\n\n  /** Nested routes that should be rendered within this route */\n  public routes: Route<any, any>[];\n\n  /** Compiled function to match URL paths against this route pattern */\n  public matchFunction: MatchFunction<TParams>;\n\n  /** Optional redirect destination if this route should redirect */\n  public redirectTo?: string;\n\n  /**\n   * Creates a new FlatRoute instance.\n   *\n   * @param input - Configuration for the flat route\n   */\n  public constructor(input: FlatRouteInput<TParams>) {\n    const { matchFunction, path, redirectTo, routes } = input;\n    this.path = path;\n    this.redirectTo = redirectTo;\n    this.routes = routes;\n    this.matchFunction = matchFunction;\n  }\n}\n\n/**\n * Type guard to check if a route configuration is a redirect.\n *\n * @param route - Route or redirect configuration to check\n * @returns True if the route is a redirect configuration\n */\nexport function isRedirect(\n  route: Route<any, any> | Redirect,\n): route is Redirect {\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  return (route as Redirect).to != null;\n}\n\n/**\n * Recursively builds a flat list of routes from a nested route configuration.\n * This function processes the route tree and creates FlatRoute instances with\n * compiled path matchers for efficient URL matching.\n *\n * @param routeConfig - Array of route or redirect configurations\n * @param parentRoutes - Parent routes in the current path (for nested routes)\n * @param prefix - URL prefix from parent routes\n * @returns Array of flattened routes ready for matching\n */\nexport function buildRoute(\n  routeConfig: (Route<any, any> | Redirect)[],\n  parentRoutes: Route<any, any>[] = [],\n  prefix = '',\n): FlatRoute<any>[] {\n  const flatRoutes: FlatRoute<any>[] = [];\n\n  for (const route of routeConfig) {\n    const parts = [];\n    if (prefix !== '') {\n      parts.push(prefix);\n    }\n    if (route.path != null && route.path !== '' && route.path !== '/') {\n      let normalized = route.path;\n      if (normalized.startsWith('/')) {\n        normalized = normalized.slice(1);\n      }\n      parts.push(normalized);\n    }\n\n    const newPath = parts.join('/');\n\n    const { children } = route as Route<any, any>;\n\n    if (!isRedirect(route) && children != null) {\n      const routes = buildRoute(children, [...parentRoutes, route], newPath);\n      flatRoutes.push(...routes);\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n\n    const matchFunction = match(`/${newPath}`, {\n      trailing: false,\n    });\n\n    let path = newPath;\n    if (!newPath.startsWith('/')) {\n      path = `/${newPath}`;\n    }\n\n    if (isRedirect(route)) {\n      let redirectTo = route.to;\n\n      if (!redirectTo.startsWith('/')) {\n        redirectTo = `${path}/${redirectTo}`;\n      }\n      flatRoutes.push(\n        new FlatRoute({\n          path,\n          redirectTo,\n          matchFunction,\n          routes: [...parentRoutes],\n        }),\n      );\n    } else {\n      flatRoutes.push(\n        new FlatRoute({\n          path,\n          matchFunction,\n          routes: [...parentRoutes, route],\n        }),\n      );\n    }\n  }\n\n  return flatRoutes;\n}\n\n/**\n * Builds a flat route list from the given route configuration.\n * This is the main entry point for route building.\n *\n * @param routeConfig - Array of route configurations to flatten\n * @returns Array of flattened routes ready for matching\n */\nexport function buildRoutes(routeConfig: Route<any, any>[]): FlatRoute<any>[] {\n  return buildRoute(routeConfig);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../src/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAsC,MAAM,gBAAgB,CAAC;AAU3E,MAAM,OAAO,SAAS;IAEb,IAAI,CAAS;IAGb,MAAM,CAAa;IAGnB,aAAa,CAAyB;IAGtC,UAAU,CAAU;IAO3B,YAAmB,KAA8B;QAC/C,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QAC1D,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACrC,CAAC;CACF;AAQD,MAAM,UAAU,UAAU,CAAC,KAA0B;IAEnD,OAAQ,KAAkB,CAAC,EAAE,IAAI,IAAI,CAAC;AACxC,CAAC;AAYD,MAAM,UAAU,UAAU,CACxB,WAAoC,EACpC,eAA2B,EAAE,EAC7B,MAAM,GAAG,EAAE;IAEX,MAAM,UAAU,GAA2B,EAAE,CAAC;IAE9C,KAAK,MAAM,KAAK,IAAI,WAAW,EAAE,CAAC;QAChC,MAAM,KAAK,GAAG,EAAE,CAAC;QACjB,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;YAClB,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrB,CAAC;QACD,IAAI,KAAK,CAAC,IAAI,IAAI,IAAI,IAAI,KAAK,CAAC,IAAI,KAAK,EAAE,IAAI,KAAK,CAAC,IAAI,KAAK,GAAG,EAAE,CAAC;YAClE,IAAI,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC;YAC5B,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC/B,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACnC,CAAC;YACD,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACzB,CAAC;QAED,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEhC,MAAM,EAAE,QAAQ,EAAE,GAAG,KAA6B,CAAC;QAEnD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;YAC3C,MAAM,MAAM,GAAG,UAAU,CACvB,QAAmC,EACnC,CAAC,GAAG,YAAY,EAAE,KAAK,CAAC,EACxB,OAAO,CACR,CAAC;YACF,UAAU,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;YAE3B,SAAS;QACX,CAAC;QAED,MAAM,aAAa,GAAG,KAAK,CAAC,IAAI,OAAO,EAAE,EAAE;YACzC,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAC;QAEH,IAAI,IAAI,GAAG,OAAO,CAAC;QACnB,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7B,IAAI,GAAG,IAAI,OAAO,EAAE,CAAC;QACvB,CAAC;QAED,IAAI,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,IAAI,UAAU,GAAG,KAAK,CAAC,EAAE,CAAC;YAE1B,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBAChC,UAAU,GAAG,GAAG,IAAI,IAAI,UAAU,EAAE,CAAC;YACvC,CAAC;YACD,UAAU,CAAC,IAAI,CACb,IAAI,SAAS,CAAC;gBACZ,IAAI;gBACJ,UAAU;gBACV,aAAa;gBACb,MAAM,EAAE,CAAC,GAAG,YAAY,CAAe;aACxC,CAAC,CACH,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,UAAU,CAAC,IAAI,CACb,IAAI,SAAS,CAAC;gBACZ,IAAI;gBACJ,aAAa;gBACb,MAAM,EAAE,CAAC,GAAG,YAAY,EAAE,KAAK,CAAe;aAC/C,CAAC,CACH,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AASD,MAAM,UAAU,WAAW,CAAC,WAAuB;IACjD,OAAO,UAAU,CAAC,WAAW,CAAC,CAAC;AACjC,CAAC","sourcesContent":["import { match, type MatchFunction, type ParamData } from 'path-to-regexp';\n\nimport type { FlatRouteInput, Redirect, Route, AnyRoute } from './types.js';\n\n/**\n * Represents a flattened route with a compiled match function.\n * This is an internal representation used by the router to efficiently match URLs.\n *\n * @template TParams - Route parameter types extracted from the URL path\n */\nexport class FlatRoute<TParams extends ParamData> {\n  /** The URL path pattern for this route */\n  public path: string;\n\n  /** Nested routes that should be rendered within this route */\n  public routes: AnyRoute[];\n\n  /** Compiled function to match URL paths against this route pattern */\n  public matchFunction: MatchFunction<TParams>;\n\n  /** Optional redirect destination if this route should redirect */\n  public redirectTo?: string;\n\n  /**\n   * Creates a new FlatRoute instance.\n   *\n   * @param input - Configuration for the flat route\n   */\n  public constructor(input: FlatRouteInput<TParams>) {\n    const { matchFunction, path, redirectTo, routes } = input;\n    this.path = path;\n    this.redirectTo = redirectTo;\n    this.routes = routes;\n    this.matchFunction = matchFunction;\n  }\n}\n\n/**\n * Type guard to check if a route configuration is a redirect.\n *\n * @param route - Route or redirect configuration to check\n * @returns True if the route is a redirect configuration\n */\nexport function isRedirect(route: AnyRoute | Redirect): route is Redirect {\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  return (route as Redirect).to != null;\n}\n\n/**\n * Recursively builds a flat list of routes from a nested route configuration.\n * This function processes the route tree and creates FlatRoute instances with\n * compiled path matchers for efficient URL matching.\n *\n * @param routeConfig - Array of route or redirect configurations\n * @param parentRoutes - Parent routes in the current path (for nested routes)\n * @param prefix - URL prefix from parent routes\n * @returns Array of flattened routes ready for matching\n */\nexport function buildRoute(\n  routeConfig: (AnyRoute | Redirect)[],\n  parentRoutes: AnyRoute[] = [],\n  prefix = '',\n): FlatRoute<ParamData>[] {\n  const flatRoutes: FlatRoute<ParamData>[] = [];\n\n  for (const route of routeConfig) {\n    const parts = [];\n    if (prefix !== '') {\n      parts.push(prefix);\n    }\n    if (route.path != null && route.path !== '' && route.path !== '/') {\n      let normalized = route.path;\n      if (normalized.startsWith('/')) {\n        normalized = normalized.slice(1);\n      }\n      parts.push(normalized);\n    }\n\n    const newPath = parts.join('/');\n\n    const { children } = route as Route<any, any, any>;\n\n    if (!isRedirect(route) && children != null) {\n      const routes = buildRoute(\n        children as (AnyRoute | Redirect)[],\n        [...parentRoutes, route],\n        newPath,\n      );\n      flatRoutes.push(...routes);\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n\n    const matchFunction = match(`/${newPath}`, {\n      trailing: false,\n    });\n\n    let path = newPath;\n    if (!newPath.startsWith('/')) {\n      path = `/${newPath}`;\n    }\n\n    if (isRedirect(route)) {\n      let redirectTo = route.to;\n\n      if (!redirectTo.startsWith('/')) {\n        redirectTo = `${path}/${redirectTo}`;\n      }\n      flatRoutes.push(\n        new FlatRoute({\n          path,\n          redirectTo,\n          matchFunction,\n          routes: [...parentRoutes] as AnyRoute[],\n        }),\n      );\n    } else {\n      flatRoutes.push(\n        new FlatRoute({\n          path,\n          matchFunction,\n          routes: [...parentRoutes, route] as AnyRoute[],\n        }),\n      );\n    }\n  }\n\n  return flatRoutes;\n}\n\n/**\n * Builds a flat route list from the given route configuration.\n * This is the main entry point for route building.\n *\n * @param routeConfig - Array of route configurations to flatten\n * @returns Array of flattened routes ready for matching\n */\nexport function buildRoutes(routeConfig: AnyRoute[]): FlatRoute<ParamData>[] {\n  return buildRoute(routeConfig);\n}\n"]}

package/lib/esm/index.d.ts

@@ -5,9 +5,5 @@ export * from './builder.js';
 export * from './ResourcePage.js';
 export * from './tools.js';
 export { q, parseTypedQuery } from './tools/query-dsl.js';
-export { defineFilters, numberFilter, stringFilter, useFilters, useQueryFilters, } from './routing/filters.js';
-export { default as useFilterState } from './routing/useFilterState.js';
-export { default as useActiveFilters } from './routing/useActiveFilters.js';
-export { default as useQueryObject } from './routing/useQueryObject.js';
 export type * from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAC;AAGlC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAG7B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAGxE,mBAAmB,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAC;AAGlC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAG7B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG1D,mBAAmB,YAAY,CAAC"}