@fluixi/router 0.1.2-alpha.3 → 0.1.2-alpha.5

package/dist/lib/history.cjs

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/history.ts
+var history_exports = {};
+__export(history_exports, {
+  createBrowserHistory: () => createBrowserHistory,
+  createMemoryHistory: () => createMemoryHistory,
+  splitPath: () => splitPath
+});
+module.exports = __toCommonJS(history_exports);
+var keys = 0;
+var nextKey = () => `${Date.now().toString(36)}-${(keys++).toString(36)}`;
+function splitPath(to) {
+  let rest = to;
+  let hash = "";
+  const hashIdx = rest.indexOf("#");
+  if (hashIdx !== -1) {
+    hash = rest.slice(hashIdx);
+    rest = rest.slice(0, hashIdx);
+  }
+  let search = "";
+  const qIdx = rest.indexOf("?");
+  if (qIdx !== -1) {
+    search = rest.slice(qIdx);
+    rest = rest.slice(0, qIdx);
+  }
+  return { pathname: rest || "/", search, hash };
+}
+function createMemoryHistory(initial = "/") {
+  let entries = [
+    { path: initial, state: null, key: nextKey() }
+  ];
+  let index = 0;
+  let action = "pop";
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => listeners.forEach((l) => l());
+  return {
+    get() {
+      const { path, state, key } = entries[index];
+      return { ...splitPath(path), state, key, action };
+    },
+    push(to, state = null) {
+      entries = entries.slice(0, index + 1);
+      entries.push({ path: to, state, key: nextKey() });
+      index = entries.length - 1;
+      action = "push";
+      notify();
+    },
+    replace(to, state = null) {
+      entries[index] = { path: to, state, key: nextKey() };
+      action = "replace";
+      notify();
+    },
+    /** Back (`-1`) or forward (`1`), as the browser's buttons would. */
+    go(delta) {
+      const next = index + delta;
+      if (next < 0 || next >= entries.length) return;
+      index = next;
+      action = "pop";
+      notify();
+    },
+    subscribe(onChange) {
+      listeners.add(onChange);
+      return () => listeners.delete(onChange);
+    }
+  };
+}
+function createBrowserHistory() {
+  const w = typeof window !== "undefined" ? window : void 0;
+  const listeners = /* @__PURE__ */ new Set();
+  let action = "pop";
+  const notify = () => listeners.forEach((l) => l());
+  if (w) w.addEventListener("popstate", () => (action = "pop", notify()));
+  const wrapped = (value) => typeof value === "object" && value !== null && typeof value.fx === "string";
+  const entry = () => {
+    const raw = w.history.state;
+    if (wrapped(raw)) return raw;
+    const keyed = { fx: nextKey(), usr: raw ?? null };
+    w.history.replaceState(keyed, "");
+    return keyed;
+  };
+  return {
+    window: w !== void 0,
+    get() {
+      if (!w) return { pathname: "/", search: "", hash: "", state: null };
+      const { pathname, search, hash } = w.location;
+      const { fx, usr } = entry();
+      return { pathname, search, hash, state: usr, key: fx, action };
+    },
+    push(to, state = null) {
+      w?.history.pushState({ fx: nextKey(), usr: state }, "", to);
+      action = "push";
+      notify();
+    },
+    replace(to, state = null) {
+      w?.history.replaceState({ fx: nextKey(), usr: state }, "", to);
+      action = "replace";
+      notify();
+    },
+    subscribe(onChange) {
+      listeners.add(onChange);
+      return () => listeners.delete(onChange);
+    }
+  };
+}

package/dist/lib/history.d.ts

@@ -12,10 +12,12 @@ export declare function splitPath(to: string): {
     hash: string;
 };
 /**
- * In-memory history — for tests and server-side rendering. Holds a stack of
+ * In-memory history: for tests and server-side rendering. Holds a stack of
  * entries; `push`/`replace` mutate it and notify subscribers synchronously.
  */
-export declare function createMemoryHistory(initial?: string): HistoryAdapter;
+export declare function createMemoryHistory(initial?: string): HistoryAdapter & {
+    go(delta: number): void;
+};
 /**
  * Browser history backed by the History API. `pushState`/`replaceState` do NOT
  * emit `popstate`, so the adapter keeps its own listener set and notifies on

package/dist/lib/history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/lib/history.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAeA;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,SAAM,GAAG,cAAc,CA4BjE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAyBrD"}
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/lib/history.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,YAAY,CAAC;AAKhE,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAeA;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,SAAM,GAAG,cAAc,GAAG;IAAE,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAuC/F;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CA2CrD"}

package/dist/lib/history.js

@@ -4,6 +4,8 @@
  * The router core depends only on the {@link HistoryAdapter} interface, so it
  * runs identically in tests/SSR (memory) and the browser (History API).
  */
+let keys = 0;
+const nextKey = () => `${Date.now().toString(36)}-${(keys++).toString(36)}`;
 /** Split a full path string into pathname / search / hash. */
 export function splitPath(to) {
     let rest = to;
@@ -22,29 +24,41 @@ export function splitPath(to) {
     return { pathname: rest || '/', search, hash };
 }
 /**
- * In-memory history — for tests and server-side rendering. Holds a stack of
+ * In-memory history: for tests and server-side rendering. Holds a stack of
  * entries; `push`/`replace` mutate it and notify subscribers synchronously.
  */
 export function createMemoryHistory(initial = '/') {
     let entries = [
-        { path: initial, state: null },
+        { path: initial, state: null, key: nextKey() },
     ];
     let index = 0;
+    let action = 'pop';
     const listeners = new Set();
     const notify = () => listeners.forEach((l) => l());
     return {
         get() {
-            const { path, state } = entries[index];
-            return { ...splitPath(path), state };
+            const { path, state, key } = entries[index];
+            return { ...splitPath(path), state, key, action };
         },
         push(to, state = null) {
             entries = entries.slice(0, index + 1);
-            entries.push({ path: to, state });
+            entries.push({ path: to, state, key: nextKey() });
             index = entries.length - 1;
+            action = 'push';
             notify();
         },
         replace(to, state = null) {
-            entries[index] = { path: to, state };
+            entries[index] = { path: to, state, key: nextKey() };
+            action = 'replace';
+            notify();
+        },
+        /** Back (`-1`) or forward (`1`), as the browser's buttons would. */
+        go(delta) {
+            const next = index + delta;
+            if (next < 0 || next >= entries.length)
+                return;
+            index = next;
+            action = 'pop';
             notify();
         },
         subscribe(onChange) {
@@ -62,22 +76,39 @@ export function createMemoryHistory(initial = '/') {
 export function createBrowserHistory() {
     const w = typeof window !== 'undefined' ? window : undefined;
     const listeners = new Set();
+    let action = 'pop';
     const notify = () => listeners.forEach((l) => l());
     if (w)
-        w.addEventListener('popstate', notify);
+        w.addEventListener('popstate', () => ((action = 'pop'), notify()));
+    // Each entry's state carries its key beside the app's own state, `{ fx, usr }`, so back
+    // and forward can tell which entry they returned to; `get` hands the app its state alone.
+    // An entry made outside the router (the first load) gets a key when it is first read.
+    const wrapped = (value) => typeof value === 'object' && value !== null && typeof value.fx === 'string';
+    const entry = () => {
+        const raw = w.history.state;
+        if (wrapped(raw))
+            return raw;
+        const keyed = { fx: nextKey(), usr: raw ?? null };
+        w.history.replaceState(keyed, '');
+        return keyed;
+    };
     return {
+        window: w !== undefined,
         get() {
             if (!w)
                 return { pathname: '/', search: '', hash: '', state: null };
             const { pathname, search, hash } = w.location;
-            return { pathname, search, hash, state: w.history.state ?? null };
+            const { fx, usr } = entry();
+            return { pathname, search, hash, state: usr, key: fx, action };
         },
         push(to, state = null) {
-            w?.history.pushState(state, '', to);
+            w?.history.pushState({ fx: nextKey(), usr: state }, '', to);
+            action = 'push';
             notify();
         },
         replace(to, state = null) {
-            w?.history.replaceState(state, '', to);
+            w?.history.replaceState({ fx: nextKey(), usr: state }, '', to);
+            action = 'replace';
             notify();
         },
         subscribe(onChange) {

package/dist/lib/history.mjs

@@ -0,0 +1,101 @@
+// src/lib/history.ts
+var keys = 0;
+var nextKey = () => `${Date.now().toString(36)}-${(keys++).toString(36)}`;
+function splitPath(to) {
+  let rest = to;
+  let hash = "";
+  const hashIdx = rest.indexOf("#");
+  if (hashIdx !== -1) {
+    hash = rest.slice(hashIdx);
+    rest = rest.slice(0, hashIdx);
+  }
+  let search = "";
+  const qIdx = rest.indexOf("?");
+  if (qIdx !== -1) {
+    search = rest.slice(qIdx);
+    rest = rest.slice(0, qIdx);
+  }
+  return { pathname: rest || "/", search, hash };
+}
+function createMemoryHistory(initial = "/") {
+  let entries = [
+    { path: initial, state: null, key: nextKey() }
+  ];
+  let index = 0;
+  let action = "pop";
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => listeners.forEach((l) => l());
+  return {
+    get() {
+      const { path, state, key } = entries[index];
+      return { ...splitPath(path), state, key, action };
+    },
+    push(to, state = null) {
+      entries = entries.slice(0, index + 1);
+      entries.push({ path: to, state, key: nextKey() });
+      index = entries.length - 1;
+      action = "push";
+      notify();
+    },
+    replace(to, state = null) {
+      entries[index] = { path: to, state, key: nextKey() };
+      action = "replace";
+      notify();
+    },
+    /** Back (`-1`) or forward (`1`), as the browser's buttons would. */
+    go(delta) {
+      const next = index + delta;
+      if (next < 0 || next >= entries.length) return;
+      index = next;
+      action = "pop";
+      notify();
+    },
+    subscribe(onChange) {
+      listeners.add(onChange);
+      return () => listeners.delete(onChange);
+    }
+  };
+}
+function createBrowserHistory() {
+  const w = typeof window !== "undefined" ? window : void 0;
+  const listeners = /* @__PURE__ */ new Set();
+  let action = "pop";
+  const notify = () => listeners.forEach((l) => l());
+  if (w) w.addEventListener("popstate", () => (action = "pop", notify()));
+  const wrapped = (value) => typeof value === "object" && value !== null && typeof value.fx === "string";
+  const entry = () => {
+    const raw = w.history.state;
+    if (wrapped(raw)) return raw;
+    const keyed = { fx: nextKey(), usr: raw ?? null };
+    w.history.replaceState(keyed, "");
+    return keyed;
+  };
+  return {
+    window: w !== void 0,
+    get() {
+      if (!w) return { pathname: "/", search: "", hash: "", state: null };
+      const { pathname, search, hash } = w.location;
+      const { fx, usr } = entry();
+      return { pathname, search, hash, state: usr, key: fx, action };
+    },
+    push(to, state = null) {
+      w?.history.pushState({ fx: nextKey(), usr: state }, "", to);
+      action = "push";
+      notify();
+    },
+    replace(to, state = null) {
+      w?.history.replaceState({ fx: nextKey(), usr: state }, "", to);
+      action = "replace";
+      notify();
+    },
+    subscribe(onChange) {
+      listeners.add(onChange);
+      return () => listeners.delete(onChange);
+    }
+  };
+}
+export {
+  createBrowserHistory,
+  createMemoryHistory,
+  splitPath
+};

package/dist/lib/match.cjs

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/match.ts
+var match_exports = {};
+__export(match_exports, {
+  matchPath: () => matchPath,
+  matchRoutes: () => matchRoutes,
+  rankRoutes: () => rankRoutes,
+  scoreRoute: () => scoreRoute
+});
+module.exports = __toCommonJS(match_exports);
+function normalizePath(p) {
+  return p.startsWith("//") ? p.replace(/^\/+/, "/") : p;
+}
+function matchPath(pattern, path, exact = false) {
+  const keys = [];
+  if (pattern === path) return { params: {}, path };
+  if (!exact && pattern === "/" && path.startsWith("/"))
+    return { params: {}, path: "/" };
+  let regexStr = pattern.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]*)/g, (_, name) => {
+    if (name) keys.push(name);
+    return "(.*)";
+  });
+  if (!regexStr.startsWith("/")) regexStr = "/" + regexStr;
+  if (regexStr === "") regexStr = "/";
+  const regex = new RegExp(`^${regexStr}${exact ? "$" : "(?=/|$)"}`);
+  const match = path.match(regex);
+  if (!match) return null;
+  const params = {};
+  keys.forEach((key, i) => {
+    params[key] = match[i + 1];
+  });
+  return { params, path: match[0] };
+}
+function scoreRoute(def) {
+  const segments = def.path.split("/").filter(Boolean);
+  if (segments.length === 0) return 5;
+  let score = 0;
+  for (const seg of segments) {
+    if (seg.startsWith("*")) score += 1;
+    else if (seg.startsWith(":")) score += 10;
+    else score += 100;
+  }
+  return score;
+}
+function rankRoutes(defs) {
+  return [...defs].sort((a, b) => scoreRoute(b) - scoreRoute(a));
+}
+function matchRoutes(routes, pathname) {
+  const path = pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
+  const result = matchInto(routes, path);
+  if (!result) return null;
+  const matched = [];
+  let cumulative = "";
+  const params = {};
+  for (const layer of result.layers) {
+    cumulative = normalizePath(joinMatched(cumulative, layer.consumed));
+    const layerParams = {};
+    for (const [k, v] of Object.entries(layer.params)) {
+      if (!(k in params)) layerParams[k] = v;
+      params[k] = v;
+    }
+    matched.push({
+      route: layer.route,
+      component: layer.route.component,
+      params: layerParams,
+      pathname: cumulative || "/"
+    });
+  }
+  return { matched, params, pathname };
+}
+function matchInto(defs, currentPath) {
+  if (!defs || defs.length === 0) return null;
+  const ranked = rankRoutes(defs);
+  for (const def of ranked) {
+    const hasChildren = !!def.children && def.children.length > 0;
+    const seg = matchPath(def.path, currentPath, !hasChildren);
+    if (!seg) continue;
+    if (hasChildren) {
+      const childMatch = matchInto(def.children, currentPath);
+      if (childMatch) {
+        return {
+          layers: [
+            { route: def, params: seg.params, consumed: seg.path },
+            ...childMatch.layers
+          ]
+        };
+      }
+      continue;
+    }
+    return { layers: [{ route: def, params: seg.params, consumed: seg.path }] };
+  }
+  return null;
+}
+function joinMatched(cumulative, consumed) {
+  if (!cumulative) return consumed;
+  if (consumed === cumulative) return cumulative;
+  if (consumed.startsWith(cumulative)) return consumed;
+  const a = cumulative.replace(/\/$/, "");
+  const b = consumed.replace(/^\//, "");
+  return `${a}/${b}`;
+}

package/dist/lib/match.d.ts

@@ -2,7 +2,7 @@
  * @fileoverview Pure route matching.
  *
  * `matchRoutes(routes, pathname)` resolves a pathname to a parent → child
- * {@link RouteMatch}. No side effects, no reactivity — same input, same output.
+ * {@link RouteMatch}. No side effects, no reactivity, same input, same output.
  * Ported from the fluixi router's matcher and made framework-agnostic.
  */
 import type { RouteDefinition, RouteMatch } from './types.js';

package/dist/lib/match.js

@@ -2,7 +2,7 @@
  * @fileoverview Pure route matching.
  *
  * `matchRoutes(routes, pathname)` resolves a pathname to a parent → child
- * {@link RouteMatch}. No side effects, no reactivity — same input, same output.
+ * {@link RouteMatch}. No side effects, no reactivity, same input, same output.
  * Ported from the fluixi router's matcher and made framework-agnostic.
  */
 /** Normalise accidental double slashes (`//x` → `/x`). */
@@ -81,7 +81,7 @@ export function matchRoutes(routes, pathname) {
     const params = {};
     for (const layer of result.layers) {
         cumulative = normalizePath(joinMatched(cumulative, layer.consumed));
-        // A layer's `params` is the DELTA it introduces — full-path nested routes
+        // A layer's `params` is the DELTA it introduces, full-path nested routes
         // re-match ancestor params, but those belong to the ancestor layer, not here.
         const layerParams = {};
         for (const [k, v] of Object.entries(layer.params)) {
@@ -117,7 +117,7 @@ function matchInto(defs, currentPath) {
                     ],
                 };
             }
-            // A layout matched the prefix but no child matched the remainder — keep
+            // A layout matched the prefix but no child matched the remainder, keep
             // searching siblings (this layout is not the right branch).
             continue;
         }

package/dist/lib/match.mjs

@@ -0,0 +1,101 @@
+// src/lib/match.ts
+function normalizePath(p) {
+  return p.startsWith("//") ? p.replace(/^\/+/, "/") : p;
+}
+function matchPath(pattern, path, exact = false) {
+  const keys = [];
+  if (pattern === path) return { params: {}, path };
+  if (!exact && pattern === "/" && path.startsWith("/"))
+    return { params: {}, path: "/" };
+  let regexStr = pattern.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]*)/g, (_, name) => {
+    if (name) keys.push(name);
+    return "(.*)";
+  });
+  if (!regexStr.startsWith("/")) regexStr = "/" + regexStr;
+  if (regexStr === "") regexStr = "/";
+  const regex = new RegExp(`^${regexStr}${exact ? "$" : "(?=/|$)"}`);
+  const match = path.match(regex);
+  if (!match) return null;
+  const params = {};
+  keys.forEach((key, i) => {
+    params[key] = match[i + 1];
+  });
+  return { params, path: match[0] };
+}
+function scoreRoute(def) {
+  const segments = def.path.split("/").filter(Boolean);
+  if (segments.length === 0) return 5;
+  let score = 0;
+  for (const seg of segments) {
+    if (seg.startsWith("*")) score += 1;
+    else if (seg.startsWith(":")) score += 10;
+    else score += 100;
+  }
+  return score;
+}
+function rankRoutes(defs) {
+  return [...defs].sort((a, b) => scoreRoute(b) - scoreRoute(a));
+}
+function matchRoutes(routes, pathname) {
+  const path = pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
+  const result = matchInto(routes, path);
+  if (!result) return null;
+  const matched = [];
+  let cumulative = "";
+  const params = {};
+  for (const layer of result.layers) {
+    cumulative = normalizePath(joinMatched(cumulative, layer.consumed));
+    const layerParams = {};
+    for (const [k, v] of Object.entries(layer.params)) {
+      if (!(k in params)) layerParams[k] = v;
+      params[k] = v;
+    }
+    matched.push({
+      route: layer.route,
+      component: layer.route.component,
+      params: layerParams,
+      pathname: cumulative || "/"
+    });
+  }
+  return { matched, params, pathname };
+}
+function matchInto(defs, currentPath) {
+  if (!defs || defs.length === 0) return null;
+  const ranked = rankRoutes(defs);
+  for (const def of ranked) {
+    const hasChildren = !!def.children && def.children.length > 0;
+    const seg = matchPath(def.path, currentPath, !hasChildren);
+    if (!seg) continue;
+    if (hasChildren) {
+      const childMatch = matchInto(def.children, currentPath);
+      if (childMatch) {
+        return {
+          layers: [
+            { route: def, params: seg.params, consumed: seg.path },
+            ...childMatch.layers
+          ]
+        };
+      }
+      continue;
+    }
+    return { layers: [{ route: def, params: seg.params, consumed: seg.path }] };
+  }
+  return null;
+}
+function joinMatched(cumulative, consumed) {
+  if (!cumulative) return consumed;
+  if (consumed === cumulative) return cumulative;
+  if (consumed.startsWith(cumulative)) return consumed;
+  const a = cumulative.replace(/\/$/, "");
+  const b = consumed.replace(/^\//, "");
+  return `${a}/${b}`;
+}
+export {
+  matchPath,
+  matchRoutes,
+  rankRoutes,
+  scoreRoute
+};