alepha 0.20.1 → 0.20.2

package/dist/react/ui/index.d.ts

@@ -0,0 +1,124 @@
+import * as _$alepha from "alepha";
+import { Static } from "alepha";
+import * as _$alepha_react_head0 from "alepha/react/head";
+import * as _$alepha_server_cookies0 from "alepha/server/cookies";
+import * as _$typebox from "typebox";
+
+//#region ../../src/react/ui/atoms/uiAtom.d.ts
+/**
+ * Persisted UI state — color mode, theme palette, sidebar collapsed state, etc.
+ *
+ * The atom is bound to a single `alepha-ui` cookie via {@link UiPersistence},
+ * so values survive page reloads and are available during SSR.
+ */
+declare const uiAtom: _$alepha.Atom<_$alepha.TObject<{
+  /** Color mode preference. `"system"` follows the OS-level setting. */mode: _$alepha.TUnsafe<"light" | "dark" | "system">; /** Theme palette name. UI consumers map this to a CSS class on the root. */
+  theme: _$alepha.TString; /** Sidebar UI state. */
+  sidebar: _$alepha.TObject<{
+    collapsed: _$alepha.TBoolean;
+  }>;
+}>, "alepha.react.ui">;
+type UiState = Static<typeof uiAtom.schema>;
+//#endregion
+//#region ../../src/react/ui/components/ColorScheme.d.ts
+/**
+ * Applies `class="dark"` and an optional theme palette class
+ * (`theme-<name>`) to the document root, syncing whenever the underlying
+ * atom mutates.
+ *
+ * Mount once near the root of your tree (typically inside the layout).
+ *
+ * @example
+ * <ColorScheme />
+ */
+declare function ColorScheme(): null;
+//#endregion
+//#region ../../src/react/ui/hooks/useColorMode.d.ts
+type ColorMode = "light" | "dark" | "system";
+type ResolvedColorMode = "light" | "dark";
+/**
+ * Read and update the user's color-mode preference. `"system"` resolves to
+ * the OS preference and updates live as the OS toggles between light/dark.
+ *
+ * @example
+ * const { mode, setMode, resolved } = useColorMode();
+ * setMode("dark");
+ * document.documentElement.classList.toggle("dark", resolved === "dark");
+ */
+declare const useColorMode: () => {
+  mode: ColorMode;
+  resolved: ResolvedColorMode;
+  setMode: (next: ColorMode) => void;
+};
+//#endregion
+//#region ../../src/react/ui/hooks/useSidebarState.d.ts
+/**
+ * Read and update the sidebar collapsed state. The value is persisted via the
+ * `alepha-ui` cookie so it survives reloads and is available during SSR — no
+ * flash of expanded-then-collapsed when the user prefers a collapsed shell.
+ *
+ * @example
+ * const { collapsed, setCollapsed, toggle } = useSidebarState();
+ */
+declare const useSidebarState: () => {
+  collapsed: boolean;
+  setCollapsed: (next: boolean) => void;
+  toggle: () => void;
+};
+//#endregion
+//#region ../../src/react/ui/hooks/useTheme.d.ts
+/**
+ * Read and update the active theme palette name. UI consumers typically map
+ * the value to a class on the document root (e.g. `theme-claude`).
+ *
+ * @example
+ * const { theme, setTheme } = useTheme();
+ * setTheme("claude");
+ */
+declare const useTheme: () => {
+  theme: string;
+  setTheme: (next: string) => void;
+};
+//#endregion
+//#region ../../src/react/ui/services/UiPersistence.d.ts
+/**
+ * Binds the {@link uiAtom} to an `alepha-ui` cookie + injects an inline
+ * boot script into the SSR head to prevent FOUC on first paint.
+ *
+ * Reading flow: on app boot the cookie is parsed and pushed into the atom
+ * (via the `key` option on `$cookie`). Writing flow: every time the atom
+ * mutates, the cookie is rewritten — a single `useStore(uiAtom)` call is
+ * enough to persist UI preferences across reloads.
+ *
+ * Persists for 365 days; SameSite=lax so it travels on top-level navigation
+ * but not on cross-origin requests.
+ */
+declare class UiPersistence {
+  ui: _$alepha_server_cookies0.AbstractCookiePrimitive<_$typebox.TObject<{
+    mode: _$typebox.TUnsafe<"light" | "dark" | "system">;
+    theme: _$typebox.TString;
+    sidebar: _$typebox.TObject<{
+      collapsed: _$typebox.TBoolean;
+    }>;
+  }>>;
+  head: _$alepha_react_head0.HeadPrimitive;
+}
+//#endregion
+//#region ../../src/react/ui/index.d.ts
+declare module "alepha" {
+  interface State {
+    "alepha.react.ui": UiState;
+  }
+}
+/**
+ * Persisted UI state: color mode, theme palette, sidebar collapsed state.
+ *
+ * Backed by an `alepha-ui` cookie so preferences survive reloads and are
+ * available during SSR (no flash of wrong theme).
+ *
+ * @module alepha.react.ui
+ */
+declare const AlephaReactUi: _$alepha.Service<_$alepha.Module>;
+//#endregion
+export { AlephaReactUi, ColorMode, ColorScheme, ResolvedColorMode, UiPersistence, UiState, uiAtom, useColorMode, useSidebarState, useTheme };
+//# sourceMappingURL=index.d.ts.map

package/dist/react/ui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/react/ui/atoms/uiAtom.ts","../../../src/react/ui/components/ColorScheme.tsx","../../../src/react/ui/hooks/useColorMode.ts","../../../src/react/ui/hooks/useSidebarState.ts","../../../src/react/ui/hooks/useTheme.ts","../../../src/react/ui/services/UiPersistence.ts","../../../src/react/ui/index.ts"],"mappings":";;;;;;;;;;;;;cAQa,MAAA,EAAM,QAAA,CAAA,IAAA,UAAA,OAAA;EAiBjB,4EAAA,QAAA,CAAA,OAAA,+BAAA;;;;;;KAEU,OAAA,GAAU,MAAA,QAAc,MAAA,CAAO,MAAA;;;;;;;;;;AAnB3C;;;iBCMgB,WAAA,CAAA;;;KCVJ,SAAA;AAAA,KACA,iBAAA;;;;;;AFGZ;;;;cEQa,YAAA;;;kBAQO,SAAA;AAAA;;;;;;;;;;AFhBpB;cGGa,eAAA;;;;;;;;;;;;;;AHHb;cIGa,QAAA;;;;;;;;;;;;;AJHb;;;;;cKoBa,aAAA;EACX,EAAA,EAAE,wBAAA,CAAA,uBAAA,WAAA,OAAA;UADsB,SAAA,CAAA,OAAA;;;;;;EASxB,IAAA,EARE,oBAAA,CAQE,aAAA;AAAA;;;;YCrBa,KAAA;IACf,iBAAA,EAAmB,OAAA;EAAA;AAAA;;;;;;;;;cAcV,aAAA,EAAa,QAAA,CAAA,OAAA,CAGxB,QAAA,CAHwB,MAAA"}

package/dist/react/ui/index.js

@@ -0,0 +1,206 @@
+import { $atom, $module, t } from "alepha";
+import { $head } from "alepha/react/head";
+import { $cookie } from "alepha/server/cookies";
+import { useEffect, useState } from "react";
+import { useStore } from "alepha/react";
+//#region ../../src/react/ui/atoms/uiAtom.ts
+/**
+* Persisted UI state — color mode, theme palette, sidebar collapsed state, etc.
+*
+* The atom is bound to a single `alepha-ui` cookie via {@link UiPersistence},
+* so values survive page reloads and are available during SSR.
+*/
+const uiAtom = $atom({
+	name: "alepha.react.ui",
+	schema: t.object({
+		mode: t.enum([
+			"light",
+			"dark",
+			"system"
+		]),
+		theme: t.string(),
+		sidebar: t.object({ collapsed: t.boolean() })
+	}),
+	default: {
+		mode: "system",
+		theme: "default",
+		sidebar: { collapsed: false }
+	}
+});
+//#endregion
+//#region ../../src/react/ui/services/UiPersistence.ts
+/**
+* Inline `<script>` rendered by SSR into the document `<head>`. Runs
+* synchronously before any CSS or React hydration: reads the `alepha-ui`
+* cookie, resolves `mode === "system"` via `prefers-color-scheme`, and
+* applies `class="dark"` (and optional `theme-<name>`) on `<html>`.
+*
+* This is what kills the flash-of-wrong-theme (FOUC) you'd otherwise get
+* with React-effect-based theming. Failures are swallowed silently — at
+* worst the page paints in light mode for one frame.
+*/
+const colorSchemeBoot = `(function(){try{var m=document.cookie.match(/(?:^|;\\s*)alepha-ui=([^;]+)/);var s=m?JSON.parse(decodeURIComponent(m[1])):{};var mode=s.mode||"system";var dark=mode==="dark"||(mode==="system"&&window.matchMedia&&window.matchMedia("(prefers-color-scheme: dark)").matches);var r=document.documentElement;if(dark)r.classList.add("dark");if(s.theme&&s.theme!=="default")r.classList.add("theme-"+s.theme);}catch(e){}})();`;
+/**
+* Binds the {@link uiAtom} to an `alepha-ui` cookie + injects an inline
+* boot script into the SSR head to prevent FOUC on first paint.
+*
+* Reading flow: on app boot the cookie is parsed and pushed into the atom
+* (via the `key` option on `$cookie`). Writing flow: every time the atom
+* mutates, the cookie is rewritten — a single `useStore(uiAtom)` call is
+* enough to persist UI preferences across reloads.
+*
+* Persists for 365 days; SameSite=lax so it travels on top-level navigation
+* but not on cross-origin requests.
+*/
+var UiPersistence = class {
+	ui = $cookie({
+		name: "alepha-ui",
+		key: uiAtom.key,
+		schema: uiAtom.schema,
+		ttl: [365, "days"],
+		sameSite: "lax"
+	});
+	head = $head({ script: [{ content: colorSchemeBoot }] });
+};
+//#endregion
+//#region ../../src/react/ui/hooks/useColorMode.ts
+/**
+* Read and update the user's color-mode preference. `"system"` resolves to
+* the OS preference and updates live as the OS toggles between light/dark.
+*
+* @example
+* const { mode, setMode, resolved } = useColorMode();
+* setMode("dark");
+* document.documentElement.classList.toggle("dark", resolved === "dark");
+*/
+const useColorMode = () => {
+	const [state, set] = useStore(uiAtom);
+	const mode = state?.mode ?? "system";
+	return {
+		mode,
+		resolved: useResolvedColorMode(mode),
+		setMode: (next) => {
+			set({
+				...state ?? uiAtom.options.default,
+				mode: next
+			});
+		}
+	};
+};
+const useResolvedColorMode = (mode) => {
+	const [systemDark, setSystemDark] = useState(() => {
+		if (typeof window === "undefined") return false;
+		return window.matchMedia?.("(prefers-color-scheme: dark)").matches ?? false;
+	});
+	useEffect(() => {
+		if (typeof window === "undefined") return;
+		const mq = window.matchMedia?.("(prefers-color-scheme: dark)");
+		if (!mq) return;
+		const onChange = (ev) => setSystemDark(ev.matches);
+		mq.addEventListener("change", onChange);
+		return () => mq.removeEventListener("change", onChange);
+	}, []);
+	if (mode === "dark") return "dark";
+	if (mode === "light") return "light";
+	return systemDark ? "dark" : "light";
+};
+//#endregion
+//#region ../../src/react/ui/hooks/useTheme.ts
+/**
+* Read and update the active theme palette name. UI consumers typically map
+* the value to a class on the document root (e.g. `theme-claude`).
+*
+* @example
+* const { theme, setTheme } = useTheme();
+* setTheme("claude");
+*/
+const useTheme = () => {
+	const [state, set] = useStore(uiAtom);
+	return {
+		theme: state?.theme ?? "default",
+		setTheme: (next) => {
+			set({
+				...state ?? uiAtom.options.default,
+				theme: next
+			});
+		}
+	};
+};
+//#endregion
+//#region ../../src/react/ui/components/ColorScheme.tsx
+/**
+* Applies `class="dark"` and an optional theme palette class
+* (`theme-<name>`) to the document root, syncing whenever the underlying
+* atom mutates.
+*
+* Mount once near the root of your tree (typically inside the layout).
+*
+* @example
+* <ColorScheme />
+*/
+function ColorScheme() {
+	const { resolved } = useColorMode();
+	const { theme } = useTheme();
+	useEffect(() => {
+		if (typeof document === "undefined") return;
+		document.documentElement.classList.toggle("dark", resolved === "dark");
+	}, [resolved]);
+	useEffect(() => {
+		if (typeof document === "undefined") return;
+		const root = document.documentElement;
+		const previous = [];
+		root.classList.forEach((cls) => {
+			if (cls.startsWith("theme-")) previous.push(cls);
+		});
+		for (const cls of previous) root.classList.remove(cls);
+		if (theme && theme !== "default") root.classList.add(`theme-${theme}`);
+	}, [theme]);
+	return null;
+}
+//#endregion
+//#region ../../src/react/ui/hooks/useSidebarState.ts
+/**
+* Read and update the sidebar collapsed state. The value is persisted via the
+* `alepha-ui` cookie so it survives reloads and is available during SSR — no
+* flash of expanded-then-collapsed when the user prefers a collapsed shell.
+*
+* @example
+* const { collapsed, setCollapsed, toggle } = useSidebarState();
+*/
+const useSidebarState = () => {
+	const [state, set] = useStore(uiAtom);
+	const collapsed = state?.sidebar.collapsed ?? false;
+	const setCollapsed = (next) => {
+		const base = state ?? uiAtom.options.default;
+		set({
+			...base,
+			sidebar: {
+				...base.sidebar,
+				collapsed: next
+			}
+		});
+	};
+	return {
+		collapsed,
+		setCollapsed,
+		toggle: () => setCollapsed(!collapsed)
+	};
+};
+//#endregion
+//#region ../../src/react/ui/index.ts
+/**
+* Persisted UI state: color mode, theme palette, sidebar collapsed state.
+*
+* Backed by an `alepha-ui` cookie so preferences survive reloads and are
+* available during SSR (no flash of wrong theme).
+*
+* @module alepha.react.ui
+*/
+const AlephaReactUi = $module({
+	name: "alepha.react.ui",
+	services: [UiPersistence]
+});
+//#endregion
+export { AlephaReactUi, ColorScheme, UiPersistence, uiAtom, useColorMode, useSidebarState, useTheme };
+
+//# sourceMappingURL=index.js.map

package/dist/react/ui/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/react/ui/atoms/uiAtom.ts","../../../src/react/ui/services/UiPersistence.ts","../../../src/react/ui/hooks/useColorMode.ts","../../../src/react/ui/hooks/useTheme.ts","../../../src/react/ui/components/ColorScheme.tsx","../../../src/react/ui/hooks/useSidebarState.ts","../../../src/react/ui/index.ts"],"sourcesContent":["import { $atom, type Static, t } from \"alepha\";\n\n/**\n * Persisted UI state — color mode, theme palette, sidebar collapsed state, etc.\n *\n * The atom is bound to a single `alepha-ui` cookie via {@link UiPersistence},\n * so values survive page reloads and are available during SSR.\n */\nexport const uiAtom = $atom({\n  name: \"alepha.react.ui\",\n  schema: t.object({\n    /** Color mode preference. `\"system\"` follows the OS-level setting. */\n    mode: t.enum([\"light\", \"dark\", \"system\"]),\n    /** Theme palette name. UI consumers map this to a CSS class on the root. */\n    theme: t.string(),\n    /** Sidebar UI state. */\n    sidebar: t.object({\n      collapsed: t.boolean(),\n    }),\n  }),\n  default: {\n    mode: \"system\",\n    theme: \"default\",\n    sidebar: { collapsed: false },\n  },\n});\n\nexport type UiState = Static<typeof uiAtom.schema>;\n","import { $head } from \"alepha/react/head\";\nimport { $cookie } from \"alepha/server/cookies\";\nimport { uiAtom } from \"../atoms/uiAtom.ts\";\n\n/**\n * Inline `<script>` rendered by SSR into the document `<head>`. Runs\n * synchronously before any CSS or React hydration: reads the `alepha-ui`\n * cookie, resolves `mode === \"system\"` via `prefers-color-scheme`, and\n * applies `class=\"dark\"` (and optional `theme-<name>`) on `<html>`.\n *\n * This is what kills the flash-of-wrong-theme (FOUC) you'd otherwise get\n * with React-effect-based theming. Failures are swallowed silently — at\n * worst the page paints in light mode for one frame.\n */\nconst colorSchemeBoot = `(function(){try{var m=document.cookie.match(/(?:^|;\\\\s*)alepha-ui=([^;]+)/);var s=m?JSON.parse(decodeURIComponent(m[1])):{};var mode=s.mode||\"system\";var dark=mode===\"dark\"||(mode===\"system\"&&window.matchMedia&&window.matchMedia(\"(prefers-color-scheme: dark)\").matches);var r=document.documentElement;if(dark)r.classList.add(\"dark\");if(s.theme&&s.theme!==\"default\")r.classList.add(\"theme-\"+s.theme);}catch(e){}})();`;\n\n/**\n * Binds the {@link uiAtom} to an `alepha-ui` cookie + injects an inline\n * boot script into the SSR head to prevent FOUC on first paint.\n *\n * Reading flow: on app boot the cookie is parsed and pushed into the atom\n * (via the `key` option on `$cookie`). Writing flow: every time the atom\n * mutates, the cookie is rewritten — a single `useStore(uiAtom)` call is\n * enough to persist UI preferences across reloads.\n *\n * Persists for 365 days; SameSite=lax so it travels on top-level navigation\n * but not on cross-origin requests.\n */\nexport class UiPersistence {\n  ui = $cookie({\n    name: \"alepha-ui\",\n    key: uiAtom.key,\n    schema: uiAtom.schema,\n    ttl: [365, \"days\"],\n    sameSite: \"lax\",\n  });\n\n  head = $head({\n    script: [{ content: colorSchemeBoot }],\n  });\n}\n","import { useStore } from \"alepha/react\";\nimport { useEffect, useState } from \"react\";\nimport { uiAtom } from \"../atoms/uiAtom.ts\";\n\nexport type ColorMode = \"light\" | \"dark\" | \"system\";\nexport type ResolvedColorMode = \"light\" | \"dark\";\n\n/**\n * Read and update the user's color-mode preference. `\"system\"` resolves to\n * the OS preference and updates live as the OS toggles between light/dark.\n *\n * @example\n * const { mode, setMode, resolved } = useColorMode();\n * setMode(\"dark\");\n * document.documentElement.classList.toggle(\"dark\", resolved === \"dark\");\n */\nexport const useColorMode = () => {\n  const [state, set] = useStore(uiAtom);\n  const mode = (state?.mode ?? \"system\") as ColorMode;\n  const resolved = useResolvedColorMode(mode);\n\n  return {\n    mode,\n    resolved,\n    setMode: (next: ColorMode) => {\n      set({ ...(state ?? uiAtom.options.default!), mode: next });\n    },\n  };\n};\n\nconst useResolvedColorMode = (mode: ColorMode): ResolvedColorMode => {\n  const [systemDark, setSystemDark] = useState<boolean>(() => {\n    if (typeof window === \"undefined\") return false;\n    return window.matchMedia?.(\"(prefers-color-scheme: dark)\").matches ?? false;\n  });\n\n  useEffect(() => {\n    if (typeof window === \"undefined\") return;\n    const mq = window.matchMedia?.(\"(prefers-color-scheme: dark)\");\n    if (!mq) return;\n    const onChange = (ev: MediaQueryListEvent) => setSystemDark(ev.matches);\n    mq.addEventListener(\"change\", onChange);\n    return () => mq.removeEventListener(\"change\", onChange);\n  }, []);\n\n  if (mode === \"dark\") return \"dark\";\n  if (mode === \"light\") return \"light\";\n  return systemDark ? \"dark\" : \"light\";\n};\n","import { useStore } from \"alepha/react\";\nimport { uiAtom } from \"../atoms/uiAtom.ts\";\n\n/**\n * Read and update the active theme palette name. UI consumers typically map\n * the value to a class on the document root (e.g. `theme-claude`).\n *\n * @example\n * const { theme, setTheme } = useTheme();\n * setTheme(\"claude\");\n */\nexport const useTheme = () => {\n  const [state, set] = useStore(uiAtom);\n  const theme = state?.theme ?? \"default\";\n\n  return {\n    theme,\n    setTheme: (next: string) => {\n      set({ ...(state ?? uiAtom.options.default!), theme: next });\n    },\n  };\n};\n","import { useEffect } from \"react\";\nimport { useColorMode } from \"../hooks/useColorMode.ts\";\nimport { useTheme } from \"../hooks/useTheme.ts\";\n\n/**\n * Applies `class=\"dark\"` and an optional theme palette class\n * (`theme-<name>`) to the document root, syncing whenever the underlying\n * atom mutates.\n *\n * Mount once near the root of your tree (typically inside the layout).\n *\n * @example\n * <ColorScheme />\n */\nexport function ColorScheme() {\n  const { resolved } = useColorMode();\n  const { theme } = useTheme();\n\n  useEffect(() => {\n    if (typeof document === \"undefined\") return;\n    document.documentElement.classList.toggle(\"dark\", resolved === \"dark\");\n  }, [resolved]);\n\n  useEffect(() => {\n    if (typeof document === \"undefined\") return;\n    const root = document.documentElement;\n    const previous: string[] = [];\n    root.classList.forEach((cls) => {\n      if (cls.startsWith(\"theme-\")) previous.push(cls);\n    });\n    for (const cls of previous) root.classList.remove(cls);\n    if (theme && theme !== \"default\") root.classList.add(`theme-${theme}`);\n  }, [theme]);\n\n  return null;\n}\n","import { useStore } from \"alepha/react\";\nimport { uiAtom } from \"../atoms/uiAtom.ts\";\n\n/**\n * Read and update the sidebar collapsed state. The value is persisted via the\n * `alepha-ui` cookie so it survives reloads and is available during SSR — no\n * flash of expanded-then-collapsed when the user prefers a collapsed shell.\n *\n * @example\n * const { collapsed, setCollapsed, toggle } = useSidebarState();\n */\nexport const useSidebarState = () => {\n  const [state, set] = useStore(uiAtom);\n  const collapsed = state?.sidebar.collapsed ?? false;\n\n  const setCollapsed = (next: boolean) => {\n    const base = state ?? uiAtom.options.default!;\n    set({ ...base, sidebar: { ...base.sidebar, collapsed: next } });\n  };\n\n  return {\n    collapsed,\n    setCollapsed,\n    toggle: () => setCollapsed(!collapsed),\n  };\n};\n","import { $module } from \"alepha\";\nimport type { UiState } from \"./atoms/uiAtom.ts\";\nimport { UiPersistence } from \"./services/UiPersistence.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./atoms/uiAtom.ts\";\nexport * from \"./components/ColorScheme.tsx\";\nexport * from \"./hooks/useColorMode.ts\";\nexport * from \"./hooks/useSidebarState.ts\";\nexport * from \"./hooks/useTheme.ts\";\nexport * from \"./services/UiPersistence.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\ndeclare module \"alepha\" {\n  export interface State {\n    \"alepha.react.ui\": UiState;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Persisted UI state: color mode, theme palette, sidebar collapsed state.\n *\n * Backed by an `alepha-ui` cookie so preferences survive reloads and are\n * available during SSR (no flash of wrong theme).\n *\n * @module alepha.react.ui\n */\nexport const AlephaReactUi = $module({\n  name: \"alepha.react.ui\",\n  services: [UiPersistence],\n});\n"],"mappings":"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"}

package/dist/router/index.d.ts

@@ -3,6 +3,7 @@ declare abstract class RouterProvider<T extends Route = Route> {
   protected routePathRegex: RegExp;
   protected tree: Tree<T>;
   protected cache: Map<string, RouteMatch<T>>;
+  protected maxCacheSize: number;
   match(path: string): RouteMatch<T>;
   protected test(path: string): void;
   protected push(route: T): void;
@@ -67,17 +68,12 @@ interface Tree<T extends Route> {
  */
 declare class TemplatedPathParser {
   protected static readonly PARAM_REGEX: RegExp;
-  protected readonly template: string;
-  protected readonly separator: string;
+  readonly template: string;
+  readonly separator: string;
+  readonly paramNames: readonly string[];
+  readonly hasParams: boolean;
+  protected readonly extractRegex: RegExp | null;
   constructor(template: string, separator?: string);
-  /**
-   * Returns true if the template contains at least one `{param}` placeholder.
-   */
-  get hasParams(): boolean;
-  /**
-   * Returns an ordered list of parameter names found in the template.
-   */
-  get paramNames(): string[];
   /**
    * Replaces each `{param}` in the template with the corresponding value
    * from the provided params record.
@@ -85,10 +81,12 @@ declare class TemplatedPathParser {
   interpolate(params: Record<string, string>): string;
   /**
    * Extracts parameter values from a concrete path by matching it against
-   * the template structure. Returns an empty object when the template has
-   * no parameters.
+   * the template structure.
+   *
+   * Returns `null` when the path does not match the template.
+   * Returns `{}` when the template has no parameters and the path matches.
    */
-  extract(path: string): Record<string, string>;
+  extract(path: string): Record<string, string> | null;
   /**
    * Replaces each `{param}` placeholder in the template with the given
    * wildcard string. Defaults to `"+"` (MQTT-style).
@@ -99,6 +97,8 @@ declare class TemplatedPathParser {
    * trailing separator (unless the path is just the separator itself).
    */
   normalize(path: string): string;
+  protected buildExtractRegex(): RegExp;
+  protected escapeRegex(s: string): string;
 }
 //#endregion
 export { Route, RouteMatch, RouterProvider, TemplatedPathParser, Tree };

package/dist/router/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/router/providers/RouterProvider.ts","../../src/router/TemplatedPathParser.ts"],"mappings":";uBAEsB,cAAA,WAAyB,KAAA,GAAQ,KAAA;EAAA,UAC3C,cAAA,EAAgB,MAAA;EAAA,UAEhB,IAAA,EAAM,IAAA,CAAK,CAAA;EAAA,UACX,KAAA,EAAK,GAAA,SAAA,UAAA,CAAA,CAAA;EAER,KAAA,CAAM,IAAA,WAAe,UAAA,CAAW,CAAA;EAAA,UAS7B,IAAA,CAAK,IAAA;EAAA,UAML,IAAA,CAAK,KAAA,EAAO,CAAA;EAAA,UA8DZ,gBAAA,CAAiB,IAAA,WAAe,UAAA,CAAW,CAAA;EAAA,UA4C3C,SAAA,CAAU,KAAA,EAAO,UAAA,CAAW,CAAA,IAAK,UAAA,CAAW,CAAA;EAAA,UAa5C,WAAA,CAAY,IAAA;AAAA;AAAA,UAYP,UAAA,WAAqB,KAAA;EACpC,KAAA,GAAQ,CAAA;EACR,MAAA,GAAS,MAAA;AAAA;AAAA,UAGM,KAAA;EACf,IAAA;EA/BsC;;;;;;;EAwCtC,SAAA,GAAY,MAAA;AAAA;AAAA,UAGG,IAAA,WAAe,KAAA;EAC9B,KAAA,GAAQ,CAAA;EACR,QAAA;IAAA,CACG,GAAA,WAAc,IAAA,CAAK,CAAA;EAAA;EAEtB,KAAA;IACE,KAAA,GAAQ,CAAA;IACR,IAAA;IACA,QAAA;MAAA,CACG,GAAA,WAAc,IAAA,CAAK,CAAA;IAAA;EAAA;EAGxB,QAAA;IACE,KAAA,EAAO,CAAA;EAAA;AAAA;;;;AAvLX;;;;;;;;;;;;;;;;;;;;;cCoBa,mBAAA;EAAA,0BACe,WAAA,EAAW,MAAA;EAAA,mBAElB,QAAA;EAAA,mBACA,SAAA;cAEP,QAAA,UAAkB,SAAA;EDzBJ;;;EAAA,ICiCtB,SAAA,CAAA;ED9BM;;;EAAA,ICqCN,UAAA,CAAA;EDnCG;;;;EC2CP,WAAA,CAAY,MAAA,EAAQ,MAAA;EDlCL;;;;;EC8Cf,OAAA,CAAQ,IAAA,WAAe,MAAA;EDsBmB;;;;ECoB1C,WAAA,CAAY,QAAA;EDwBQ;;;;EChBpB,SAAA,CAAU,IAAA;AAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/router/providers/RouterProvider.ts","../../src/router/TemplatedPathParser.ts"],"mappings":";uBAEsB,cAAA,WAAyB,KAAA,GAAQ,KAAA;EAAA,UAC3C,cAAA,EAAgB,MAAA;EAAA,UAEhB,IAAA,EAAM,IAAA,CAAK,CAAA;EAAA,UACX,KAAA,EAAK,GAAA,SAAA,UAAA,CAAA,CAAA;EAAA,UACL,YAAA;EAEH,KAAA,CAAM,IAAA,WAAe,UAAA,CAAW,CAAA;EAAA,UAY7B,IAAA,CAAK,IAAA;EAAA,UAML,IAAA,CAAK,KAAA,EAAO,CAAA;EAAA,UA+DZ,gBAAA,CAAiB,IAAA,WAAe,UAAA,CAAW,CAAA;EAAA,UA4C3C,SAAA,CAAU,KAAA,EAAO,UAAA,CAAW,CAAA,IAAK,UAAA,CAAW,CAAA;EAAA,UAa5C,WAAA,CAAY,IAAA;AAAA;AAAA,UAYP,UAAA,WAAqB,KAAA;EACpC,KAAA,GAAQ,CAAA;EACR,MAAA,GAAS,MAAA;AAAA;AAAA,UAGM,KAAA;EACf,IAAA;EA/B2B;;;;;;;EAwC3B,SAAA,GAAY,MAAA;AAAA;AAAA,UAGG,IAAA,WAAe,KAAA;EAC9B,KAAA,GAAQ,CAAA;EACR,QAAA;IAAA,CACG,GAAA,WAAc,IAAA,CAAK,CAAA;EAAA;EAEtB,KAAA;IACE,KAAA,GAAQ,CAAA;IACR,IAAA;IACA,QAAA;MAAA,CACG,GAAA,WAAc,IAAA,CAAK,CAAA;IAAA;EAAA;EAGxB,QAAA;IACE,KAAA,EAAO,CAAA;EAAA;AAAA;;;;AA5LX;;;;;;;;;;;;;;;;;;;;;cCsBa,mBAAA;EAAA,0BACe,WAAA,EAAW,MAAA;EAAA,SAErB,QAAA;EAAA,SACA,SAAA;EAAA,SACA,UAAA;EAAA,SACA,SAAA;EAAA,mBACG,YAAA,EAAc,MAAA;cAErB,QAAA,UAAkB,SAAA;ED5BT;;;;EC+CrB,WAAA,CAAY,MAAA,EAAQ,MAAA;ED7CV;;;;;;;EC2DV,OAAA,CAAQ,IAAA,WAAe,MAAA;EDvCD;;;;EC4DtB,WAAA,CAAY,QAAA;EDGyC;;;;ECKrD,SAAA,CAAU,IAAA;EAAA,UAaA,iBAAA,CAAA,GAAqB,MAAA;EAAA,UAerB,WAAA,CAAY,CAAA;AAAA"}

package/dist/router/index.js

@@ -4,11 +4,21 @@ var RouterProvider = class {
 	routePathRegex = /^\/[A-Za-z0-9._~!$&%'()*+,;=:@{}?/-]*$/;
 	tree = { children: {} };
 	cache = /* @__PURE__ */ new Map();
+	maxCacheSize = 1e4;
 	match(path) {
-		if (this.cache.has(path)) return this.cache.get(path);
-		const result = this.mapParams(this.createRouteMatch(path));
-		this.cache.set(path, result);
-		return result;
+		const pathname = path.split("?", 1)[0];
+		const hit = this.cache.get(pathname);
+		if (hit) return {
+			route: hit.route,
+			params: { ...hit.params }
+		};
+		const result = this.mapParams(this.createRouteMatch(pathname));
+		if (this.cache.size >= this.maxCacheSize) this.cache.clear();
+		this.cache.set(pathname, result);
+		return {
+			route: result.route,
+			params: { ...result.params }
+		};
 	}
 	test(path) {
 		if (!this.routePathRegex.test(path)) throw new AlephaError(`Route '${path}' is not valid`);
@@ -16,6 +26,7 @@ var RouterProvider = class {
 	push(route) {
 		const path = route.path.replaceAll("//", "/");
 		this.test(path);
+		this.cache.clear();
 		const parts = this.createParts(path);
 		let cursor = this.tree;
 		for (let i = 0; i < parts.length; i++) {
@@ -128,50 +139,41 @@ var RouterProvider = class {
 * parser.wildcardize("*");                               // "cache:*:*"
 * ```
 */
-var TemplatedPathParser = class {
+var TemplatedPathParser = class TemplatedPathParser {
 	static PARAM_REGEX = /\{([^}]+)\}/g;
 	template;
 	separator;
+	paramNames;
+	hasParams;
+	extractRegex;
 	constructor(template, separator = "/") {
+		if (separator.length !== 1) throw new AlephaError(`TemplatedPathParser separator must be a single character, got '${separator}'`);
 		this.template = template;
 		this.separator = separator;
-	}
-	/**
-	* Returns true if the template contains at least one `{param}` placeholder.
-	*/
-	get hasParams() {
-		return /\{[^}]+\}/.test(this.template);
-	}
-	/**
-	* Returns an ordered list of parameter names found in the template.
-	*/
-	get paramNames() {
-		return [...this.template.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+		this.paramNames = [...template.matchAll(TemplatedPathParser.PARAM_REGEX)].map((m) => m[1]);
+		this.hasParams = this.paramNames.length > 0;
+		this.extractRegex = this.hasParams ? this.buildExtractRegex() : null;
 	}
 	/**
 	* Replaces each `{param}` in the template with the corresponding value
 	* from the provided params record.
 	*/
 	interpolate(params) {
-		return this.template.replace(/\{([^}]+)\}/g, (_, name) => params[name] ?? `{${name}}`);
+		return this.template.replace(TemplatedPathParser.PARAM_REGEX, (_, name) => params[name] ?? `{${name}}`);
 	}
 	/**
 	* Extracts parameter values from a concrete path by matching it against
-	* the template structure. Returns an empty object when the template has
-	* no parameters.
+	* the template structure.
+	*
+	* Returns `null` when the path does not match the template.
+	* Returns `{}` when the template has no parameters and the path matches.
 	*/
 	extract(path) {
-		const names = this.paramNames;
-		if (names.length === 0) return {};
-		const escapedSeparator = this.separator.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-		const regexSource = this.template.replace(/[.*+?^${}()|[\]\\]/g, (char) => {
-			if (char === "{" || char === "}") return char;
-			return `\\${char}`;
-		}).replace(/\{([^}]+)\}/g, `([^${escapedSeparator}]+)`);
-		const match = new RegExp(`^${regexSource}$`).exec(path);
-		if (!match) return {};
+		if (!this.extractRegex) return path === this.template ? {} : null;
+		const match = this.extractRegex.exec(path);
+		if (!match) return null;
 		const result = {};
-		for (let i = 0; i < names.length; i++) result[names[i]] = match[i + 1];
+		for (let i = 0; i < this.paramNames.length; i++) result[this.paramNames[i]] = match[i + 1];
 		return result;
 	}
 	/**
@@ -179,7 +181,7 @@ var TemplatedPathParser = class {
 	* wildcard string. Defaults to `"+"` (MQTT-style).
 	*/
 	wildcardize(wildcard = "+") {
-		return this.template.replace(/\{[^}]+\}/g, wildcard);
+		return this.template.replace(TemplatedPathParser.PARAM_REGEX, wildcard);
 	}
 	/**
 	* Normalises a path by collapsing repeated separators and stripping a
@@ -187,11 +189,22 @@ var TemplatedPathParser = class {
 	*/
 	normalize(path) {
 		const sep = this.separator;
-		const escapedSep = sep.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const escapedSep = this.escapeRegex(sep);
 		let result = path.replace(new RegExp(`${escapedSep}{2,}`, "g"), sep);
 		if (result.endsWith(sep) && result.length > sep.length) result = result.slice(0, -sep.length);
 		return result;
 	}
+	buildExtractRegex() {
+		const escapedSeparator = this.escapeRegex(this.separator);
+		const regexSource = this.template.replace(/[.*+?^${}()|[\]\\]/g, (char) => {
+			if (char === "{" || char === "}") return char;
+			return `\\${char}`;
+		}).replace(/\{[^}]+\}/g, `([^${escapedSeparator}]+)`);
+		return new RegExp(`^${regexSource}$`);
+	}
+	escapeRegex(s) {
+		return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}
 };
 //#endregion
 export { RouterProvider, TemplatedPathParser };

package/dist/router/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/router/providers/RouterProvider.ts","../../src/router/TemplatedPathParser.ts"],"sourcesContent":["import { AlephaError } from \"alepha\";\n\nexport abstract class RouterProvider<T extends Route = Route> {\n  protected routePathRegex: RegExp = /^\\/[A-Za-z0-9._~!$&%'()*+,;=:@{}?/-]*$/;\n\n  protected tree: Tree<T> = { children: {} };\n  protected cache = new Map<string, RouteMatch<T>>();\n\n  public match(path: string): RouteMatch<T> {\n    if (this.cache.has(path)) {\n      return this.cache.get(path)!;\n    }\n    const result = this.mapParams(this.createRouteMatch(path));\n    this.cache.set(path, result);\n    return result;\n  }\n\n  protected test(path: string): void {\n    if (!this.routePathRegex.test(path)) {\n      throw new AlephaError(`Route '${path}' is not valid`);\n    }\n  }\n\n  protected push(route: T): void {\n    const path = route.path.replaceAll(\"//\", \"/\");\n\n    this.test(path);\n\n    const parts = this.createParts(path);\n\n    let cursor = this.tree;\n    for (let i = 0; i < parts.length; i++) {\n      const isLast = i === parts.length - 1;\n      let part = parts[i].toLowerCase(); // url is case-insensitive\n      if (part === \"*\" && isLast) {\n        cursor.wildcard = { route };\n        break;\n      }\n\n      if (part.includes(\"*\")) {\n        throw new AlephaError(`Route '${path}' has an invalid wildcard syntax`);\n      }\n\n      if (part.includes(\"{\") || part.includes(\"}\")) {\n        if (part.startsWith(\"{\") && part.endsWith(\"}\")) {\n          part = `:${part.slice(1, -1)}`; // convert {param} to :param\n        } else {\n          throw new AlephaError(`Route '${path}' has an invalid param syntax`);\n        }\n      }\n\n      if (part.startsWith(\":\")) {\n        const name = parts[i].slice(1).replaceAll(\"}\", \"\");\n        if (!name) {\n          throw new AlephaError(`Route '${path}' has an empty param name`);\n        }\n        if (!cursor.param) {\n          cursor.param = { name, children: {} };\n        } else if (cursor.param.name !== name) {\n          // damn, 2 url params with different names\n          // got this case with /customers/:id and /customers/:userId/payments\n          route.mapParams ??= {};\n          route.mapParams[cursor.param.name] = name;\n        }\n\n        if (isLast) {\n          cursor.param.route = route;\n        }\n\n        cursor = cursor.param;\n        continue;\n      }\n\n      if (!cursor.children[part]) {\n        cursor.children[part] = { children: {} };\n      }\n\n      if (isLast) {\n        cursor.children[part].route = route;\n      }\n\n      cursor = cursor.children[part];\n    }\n  }\n\n  protected createRouteMatch(path: string): RouteMatch<T> {\n    if (path[0] !== \"/\") {\n      throw new AlephaError(`Path '${path}' must start with \"/\"`);\n    }\n\n    const parts = this.createParts(path);\n\n    let cursor = this.tree;\n    let wildcard: { route: T } | undefined;\n    const params: Record<string, string> = {};\n\n    for (let i = 0; i < parts.length; i++) {\n      const part = parts[i].toLowerCase(); // url is case-insensitive\n      if (cursor.children[part]) {\n        if (cursor.wildcard) {\n          wildcard = cursor.wildcard;\n        }\n        cursor = cursor.children[part];\n      } else if (cursor.param) {\n        if (cursor.wildcard) {\n          wildcard = cursor.wildcard;\n        }\n        params[cursor.param.name] = parts[i];\n        cursor = cursor.param;\n      } else if (cursor.wildcard) {\n        params[\"*\"] = parts.slice(i).join(\"/\");\n        return { route: cursor.wildcard.route, params };\n      } else {\n        return { route: wildcard?.route, params };\n      }\n    }\n\n    if (!cursor?.route) {\n      // when \"/a/*\" - trigger if \"/a\"\n      if (cursor.wildcard) {\n        return { route: cursor.wildcard.route, params };\n      }\n      // return deep wildcard or nothing\n      return { route: wildcard?.route, params };\n    }\n\n    return { route: cursor.route, params };\n  }\n\n  protected mapParams(match: RouteMatch<T>): RouteMatch<T> {\n    if (match.route?.mapParams && match.params) {\n      for (const [key, value] of Object.entries(match.route.mapParams)) {\n        if (match.params[key]) {\n          match.params[value] = match.params[key];\n          delete match.params[key];\n        }\n      }\n    }\n\n    return match;\n  }\n\n  protected createParts(path: string): string[] {\n    let pathname = path.split(\"?\")[0].replaceAll(\"//\", \"/\");\n\n    // remove trailing slash\n    if (pathname.endsWith(\"/\") && pathname.length > 1) {\n      pathname = pathname.slice(0, -1);\n    }\n\n    return pathname.split(\"/\").slice(1);\n  }\n}\n\nexport interface RouteMatch<T extends Route> {\n  route?: T;\n  params?: Record<string, string>;\n}\n\nexport interface Route {\n  path: string;\n\n  /**\n   * Rename a param in the route.\n   * This is automatically filled when you have scenarios like:\n   * `/customers/:id` and `/customers/:userId/payments`\n   *\n   * In this case, `:id` will be renamed to `:userId` in the second route.\n   */\n  mapParams?: Record<string, string>;\n}\n\nexport interface Tree<T extends Route> {\n  route?: T;\n  children: {\n    [key: string]: Tree<T>;\n  };\n  param?: {\n    route?: T;\n    name: string;\n    children: {\n      [key: string]: Tree<T>;\n    };\n  };\n  wildcard?: {\n    route: T;\n  };\n}\n","/**\n * Parses and manipulates templated paths with `{param}` placeholders.\n *\n * Used by both RouterProvider (HTTP routes) and TopicProvider (pub/sub topics)\n * to handle parameterized path templates in a unified way.\n *\n * @example\n * ```ts\n * const parser = new TemplatedPathParser(\"/users/{userId}/posts/{postId}\");\n * parser.interpolate({ userId: \"7\", postId: \"42\" }); // \"/users/7/posts/42\"\n * parser.extract(\"/users/7/posts/42\");               // { userId: \"7\", postId: \"42\" }\n * parser.wildcardize(\"+\");                           // \"/users/+/posts/+\"\n * ```\n *\n * @example\n * ```ts\n * // Redis-style colon-separated keys\n * const parser = new TemplatedPathParser(\"cache:{namespace}:{key}\", \":\");\n * parser.interpolate({ namespace: \"users\", key: \"42\" }); // \"cache:users:42\"\n * parser.wildcardize(\"*\");                               // \"cache:*:*\"\n * ```\n */\nexport class TemplatedPathParser {\n  protected static readonly PARAM_REGEX = /\\{([^}]+)\\}/g;\n\n  protected readonly template: string;\n  protected readonly separator: string;\n\n  constructor(template: string, separator = \"/\") {\n    this.template = template;\n    this.separator = separator;\n  }\n\n  /**\n   * Returns true if the template contains at least one `{param}` placeholder.\n   */\n  get hasParams(): boolean {\n    return /\\{[^}]+\\}/.test(this.template);\n  }\n\n  /**\n   * Returns an ordered list of parameter names found in the template.\n   */\n  get paramNames(): string[] {\n    return [...this.template.matchAll(/\\{([^}]+)\\}/g)].map((m) => m[1]);\n  }\n\n  /**\n   * Replaces each `{param}` in the template with the corresponding value\n   * from the provided params record.\n   */\n  interpolate(params: Record<string, string>): string {\n    return this.template.replace(\n      /\\{([^}]+)\\}/g,\n      (_, name: string) => params[name] ?? `{${name}}`,\n    );\n  }\n\n  /**\n   * Extracts parameter values from a concrete path by matching it against\n   * the template structure. Returns an empty object when the template has\n   * no parameters.\n   */\n  extract(path: string): Record<string, string> {\n    const names = this.paramNames;\n    if (names.length === 0) {\n      return {};\n    }\n\n    const escapedSeparator = this.separator.replace(\n      /[.*+?^${}()|[\\]\\\\]/g,\n      \"\\\\$&\",\n    );\n\n    // Build a regex from the template: escape literal parts, replace {param} with a capture group\n    const regexSource = this.template\n      .replace(/[.*+?^${}()|[\\]\\\\]/g, (char) => {\n        // Allow { and } through so we can then replace them as param groups\n        if (char === \"{\" || char === \"}\") {\n          return char;\n        }\n        return `\\\\${char}`;\n      })\n      // After escaping literal chars, replace {name} patterns with capture groups.\n      // The separator is already escaped above, so we match anything that is not the separator.\n      .replace(/\\{([^}]+)\\}/g, `([^${escapedSeparator}]+)`);\n\n    const regex = new RegExp(`^${regexSource}$`);\n    const match = regex.exec(path);\n\n    if (!match) {\n      return {};\n    }\n\n    const result: Record<string, string> = {};\n    for (let i = 0; i < names.length; i++) {\n      result[names[i]] = match[i + 1];\n    }\n    return result;\n  }\n\n  /**\n   * Replaces each `{param}` placeholder in the template with the given\n   * wildcard string. Defaults to `\"+\"` (MQTT-style).\n   */\n  wildcardize(wildcard = \"+\"): string {\n    return this.template.replace(/\\{[^}]+\\}/g, wildcard);\n  }\n\n  /**\n   * Normalises a path by collapsing repeated separators and stripping a\n   * trailing separator (unless the path is just the separator itself).\n   */\n  normalize(path: string): string {\n    const sep = this.separator;\n    const escapedSep = sep.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n    // Replace consecutive separators with a single one\n    let result = path.replace(new RegExp(`${escapedSep}{2,}`, \"g\"), sep);\n\n    // Strip trailing separator, but preserve a lone separator\n    if (result.endsWith(sep) && result.length > sep.length) {\n      result = result.slice(0, -sep.length);\n    }\n\n    return result;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/router/providers/RouterProvider.ts","../../src/router/TemplatedPathParser.ts"],"sourcesContent":["import { AlephaError } from \"alepha\";\n\nexport abstract class RouterProvider<T extends Route = Route> {\n  protected routePathRegex: RegExp = /^\\/[A-Za-z0-9._~!$&%'()*+,;=:@{}?/-]*$/;\n\n  protected tree: Tree<T> = { children: {} };\n  protected cache = new Map<string, RouteMatch<T>>();\n  protected maxCacheSize = 10_000;\n\n  public match(path: string): RouteMatch<T> {\n    const pathname = path.split(\"?\", 1)[0];\n    const hit = this.cache.get(pathname);\n    if (hit) {\n      return { route: hit.route, params: { ...hit.params } };\n    }\n    const result = this.mapParams(this.createRouteMatch(pathname));\n    if (this.cache.size >= this.maxCacheSize) this.cache.clear();\n    this.cache.set(pathname, result);\n    return { route: result.route, params: { ...result.params } };\n  }\n\n  protected test(path: string): void {\n    if (!this.routePathRegex.test(path)) {\n      throw new AlephaError(`Route '${path}' is not valid`);\n    }\n  }\n\n  protected push(route: T): void {\n    const path = route.path.replaceAll(\"//\", \"/\");\n\n    this.test(path);\n    this.cache.clear();\n\n    const parts = this.createParts(path);\n\n    let cursor = this.tree;\n    for (let i = 0; i < parts.length; i++) {\n      const isLast = i === parts.length - 1;\n      let part = parts[i].toLowerCase(); // url is case-insensitive\n      if (part === \"*\" && isLast) {\n        cursor.wildcard = { route };\n        break;\n      }\n\n      if (part.includes(\"*\")) {\n        throw new AlephaError(`Route '${path}' has an invalid wildcard syntax`);\n      }\n\n      if (part.includes(\"{\") || part.includes(\"}\")) {\n        if (part.startsWith(\"{\") && part.endsWith(\"}\")) {\n          part = `:${part.slice(1, -1)}`; // convert {param} to :param\n        } else {\n          throw new AlephaError(`Route '${path}' has an invalid param syntax`);\n        }\n      }\n\n      if (part.startsWith(\":\")) {\n        const name = parts[i].slice(1).replaceAll(\"}\", \"\");\n        if (!name) {\n          throw new AlephaError(`Route '${path}' has an empty param name`);\n        }\n        if (!cursor.param) {\n          cursor.param = { name, children: {} };\n        } else if (cursor.param.name !== name) {\n          // damn, 2 url params with different names\n          // got this case with /customers/:id and /customers/:userId/payments\n          route.mapParams ??= {};\n          route.mapParams[cursor.param.name] = name;\n        }\n\n        if (isLast) {\n          cursor.param.route = route;\n        }\n\n        cursor = cursor.param;\n        continue;\n      }\n\n      if (!cursor.children[part]) {\n        cursor.children[part] = { children: {} };\n      }\n\n      if (isLast) {\n        cursor.children[part].route = route;\n      }\n\n      cursor = cursor.children[part];\n    }\n  }\n\n  protected createRouteMatch(path: string): RouteMatch<T> {\n    if (path[0] !== \"/\") {\n      throw new AlephaError(`Path '${path}' must start with \"/\"`);\n    }\n\n    const parts = this.createParts(path);\n\n    let cursor = this.tree;\n    let wildcard: { route: T } | undefined;\n    const params: Record<string, string> = {};\n\n    for (let i = 0; i < parts.length; i++) {\n      const part = parts[i].toLowerCase(); // url is case-insensitive\n      if (cursor.children[part]) {\n        if (cursor.wildcard) {\n          wildcard = cursor.wildcard;\n        }\n        cursor = cursor.children[part];\n      } else if (cursor.param) {\n        if (cursor.wildcard) {\n          wildcard = cursor.wildcard;\n        }\n        params[cursor.param.name] = parts[i];\n        cursor = cursor.param;\n      } else if (cursor.wildcard) {\n        params[\"*\"] = parts.slice(i).join(\"/\");\n        return { route: cursor.wildcard.route, params };\n      } else {\n        return { route: wildcard?.route, params };\n      }\n    }\n\n    if (!cursor?.route) {\n      // when \"/a/*\" - trigger if \"/a\"\n      if (cursor.wildcard) {\n        return { route: cursor.wildcard.route, params };\n      }\n      // return deep wildcard or nothing\n      return { route: wildcard?.route, params };\n    }\n\n    return { route: cursor.route, params };\n  }\n\n  protected mapParams(match: RouteMatch<T>): RouteMatch<T> {\n    if (match.route?.mapParams && match.params) {\n      for (const [key, value] of Object.entries(match.route.mapParams)) {\n        if (match.params[key]) {\n          match.params[value] = match.params[key];\n          delete match.params[key];\n        }\n      }\n    }\n\n    return match;\n  }\n\n  protected createParts(path: string): string[] {\n    let pathname = path.split(\"?\")[0].replaceAll(\"//\", \"/\");\n\n    // remove trailing slash\n    if (pathname.endsWith(\"/\") && pathname.length > 1) {\n      pathname = pathname.slice(0, -1);\n    }\n\n    return pathname.split(\"/\").slice(1);\n  }\n}\n\nexport interface RouteMatch<T extends Route> {\n  route?: T;\n  params?: Record<string, string>;\n}\n\nexport interface Route {\n  path: string;\n\n  /**\n   * Rename a param in the route.\n   * This is automatically filled when you have scenarios like:\n   * `/customers/:id` and `/customers/:userId/payments`\n   *\n   * In this case, `:id` will be renamed to `:userId` in the second route.\n   */\n  mapParams?: Record<string, string>;\n}\n\nexport interface Tree<T extends Route> {\n  route?: T;\n  children: {\n    [key: string]: Tree<T>;\n  };\n  param?: {\n    route?: T;\n    name: string;\n    children: {\n      [key: string]: Tree<T>;\n    };\n  };\n  wildcard?: {\n    route: T;\n  };\n}\n","import { AlephaError } from \"alepha\";\n\n/**\n * Parses and manipulates templated paths with `{param}` placeholders.\n *\n * Used by both RouterProvider (HTTP routes) and TopicProvider (pub/sub topics)\n * to handle parameterized path templates in a unified way.\n *\n * @example\n * ```ts\n * const parser = new TemplatedPathParser(\"/users/{userId}/posts/{postId}\");\n * parser.interpolate({ userId: \"7\", postId: \"42\" }); // \"/users/7/posts/42\"\n * parser.extract(\"/users/7/posts/42\");               // { userId: \"7\", postId: \"42\" }\n * parser.wildcardize(\"+\");                           // \"/users/+/posts/+\"\n * ```\n *\n * @example\n * ```ts\n * // Redis-style colon-separated keys\n * const parser = new TemplatedPathParser(\"cache:{namespace}:{key}\", \":\");\n * parser.interpolate({ namespace: \"users\", key: \"42\" }); // \"cache:users:42\"\n * parser.wildcardize(\"*\");                               // \"cache:*:*\"\n * ```\n */\nexport class TemplatedPathParser {\n  protected static readonly PARAM_REGEX = /\\{([^}]+)\\}/g;\n\n  public readonly template: string;\n  public readonly separator: string;\n  public readonly paramNames: readonly string[];\n  public readonly hasParams: boolean;\n  protected readonly extractRegex: RegExp | null;\n\n  constructor(template: string, separator = \"/\") {\n    if (separator.length !== 1) {\n      throw new AlephaError(\n        `TemplatedPathParser separator must be a single character, got '${separator}'`,\n      );\n    }\n    this.template = template;\n    this.separator = separator;\n    this.paramNames = [\n      ...template.matchAll(TemplatedPathParser.PARAM_REGEX),\n    ].map((m) => m[1]);\n    this.hasParams = this.paramNames.length > 0;\n    this.extractRegex = this.hasParams ? this.buildExtractRegex() : null;\n  }\n\n  /**\n   * Replaces each `{param}` in the template with the corresponding value\n   * from the provided params record.\n   */\n  interpolate(params: Record<string, string>): string {\n    return this.template.replace(\n      TemplatedPathParser.PARAM_REGEX,\n      (_, name: string) => params[name] ?? `{${name}}`,\n    );\n  }\n\n  /**\n   * Extracts parameter values from a concrete path by matching it against\n   * the template structure.\n   *\n   * Returns `null` when the path does not match the template.\n   * Returns `{}` when the template has no parameters and the path matches.\n   */\n  extract(path: string): Record<string, string> | null {\n    if (!this.extractRegex) {\n      return path === this.template ? {} : null;\n    }\n\n    const match = this.extractRegex.exec(path);\n    if (!match) {\n      return null;\n    }\n\n    const result: Record<string, string> = {};\n    for (let i = 0; i < this.paramNames.length; i++) {\n      result[this.paramNames[i]] = match[i + 1];\n    }\n    return result;\n  }\n\n  /**\n   * Replaces each `{param}` placeholder in the template with the given\n   * wildcard string. Defaults to `\"+\"` (MQTT-style).\n   */\n  wildcardize(wildcard = \"+\"): string {\n    return this.template.replace(TemplatedPathParser.PARAM_REGEX, wildcard);\n  }\n\n  /**\n   * Normalises a path by collapsing repeated separators and stripping a\n   * trailing separator (unless the path is just the separator itself).\n   */\n  normalize(path: string): string {\n    const sep = this.separator;\n    const escapedSep = this.escapeRegex(sep);\n\n    let result = path.replace(new RegExp(`${escapedSep}{2,}`, \"g\"), sep);\n\n    if (result.endsWith(sep) && result.length > sep.length) {\n      result = result.slice(0, -sep.length);\n    }\n\n    return result;\n  }\n\n  protected buildExtractRegex(): RegExp {\n    const escapedSeparator = this.escapeRegex(this.separator);\n\n    const regexSource = this.template\n      .replace(/[.*+?^${}()|[\\]\\\\]/g, (char) => {\n        if (char === \"{\" || char === \"}\") {\n          return char;\n        }\n        return `\\\\${char}`;\n      })\n      .replace(/\\{[^}]+\\}/g, `([^${escapedSeparator}]+)`);\n\n    return new RegExp(`^${regexSource}$`);\n  }\n\n  protected escapeRegex(s: string): string {\n    return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n  }\n}\n"],"mappings":"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"}