vue-micro-router 1.0.1

package/dist/index.mjs

@@ -0,0 +1,1230 @@
+import { markRaw as Ge, shallowReactive as K, computed as C, defineAsyncComponent as ge, reactive as fe, nextTick as J, ref as de, inject as z, watch as j, onMounted as H, onBeforeUnmount as Ae, provide as N, toRefs as Ie, toRef as Ne, defineComponent as ee, openBlock as I, createBlock as U, resolveDynamicComponent as ve, mergeProps as me, Teleport as Be, createElementVNode as Q, normalizeStyle as Re, normalizeClass as le, withModifiers as Oe, renderSlot as he, createElementBlock as q, Fragment as Z, createVNode as De, TransitionGroup as we, withCtx as ae, renderList as ie, unref as Y } from "vue";
+import { c as pe, d as se } from "./timer-manager.mjs";
+const Ee = Symbol("micro-router");
+function lt() {
+  return Symbol("micro-router-nested");
+}
+const ce = Symbol("micro-router-root"), Se = Symbol("micro-route-path"), Le = Symbol("micro-dialog-path"), Me = Symbol("micro-control-name"), te = Symbol("micro-attrs-read"), ne = Symbol("micro-attrs-write"), We = 550;
+function $(e) {
+  return e.startsWith("/") ? e : `/${e}`;
+}
+function T(e) {
+  return e.split("/").filter(Boolean);
+}
+function W(e) {
+  return `/${e.join("/")}`;
+}
+function V(e) {
+  return e.split("/").filter(Boolean).at(-1) ?? "";
+}
+function ye(e) {
+  try {
+    return Ge(e);
+  } catch {
+    return e;
+  }
+}
+function Pe(e) {
+  return typeof e == "function" && !("__name" in e) && !("setup" in e) && !("render" in e);
+}
+async function k(e) {
+  try {
+    await e();
+  } catch {
+  }
+}
+function $e(e, n) {
+  const o = e.defaultControlName, a = e.onboardingControlName, t = 300, c = pe();
+  let l = !1;
+  const r = K(/* @__PURE__ */ new Map()), u = K(
+    /* @__PURE__ */ new Map()
+  ), i = C(() => {
+    const s = [];
+    for (const f of r.values())
+      f.activated && s.push(f);
+    return s;
+  }), d = i, E = C(
+    () => i.value.some((s) => s.name !== o)
+  ), M = C(() => {
+    const s = i.value.find((f) => f.name !== o);
+    return (s == null ? void 0 : s.name) ?? o;
+  });
+  function A(s, f, y) {
+    var D, b, p;
+    if (!(f && l)) {
+      f && (l = !0);
+      try {
+        const h = r.get(s);
+        if (!h) return;
+        const v = r.get(o), w = s === o || s === a;
+        if (f)
+          (D = n == null ? void 0 : n.trackGuiEnter) == null || D.call(n, s), w ? r.forEach((P) => {
+            var L;
+            P.name !== o && P.activated && ((L = n == null ? void 0 : n.trackGuiLeave) == null || L.call(n, P.name), r.set(P.name, {
+              ...P,
+              activated: !1,
+              attrs: void 0
+            }));
+          }) : v != null && v.activated && ((b = n == null ? void 0 : n.trackGuiLeave) == null || b.call(n, o), r.set(o, { ...v, activated: !1 })), y && u.set(s, { ...y }), r.set(s, {
+            ...h,
+            activated: !0,
+            componentKey: (h.componentKey || 0) + 1,
+            attrs: y ? { ...y } : void 0
+          });
+        else {
+          (p = n == null ? void 0 : n.trackGuiLeave) == null || p.call(n, s), u.delete(s), r.set(s, { ...h, activated: !1, attrs: void 0 });
+          const P = r.get(o);
+          if (!w && P && !P.activated) {
+            if (P.name === a) return;
+            r.set(o, { ...P, activated: !0 });
+          }
+        }
+      } finally {
+        f && c.schedule(() => {
+          l = !1;
+        }, t);
+      }
+    }
+  }
+  function _(s) {
+    r.has(s.name) && console.warn(`[vue-micro-router] Control "${s.name}" already registered. Overwriting.`);
+    let { component: f } = s;
+    Pe(f) && (f = ge(f)), r.set(s.name, {
+      ...s,
+      component: ye(f)
+    });
+  }
+  function G(s) {
+    s.forEach(_);
+  }
+  function g(s) {
+    return u.get(s);
+  }
+  function m(s, f) {
+    const y = u.get(s);
+    u.set(s, { ...y, ...f });
+  }
+  return {
+    resolveControls: d,
+    activeControl: E,
+    currentControl: M,
+    toggleControl: A,
+    registerControl: _,
+    registerControls: G,
+    getControlAttrs: g,
+    updateControlAttrs: m,
+    cleanup: c.cleanup
+  };
+}
+const re = "micro-router-inspector", Ke = "micro-router-events";
+async function Ye(e) {
+  if (typeof import.meta < "u") return;
+  let n;
+  try {
+    n = (await import(
+      /* @vite-ignore */
+      "@vue/devtools-api"
+    )).setupDevtoolsPlugin;
+  } catch {
+    return;
+  }
+  n && n(
+    {
+      id: "vue-micro-router",
+      label: "Micro Router",
+      packageName: "vue-micro-router",
+      homepage: "https://github.com/danh121097/vue-micro-router"
+    },
+    (o) => {
+      o.addInspector({
+        id: re,
+        label: "Micro Router",
+        icon: "route"
+      }), o.addTimelineLayer({
+        id: Ke,
+        label: "Micro Router",
+        color: 4372611
+      }), o.on.getInspectorTree((a) => {
+        a.inspectorId === re && (a.rootNodes = [
+          {
+            id: "routes",
+            label: `Routes (${e.resolveRoutes.value.length} active)`,
+            children: e.resolveRoutes.value.map((t) => ({
+              id: `route-${t.path}`,
+              label: t.path
+            }))
+          },
+          {
+            id: "dialogs",
+            label: `Dialogs (${e.resolveDialogs.value.length} open)`,
+            children: e.resolveDialogs.value.map((t) => ({
+              id: `dialog-${t.path}`,
+              label: t.path
+            }))
+          },
+          {
+            id: "controls",
+            label: `Controls (${e.resolveControls.value.length} active)`,
+            children: e.resolveControls.value.map((t) => ({
+              id: `control-${t.name}`,
+              label: t.name
+            }))
+          }
+        ]);
+      }), o.on.getInspectorState((a) => {
+        if (a.inspectorId === re) {
+          if (a.nodeId === "routes")
+            a.state = {
+              Navigation: [
+                { key: "activePath", value: e.activePath.value },
+                { key: "fromPath", value: e.fromPath.value },
+                { key: "toPath", value: e.toPath.value },
+                { key: "activePage", value: e.activePage.value }
+              ]
+            };
+          else if (a.nodeId.startsWith("route-")) {
+            const t = a.nodeId.replace("route-", "");
+            a.state = {
+              Route: [
+                { key: "path", value: t },
+                { key: "attrs", value: e.getRouteAttrs(t) ?? {} }
+              ]
+            };
+          } else if (a.nodeId.startsWith("dialog-")) {
+            const t = a.nodeId.replace("dialog-", "");
+            a.state = {
+              Dialog: [
+                { key: "path", value: t },
+                { key: "attrs", value: e.getDialogAttrs(t) ?? {} }
+              ]
+            };
+          } else if (a.nodeId.startsWith("control-")) {
+            const t = a.nodeId.replace("control-", "");
+            a.state = {
+              Control: [
+                { key: "name", value: t },
+                { key: "attrs", value: e.getControlAttrs(t) ?? {} }
+              ]
+            };
+          }
+        }
+      });
+    }
+  );
+}
+function Xe(e) {
+  const n = e.activePath.value.split("/").filter(Boolean), o = {};
+  for (const r of n) {
+    const u = e.getRouteAttrs(r);
+    u && (o[r] = { ...u });
+  }
+  const a = [], t = {};
+  for (const r of e.resolveDialogs.value) {
+    if (r.closing) continue;
+    a.push(r.path);
+    const u = e.getDialogAttrs(r.path);
+    u && (t[r.path] = { ...u });
+  }
+  const c = [], l = {};
+  for (const r of e.resolveControls.value) {
+    c.push(r.name);
+    const u = e.getControlAttrs(r.name);
+    u && (l[r.name] = { ...u });
+  }
+  return {
+    version: 1,
+    navigation: { activePath: e.activePath.value, routeAttrs: o },
+    dialogs: { stack: a, attrs: t },
+    controls: { active: c, attrs: l }
+  };
+}
+async function Ue(e, n) {
+  if (n.version !== 1) {
+    console.warn("[vue-micro-router] Unknown serialized state version:", n.version);
+    return;
+  }
+  const { activePath: o, routeAttrs: a } = n.navigation;
+  await e.push(o);
+  for (const [t, c] of Object.entries(a))
+    e.updateRouteAttrs(t, c);
+  for (const t of n.dialogs.stack) {
+    const c = n.dialogs.attrs[t];
+    e.openDialog(t, c);
+  }
+  for (const t of n.controls.active) {
+    const c = n.controls.attrs[t];
+    e.toggleControl(t, !0, c);
+  }
+}
+function ze(e) {
+  const o = pe();
+  let a = !1;
+  const t = fe({
+    activeDialog: "",
+    fromDialog: "",
+    toDialog: "",
+    /** Open order stack — last entry = topmost dialog. Used for z-index and focus management. */
+    dialogStack: [],
+    /** Dialog definitions. Re-set on open/close to trigger shallowReactive reactivity. */
+    dialogs: K(/* @__PURE__ */ new Map()),
+    /** Attrs stored separately for useMicroState access inside dialog components */
+    dialogAttrs: K(/* @__PURE__ */ new Map())
+  }), c = C(() => {
+    const g = [];
+    for (const m of t.dialogs.values())
+      (m.activated || m.closing) && g.push(m);
+    return g;
+  }), l = o.schedule;
+  function r(g, m) {
+    return { path: g, attrs: m };
+  }
+  function u({ path: g, open: m, attrs: s }) {
+    const f = t.dialogs.get(g);
+    return f && J(() => {
+      if (m)
+        t.fromDialog = t.activeDialog, t.toDialog = g, t.dialogStack.includes(g) || t.dialogStack.push(g), t.activeDialog = g, s && t.dialogAttrs.set(g, { ...s }), t.dialogs.set(g, {
+          ...f,
+          activated: !0,
+          componentKey: (f.componentKey || 0) + 1,
+          attrs: {
+            path: g,
+            ...s,
+            onClose: () => {
+              d(g), s != null && s.onClose && typeof s.onClose == "function" && s.onClose();
+            }
+          }
+        });
+      else {
+        t.fromDialog = t.activeDialog;
+        const y = t.dialogStack.indexOf(g);
+        y > -1 && t.dialogStack.splice(y, 1), t.activeDialog = t.dialogStack.at(-1) ?? "", t.toDialog = t.activeDialog;
+        const D = f.transitionDuration ?? (f.transition === "slide" ? 500 : 300);
+        t.dialogs.set(g, {
+          ...f,
+          activated: !1,
+          closing: !0,
+          attrs: void 0
+        }), l(() => {
+          const b = t.dialogs.get(g);
+          b && !b.activated && t.dialogs.set(g, { ...b, closing: !1 });
+        }, D + 200);
+      }
+    }), r(g, s);
+  }
+  function i(g, m) {
+    var s;
+    if (a) return r(g, m);
+    a = !0;
+    try {
+      const f = t.activeDialog || "";
+      (s = e == null ? void 0 : e.trackDialogEnter) == null || s.call(e, g, f, g);
+      const y = u({ path: g, open: !0, attrs: m });
+      return l(() => {
+        a = !1;
+      }, 300), y;
+    } catch (f) {
+      throw a = !1, f;
+    }
+  }
+  function d(g) {
+    var m;
+    (m = e == null ? void 0 : e.trackDialogLeave) == null || m.call(e, g, g, ""), t.dialogAttrs.delete(g), u({ path: g, open: !1 });
+  }
+  function E() {
+    const g = [], m = [];
+    t.dialogs.forEach((s, f) => {
+      var y, D;
+      if (s.activated) {
+        (y = e == null ? void 0 : e.trackDialogLeave) == null || y.call(e, f, f, "");
+        const b = (D = s.attrs) == null ? void 0 : D.onClose;
+        typeof b == "function" && m.push(b), t.dialogs.set(f, {
+          ...s,
+          activated: !1,
+          closing: !0,
+          attrs: void 0
+        }), g.push(f);
+      }
+    }), m.forEach((s) => s()), t.dialogAttrs.clear(), t.fromDialog = t.activeDialog, t.toDialog = "", t.activeDialog = "", t.dialogStack = [], l(() => {
+      g.forEach((s) => {
+        const f = t.dialogs.get(s);
+        f && !f.activated && t.dialogs.set(s, { ...f, closing: !1 });
+      });
+    }, 500);
+  }
+  function M(g) {
+    t.dialogs.has(g.path) && console.warn(`[vue-micro-router] Dialog "${g.path}" already registered. Overwriting.`);
+    let { component: m } = g;
+    Pe(m) && (m = ge(m)), t.dialogs.set(g.path, {
+      persistent: !0,
+      ...g,
+      component: ye(m)
+    });
+  }
+  function A(g) {
+    g.forEach(M);
+  }
+  function _(g) {
+    return t.dialogAttrs.get(g);
+  }
+  function G(g, m) {
+    const s = t.dialogAttrs.get(g);
+    t.dialogAttrs.set(g, { ...s, ...m });
+  }
+  return {
+    activeDialog: C(() => t.activeDialog),
+    fromDialog: C(() => t.fromDialog),
+    toDialog: C(() => t.toDialog),
+    resolveDialogs: c,
+    openDialog: i,
+    closeDialog: d,
+    closeAllDialogs: E,
+    registerDialog: M,
+    registerDialogs: A,
+    getDialogAttrs: _,
+    updateDialogAttrs: G,
+    cleanup: o.cleanup
+  };
+}
+const be = 5e3;
+async function ue(e, n, o, a) {
+  let t;
+  try {
+    const c = await Promise.race([
+      Promise.resolve(e(n, o)),
+      new Promise((l, r) => {
+        t = setTimeout(() => r(new Error("Navigation guard timed out")), a);
+      })
+    ]);
+    return clearTimeout(t), c !== !1;
+  } catch {
+    return clearTimeout(t), !1;
+  }
+}
+async function Fe(e, n, o, a = be) {
+  for (const t of e)
+    if (!await ue(t, n, o, a)) return !1;
+  return !0;
+}
+async function Ce(e, n, o, a) {
+  var r;
+  const t = o.guardTimeout ?? be;
+  if ((r = o.beforeEach) != null && r.length && !await Fe(o.beforeEach, e, n, t))
+    return !1;
+  const c = V(e);
+  if (c) {
+    const u = a.getRoute(c);
+    if (u != null && u.beforeEnter && !await ue(u.beforeEnter, e, n, t))
+      return !1;
+  }
+  const l = V(n);
+  if (l) {
+    const u = a.getRoute(l);
+    if (u != null && u.beforeLeave && !await ue(u.beforeLeave, e, n, t))
+      return !1;
+  }
+  return !0;
+}
+function Ve(e, n, o) {
+  if (o != null && o.length)
+    for (const a of o)
+      try {
+        a(e, n);
+      } catch {
+      }
+}
+function je(e, n) {
+  const o = e.maxEntries ?? 50, a = [];
+  let t = -1, c = !1;
+  const l = de(0);
+  function r(g, m) {
+    !e.enabled || c || (t < a.length - 1 && a.splice(t + 1), a.push({ path: g, timestamp: Date.now(), props: m ? { ...m } : void 0 }), t = a.length - 1, a.length > o && (a.shift(), t--), l.value++);
+  }
+  const u = C(() => (l.value, [...a])), i = C(() => (l.value, t > 0)), d = C(() => (l.value, t < a.length - 1));
+  async function E(g) {
+    if (g < 0 || g >= a.length) return;
+    const m = a[g];
+    if (m) {
+      t = g, c = !0, l.value++;
+      try {
+        await n(m.path);
+      } finally {
+        c = !1;
+      }
+    }
+  }
+  async function M() {
+    i.value && await E(t - 1);
+  }
+  async function A() {
+    d.value && await E(t + 1);
+  }
+  async function _(g) {
+    const m = t + g;
+    await E(m);
+  }
+  function G() {
+    a.length = 0, t = -1, l.value++;
+  }
+  return { entries: u, canGoBack: i, canGoForward: d, back: M, forward: A, go: _, clear: G, record: r };
+}
+function He() {
+  const e = K(/* @__PURE__ */ new Map()), n = /* @__PURE__ */ new Map();
+  function o(l) {
+    e.has(l.path) && console.warn(`[vue-micro-router] Route "${l.path}" already registered. Overwriting.`);
+    let { component: r } = l;
+    Pe(r) && (n.set(l.path, r), r = ge(r)), e.set(l.path, {
+      ...l,
+      component: ye(r)
+    }), l.preload === "eager" && n.has(l.path) && k(n.get(l.path));
+  }
+  function a(l) {
+    l.forEach(o);
+  }
+  async function t(l) {
+    const r = n.get(l);
+    r && await k(r);
+  }
+  function c(l) {
+    for (const [r, u] of e.entries())
+      if (u.preload === "adjacent" && !l.includes(r)) {
+        const i = n.get(r);
+        i && k(i);
+      }
+  }
+  return { routes: e, asyncLoaders: n, registerRoute: o, registerRoutes: a, preloadRoute: t, preloadAdjacent: c };
+}
+function xe(e) {
+  const n = e.stepWiseDelay ?? Math.max(e.stepDelay * 1.2, e.stepDelay + 100);
+  async function o(t, c) {
+    if (!t || e.isLocked()) return;
+    const l = $(t);
+    if (e.getActivePath() !== l) {
+      e.lock();
+      try {
+        if (e.runGuards) {
+          const i = $(e.getActivePath());
+          if (!await e.runGuards(l, i)) {
+            e.unlock();
+            return;
+          }
+        }
+        const r = T(e.getActivePath()), u = T(l);
+        if (t.startsWith("/"))
+          for (let i = 0; i < u.length; i++) {
+            const d = W(
+              u.slice(0, i + 1)
+            );
+            if (e.getActivePath() === d) continue;
+            const E = i === u.length - 1;
+            await e.pushCore(d, E ? c : void 0), E || await se(n);
+          }
+        else {
+          const i = u.filter(
+            (d) => !r.includes(d)
+          );
+          if (i.length === 0) {
+            await e.pushCore(t, c), e.scheduleUnlock();
+            return;
+          }
+          for (let d = 0; d < i.length; d++) {
+            const E = d === i.length - 1;
+            await e.pushCore(i[d], E ? c : void 0), E || await se(n);
+          }
+        }
+        e.scheduleUnlock();
+      } catch (r) {
+        throw e.unlock(), r;
+      }
+    }
+  }
+  async function a(t) {
+    if (t < 1 || e.isLocked()) return;
+    const c = T(e.getActivePath()), l = Math.min(t, c.length - 1);
+    if (!(l < 1)) {
+      e.lock();
+      try {
+        if (e.runGuards) {
+          const r = c.slice(0, c.length - l), u = W(r), i = $(e.getActivePath());
+          if (!await e.runGuards(u, i)) {
+            e.unlock();
+            return;
+          }
+        }
+        for (let r = 0; r < l; r++)
+          await e.pushCore(-1), r < l - 1 && await se(n);
+        e.scheduleUnlock();
+      } catch (r) {
+        throw e.unlock(), r;
+      }
+    }
+  }
+  return { stepWisePush: o, stepWiseBack: a };
+}
+function qe(e, n) {
+  const o = e.defaultPath, a = e.stepDelay ?? We, t = e.guards ?? {}, c = e.history ?? {}, l = pe(), r = He();
+  let u = !1;
+  const i = fe({
+    activePath: o,
+    fromPath: o,
+    toPath: o,
+    /** Attrs stored separately — changes here do NOT invalidate resolveRoutes computed */
+    routeAttrs: K(/* @__PURE__ */ new Map()),
+    /** Version stamp per segment — incremented on re-navigation to same segment (forces transition) */
+    routeKeys: K(/* @__PURE__ */ new Map()),
+    /** Component key per segment — incremented to force Vue full remount (resets local state) */
+    componentKeys: K(/* @__PURE__ */ new Map())
+  }), d = /* @__PURE__ */ new Map(), E = C(() => {
+    const p = T(i.activePath), h = [];
+    for (const v of p) {
+      const w = r.routes.get(v);
+      if (!w) continue;
+      const P = i.routeKeys.get(v) || 0, L = i.componentKeys.get(v) || 0, S = `${w.path}-${P}`, R = d.get(v);
+      if (R && R.key === S && R.componentKey === L)
+        h.push(R);
+      else {
+        const B = { ...w, key: S, componentKey: L };
+        d.set(v, B), h.push(B);
+      }
+    }
+    for (const v of d.keys())
+      p.includes(v) || d.delete(v);
+    return h;
+  });
+  function M(p, h) {
+    var B, O;
+    const v = T(i.activePath), w = Math.min(p, v.length - 1);
+    if (w <= 0) return;
+    const P = v.slice(0, -w), L = W(P);
+    v.slice(-w).forEach((F) => {
+      i.routeAttrs.delete(F);
+    });
+    const S = P.at(-1);
+    if (S && h) {
+      const F = i.routeAttrs.get(S);
+      i.routeAttrs.set(S, { ...F, ...h }), i.componentKeys.set(
+        S,
+        (i.componentKeys.get(S) || 0) + 1
+      );
+    }
+    const R = i.activePath;
+    (B = n == null ? void 0 : n.trackPageLeave) == null || B.call(n, R, R, L), i.fromPath = R, i.toPath = L, i.activePath = L, (O = n == null ? void 0 : n.trackPageEnter) == null || O.call(n, L, R, L);
+  }
+  async function A(p, h) {
+    var L, S;
+    const v = $(p), w = T(v);
+    await Promise.all(
+      w.map((R) => r.asyncLoaders.get(R)).filter((R) => !!R).map((R) => k(R))
+    );
+    const P = i.activePath;
+    P !== v && ((L = n == null ? void 0 : n.trackPageLeave) == null || L.call(n, P, P, v)), i.fromPath = P, i.toPath = v, i.activePath = v, h && _(v, h), (S = n == null ? void 0 : n.trackPageEnter) == null || S.call(n, v, P, v);
+  }
+  function _(p, h) {
+    const v = T(p).at(-1);
+    if (!v) return;
+    const w = i.routeAttrs.get(v);
+    i.routeAttrs.set(v, { ...w, ...h });
+  }
+  function G(p, h) {
+    const v = i.routeAttrs.get(p);
+    i.routeAttrs.set(p, { ...v, ...h });
+  }
+  function g(p) {
+    return i.routeAttrs.get(p);
+  }
+  async function m(p, h) {
+    if (!p && p !== 0) return;
+    if (typeof p == "number" && p < 0) {
+      M(Math.abs(p), h);
+      return;
+    }
+    const v = p.toString();
+    if (v.startsWith("/")) {
+      const S = T(v), R = T(i.activePath);
+      if (S.length < R.length && S.every((F, oe) => R[oe] === F)) {
+        if (R.length - S.length === 1)
+          M(1, h);
+        else {
+          const oe = R.slice(0, S.length + 1), _e = W(oe);
+          R.slice(S.length + 1).forEach((Te) => {
+            i.routeAttrs.delete(Te);
+          }), i.activePath = _e, await J(), M(1, h);
+        }
+        return;
+      }
+      const O = S.at(-1);
+      O && R.at(-1) === O && i.routeKeys.set(
+        O,
+        (i.routeKeys.get(O) || 0) + 1
+      ), await A(v, h);
+      return;
+    }
+    const w = T(i.activePath), P = w.indexOf(v);
+    if (P !== -1) {
+      const S = w.length - (P + 1);
+      if (S === 1)
+        M(1, h);
+      else if (S > 1) {
+        const R = w.slice(0, P + 2), B = W(R);
+        w.slice(P + 2).forEach((O) => {
+          i.routeAttrs.delete(O);
+        }), i.activePath = B, await J(), M(1, h);
+      } else
+        i.routeKeys.set(v, (i.routeKeys.get(v) || 0) + 1), await A(
+          W(w.slice(0, P + 1)),
+          h
+        );
+      return;
+    }
+    const L = W([...w, v]);
+    await A(L, h);
+  }
+  function s(p) {
+    if (typeof p == "number" && p < 0) {
+      const P = T(i.activePath), L = Math.min(Math.abs(p), P.length - 1);
+      return L <= 0 ? i.activePath : W(P.slice(0, -L));
+    }
+    const h = p.toString();
+    if (h.startsWith("/")) return $(h);
+    const v = T(i.activePath), w = v.indexOf(h);
+    return W(w !== -1 ? v.slice(0, w + 1) : [...v, h]);
+  }
+  const f = { getRoute: (p) => r.routes.get(p) };
+  async function y(p, h) {
+    var v;
+    if (!u) {
+      u = !0;
+      try {
+        const w = (((v = t.beforeEach) == null ? void 0 : v.length) ?? 0) > 0, P = r.routes.size > 0;
+        if ((w || P) && p) {
+          const R = s(p), B = $(i.activePath);
+          if (!await Ce(R, B, t, f)) {
+            u = !1;
+            return;
+          }
+        }
+        const L = $(i.activePath);
+        await m(p, h);
+        const S = $(i.activePath);
+        D == null || D.record(S, h), Ve(S, L, t.afterEach), r.preloadAdjacent(T(i.activePath)), l.schedule(() => {
+          u = !1;
+        }, a);
+      } catch (w) {
+        throw u = !1, w;
+      }
+    }
+  }
+  const D = c.enabled ? je(c, async (p) => {
+    const h = T(i.activePath), v = T(p);
+    if (v.length < h.length && v.every((P, L) => h[L] === P)) {
+      const P = h.length - v.length;
+      await y(-P);
+    } else
+      await y(p);
+  }) : void 0;
+  D && D.record($(o));
+  const b = xe({
+    getActivePath: () => i.activePath,
+    pushCore: m,
+    runGuards: (p, h) => Ce(p, h, t, f),
+    scheduleUnlock: () => l.schedule(() => {
+      u = !1;
+    }, a),
+    lock: () => {
+      u = !0;
+    },
+    unlock: () => {
+      u = !1;
+    },
+    isLocked: () => u,
+    stepDelay: a
+  });
+  return {
+    activePath: C(() => i.activePath),
+    fromPath: C(() => i.fromPath),
+    toPath: C(() => i.toPath),
+    activePage: C(() => V(i.activePath)),
+    fromPage: C(() => V(i.fromPath)),
+    toPage: C(() => V(i.toPath)),
+    resolveRoutes: E,
+    push: y,
+    stepWisePush: b.stepWisePush,
+    stepWiseBack: b.stepWiseBack,
+    registerRoute: r.registerRoute,
+    registerRoutes: r.registerRoutes,
+    updateRouteAttrs: G,
+    getRouteAttrs: g,
+    preloadRoute: r.preloadRoute,
+    history: D,
+    cleanup: l.cleanup
+  };
+}
+const X = () => {
+};
+function Je(e) {
+  return {
+    trackPageEnter: (e == null ? void 0 : e.trackPageEnter) ?? X,
+    trackPageLeave: (e == null ? void 0 : e.trackPageLeave) ?? X,
+    trackDialogEnter: (e == null ? void 0 : e.trackDialogEnter) ?? X,
+    trackDialogLeave: (e == null ? void 0 : e.trackDialogLeave) ?? X,
+    trackGuiEnter: (e == null ? void 0 : e.trackGuiEnter) ?? X,
+    trackGuiLeave: (e == null ? void 0 : e.trackGuiLeave) ?? X,
+    cleanupAllSessions: (e == null ? void 0 : e.cleanupAllSessions) ?? X
+  };
+}
+function Qe(e) {
+  const n = Je(e.tracker), o = qe(
+    {
+      defaultPath: e.defaultPath,
+      stepDelay: e.stepDelay,
+      guards: e.guards,
+      history: e.history
+    },
+    n
+  ), a = ze(n), t = $e(
+    {
+      defaultControlName: e.defaultControlName,
+      onboardingControlName: e.onboardingControlName
+    },
+    n
+  ), c = {
+    // Navigation
+    activePath: o.activePath,
+    fromPath: o.fromPath,
+    toPath: o.toPath,
+    activePage: o.activePage,
+    fromPage: o.fromPage,
+    toPage: o.toPage,
+    resolveRoutes: o.resolveRoutes,
+    push: o.push,
+    stepWisePush: o.stepWisePush,
+    stepWiseBack: o.stepWiseBack,
+    registerRoute: o.registerRoute,
+    registerRoutes: o.registerRoutes,
+    updateRouteAttrs: o.updateRouteAttrs,
+    getRouteAttrs: o.getRouteAttrs,
+    preloadRoute: o.preloadRoute,
+    // History (conditional — only if enabled)
+    ...o.history ? {
+      canGoBack: o.history.canGoBack,
+      canGoForward: o.history.canGoForward,
+      historyBack: o.history.back,
+      historyForward: o.history.forward,
+      historyGo: o.history.go
+    } : {},
+    // Dialogs
+    activeDialog: a.activeDialog,
+    fromDialog: a.fromDialog,
+    toDialog: a.toDialog,
+    resolveDialogs: a.resolveDialogs,
+    openDialog: a.openDialog,
+    closeDialog: a.closeDialog,
+    closeAllDialogs: a.closeAllDialogs,
+    registerDialog: a.registerDialog,
+    registerDialogs: a.registerDialogs,
+    getDialogAttrs: a.getDialogAttrs,
+    updateDialogAttrs: a.updateDialogAttrs,
+    // Controls
+    resolveControls: t.resolveControls,
+    activeControl: t.activeControl,
+    currentControl: t.currentControl,
+    toggleControl: t.toggleControl,
+    registerControl: t.registerControl,
+    registerControls: t.registerControls,
+    getControlAttrs: t.getControlAttrs,
+    updateControlAttrs: t.updateControlAttrs,
+    // Serialization
+    serialize: () => Xe(c),
+    restore: (u) => Ue(c, u)
+  }, l = V(e.defaultPath);
+  return j(o.activePage, (u, i) => {
+    if (!i) return;
+    const d = t.currentControl.value;
+    i === l && u !== l && n.trackGuiLeave(d), u === l && i !== l && n.trackGuiEnter(d);
+  }), H(async () => {
+    await J(), t.toggleControl(e.defaultControlName, !0), n.trackPageEnter(
+      o.activePath.value,
+      void 0,
+      o.activePath.value
+    ), Ye(c);
+  }), Ae(() => {
+    n.cleanupAllSessions(), o.cleanup(), a.cleanup(), t.cleanup();
+  }), N(Ee, c), z(ce, null) || N(ce, c), c;
+}
+function x(e) {
+  const n = e != null && e.root ? ce : Ee, o = z(n);
+  if (!o)
+    throw new Error(
+      e != null && e.root ? "[vue-micro-router] useMicroRouter({ root: true }) failed — no root <MicroRouterView> found." : "[vue-micro-router] useMicroRouter() must be called inside <MicroRouterView>. Did you forget to wrap your app with <MicroRouterView>?"
+    );
+  return o;
+}
+function ct(e) {
+  const n = z(te), o = z(ne);
+  !n && !e && console.warn(
+    "[vue-micro-router] useMicroState() called without provider and no defaults. Ensure component is inside <RoutePage>, <MicroDialog>, or <MicroControlWrapper>."
+  );
+  const a = (n == null ? void 0 : n()) ?? {}, t = e ? { ...e } : {};
+  for (const r of Object.keys(a))
+    t[r] = a[r];
+  const c = fe(t);
+  o && j(
+    c,
+    (r) => o({ ...r }),
+    { deep: !0, flush: "post" }
+  );
+  const l = Ie(c);
+  return new Proxy(l, {
+    get(r, u, i) {
+      return typeof u == "string" && !(u in r) && (r[u] = Ne(c, u)), Reflect.get(r, u, i);
+    }
+  });
+}
+function ut(e) {
+  const n = z(Se);
+  if (!n) {
+    console.warn(
+      "[vue-micro-router] useRouteLifecycle() must be called inside a route component rendered by <MicroRouterView>."
+    );
+    return;
+  }
+  const { activePage: o } = x();
+  let a = o.value === n;
+  a && H(() => {
+    var t;
+    return (t = e.onRouteEnter) == null ? void 0 : t.call(e);
+  }), j(o, (t) => {
+    var l, r;
+    const c = t === n;
+    c && !a ? (l = e.onRouteEnter) == null || l.call(e) : !c && a && ((r = e.onRouteLeave) == null || r.call(e)), a = c;
+  });
+}
+function gt(e) {
+  const n = z(Le);
+  if (!n) {
+    console.warn(
+      "[vue-micro-router] useDialogLifecycle() must be called inside a dialog component rendered by <MicroDialog>."
+    );
+    return;
+  }
+  const { activeDialog: o } = x();
+  let a = o.value === n;
+  a && H(() => {
+    var t;
+    return (t = e.onDialogEnter) == null ? void 0 : t.call(e);
+  }), j(o, (t) => {
+    var l, r;
+    const c = t === n;
+    c && !a ? (l = e.onDialogEnter) == null || l.call(e) : !c && a && ((r = e.onDialogLeave) == null || r.call(e)), a = c;
+  });
+}
+function ft(e) {
+  const n = z(Me);
+  if (!n) {
+    console.warn(
+      "[vue-micro-router] useControlLifecycle() must be called inside a control component rendered by <MicroControlWrapper>."
+    );
+    return;
+  }
+  const { currentControl: o } = x();
+  let a = o.value === n;
+  a && H(() => {
+    var t;
+    return (t = e.onControlEnter) == null ? void 0 : t.call(e);
+  }), j(o, (t) => {
+    var l, r;
+    const c = t === n;
+    c && !a ? (l = e.onControlEnter) == null || l.call(e) : !c && a && ((r = e.onControlLeave) == null || r.call(e)), a = c;
+  });
+}
+function Ze(e, n) {
+  if (!e.enabled) return;
+  const o = e.edgeWidth ?? 20, a = e.threshold ?? 0.3, t = e.velocityThreshold ?? 0.5;
+  let c = 0, l = 0, r = 0, u = !1, i = null, d = null;
+  function E() {
+    const s = n.containerRef.value;
+    return s ? "$el" in s ? s.$el : s : null;
+  }
+  function M() {
+    const s = E();
+    if (!s) return { current: null, previous: null };
+    const f = s.querySelectorAll(".route-page");
+    return f.length < 2 ? { current: f[f.length - 1] ?? null, previous: null } : {
+      current: f[f.length - 1],
+      previous: f[f.length - 2]
+    };
+  }
+  function A(s) {
+    var b;
+    if (!n.canGoBack() || s.clientX > o) return;
+    const { current: f, previous: y } = M();
+    if (!f) return;
+    u = !0, c = s.clientX, l = s.clientY, r = Date.now(), i = f, d = y;
+    const D = E();
+    (b = D == null ? void 0 : D.setPointerCapture) == null || b.call(D, s.pointerId), i.style.willChange = "transform", d && (d.style.willChange = "transform", d.style.transition = "none"), i.style.transition = "none";
+  }
+  function _(s) {
+    if (!u || !i) return;
+    const f = Math.max(0, s.clientX - c);
+    if (Math.abs(s.clientY - l) > f * 1.5) {
+      g();
+      return;
+    }
+    const D = f / window.innerWidth;
+    if (i.style.transform = `translateX(${f}px)`, d) {
+      const b = -20 + 20 * D;
+      d.style.transform = `translateX(${b}%)`;
+    }
+  }
+  function G(s) {
+    if (!u || !i) return;
+    if (!i.isConnected) {
+      m(), u = !1;
+      return;
+    }
+    const f = s.clientX - c, y = Date.now() - r, D = f / y;
+    f / window.innerWidth > a || D > t ? (i.style.transition = "transform 0.2s ease-out", i.style.transform = "translateX(100%)", d && (d.style.transition = "transform 0.2s ease-out", d.style.transform = "translateX(0)"), setTimeout(() => {
+      m(), n.goBack();
+    }, 200)) : (i.style.transition = "transform 0.2s ease-out", i.style.transform = "translateX(0)", d && (d.style.transition = "transform 0.2s ease-out", d.style.transform = "translateX(-20%)"), setTimeout(m, 200)), u = !1;
+  }
+  function g() {
+    u && (i && (i.style.transition = "transform 0.15s ease-out", i.style.transform = "translateX(0)"), d && (d.style.transition = "transform 0.15s ease-out", d.style.transform = "translateX(-20%)"), setTimeout(m, 150), u = !1);
+  }
+  function m() {
+    i && (i.style.willChange = "", i.style.transition = "", i.style.transform = ""), d && (d.style.willChange = "", d.style.transition = "", d.style.transform = ""), i = null, d = null;
+  }
+  H(() => {
+    const s = E();
+    s != null && s.addEventListener && (s.addEventListener("pointerdown", A, { passive: !0 }), s.addEventListener("pointermove", _, { passive: !0 }), s.addEventListener("pointerup", G, { passive: !0 }), s.addEventListener("pointercancel", g, { passive: !0 }));
+  }), Ae(() => {
+    const s = E();
+    s != null && s.removeEventListener && (s.removeEventListener("pointerdown", A), s.removeEventListener("pointermove", _), s.removeEventListener("pointerup", G), s.removeEventListener("pointercancel", g));
+  });
+}
+function dt(e) {
+  return { ...e };
+}
+function ke(e, n) {
+  var o, a, t;
+  for (const c of e)
+    (o = c.routes) != null && o.length && n.registerRoutes(c.routes), (a = c.dialogs) != null && a.length && n.registerDialogs(c.dialogs), (t = c.controls) != null && t.length && n.registerControls(c.controls);
+}
+const et = /* @__PURE__ */ ee({
+  __name: "MicroControlWrapper",
+  props: {
+    control: {}
+  },
+  setup(e) {
+    const n = e, { getControlAttrs: o, updateControlAttrs: a } = x();
+    return N(Me, n.control.name), N(te, () => o(n.control.name)), N(ne, (t) => {
+      a(n.control.name, t);
+    }), (t, c) => (I(), U(ve(e.control.component), me({
+      key: e.control.componentKey || 0
+    }, e.control.attrs), null, 16));
+  }
+}), tt = /* @__PURE__ */ ee({
+  __name: "MicroDialog",
+  props: {
+    dialog: {},
+    stackIndex: {}
+  },
+  emits: ["close"],
+  setup(e, { emit: n }) {
+    const o = e, a = n, { getDialogAttrs: t, updateDialogAttrs: c } = x(), l = de(null);
+    N(Le, o.dialog.path), N(te, () => t(o.dialog.path)), N(ne, (A) => {
+      c(o.dialog.path, A);
+    });
+    const r = C(() => o.dialog.transition ?? "scale"), u = C(() => o.dialog.transitionDuration != null ? o.dialog.transitionDuration : r.value === "slide" ? 500 : 300), i = C(() => o.dialog.position ?? "standard"), d = C(() => o.dialog.seamless ?? !0);
+    function E(A) {
+      if (o.dialog.persistent) {
+        A.preventDefault();
+        return;
+      }
+      A.preventDefault(), a("close", o.dialog.path);
+    }
+    function M(A) {
+      o.dialog.persistent || A.target === l.value && a("close", o.dialog.path);
+    }
+    return j(
+      () => o.dialog.activated,
+      (A) => {
+        J(() => {
+          l.value && (A && !l.value.open ? l.value.showModal() : !A && l.value.open && l.value.close());
+        });
+      },
+      { immediate: !0 }
+    ), H(() => {
+      o.dialog.activated && l.value && !l.value.open && l.value.showModal();
+    }), (A, _) => (I(), U(Be, { to: "body" }, [
+      Q("dialog", {
+        ref_key: "dialogRef",
+        ref: l,
+        class: le([
+          "micro-dialog",
+          `micro-dialog--${i.value}`,
+          e.dialog.fullscreen && "micro-dialog--fullscreen",
+          d.value && "micro-dialog--seamless",
+          `dialog-transition-${r.value}`,
+          e.dialog.closing && "micro-dialog--closing"
+        ]),
+        style: Re({
+          "--dialog-duration": `${u.value}ms`,
+          zIndex: 100 + e.stackIndex
+        }),
+        onCancel: E,
+        onClick: M
+      }, [
+        Q("div", {
+          class: "micro-dialog__content",
+          onClick: _[0] || (_[0] = Oe(() => {
+          }, ["stop"]))
+        }, [
+          he(A.$slots, "default"),
+          (I(), U(ve(e.dialog.component), me({
+            key: e.dialog.componentKey
+          }, e.dialog.attrs), null, 16))
+        ])
+      ], 38)
+    ]));
+  }
+}), nt = { class: "route-page" }, ot = { class: "route-page__body" }, at = /* @__PURE__ */ ee({
+  __name: "RoutePage",
+  props: {
+    routePath: {}
+  },
+  setup(e) {
+    const n = e;
+    if (n.routePath) {
+      const o = n.routePath;
+      N(Se, o);
+      const { updateRouteAttrs: a, getRouteAttrs: t } = x();
+      N(te, () => t(o)), N(ne, (c) => {
+        a(o, c);
+      });
+    }
+    return (o, a) => (I(), q("div", nt, [
+      Q("div", ot, [
+        he(o.$slots, "default")
+      ])
+    ]));
+  }
+}), it = { class: "micro-router-content-layer" }, vt = /* @__PURE__ */ ee({
+  __name: "MicroRouterView",
+  props: {
+    config: {},
+    plugins: {},
+    nested: { type: Boolean }
+  },
+  setup(e) {
+    var g, m;
+    const n = e, o = Qe(n.config);
+    (g = n.plugins) != null && g.length && ke(n.plugins, o);
+    const {
+      resolveRoutes: a,
+      resolveDialogs: t,
+      resolveControls: c,
+      fromPath: l,
+      toPath: r,
+      closeDialog: u
+    } = o, i = de(null), d = C(() => {
+      const s = l.value.split("/").filter(Boolean), f = r.value.split("/").filter(Boolean);
+      return s.some((y) => f.includes(y));
+    }), E = C(() => c.value.length > 0), M = C(() => {
+      const s = a.value.at(-1);
+      return (s == null ? void 0 : s.transition) ?? "slide";
+    }), A = C(() => M.value === "none" ? "" : M.value === "fade" ? "page-fade" : "page-slide"), _ = C(() => {
+      const s = a.value.at(-1);
+      return s != null && s.transitionDuration ? s.transitionDuration : M.value === "fade" ? 300 : 500;
+    }), G = C(() => d.value && M.value !== "none");
+    return (m = n.config.gesture) != null && m.enabled && Ze(n.config.gesture, {
+      containerRef: i,
+      goBack: () => o.push(-1),
+      canGoBack: () => a.value.length > 1
+    }), (s, f) => (I(), q(Z, null, [
+      De(we, {
+        ref_key: "pageContainerRef",
+        ref: i,
+        name: A.value,
+        css: G.value
+      }, {
+        default: ae(() => [
+          (I(!0), q(Z, null, ie(Y(a), (y, D) => (I(), U(at, {
+            key: y.key || y.path,
+            "route-path": y.path,
+            class: le({
+              deactive: Y(a).length > 1 && D !== Y(a).length - 1
+            }),
+            style: Re({
+              transition: G.value ? `transform ${_.value}ms cubic-bezier(0.65, 0, 0.35, 1), opacity ${_.value}ms ease` : "none",
+              zIndex: D,
+              "--mr-page-height": e.nested ? "100%" : "100dvh"
+            })
+          }, {
+            default: ae(() => [
+              (I(), U(ve(y.component), me({
+                key: y.componentKey
+              }, { ref_for: !0 }, Y(o).getRouteAttrs(y.path)), null, 16))
+            ]),
+            _: 2
+          }, 1032, ["route-path", "class", "style"]))), 128))
+        ]),
+        _: 1
+      }, 8, ["name", "css"]),
+      Q("div", it, [
+        he(s.$slots, "default")
+      ]),
+      Q("div", {
+        class: le(["micro-router-gui-layer", { "gui-visible": E.value }])
+      }, [
+        De(we, { name: "control-fade" }, {
+          default: ae(() => [
+            (I(!0), q(Z, null, ie(Y(c), (y) => (I(), U(et, {
+              key: y.name + "-" + (y.componentKey || 0),
+              control: y
+            }, null, 8, ["control"]))), 128))
+          ]),
+          _: 1
+        })
+      ], 2),
+      (I(!0), q(Z, null, ie(Y(t), (y, D) => (I(), U(tt, {
+        key: "dialog-" + y.path,
+        dialog: y,
+        "stack-index": D,
+        onClose: Y(u)
+      }, null, 8, ["dialog", "stack-index", "onClose"]))), 128))
+    ], 64));
+  }
+});
+export {
+  te as MICRO_ATTRS_READ_KEY,
+  ne as MICRO_ATTRS_WRITE_KEY,
+  Me as MICRO_CONTROL_NAME_KEY,
+  Le as MICRO_DIALOG_PATH_KEY,
+  Ee as MICRO_ROUTER_KEY,
+  ce as MICRO_ROUTER_ROOT_KEY,
+  Se as MICRO_ROUTE_PATH_KEY,
+  et as MicroControlWrapper,
+  tt as MicroDialogComponent,
+  vt as MicroRouterView,
+  at as RoutePage,
+  We as STEP_DELAY,
+  W as buildPathFromSegments,
+  lt as createRouterKey,
+  dt as defineFeaturePlugin,
+  V as getLastSegment,
+  Pe as isAsyncLoader,
+  $ as normalizePath,
+  T as parsePathSegments,
+  ke as registerFeaturePlugins,
+  ye as safeMarkRaw,
+  ft as useControlLifecycle,
+  $e as useControlManager,
+  gt as useDialogLifecycle,
+  ze as useDialogManager,
+  Ze as useGestureNavigation,
+  Qe as useGlobalMicroRouter,
+  x as useMicroRouter,
+  ct as useMicroState,
+  qe as useNavigation,
+  Je as usePageTracker,
+  ut as useRouteLifecycle
+};