@plumile/router 0.1.11 → 0.1.12

package/README.md

@@ -111,13 +111,15 @@ function Navigation() {
 
 ### Core Components
 
-#### `createRouter(routes: Route[])`
+#### `createRouter(routes: Route[], options?)`
 
 Creates a router instance with the given route configuration.
 
 **Parameters:**
 
 - `routes`: Array of route definitions
+- `options?`: Optional object
+  - `devtools?: boolean` Force enable/disable the global inspector. Defaults to enabled when `NODE_ENV !== 'production'`, disabled otherwise.
 
 **Returns:**
 
@@ -228,6 +230,345 @@ Type helper for strongly-typed route definitions.
 
 ## Advanced Usage
 
+### Typed Query Parameters (DSL)
+
+The router provides a lightweight schema DSL for parsing, typing, normalizing and serializing query strings.
+
+#### 1. Define a schema on the deepest route
+
+```ts
+import { q, r } from '@plumile/router';
+
+const routes = [
+  r({
+    path: '/items',
+    // Schema: page = number (default 1), tag(s) = array of strings, flag = optional boolean
+    query: {
+      page: q.default(q.number(), 1),
+      tags: q.array(q.string()),
+      flag: q.optional(q.boolean()),
+    },
+    prepare: ({ query }) => {
+      // query is typed: { page: number; tags: string[]; flag?: boolean }
+      return { page: query.page };
+    },
+    render: () => null,
+  }),
+];
+```
+
+#### 2. Access parsed & typed queries
+
+```tsx
+import { useQuery, useTypedQuery } from '@plumile/router';
+
+function List() {
+  const raw = useQuery(); // Record<string, string | string[]>
+  const typed = useTypedQuery(); // Auto‑inferred from deepest route schema (no generic needed)
+  const [page, setPage] = useQueryState<number>('page'); // Bidirectional state ↔ URL for one param
+  return <pre>{JSON.stringify({ raw, typed }, null, 2)}</pre>;
+}
+```
+
+Referential stability: both `raw` (from `useQuery()`) and `typed` (from `useTypedQuery()`) are memoized per canonical search string. If the URL search part doesn't change semantically (including key order canonicalization), the hook returns the exact same object reference. You can safely list either in React dependency arrays without extra `useMemo` or a hypothetical `useStableQuery` helper (not needed).
+
+Type inference:
+
+- If the matched deepest route has a `query` schema, `useTypedQuery()` returns the inferred `InferQuery<typeof schema>` shape automatically.
+- If no schema exists, it returns the raw parsed object (record of string | string[]) so you can still read values safely.
+- You can still supply a generic manually (`useTypedQuery<MyShape>()`) in edge cases (e.g. incremental migration) but it is usually unnecessary now.
+
+#### 3. Programmatic navigation with typed query
+
+```tsx
+import { useNavigate } from '@plumile/router';
+
+function Pager({ page }: { page: number }) {
+  const navigate = useNavigate();
+  return (
+    <button
+      onClick={() => {
+        navigate({ query: { page: page + 1 } });
+      }}
+    >
+      Next page
+    </button>
+  );
+}
+```
+
+#### 4. Link component with query
+
+```tsx
+import { Link } from '@plumile/router';
+
+<Link to="/items" query={{ page: 2, tags: ['a', 'b'], flag: true }}>
+  Filter
+</Link>;
+```
+
+`Link` & `navigate` automatically serialize using the route schema, applying:
+
+- Schema key order
+- Array repetition (`?tags=a&tags=b`)
+- Omission of default values when `omitDefaults` optimization applies internally
+
+#### 5. Normalization
+
+Built‑in simple normalization currently clamps `page < 1` to `1` and issues a `replaceState` to avoid polluting history.
+
+#### 6. Serialization utility
+
+```ts
+import { buildSearch, q } from '@plumile/router';
+
+const schema = {
+  page: q.default(q.number(), 1),
+  tag: q.array(q.string()),
+} as const;
+const search = buildSearch({ page: 1, tag: ['x', 'y'] }, schema, {
+  omitDefaults: true,
+});
+// => '?tag=x&tag=y'
+```
+
+#### 7. Parsing utility / alias
+
+```ts
+import { parseSearch, q } from '@plumile/router';
+
+const schema = { flag: q.boolean() } as const;
+const typed = parseSearch(schema, '?flag=1'); // { flag: true }
+```
+
+#### 8. Performance and stability
+
+There are two coordinated caching layers:
+
+1. Raw query cache: A process-wide Map keyed by a canonicalized search string (sorted keys, ordered value emission). Produces a frozen empty object for the empty search and reuses prior parsed objects, yielding stable references for unchanged search state.
+2. Typed query cache: A WeakMap keyed by (schema reference → canonical search signature) that parses once and reuses the typed value. Structural deep-equality canonicalization means semantically equivalent searches (e.g. reordered keys) reuse object identity.
+
+Effects:
+
+- Stable object identity for both raw and typed queries eliminates needless renders and removes the need for an extra `useStableQuery` hook.
+- Safe to put `useQuery()` / `useTypedQuery()` results directly in dependency arrays (`useEffect`, `useMemo`, selectors, etc.).
+- Empty query allocations are avoided (shared frozen object).
+
+Guideline: If you need to derive lightweight projections (e.g. `const { page } = typed`), you can still destructure; but avoid spreading into a new object if you rely on reference equality downstream.
+
+#### Devtools / Inspection
+
+In development (`NODE_ENV !== 'production'` by default, or when `createRouter(..., { devtools: true })` is passed), the router exposes a lightweight global inspector.
+
+Optionally you can enable an in‑page overlay panel for quick visual inspection:
+
+```ts
+createRouter(routes, {
+  devtools: { panel: true, global: true, shortcut: 'Alt+Shift+R' },
+});
+```
+
+Devtools option forms:
+
+- `devtools: true | false` (boolean) – legacy form, controls global only.
+- `devtools: { global?: boolean; panel?: boolean; shortcut?: string }` – granular.
+  - `global` (default: NODE_ENV !== 'production') exposes `window.__PLUMILE_ROUTER__`.
+  - `panel` (default: false) mounts an overlay; closed with the close button or page reload.
+  - `shortcut` (default: `Alt+Shift+R`) toggles panel visibility.
+
+The panel displays current path+search, variables, raw query and typed query. It is intentionally framework‑agnostic (no React runtime cost) and uses a shadow root to minimize style collisions.
+
+```js
+window.__PLUMILE_ROUTER__.get(); // current RouteEntry
+const unsub = window.__PLUMILE_ROUTER__.subscribe((entry) =>
+  console.log(entry.typedQuery),
+);
+```
+
+This lets you introspect parsed queries & variables without adding debug code. Neither global nor panel is present in production unless explicitly forced with `devtools: { global: true, panel: true }` (discouraged).
+
+##### Detailed Usage
+
+The global is intentionally tiny to avoid coupling and bundle weight. It only appears when the devtools flag resolves truthy:
+
+1. Explicit: `createRouter(routes, { devtools: true })`
+2. Implicit heuristic: `NODE_ENV !== 'production'`
+3. Disabled explicitly: `createRouter(routes, { devtools: false })`
+
+Always guard in snippets that might be copied to production code:
+
+```js
+if (window.__PLUMILE_ROUTER__) {
+  console.log(window.__PLUMILE_ROUTER__.get());
+}
+```
+
+`get()` returns the current `RouteEntry` (simplified shape):
+
+```ts
+type RouteEntry = {
+  location: Location; // window.location snapshot
+  route: { match; params; path } | null; // current matched route (or null)
+  preparedMatch: { routes: { prepared; render?; resourcePage? }[]; match }; // internal prepared tree
+  forceRerender: boolean; // indicates forced re-render situations
+  rawSearch: string; // '?page=2&tag=a'
+  query: Record<string, string | string[]>; // raw aggregated query params
+  typedQuery: any; // typed query if schema present
+};
+```
+
+Common console patterns:
+
+1. Log every navigation with typed query & params:
+
+```js
+const dev = window.__PLUMILE_ROUTER__;
+if (dev) {
+  const off = dev.subscribe((e) => {
+    console.log('[router]', e.location.pathname + e.location.search, {
+      vars: e.route?.params,
+      typed: e.typedQuery,
+    });
+  });
+  // later: off();
+}
+```
+
+2. Inspect prepared data for the deepest route (last element):
+
+```js
+const entry = window.__PLUMILE_ROUTER__?.get();
+const deepest = entry?.preparedMatch.routes.at(-1);
+deepest?.prepared; // Prepared data returned by deepest prepare()
+```
+
+3. Quick diff watcher for query changes only:
+
+```js
+let last = window.__PLUMILE_ROUTER__?.get().rawSearch;
+const off = window.__PLUMILE_ROUTER__?.subscribe((e) => {
+  if (e.rawSearch !== last) {
+    console.log('query changed', last, '=>', e.rawSearch, e.typedQuery);
+    last = e.rawSearch;
+  }
+});
+```
+
+4. Measuring parse performance (rough dev-only micro‑benchmark):
+
+```js
+const { get } = window.__PLUMILE_ROUTER__;
+const before = performance.now();
+for (let i = 0; i < 200; i++) get().typedQuery; // use cache; ensures no GC
+console.log('elapsed ms', performance.now() - before);
+```
+
+5. Safe optional chaining helper (copy/paste):
+
+```js
+const R = window.__PLUMILE_ROUTER__;
+R && R.subscribe((e) => console.debug('[typedQuery]', e.typedQuery));
+```
+
+Unsubscribing: every `subscribe` returns a disposer function. Always call it if you set up long‑lived listeners in a debugging session to avoid memory leaks during hot reloads.
+
+Extending: if you need more (e.g. trigger navigations) you can wrap `createRouter` in your app and attach additional methods to `window.__PLUMILE_ROUTER__` (e.g. `navigate: context.navigate`) — omitted by default to avoid accidental production reliance.
+
+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 [
+  {
+    plugins: {
+      '@plumile-router/dx': {
+        rules: {
+          'no-direct-window-location-search': noDirectWindowLocationSearch,
+        },
+      },
+    },
+    rules: {
+      '@plumile-router/dx/no-direct-window-location-search': 'warn',
+    },
+  },
+];
+```
+
+Optional configuration:
+
+```js
+// allow some files (e.g. legacy bootstrap) to keep direct access
+rules: {
+  '@plumile-router/dx/no-direct-window-location-search': [
+    'warn',
+    { allowInFiles: ['legacy-entry.ts'] },
+  ],
+},
+```
+
+When triggered, replace patterns like:
+
+```ts
+const qs = window.location.search;
+```
+
+with:
+
+```ts
+const query = useQuery(); // or useTypedQuery()
+```
+
+### Migration Guide (Phases 1 → 5)
+
+1. Phase 1/2: Upgrade — no schema needed. Use `useQuery()` for raw params.
+2. Phase 3: Add `query` schema to your deepest route; adopt `useTypedQuery()` where type safety is desirable.
+3. Phase 4: Replace manual URL building with `navigate({ query })` or `<Link query={...} />`. Remove ad‑hoc serialization logic.
+4. Phase 5: Move lightweight data loading logic that depends on query into `prepare({ query })` (now typed). Rely on built‑in normalization (e.g. page clamp) or add custom normalization inside `prepare` followed by a `navigate({ replace: true, query: normalized })` if needed.
+5. Optional: Use `buildSearch` / `parseSearch` for unit tests & utilities.
+
+### Query Descriptor Reference
+
+| Descriptor                       | Description                                         | Serialize Example                    |
+| -------------------------------- | --------------------------------------------------- | ------------------------------------ |
+| `q.string()`                     | Last occurrence string                              | `{ q: 'x' } -> ?q=x`                 |
+| `q.number()`                     | Number (invalid => undefined)                       | `{ n: 2 } -> ?n=2`                   |
+| `q.boolean()`                    | Presence / true/false/1/0                           | `{ f: true } -> ?f=1`                |
+| `q.enum('a','b')`                | Restricted string                                   | `{ e: 'a' } -> ?e=a`                 |
+| `q.array(inner)`                 | Repeated key multi-values                           | `{ tag: ['x','y'] } -> ?tag=x&tag=y` |
+| `q.optional(d)`                  | Marks descriptor optional                           | omitted if undefined                 |
+| `q.default(d, v)`                | Supplies default + omit on serialize (omitDefaults) | default skipped                      |
+| `q.emptyAsUndefined(q.string())` | Maps empty string '' to undefined                   | omitted                              |
+| `q.custom({ parse, serialize })` | Custom parse/serialize logic                        | depends                              |
+
+Custom: `q.custom({ parse(values), serialize(value) })` lets you wire bespoke formats. Ensure `serialize` outputs an array of raw string values. Use sparingly to keep schemas readable.
+
+### useQueryState Hook
+
+`useQueryState(key, opts?)` creates a controlled binding between a single query parameter and component state.
+
+```tsx
+const [page, setPage] = useQueryState<number>('page');
+// Increment page without pushing a new history entry
+setPage(page! + 1, { replace: true });
+```
+
+Behavior:
+
+- Reads from typedQuery if schema present, else raw query.
+- Respects schema defaults (and `defaultValue` override in options) and omits key when value equals default (with `omitIfDefault: true`).
+- Pass `{ raw: true }` to force raw (string) source for incremental migrations.
+- Uses existing navigation serialization (ordering, omit defaults, arrays).
+
+Options:
+`{ defaultValue?, omitIfDefault?: boolean = true, replace?: boolean, raw?: boolean }`
+
 ### Data Preloading
 
 ```typescript

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,CAuDlB;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,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"}

package/lib/esm/builder.js

@@ -23,7 +23,11 @@ export function buildRoute(routeConfig, parentRoutes = [], prefix = '') {
             parts.push(prefix);
         }
         if (route.path != null && route.path !== '' && route.path !== '/') {
-            parts.push(route.path);
+            let normalized = route.path;
+            if (normalized.startsWith('/')) {
+                normalized = normalized.slice(1);
+            }
+            parts.push(normalized);
         }
         const newPath = parts.join('/');
         const { children } = route;
@@ -35,7 +39,10 @@ export function buildRoute(routeConfig, parentRoutes = [], prefix = '') {
         const matchFunction = match(`/${newPath}`, {
             trailing: false,
         });
-        const path = `/${newPath}`;
+        let path = newPath;
+        if (!newPath.startsWith('/')) {
+            path = `/${newPath}`;
+        }
         if (isRedirect(route)) {
             let redirectTo = route.to;
             if (!redirectTo.startsWith('/')) {
@@ -61,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":"AAAA,OAAO,EAAE,KAAK,EAAsC,MAAM,gBAAgB,CAAC;AAU3E,MAAM,OAAO,SAAS;IAEb,IAAI,CAAS;IAGb,MAAM,CAAoB;IAG1B,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,CACxB,KAAiC;IAGjC,OAAQ,KAAkB,CAAC,EAAE,IAAI,IAAI,CAAC;AACxC,CAAC;AAYD,MAAM,UAAU,UAAU,CACxB,WAA2C,EAC3C,eAAkC,EAAE,EACpC,MAAM,GAAG,EAAE;IAEX,MAAM,UAAU,GAAqB,EAAE,CAAC;IAExC,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,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QAED,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEhC,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAwB,CAAC;QAE9C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;YAC3C,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,YAAY,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC;YACvE,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,MAAM,IAAI,GAAG,IAAI,OAAO,EAAE,CAAC;QAE3B,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,CAAC;aAC1B,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,CAAC;aACjC,CAAC,CACH,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AASD,MAAM,UAAU,WAAW,CAAC,WAA8B;IACxD,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 } 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      parts.push(route.path);\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    const path = `/${newPath}`;\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,CAAoB;IAG1B,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,CACxB,KAAiC;IAGjC,OAAQ,KAAkB,CAAC,EAAE,IAAI,IAAI,CAAC;AACxC,CAAC;AAYD,MAAM,UAAU,UAAU,CACxB,WAA2C,EAC3C,eAAkC,EAAE,EACpC,MAAM,GAAG,EAAE;IAEX,MAAM,UAAU,GAAqB,EAAE,CAAC;IAExC,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,KAAwB,CAAC;QAE9C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;YAC3C,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,YAAY,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC;YACvE,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,CAAC;aAC1B,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,CAAC;aACjC,CAAC,CACH,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AASD,MAAM,UAAU,WAAW,CAAC,WAA8B;IACxD,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 } 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"]}

package/lib/esm/eslint-rules/index.d.ts

@@ -0,0 +1,2 @@
+export { default as noDirectWindowLocationSearch } from './no-direct-window-location-search.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/esm/eslint-rules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/eslint-rules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,uCAAuC,CAAC"}

package/lib/esm/eslint-rules/index.js

@@ -0,0 +1,2 @@
+export { default as noDirectWindowLocationSearch } from './no-direct-window-location-search.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXNsaW50LXJ1bGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLElBQUksNEJBQTRCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGRlZmF1bHQgYXMgbm9EaXJlY3RXaW5kb3dMb2NhdGlvblNlYXJjaCB9IGZyb20gJy4vbm8tZGlyZWN0LXdpbmRvdy1sb2NhdGlvbi1zZWFyY2guanMnO1xuIl19

package/lib/esm/eslint-rules/no-direct-window-location-search.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-direct-window-location-search.d.ts.map

package/lib/esm/eslint-rules/no-direct-window-location-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-direct-window-location-search.d.ts","sourceRoot":"","sources":["../../../src/eslint-rules/no-direct-window-location-search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAMnC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UAmDhB,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/lib/esm/eslint-rules/no-direct-window-location-search.js

@@ -0,0 +1,48 @@
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Discourage direct window.location.search access; use useQuery()/useTypedQuery() instead',
+            recommended: false,
+        },
+        messages: {
+            avoid: 'Avoid direct access to window.location.search. Use useQuery() / useTypedQuery() from @plumile/router.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowInFiles: { type: 'array', items: { type: 'string' } },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const rawOption = context.options[0];
+        const allowIn = new Set(rawOption?.allowInFiles ?? []);
+        const filename = context.getFilename();
+        const isAllowed = [...allowIn].some((pat) => {
+            return filename.includes(pat);
+        });
+        return {
+            MemberExpression(node) {
+                if (isAllowed)
+                    return;
+                if (node.property.type === 'Identifier' &&
+                    node.property.name === 'search' &&
+                    node.object.type === 'MemberExpression') {
+                    const obj = node.object;
+                    if (obj.property.type === 'Identifier' &&
+                        obj.property.name === 'location' &&
+                        obj.object.type === 'Identifier' &&
+                        obj.object.name === 'window') {
+                        context.report({ node, messageId: 'avoid' });
+                    }
+                }
+            },
+        };
+    },
+};
+export default rule;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/history/BrowserHistory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserHistory.d.ts","sourceRoot":"","sources":["../../../src/history/BrowserHistory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAQ5E,wBAAgB,UAAU,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAI5D;AAOD,MAAM,CAAC,OAAO,OAAO,cAAe,YAAW,OAAO;IAEpD,OAAO,CAAC,WAAW,CAAyB;;IAe5C,IAAW,QAAQ,IAAI,QAAQ,CAI9B;IAKM,IAAI,IAAI,IAAI;IAUZ,GAAG,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAapC,IAAI,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAYrC,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAY5C,SAAS,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI;IAWvD,OAAO,CAAC,MAAM,CAOZ;IAOF,OAAO,CAAC,QAAQ,CAOd;IAKF,OAAO,CAAC,WAAW;CAGpB"}
+{"version":3,"file":"BrowserHistory.d.ts","sourceRoot":"","sources":["../../../src/history/BrowserHistory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAQ5E,wBAAgB,UAAU,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAI5D;AAOD,MAAM,CAAC,OAAO,OAAO,cAAe,YAAW,OAAO;IAEpD,OAAO,CAAC,WAAW,CAAyB;;IAe5C,IAAW,QAAQ,IAAI,QAAQ,CAU9B;IAKM,IAAI,IAAI,IAAI;IAUZ,GAAG,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAapC,IAAI,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAYrC,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAY5C,SAAS,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI;IAWvD,OAAO,CAAC,MAAM,CAOZ;IAOF,OAAO,CAAC,QAAQ,CAOd;IAKF,OAAO,CAAC,WAAW;CAGpB"}

package/lib/esm/history/BrowserHistory.js

@@ -9,7 +9,9 @@ export default class BrowserHistory {
     }
     get location() {
         return {
-            ...window.location,
+            pathname: window.location.pathname,
+            search: window.location.search,
+            hash: window.location.hash,
         };
     }
     init() {
@@ -56,4 +58,4 @@ export default class BrowserHistory {
         window.addEventListener('popstate', this.__fire);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BrowserHistory.js","sourceRoot":"","sources":["../../../src/history/BrowserHistory.ts"],"names":[],"mappings":"AAQA,MAAM,UAAU,UAAU,CAAC,QAAyB;IAClD,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,EAAE,EAAE,IAAI,GAAG,EAAE,EAAE,GAAG,QAAQ,CAAC;IAEtD,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,IAAI,EAAE,CAAC;AACvC,CAAC;AAOD,MAAM,CAAC,OAAO,OAAO,cAAc;IAEzB,WAAW,GAAsB,EAAE,CAAC;IAK5C;QACE,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAQD,IAAW,QAAQ;QAIjB,OAAO;YAEL,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,QAAQ;YAClC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM;YAC9B,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI;SACJ,CAAC;IAC3B,CAAC;IAKM,IAAI;QACT,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAQM,GAAG,CAAC,QAAyB;QAClC,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QAElC,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;IAQM,IAAI,CAAC,QAAyB;QACnC,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QAElC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAOM,WAAW,CAAC,QAAyB;QAC1C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;YAClD,OAAO,IAAI,KAAK,QAAQ,CAAC;QAC3B,CAAC,CAAC,CAAC;IACL,CAAC;IAQM,SAAS,CAAC,QAAyB;QACxC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAChC,OAAO,GAAG,EAAE;YACV,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC7B,CAAC,CAAC;IACJ,CAAC;IAMO,MAAM,GAAG,GAAS,EAAE;QAC1B,UAAU,CAAC,GAAG,EAAE;YACd,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;YAC1B,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACpC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YAC5B,CAAC,CAAC,CAAC;QACL,CAAC,EAAE,CAAC,CAAC,CAAC;IACR,CAAC,CAAC;IAOM,QAAQ,GAAG,CAAC,aAAa,GAAG,KAAK,EAAE,EAAE;QAC3C,UAAU,CAAC,GAAG,EAAE;YACd,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;YAC1B,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACpC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;YACpC,CAAC,CAAC,CAAC;QACL,CAAC,EAAE,CAAC,CAAC,CAAC;IACR,CAAC,CAAC;IAKM,WAAW;QACjB,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC;CACF","sourcesContent":["import type { History, HistoryListener, HistoryLocation } from './types.js';\n\n/**\n * Creates a complete URL path from a HistoryLocation object.\n *\n * @param location - Location object containing pathname, search, and hash\n * @returns Complete path string combining all components\n */\nexport function createPath(location: HistoryLocation): string {\n  const { pathname, search = '', hash = '' } = location;\n\n  return `${pathname}${search}${hash}`;\n}\n\n/**\n * Browser history implementation using the HTML5 History API.\n * Manages browser navigation state and provides a consistent interface\n * for programmatic navigation and location change notifications.\n */\nexport default class BrowserHistory implements History {\n  /** Array of listeners for location changes */\n  private __listeners: HistoryListener[] = [];\n\n  /**\n   * Creates a new BrowserHistory instance and initializes event listeners.\n   */\n  public constructor() {\n    this.init();\n  }\n\n  /**\n   * Gets the current browser location.\n   *\n   * @returns Current window.location object\n   */\n  // eslint-disable-next-line class-methods-use-this\n  public get location(): Location {\n    // Some test DOM environments (e.g. happy-dom) expose non-enumerable\n    // Location properties so a simple spread returns an empty object.\n    // Return an explicit plain object with the fields we rely on.\n    return {\n      // pathname/search/hash are sufficient for our router logic\n      pathname: window.location.pathname,\n      search: window.location.search,\n      hash: window.location.hash,\n    } as unknown as Location;\n  }\n\n  /**\n   * Initializes the history instance by setting up event listeners.\n   */\n  public init(): void {\n    this.__subscribe();\n  }\n\n  /**\n   * Replaces the current history entry with a new location.\n   * This updates the URL without creating a new history entry.\n   *\n   * @param location - New location to set\n   */\n  public set(location: HistoryLocation): void {\n    const path = createPath(location);\n\n    window.history.replaceState({}, '', path);\n    this.__doFire(true);\n  }\n\n  /**\n   * Navigates to a new location by pushing a new history entry.\n   * This creates a new entry in the browser's history stack.\n   *\n   * @param location - Location to navigate to\n   */\n  public push(location: HistoryLocation): void {\n    const path = createPath(location);\n\n    window.history.pushState({}, '', path);\n    this.__fire();\n  }\n\n  /**\n   * Removes a listener from the history change notifications.\n   *\n   * @param listener - Listener function to remove\n   */\n  public unsubscribe(listener: HistoryListener): void {\n    this.__listeners = this.__listeners.filter((item) => {\n      return item !== listener;\n    });\n  }\n\n  /**\n   * Subscribes to history changes.\n   *\n   * @param listener - Function to call when location changes\n   * @returns Unsubscribe function\n   */\n  public subscribe(listener: HistoryListener): () => void {\n    this.__listeners.push(listener);\n    return () => {\n      this.unsubscribe(listener);\n    };\n  }\n\n  /**\n   * Notifies all listeners of a location change.\n   * Uses setTimeout to ensure the notification happens after the current execution.\n   */\n  private __fire = (): void => {\n    setTimeout(() => {\n      const { location } = this;\n      this.__listeners.forEach((listener) => {\n        listener(location, false);\n      });\n    }, 0);\n  };\n\n  /**\n   * Notifies all listeners of a location change with optional force rerender.\n   *\n   * @param forceRerender - Whether to force a re-render\n   */\n  private __doFire = (forceRerender = false) => {\n    setTimeout(() => {\n      const { location } = this;\n      this.__listeners.forEach((listener) => {\n        listener(location, forceRerender);\n      });\n    }, 0);\n  };\n\n  /**\n   * Sets up the popstate event listener for browser back/forward navigation.\n   */\n  private __subscribe() {\n    window.addEventListener('popstate', this.__fire);\n  }\n}\n"]}

package/lib/esm/index.d.ts

@@ -4,5 +4,6 @@ export * from './routing/index.js';
 export * from './builder.js';
 export * from './ResourcePage.js';
 export * from './tools.js';
+export { q, parseTypedQuery } from './tools/query-dsl.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;AAG3B,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"}

package/lib/esm/index.js

@@ -4,4 +4,5 @@ export * from './routing/index.js';
 export * from './builder.js';
 export * from './ResourcePage.js';
 export * from './tools.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLG9CQUFvQixDQUFDO0FBR25DLGNBQWMsb0JBQW9CLENBQUM7QUFHbkMsY0FBYyxjQUFjLENBQUM7QUFHN0IsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEV4cG9ydCBlcnJvciBoYW5kbGluZyB1dGlsaXRpZXNcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3JzL2luZGV4LmpzJztcblxuLy8gRXhwb3J0IGJyb3dzZXIgaGlzdG9yeSBtYW5hZ2VtZW50XG5leHBvcnQgKiBmcm9tICcuL2hpc3RvcnkvaW5kZXguanMnO1xuXG4vLyBFeHBvcnQgcm91dGluZyBjb21wb25lbnRzIGFuZCB1dGlsaXRpZXNcbmV4cG9ydCAqIGZyb20gJy4vcm91dGluZy9pbmRleC5qcyc7XG5cbi8vIEV4cG9ydCByb3V0ZSBidWlsZGluZyB1dGlsaXRpZXNcbmV4cG9ydCAqIGZyb20gJy4vYnVpbGRlci5qcyc7XG5cbi8vIEV4cG9ydCByZXNvdXJjZSBwYWdlIG1hbmFnZW1lbnQgZm9yIGxhenkgbG9hZGluZ1xuZXhwb3J0ICogZnJvbSAnLi9SZXNvdXJjZVBhZ2UuanMnO1xuXG4vLyBFeHBvcnQgdXRpbGl0eSBmdW5jdGlvbnNcbmV4cG9ydCAqIGZyb20gJy4vdG9vbHMuanMnO1xuXG4vLyBFeHBvcnQgYWxsIFR5cGVTY3JpcHQgdHlwZXNcbmV4cG9ydCB0eXBlICogZnJvbSAnLi90eXBlcy5qcyc7XG4iXX0=
+export { q, parseTypedQuery } from './tools/query-dsl.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLG9CQUFvQixDQUFDO0FBR25DLGNBQWMsb0JBQW9CLENBQUM7QUFHbkMsY0FBYyxjQUFjLENBQUM7QUFHN0IsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLFlBQVksQ0FBQztBQUMzQixPQUFPLEVBQUUsQ0FBQyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gRXhwb3J0IGVycm9yIGhhbmRsaW5nIHV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvcnMvaW5kZXguanMnO1xuXG4vLyBFeHBvcnQgYnJvd3NlciBoaXN0b3J5IG1hbmFnZW1lbnRcbmV4cG9ydCAqIGZyb20gJy4vaGlzdG9yeS9pbmRleC5qcyc7XG5cbi8vIEV4cG9ydCByb3V0aW5nIGNvbXBvbmVudHMgYW5kIHV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9yb3V0aW5nL2luZGV4LmpzJztcblxuLy8gRXhwb3J0IHJvdXRlIGJ1aWxkaW5nIHV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9idWlsZGVyLmpzJztcblxuLy8gRXhwb3J0IHJlc291cmNlIHBhZ2UgbWFuYWdlbWVudCBmb3IgbGF6eSBsb2FkaW5nXG5leHBvcnQgKiBmcm9tICcuL1Jlc291cmNlUGFnZS5qcyc7XG5cbi8vIEV4cG9ydCB1dGlsaXR5IGZ1bmN0aW9uc1xuZXhwb3J0ICogZnJvbSAnLi90b29scy5qcyc7XG5leHBvcnQgeyBxLCBwYXJzZVR5cGVkUXVlcnkgfSBmcm9tICcuL3Rvb2xzL3F1ZXJ5LWRzbC5qcyc7XG5cbi8vIEV4cG9ydCBhbGwgVHlwZVNjcmlwdCB0eXBlc1xuZXhwb3J0IHR5cGUgKiBmcm9tICcuL3R5cGVzLmpzJztcbiJdfQ==

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

@@ -15,6 +15,7 @@ type Props = {
     onMouseOver?: React.MouseEventHandler<HTMLAnchorElement>;
     target?: HTMLAttributeAnchorTarget;
     to?: HistoryLocation | string;
+    query?: Record<string, any>;
 };
 declare const Link: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLAnchorElement>>;
 export default Link;

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

@@ -1 +1 @@
-{"version":3,"file":"Link.d.ts","sourceRoot":"","sources":["../../../src/routing/Link.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EACZ,KAAK,yBAAyB,EAE9B,KAAK,SAAS,EAIf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAW3E,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,cAAc,GAAG,SAAS,EACnC,QAAQ,EAAE,MAAM,GACf,OAAO,CAmBT;AAKD,KAAK,KAAK,GAAG;IAEX,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,QAAQ,EAAE,SAAS,CAAC;IAEpB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,OAAO,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAErD,OAAO,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAErD,WAAW,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAEzD,MAAM,CAAC,EAAE,yBAAyB,CAAC;IAEnC,EAAE,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC;CAC/B,CAAC;AAyBF,QAAA,MAAM,IAAI,iFAuIR,CAAC;AAEH,eAAe,IAAI,CAAC"}
+{"version":3,"file":"Link.d.ts","sourceRoot":"","sources":["../../../src/routing/Link.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EACZ,KAAK,yBAAyB,EAE9B,KAAK,SAAS,EAIf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAY3E,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,cAAc,GAAG,SAAS,EACnC,QAAQ,EAAE,MAAM,GACf,OAAO,CAmBT;AAKD,KAAK,KAAK,GAAG;IAEX,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,QAAQ,EAAE,SAAS,CAAC;IAEpB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,OAAO,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAErD,OAAO,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAErD,WAAW,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAEzD,MAAM,CAAC,EAAE,yBAAyB,CAAC;IAEnC,EAAE,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC;IAE9B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC7B,CAAC;AAyBF,QAAA,MAAM,IAAI,iFA2KR,CAAC;AAEH,eAAe,IAAI,CAAC"}