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

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Fluixi
+Copyright (c) 2026 Ibrahima Touré
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -17,7 +17,7 @@
 
 `@fluixi/router` is the routing **core** — pure state and a `subscribe` API, with **no
 reactivity, no DOM, no view framework**. View adapters (the Fluixi adapter lives in
-[`@fluixi/core/router-next`](../core)) render the match tree **top-down**, which makes
+[`@fluixi/core/router`](../core)) render the match tree **top-down**, which makes
 deeply nested layout/outlet rendering work by construction. See [DESIGN.md](./DESIGN.md).
 
 ## 📦 Installation

package/dist/index.cjs

@@ -0,0 +1,299 @@
+/*! @fluixi/router v0.1.2-alpha.5 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createBrowserHistory: () => createBrowserHistory,
+  createMemoryHistory: () => createMemoryHistory,
+  createRouter: () => createRouter,
+  matchPath: () => matchPath,
+  matchRoutes: () => matchRoutes,
+  rankRoutes: () => rankRoutes,
+  scoreRoute: () => scoreRoute,
+  splitPath: () => splitPath
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/match.ts
+function normalizePath(p) {
+  return p.startsWith("//") ? p.replace(/^\/+/, "/") : p;
+}
+function matchPath(pattern, path, exact = false) {
+  const keys2 = [];
+  if (pattern === path) return { params: {}, path };
+  if (!exact && pattern === "/" && path.startsWith("/"))
+    return { params: {}, path: "/" };
+  let regexStr = pattern.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+    keys2.push(key);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]*)/g, (_, name) => {
+    if (name) keys2.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 = {};
+  keys2.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}`;
+}
+
+// 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);
+    }
+  };
+}
+
+// src/lib/router.ts
+function parseQuery(search) {
+  const q = {};
+  if (search) {
+    const usp = new URLSearchParams(
+      search.startsWith("?") ? search.slice(1) : search
+    );
+    usp.forEach((v, k) => q[k] = v);
+  }
+  return q;
+}
+function stripBase(pathname, base) {
+  if (!base) return pathname || "/";
+  const b = base.replace(/\/$/, "");
+  if (pathname === b) return "/";
+  if (pathname.startsWith(b + "/")) return pathname.slice(b.length) || "/";
+  return pathname || "/";
+}
+function withBase(to, base) {
+  if (!base) return to;
+  if (/^https?:\/\//.test(to)) return to;
+  const b = base.replace(/\/$/, "");
+  return `${b}${to.startsWith("/") ? to : "/" + to}`;
+}
+function createRouter(config) {
+  const { routes, history, base } = config;
+  const listeners = /* @__PURE__ */ new Set();
+  const readLocation = () => {
+    const raw = history.get();
+    return {
+      pathname: raw.pathname,
+      search: raw.search,
+      hash: raw.hash,
+      state: raw.state,
+      query: parseQuery(raw.search),
+      ...raw.key !== void 0 ? { key: raw.key } : {},
+      ...raw.action !== void 0 ? { action: raw.action } : {}
+    };
+  };
+  const computeMatch = (pathname) => matchRoutes(routes, stripBase(pathname, base));
+  let current = (() => {
+    const location = readLocation();
+    return { location, match: computeMatch(location.pathname) };
+  })();
+  const recompute = () => {
+    const location = readLocation();
+    current = { location, match: computeMatch(location.pathname) };
+    listeners.forEach((l) => l(current));
+  };
+  const unsubscribeHistory = history.subscribe(recompute);
+  return {
+    state() {
+      return current;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    navigate(to, options = {}) {
+      const target = withBase(to, base);
+      if (options.replace) history.replace(target, options.state ?? null);
+      else history.push(target, options.state ?? null);
+    },
+    match(pathname) {
+      return computeMatch(pathname);
+    },
+    destroy() {
+      unsubscribeHistory();
+      listeners.clear();
+    }
+  };
+}

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 /**
- * @fluixi/router — framework-agnostic router core.
+ * @fluixi/router: framework-agnostic router core.
  *
  * Routing as pure state: URL → resolved match tree + navigation. No reactivity,
  * no DOM, no view framework. View adapters subscribe and render the match tree
  * top-down (see DESIGN.md).
  */
-export type { RouteDefinition, MatchedRoute, RouteMatch, RouterLocation, NavigateOptions, RouterState, HistoryAdapter, Router, RouterConfig, RouteData, } from './lib/types.js';
+export type { RouteDefinition, MatchedRoute, RouteMatch, RouterLocation, HistoryAction, NavigateOptions, RouterState, HistoryAdapter, Router, RouterConfig, RouteData, } from './lib/types.js';
 export { matchRoutes, matchPath, scoreRoute, rankRoutes } from './lib/match.js';
 export { createMemoryHistory, createBrowserHistory, splitPath, } from './lib/history.js';
 export { createRouter } from './lib/router.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY,EACV,eAAe,EACf,YAAY,EACZ,UAAU,EACV,cAAc,EACd,eAAe,EACf,WAAW,EACX,cAAc,EACd,MAAM,EACN,YAAY,EACZ,SAAS,GACV,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAChF,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,SAAS,GACV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY,EACV,eAAe,EACf,YAAY,EACZ,UAAU,EACV,cAAc,EACd,aAAa,EACb,eAAe,EACf,WAAW,EACX,cAAc,EACd,MAAM,EACN,YAAY,EACZ,SAAS,GACV,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAChF,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,SAAS,GACV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @fluixi/router — framework-agnostic router core.
+ * @fluixi/router: framework-agnostic router core.
  *
  * Routing as pure state: URL → resolved match tree + navigation. No reactivity,
  * no DOM, no view framework. View adapters subscribe and render the match tree

package/dist/index.mjs

@@ -0,0 +1,277 @@
+/*! @fluixi/router v0.1.2-alpha.5 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/lib/match.ts
+function normalizePath(p) {
+  return p.startsWith("//") ? p.replace(/^\/+/, "/") : p;
+}
+function matchPath(pattern, path, exact = false) {
+  const keys2 = [];
+  if (pattern === path) return { params: {}, path };
+  if (!exact && pattern === "/" && path.startsWith("/"))
+    return { params: {}, path: "/" };
+  let regexStr = pattern.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+    keys2.push(key);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]*)/g, (_, name) => {
+    if (name) keys2.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 = {};
+  keys2.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}`;
+}
+
+// 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);
+    }
+  };
+}
+
+// src/lib/router.ts
+function parseQuery(search) {
+  const q = {};
+  if (search) {
+    const usp = new URLSearchParams(
+      search.startsWith("?") ? search.slice(1) : search
+    );
+    usp.forEach((v, k) => q[k] = v);
+  }
+  return q;
+}
+function stripBase(pathname, base) {
+  if (!base) return pathname || "/";
+  const b = base.replace(/\/$/, "");
+  if (pathname === b) return "/";
+  if (pathname.startsWith(b + "/")) return pathname.slice(b.length) || "/";
+  return pathname || "/";
+}
+function withBase(to, base) {
+  if (!base) return to;
+  if (/^https?:\/\//.test(to)) return to;
+  const b = base.replace(/\/$/, "");
+  return `${b}${to.startsWith("/") ? to : "/" + to}`;
+}
+function createRouter(config) {
+  const { routes, history, base } = config;
+  const listeners = /* @__PURE__ */ new Set();
+  const readLocation = () => {
+    const raw = history.get();
+    return {
+      pathname: raw.pathname,
+      search: raw.search,
+      hash: raw.hash,
+      state: raw.state,
+      query: parseQuery(raw.search),
+      ...raw.key !== void 0 ? { key: raw.key } : {},
+      ...raw.action !== void 0 ? { action: raw.action } : {}
+    };
+  };
+  const computeMatch = (pathname) => matchRoutes(routes, stripBase(pathname, base));
+  let current = (() => {
+    const location = readLocation();
+    return { location, match: computeMatch(location.pathname) };
+  })();
+  const recompute = () => {
+    const location = readLocation();
+    current = { location, match: computeMatch(location.pathname) };
+    listeners.forEach((l) => l(current));
+  };
+  const unsubscribeHistory = history.subscribe(recompute);
+  return {
+    state() {
+      return current;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    navigate(to, options = {}) {
+      const target = withBase(to, base);
+      if (options.replace) history.replace(target, options.state ?? null);
+      else history.push(target, options.state ?? null);
+    },
+    match(pathname) {
+      return computeMatch(pathname);
+    },
+    destroy() {
+      unsubscribeHistory();
+      listeners.clear();
+    }
+  };
+}
+export {
+  createBrowserHistory,
+  createMemoryHistory,
+  createRouter,
+  matchPath,
+  matchRoutes,
+  rankRoutes,
+  scoreRoute,
+  splitPath
+};