@multiplatform.one/router 6.1.0 → 6.3.0

package/dist/cjs/seam/index.native.js

@@ -0,0 +1,50 @@
+"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);
+var seam_exports = {};
+__export(seam_exports, {
+  DomNavigationHost: () => import_DomNavigationHost.DomNavigationHost,
+  DomStackAdapter: () => import_DomNavigationHost.DomStackAdapter,
+  Link: () => import_oneAdapter.Link,
+  LoadProgressBar: () => import_oneAdapter.LoadProgressBar,
+  RouteTagContext: () => import_navigator.RouteTagContext,
+  Slot: () => import_oneAdapter.Slot,
+  StackNavigator: () => import_navigator.StackNavigator,
+  hrefToString: () => import_navigator.hrefToString,
+  stackNavigator: () => import_navigator.stackNavigator,
+  useBlocker: () => import_oneAdapter.useBlocker,
+  useLoader: () => import_oneAdapter.useLoader,
+  useLocalSearchParams: () => import_oneAdapter.useLocalSearchParams,
+  useMatches: () => import_oneAdapter.useMatches,
+  useNavState: () => import_navigator.useNavState,
+  useParams: () => import_oneAdapter.useParams,
+  usePathname: () => import_oneAdapter.usePathname,
+  useRouteParams: () => import_navigator.useRouteParams,
+  useRouter: () => import_oneAdapter.useRouter
+});
+module.exports = __toCommonJS(seam_exports);
+var import_navigator = require("./navigator.native.js");
+var import_DomNavigationHost = require("./DomNavigationHost.native.js");
+var import_oneAdapter = require("./oneAdapter.native.js");
+//# sourceMappingURL=index.native.js.map

package/dist/cjs/seam/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","seam_exports","__export","DomNavigationHost","import_DomNavigationHost","DomStackAdapter","Link","import_oneAdapter","LoadProgressBar","RouteTagContext","import_navigator","Slot","StackNavigator","hrefToString","stackNavigator","useBlocker","useLoader","useLocalSearchParams","useMatches","useNavState","useParams","usePathname","useRouteParams","useRouter","module","exports","require"],"sources":["../../../src/seam/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,YAAA;AAAAC,QAAA,CAAAD,YAAA;EAAAE,iBAAA,EAAAA,CAAA,KAAAC,wBAAA,CAAAD,iBAAA;EAAAE,eAAA,EAAAA,CAAA,KAAAD,wBAAA,CAAAC,eAAA;EAAAC,IAAA,EAAAA,CAAA,KAAAC,iBAAA,CAAAD,IAAA;EAAAE,eAAA,EAAAA,CAAA,KAAAD,iBAAA,CAAAC,eAAA;EAAAC,eAAA,EAAAA,CAAA,KAAAC,gBAAA,CAAAD,eAAA;EAAAE,IAAA,EAAAA,CAAA,KAAAJ,iBAAA,CAAAI,IAAA;EAAAC,cAAA,EAAAA,CAAA,KAAAF,gBAAA,CAAAE,cAAA;EAAAC,YAAA,EAAAA,CAAA,KAAAH,gBAAA,CAAAG,YAAA;EAAAC,cAAA,EAAAA,CAAA,KAAAJ,gBAAA,CAAAI,cAAA;EAAAC,UAAA,EAAAA,CAAA,KAAAR,iBAAA,CAAAQ,UAAA;EAAAC,SAAA,EAAAA,CAAA,KAAAT,iBAAA,CAAAS,SAAA;EAAAC,oBAAA,EAAAA,CAAA,KAAAV,iBAAA,CAAAU,oBAAA;EAAAC,UAAA,EAAAA,CAAA,KAAAX,iBAAA,CAAAW,UAAA;EAAAC,WAAA,EAAAA,CAAA,KAAAT,gBAAA,CAAAS,WAAA;EAAAC,SAAA,EAAAA,CAAA,KAAAb,iBAAA,CAAAa,SAAA;EAAAC,WAAA,EAAAA,CAAA,KAAAd,iBAAA,CAAAc,WAAA;EAAAC,cAAA,EAAAA,CAAA,KAAAZ,gBAAA,CAAAY,cAAA;EAAAC,SAAA,EAAAA,CAAA,KAAAhB,iBAAA,CAAAgB;AAAA;AASAC,MAAA,CAAAC,OAAA,GAAA7B,YAOO,CAAAK,YAAA;AAUP,IAAAS,gBAAA,GAAAgB,OAAA,CAAmD;AAEnD,IAAAtB,wBAWO,GAAAsB,OAAA","ignoreList":[]}

package/dist/cjs/seam/navigator.cjs

@@ -0,0 +1,309 @@
+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);
+var navigator_exports = {};
+__export(navigator_exports, {
+  RouteTagContext: () => RouteTagContext,
+  StackNavigator: () => StackNavigator,
+  hrefToString: () => hrefToString,
+  stackNavigator: () => stackNavigator,
+  useNavState: () => useNavState,
+  useRouteParams: () => useRouteParams
+});
+module.exports = __toCommonJS(navigator_exports);
+var import_react = require("react");
+function compileRoute(def) {
+  const segments = def.pattern.split("/").filter(Boolean).map(seg => {
+    const m = seg.match(/^\[(\.{3})?(.+)\]$/);
+    return m ? {
+      param: m[2]
+    } : {
+      literal: seg
+    };
+  });
+  return {
+    ...def,
+    segments
+  };
+}
+function parseQuery(query) {
+  const params = {};
+  if (!query) return params;
+  for (const pair of query.split("&")) {
+    if (!pair) continue;
+    const eq = pair.indexOf("=");
+    const key = decodeURIComponent(eq === -1 ? pair : pair.slice(0, eq));
+    const value = eq === -1 ? "" : decodeURIComponent(pair.slice(eq + 1));
+    const prev = params[key];
+    if (prev === void 0) params[key] = value;else if (Array.isArray(prev)) prev.push(value);else params[key] = [prev, value];
+  }
+  return params;
+}
+function hrefToString(href) {
+  if (typeof href === "string") return href;
+  let path = href.pathname;
+  const leftover = [];
+  for (const [key, raw] of Object.entries(href.params ?? {})) {
+    const value = String(raw);
+    const token = `[${key}]`;
+    if (path.includes(token)) path = path.replace(token, encodeURIComponent(value));else leftover.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+  }
+  return leftover.length ? `${path}?${leftover.join("&")}` : path;
+}
+const EMPTY_PARAMS = Object.freeze({});
+class StackNavigator {
+  routes = [];
+  host = null;
+  listeners = /* @__PURE__ */new Set();
+  /** Stack mirror rebuilt from the host on every pushed/popped/replaced
+   *  signal. */
+  stackTags = [];
+  paramsByTag = /* @__PURE__ */new Map();
+  pathnameByTag = /* @__PURE__ */new Map();
+  /** Tags whose page content has been navigated to at least once. The host
+   *  gates each page's React content on this (lazy mounting) — a tag enters
+   *  the set right before its first host push and never leaves (backgrounded
+   *  pages stay alive, same as One keeping stack screens mounted). */
+  visitedTags = /* @__PURE__ */new Set();
+  /** Route-loader results, per tag (the loader bridge's store). */
+  loaderDataByTag = /* @__PURE__ */new Map();
+  /** Monotonic navigation sequence — a loader that resolves after a NEWER
+   *  navigation started must not perform its (stale) host action. */
+  navSeq = 0;
+  generation = 0;
+  snapshot = {
+    pathname: "/",
+    tag: "",
+    depth: 0,
+    canGoBack: false,
+    generation: 0
+  };
+  get isConfigured() {
+    return this.routes.length > 0;
+  }
+  /** Register the route manifest. The FIRST route is the root page. */
+  configure(defs) {
+    this.routes = defs.map(compileRoute);
+    this.visitedTags = /* @__PURE__ */new Set();
+    this.loaderDataByTag = /* @__PURE__ */new Map();
+    const root = defs[0];
+    if (root) {
+      this.stackTags = [root.tag];
+      this.visitedTags.add(root.tag);
+      this.pathnameByTag.set(root.tag, root.pattern);
+      this.rebuildSnapshot();
+    }
+  }
+  /** Has this route's page been navigated to (⇒ its content may mount)? */
+  isVisited(tag) {
+    return tag !== null && this.visitedTags.has(tag);
+  }
+  /** The route's last loader result (stable identity until the loader runs
+   *  again). undefined when the route has no loader / hasn't resolved. */
+  loaderSnapshot(tag) {
+    if (!tag) return void 0;
+    return this.loaderDataByTag.get(tag);
+  }
+  /** Resolve a route's loader WITHOUT navigating. For the initial page:
+   *  entries can `await stackNavigator.preload("/")` during top-level await
+   *  (where GJS reliably drains promise jobs) so even the root page's first
+   *  paint has loader data. */
+  async preload(href) {
+    const hit = this.match(href);
+    if (!hit?.route.loader) return;
+    try {
+      const data = await hit.route.loader({
+        path: hit.pathname,
+        params: hit.params
+      });
+      this.loaderDataByTag.set(hit.route.tag, data);
+      this.rebuildSnapshot();
+    } catch (err) {
+      console.error(`[stack nav] preload loader for ${hit.route.tag} failed: ${String(err)}`);
+    }
+  }
+  /** Bind the live host stack (an Adw.NavigationView widget on GTK, a
+   *  DomStackAdapter on DOM targets). */
+  attach(host) {
+    this.host = host;
+    this.syncFromHost();
+  }
+  detach() {
+    this.host = null;
+  }
+  subscribe = fn => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+  getSnapshot = () => this.snapshot;
+  paramsSnapshot(tag) {
+    if (!tag) return EMPTY_PARAMS;
+    return this.paramsByTag.get(tag) ?? EMPTY_PARAMS;
+  }
+  match(href) {
+    const str = hrefToString(href);
+    const [path = "", query] = str.split("?");
+    const parts = path.split("/").filter(Boolean);
+    for (const route of this.routes) {
+      if (route.segments.length !== parts.length) continue;
+      const params = parseQuery(query);
+      let ok = true;
+      for (let i = 0; i < parts.length; i++) {
+        const seg = route.segments[i];
+        const part = decodeURIComponent(parts[i]);
+        if (seg.literal !== void 0) {
+          if (seg.literal !== part) {
+            ok = false;
+            break;
+          }
+        } else if (seg.param !== void 0) {
+          params[seg.param] = part;
+        }
+      }
+      if (ok) return {
+        route,
+        pathname: path === "" ? "/" : `/${parts.join("/")}`,
+        params
+      };
+    }
+    return null;
+  }
+  push = href => {
+    void this.navigate(href, "push");
+  };
+  replace = href => {
+    void this.navigate(href, "replace");
+  };
+  /** Shared push/replace flow, incl. the loader bridge. When the target
+   *  route has no loader the whole body runs SYNCHRONOUSLY (an async
+   *  function only yields at its first await), preserving the original
+   *  timing. With a loader, the host action waits for the loader to resolve
+   *  — same contract as One on web, where client navigation completes only
+   *  after the route's loader data arrived — so the page's first paint has
+   *  its data (and the lazily-mounted content mounts with it). */
+  async navigate(href, mode) {
+    const hit = this.match(href);
+    if (!hit) {
+      console.log(`[stack nav] ${mode} ${hrefToString(href)} \u2014 no page in the route manifest, ignored`);
+      return;
+    }
+    if (!this.host) {
+      console.log(`[stack nav] ${mode} ${hrefToString(href)} \u2014 no stack host attached, ignored`);
+      return;
+    }
+    const {
+      route,
+      pathname,
+      params
+    } = hit;
+    const seq = ++this.navSeq;
+    if (route.loader) {
+      try {
+        const data = await route.loader({
+          path: pathname,
+          params
+        });
+        if (seq !== this.navSeq) return;
+        this.loaderDataByTag.set(route.tag, data);
+      } catch (err) {
+        if (seq !== this.navSeq) return;
+        console.error(`[stack nav] loader for ${route.tag} failed: ${String(err)}`);
+      }
+    }
+    this.visitedTags.add(route.tag);
+    this.setRouteState(route.tag, pathname, params);
+    if (mode === "replace") {
+      const top = this.stackTags[this.stackTags.length - 1];
+      if (top === route.tag) return;
+      const tags = [...this.stackTags.slice(0, -1), route.tag];
+      this.host.replace_with_tags(tags);
+      return;
+    }
+    const idx = this.stackTags.indexOf(route.tag);
+    if (idx === -1) {
+      this.host.push_by_tag(route.tag);
+    } else if (idx < this.stackTags.length - 1) {
+      this.host.pop_to_tag(route.tag);
+    }
+  }
+  back = () => {
+    if (!this.host) {
+      console.log("[stack nav] back \u2014 no stack host attached, ignored");
+      return;
+    }
+    this.navSeq++;
+    this.host.pop();
+  };
+  setParams = params => {
+    const top = this.stackTags[this.stackTags.length - 1];
+    if (!top) return;
+    const prev = this.paramsByTag.get(top) ?? {};
+    this.paramsByTag.set(top, {
+      ...prev,
+      ...params
+    });
+    this.rebuildSnapshot();
+  };
+  /** Re-read the host navigation stack (called from pushed/popped/replaced
+   *  signal handlers and attach). The host is the source of truth. */
+  syncFromHost = () => {
+    if (!this.host) return;
+    this.navSeq++;
+    const model = this.host.get_navigation_stack();
+    const tags = [];
+    const count = model.get_n_items();
+    for (let i = 0; i < count; i++) {
+      const tag = model.get_item(i)?.get_tag();
+      if (tag) tags.push(tag);
+    }
+    if (tags.length > 0) this.stackTags = tags;
+    for (const tag of this.stackTags) this.visitedTags.add(tag);
+    this.rebuildSnapshot();
+  };
+  setRouteState(tag, pathname, params) {
+    this.paramsByTag.set(tag, params);
+    this.pathnameByTag.set(tag, pathname);
+    this.rebuildSnapshot();
+  }
+  rebuildSnapshot() {
+    const tag = this.stackTags[this.stackTags.length - 1] ?? "";
+    const route = this.routes.find(r => r.tag === tag);
+    this.generation++;
+    this.snapshot = {
+      pathname: this.pathnameByTag.get(tag) ?? route?.pattern ?? "/",
+      tag,
+      depth: this.stackTags.length,
+      canGoBack: this.stackTags.length > 1,
+      generation: this.generation
+    };
+    for (const fn of this.listeners) fn();
+  }
+}
+const stackNavigator = new StackNavigator();
+const RouteTagContext = (0, import_react.createContext)(null);
+function useNavState() {
+  return (0, import_react.useSyncExternalStore)(stackNavigator.subscribe, stackNavigator.getSnapshot);
+}
+function useRouteParams() {
+  const tag = (0, import_react.useContext)(RouteTagContext);
+  return (0, import_react.useSyncExternalStore)(stackNavigator.subscribe, () => stackNavigator.paramsSnapshot(tag));
+}