@plumile/router 0.1.12 → 0.1.14

package/README.md

@@ -37,6 +37,9 @@ import { Route, getResourcePage } from '@plumile/router';
 const routes: Route<any, any>[] = [
   {
     path: '/',
+
+  ## Advanced Hooks Deep Dive & Combined Examples
+
     resourcePage: getResourcePage('Home', () => import('./pages/Home')),
   },
   {
@@ -144,6 +147,9 @@ 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
@@ -482,25 +488,113 @@ To encourage consistent usage of the query hooks, a custom rule is provided insi
 
 Add to your flat ESLint config:
 
-```js
+````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',
-    },
-  },
+
+## 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:
+
+- 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:
+
+```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
+
+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';
+
+export const routes = [
+  r({
+    path: '/products',
+    filterSchema: defineFilters({
+      price: numberFilter({ operators: ['gte', 'lte'] }),
+    }),
+    children: [
+      r({
+        path: '/:id',
+        filterSchema: defineFilters({
+          name: stringFilter({ operators: ['contains'] }),
+        }),
+      }),
+    ],
+  }),
 ];
 ```
 
+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.
+
+Rules:
+
+- Order: shallow override by field name.
+- No deep merge inside a field definition.
+- Omitted routes: ignored.
+
+Limitations / current behavior:
+
+- 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).
+
+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',
+},
+},
+];
+
+````
+
 Optional configuration:
 
 ```js
@@ -511,7 +605,7 @@ rules: {
     { allowInFiles: ['legacy-entry.ts'] },
   ],
 },
-```
+````
 
 When triggered, replace patterns like:
 
@@ -569,6 +663,242 @@ 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
@@ -616,6 +946,89 @@ 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/index.d.ts

@@ -5,5 +5,9 @@ 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;AAG1D,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;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"}

package/lib/esm/index.js

@@ -5,4 +5,8 @@ export * from './builder.js';
 export * from './ResourcePage.js';
 export * from './tools.js';
 export { q, parseTypedQuery } from './tools/query-dsl.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLG9CQUFvQixDQUFDO0FBR25DLGNBQWMsb0JBQW9CLENBQUM7QUFHbkMsY0FBYyxjQUFjLENBQUM7QUFHN0IsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLFlBQVksQ0FBQztBQUMzQixPQUFPLEVBQUUsQ0FBQyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gRXhwb3J0IGVycm9yIGhhbmRsaW5nIHV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvcnMvaW5kZXguanMnO1xuXG4vLyBFeHBvcnQgYnJvd3NlciBoaXN0b3J5IG1hbmFnZW1lbnRcbmV4cG9ydCAqIGZyb20gJy4vaGlzdG9yeS9pbmRleC5qcyc7XG5cbi8vIEV4cG9ydCByb3V0aW5nIGNvbXBvbmVudHMgYW5kIHV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9yb3V0aW5nL2luZGV4LmpzJztcblxuLy8gRXhwb3J0IHJvdXRlIGJ1aWxkaW5nIHV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9idWlsZGVyLmpzJztcblxuLy8gRXhwb3J0IHJlc291cmNlIHBhZ2UgbWFuYWdlbWVudCBmb3IgbGF6eSBsb2FkaW5nXG5leHBvcnQgKiBmcm9tICcuL1Jlc291cmNlUGFnZS5qcyc7XG5cbi8vIEV4cG9ydCB1dGlsaXR5IGZ1bmN0aW9uc1xuZXhwb3J0ICogZnJvbSAnLi90b29scy5qcyc7XG5leHBvcnQgeyBxLCBwYXJzZVR5cGVkUXVlcnkgfSBmcm9tICcuL3Rvb2xzL3F1ZXJ5LWRzbC5qcyc7XG5cbi8vIEV4cG9ydCBhbGwgVHlwZVNjcmlwdCB0eXBlc1xuZXhwb3J0IHR5cGUgKiBmcm9tICcuL3R5cGVzLmpzJztcbiJdfQ==
+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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLG9CQUFvQixDQUFDO0FBR25DLGNBQWMsb0JBQW9CLENBQUM7QUFHbkMsY0FBYyxjQUFjLENBQUM7QUFHN0IsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLFlBQVksQ0FBQztBQUMzQixPQUFPLEVBQUUsQ0FBQyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzFELE9BQU8sRUFDTCxhQUFhLEVBQ2IsWUFBWSxFQUNaLFlBQVksRUFDWixVQUFVLEVBQ1YsZUFBZSxHQUNoQixNQUFNLHNCQUFzQixDQUFDO0FBQzlCLE9BQU8sRUFBRSxPQUFPLElBQUksY0FBYyxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDeEUsT0FBTyxFQUFFLE9BQU8sSUFBSSxnQkFBZ0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzVFLE9BQU8sRUFBRSxPQUFPLElBQUksY0FBYyxFQUFFLE1BQU0sNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBFeHBvcnQgZXJyb3IgaGFuZGxpbmcgdXRpbGl0aWVzXG5leHBvcnQgKiBmcm9tICcuL2Vycm9ycy9pbmRleC5qcyc7XG5cbi8vIEV4cG9ydCBicm93c2VyIGhpc3RvcnkgbWFuYWdlbWVudFxuZXhwb3J0ICogZnJvbSAnLi9oaXN0b3J5L2luZGV4LmpzJztcblxuLy8gRXhwb3J0IHJvdXRpbmcgY29tcG9uZW50cyBhbmQgdXRpbGl0aWVzXG5leHBvcnQgKiBmcm9tICcuL3JvdXRpbmcvaW5kZXguanMnO1xuXG4vLyBFeHBvcnQgcm91dGUgYnVpbGRpbmcgdXRpbGl0aWVzXG5leHBvcnQgKiBmcm9tICcuL2J1aWxkZXIuanMnO1xuXG4vLyBFeHBvcnQgcmVzb3VyY2UgcGFnZSBtYW5hZ2VtZW50IGZvciBsYXp5IGxvYWRpbmdcbmV4cG9ydCAqIGZyb20gJy4vUmVzb3VyY2VQYWdlLmpzJztcblxuLy8gRXhwb3J0IHV0aWxpdHkgZnVuY3Rpb25zXG5leHBvcnQgKiBmcm9tICcuL3Rvb2xzLmpzJztcbmV4cG9ydCB7IHEsIHBhcnNlVHlwZWRRdWVyeSB9IGZyb20gJy4vdG9vbHMvcXVlcnktZHNsLmpzJztcbmV4cG9ydCB7XG4gIGRlZmluZUZpbHRlcnMsXG4gIG51bWJlckZpbHRlcixcbiAgc3RyaW5nRmlsdGVyLFxuICB1c2VGaWx0ZXJzLFxuICB1c2VRdWVyeUZpbHRlcnMsXG59IGZyb20gJy4vcm91dGluZy9maWx0ZXJzLmpzJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgdXNlRmlsdGVyU3RhdGUgfSBmcm9tICcuL3JvdXRpbmcvdXNlRmlsdGVyU3RhdGUuanMnO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyB1c2VBY3RpdmVGaWx0ZXJzIH0gZnJvbSAnLi9yb3V0aW5nL3VzZUFjdGl2ZUZpbHRlcnMuanMnO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyB1c2VRdWVyeU9iamVjdCB9IGZyb20gJy4vcm91dGluZy91c2VRdWVyeU9iamVjdC5qcyc7XG5cbi8vIEV4cG9ydCBhbGwgVHlwZVNjcmlwdCB0eXBlc1xuZXhwb3J0IHR5cGUgKiBmcm9tICcuL3R5cGVzLmpzJztcbiJdfQ==

package/lib/esm/routing/createRouter.d.ts

@@ -9,5 +9,6 @@ export default function createRouter(routes: Route<any, any>[], opts?: {
         panel?: boolean;
         shortcut?: string;
     };
+    autoBatch?: boolean;
 }): CreateRouterReturn;
 //# sourceMappingURL=createRouter.d.ts.map

package/lib/esm/routing/createRouter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createRouter.d.ts","sourceRoot":"","sources":["../../../src/routing/createRouter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,KAAK,EAEL,kBAAkB,EAEnB,MAAM,aAAa,CAAC;AAKrB,MAAM,MAAM,kBAAkB,GAAG;IAE/B,OAAO,EAAE,MAAM,IAAI,CAAC;IAEpB,OAAO,EAAE,kBAAkB,CAAC,GAAG,CAAC,CAAC;CAClC,CAAC;AAkCF,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EACzB,IAAI,GAAE;IACJ,QAAQ,CAAC,EACL,OAAO,GACP;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACzD,GACL,kBAAkB,CA4nBpB"}
+{"version":3,"file":"createRouter.d.ts","sourceRoot":"","sources":["../../../src/routing/createRouter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,KAAK,EAEL,kBAAkB,EAEnB,MAAM,aAAa,CAAC;AAKrB,MAAM,MAAM,kBAAkB,GAAG;IAE/B,OAAO,EAAE,MAAM,IAAI,CAAC;IAEpB,OAAO,EAAE,kBAAkB,CAAC,GAAG,CAAC,CAAC;CAClC,CAAC;AAkCF,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EACzB,IAAI,GAAE;IACJ,QAAQ,CAAC,EACL,OAAO,GACP;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAE7D,SAAS,CAAC,EAAE,OAAO,CAAC;CAChB,GACL,kBAAkB,CAkxBpB"}