@wow-two-beta/ui-vue 0.0.2

package/dist/router/index.js

@@ -0,0 +1,711 @@
+import { RouterLink, useRoute, routerKey, createRouter, createMemoryHistory, createWebHashHistory, createWebHistory, useRouter, useLink } from "vue-router";
+import { defineComponent, openBlock, createElementBlock, createElementVNode, createVNode, unref, withCtx, createTextVNode, computed, toValue, inject, shallowRef, onMounted, watch, toDisplayString, onErrorCaptured, onScopeDispose, renderSlot, createBlock, resolveDynamicComponent, createCommentVNode, useAttrs, mergeProps, Fragment, createSlots } from "vue";
+import { a as useOptionalNavigationProgress, p as provideNavigationProgress } from "../chunks/UseNavigationProgress-TQIkkXyU.js";
+import { N, c, u } from "../chunks/UseNavigationProgress-TQIkkXyU.js";
+import { c as cn } from "../chunks/cn-CzDCF-Ah.js";
+import { _ as _sfc_main$6 } from "../chunks/NavItem.vue_vue_type_script_setup_true_lang-CGBo2TiV.js";
+function toHandle(meta) {
+  return meta ?? void 0;
+}
+function deepestHandleValue(route, read) {
+  for (let index = route.matched.length - 1; index >= 0; index -= 1) {
+    const handle = toHandle(route.matched[index]?.meta);
+    const value = handle ? read(handle) : void 0;
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+const ParamPattern$1 = /:([A-Za-z0-9_]+)(?:\([^)]*\))?[?*+]?/g;
+function resolveMatchedPath(pattern, params) {
+  return pattern.replace(ParamPattern$1, (match, name) => {
+    const value = params[name];
+    if (value === void 0) return match;
+    return Array.isArray(value) ? value.map(encodeURIComponent).join("/") : encodeURIComponent(value);
+  });
+}
+const MetaTagName = "meta";
+const NameAttribute = "name";
+const ContentAttribute = "content";
+const DescriptionName = "description";
+function setMetaTag(name, content) {
+  let tag = document.head.querySelector(`${MetaTagName}[${NameAttribute}="${name}"]`);
+  if (content == null) {
+    tag?.removeAttribute(ContentAttribute);
+    return;
+  }
+  if (!tag) {
+    tag = document.createElement(MetaTagName);
+    tag.setAttribute(NameAttribute, name);
+    document.head.appendChild(tag);
+  }
+  tag.setAttribute(ContentAttribute, content);
+}
+function installDocumentMeta(router) {
+  if (typeof document === "undefined") return () => {
+  };
+  let managedNames = /* @__PURE__ */ new Set();
+  return router.afterEach((to) => {
+    const meta = deepestHandleValue(to, (handle) => handle.meta);
+    const nextNames = /* @__PURE__ */ new Set([DescriptionName, ...Object.keys(meta ?? {})]);
+    for (const name of managedNames) {
+      if (!nextNames.has(name)) setMetaTag(name, void 0);
+    }
+    managedNames = nextNames;
+    setMetaTag(DescriptionName, meta?.description);
+    for (const [name, content] of Object.entries(meta ?? {})) {
+      if (name !== DescriptionName) setMetaTag(name, content);
+    }
+  });
+}
+function installDocumentTitle(router, options = {}) {
+  if (typeof document === "undefined") return () => {
+  };
+  const { suffix } = options;
+  return router.afterEach((to) => {
+    const title = deepestHandleValue(to, (handle) => handle.title);
+    document.title = title ? suffix ? `${title} · ${suffix}` : title : suffix ?? document.title;
+  });
+}
+const RetryDelayMs = 300;
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function reloadOnChunkError() {
+  if (typeof window === "undefined") return;
+  window.location.reload();
+}
+function lazyRoute(importer) {
+  return async () => {
+    try {
+      return await importer();
+    } catch {
+      await delay(RetryDelayMs);
+      return importer();
+    }
+  };
+}
+function toAsyncComponent(lazy) {
+  return async () => {
+    const module = await lazy();
+    return "default" in module ? module.default : module.Component;
+  };
+}
+const _hoisted_1$3 = { class: "flex min-h-svh flex-col items-center justify-center gap-3 bg-background p-8 text-center" };
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  ...{ name: "NotFound" },
+  __name: "NotFound",
+  props: {
+    homePath: { default: "/" }
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$3, [
+        _cache[1] || (_cache[1] = createElementVNode("p", { class: "font-mono text-sm text-muted-foreground" }, "404", -1)),
+        _cache[2] || (_cache[2] = createElementVNode("h1", { class: "text-lg font-semibold text-foreground" }, "Page not found", -1)),
+        _cache[3] || (_cache[3] = createElementVNode("p", { class: "max-w-md text-sm text-muted-foreground" }, "That page doesn't exist or has moved.", -1)),
+        createVNode(unref(RouterLink), {
+          to: props.homePath,
+          class: "mt-2 text-sm font-medium text-primary hover:underline"
+        }, {
+          default: withCtx(() => [..._cache[0] || (_cache[0] = [
+            createTextVNode(" Back to start ", -1)
+          ])]),
+          _: 1
+        }, 8, ["to"])
+      ]);
+    };
+  }
+});
+function installPageViewTracker(router, options) {
+  const { onPageView } = options;
+  return router.afterEach((to, _from, failure) => {
+    if (failure) return;
+    onPageView({ pathname: to.path, title: deepestHandleValue(to, (handle) => handle.title) });
+  });
+}
+function requireAuth(isAuthenticated, loginPath = "/login") {
+  return async (context) => {
+    if (await isAuthenticated()) return true;
+    return { redirect: buildReturnTo(loginPath, context.to.fullPath) };
+  };
+}
+function buildReturnTo(loginPath, from) {
+  return `${loginPath}?returnTo=${encodeURIComponent(toPathAndSearch(from))}`;
+}
+function resolveReturnTo(search, fallback = "/") {
+  const target = readReturnTo(search);
+  if (target === null) return fallback;
+  return isSafeInternalPath(target) ? target : fallback;
+}
+function useReturnTo(fallback = "/") {
+  const route = useRoute();
+  return computed(() => resolveReturnTo(route.query, toValue(fallback)));
+}
+function readReturnTo(search) {
+  if (typeof search === "string") return new URLSearchParams(search).get("returnTo");
+  if (search instanceof URLSearchParams) return search.get("returnTo");
+  const value = search.returnTo;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value ?? null;
+}
+function toPathAndSearch(from) {
+  const url = new URL(from, "http://localhost");
+  return url.pathname + url.search;
+}
+function isSafeInternalPath(target) {
+  if (!target.startsWith("/")) return false;
+  if (target.startsWith("//")) return false;
+  if (target.includes("\\")) return false;
+  if ([...target].some((ch) => ch.charCodeAt(0) < 32 || ch.charCodeAt(0) === 127)) return false;
+  return true;
+}
+const DefaultStorageKey = "app:lastRoute";
+function installRoutePersistence(router, options = {}) {
+  if (typeof window === "undefined") return () => {
+  };
+  const { storageKey = DefaultStorageKey, restore = false } = options;
+  let didRestore = !restore;
+  const unregisterRestore = router.beforeEach((to) => {
+    if (didRestore) return true;
+    didRestore = true;
+    const saved = readRoute(storageKey);
+    if (saved && to.path === "/" && isNonRootPath(saved) && isSafeInternalPath(saved)) return saved;
+    return true;
+  });
+  const unregisterPersist = router.afterEach((to) => {
+    writeRoute(storageKey, to.fullPath);
+  });
+  return () => {
+    unregisterRestore();
+    unregisterPersist();
+  };
+}
+function readRoute(key) {
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeRoute(key, value) {
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {
+  }
+}
+function isNonRootPath(route) {
+  const [path] = route.split("?");
+  return !!path && path !== "/";
+}
+const registry = /* @__PURE__ */ new WeakMap();
+function installRouteNavigating(router) {
+  const existing = registry.get(router);
+  if (existing) return existing;
+  const busy = shallowRef(false);
+  registry.set(router, busy);
+  router.beforeEach(() => {
+    busy.value = true;
+  });
+  router.afterEach(() => {
+    busy.value = false;
+  });
+  router.onError(() => {
+    busy.value = false;
+  });
+  return busy;
+}
+function useRouteNavigating(router) {
+  const resolved = router ?? inject(routerKey, null);
+  if (!resolved) return computed(() => false);
+  const busy = installRouteNavigating(resolved);
+  return computed(() => busy.value);
+}
+const CatchAllPath = "/:pathMatch(.*)*";
+const RouterHistoryMode = {
+  /** Refers to the HTML5 History API — clean URLs (default). */
+  Browser: "browser",
+  /** Refers to hash-based history — static hosting / file protocol. */
+  Hash: "hash",
+  /** Refers to in-memory history — SSR and tests; no URL bar involvement. */
+  Memory: "memory"
+};
+const RouterHistory = RouterHistoryMode;
+function toGuards(guard) {
+  if (!guard) return [];
+  return [].concat(guard);
+}
+function toBeforeEnter(guards, redirectTo) {
+  if (!guards.length) return void 0;
+  return async (to, from) => {
+    for (const guard of guards) {
+      const result = await guard({ to, from, params: to.params });
+      if (result !== true) return result.redirect;
+    }
+    return redirectTo ?? true;
+  };
+}
+function toRouteRecord(route, isRoot) {
+  const { path, index, component, layout, lazy, redirect, guard, handle, errorComponent, children, id } = route;
+  const guards = toGuards(guard);
+  const beforeEnter = toBeforeEnter(guards, redirect);
+  const record = { path: toPath(path, index, isRoot) };
+  if (id !== void 0) record.name = id;
+  if (beforeEnter) record.beforeEnter = beforeEnter;
+  else if (redirect !== void 0) record.redirect = redirect;
+  if (lazy) record.component = toAsyncComponent(lazy);
+  else if (component ?? layout) record.component = component ?? layout;
+  const meta = { ...handle, ...errorComponent ? { errorComponent } : {} };
+  if (Object.keys(meta).length > 0) record.meta = meta;
+  if (children) record.children = children.map((child) => toRouteRecord(child, false));
+  return record;
+}
+function toPath(path, index, isRoot) {
+  if (index) return "";
+  if (path === "*" || path === "/*") return CatchAllPath;
+  if (path !== void 0) return path;
+  return isRoot ? "/" : "";
+}
+const houseScrollBehavior = (to, _from, savedPosition) => {
+  if (savedPosition) return savedPosition;
+  if (to.hash) return { el: to.hash };
+  return { left: 0, top: 0 };
+};
+function toHistory(options) {
+  const { basename, history } = options;
+  if (typeof window === "undefined" || history === RouterHistoryMode.Memory) return createMemoryHistory(basename);
+  if (history === RouterHistoryMode.Hash) return createWebHashHistory(basename);
+  return createWebHistory(basename);
+}
+function createAppRouter(config, options = {}) {
+  const routes = config.map((route) => toRouteRecord(route, true));
+  routes.push({ path: CatchAllPath, component: options.notFound ?? _sfc_main$5 });
+  const router = createRouter({
+    history: toHistory(options),
+    routes,
+    scrollBehavior: options.scrollRestoration ?? true ? houseScrollBehavior : void 0
+  });
+  installRouteNavigating(router);
+  installDocumentTitle(router, { suffix: options.titleSuffix });
+  installDocumentMeta(router);
+  if (options.routePersistence !== false) installRoutePersistence(router, options.routePersistence ?? {});
+  if (options.onPageView) installPageViewTracker(router, { onPageView: options.onPageView });
+  return router;
+}
+const _hoisted_1$2 = {
+  "aria-live": "polite",
+  "aria-atomic": "true",
+  class: "sr-only"
+};
+function focusMainContent() {
+  const target = document.getElementById("app-shell-main") ?? document.querySelector("main") ?? document.querySelector("h1");
+  if (!target) return;
+  target.tabIndex = -1;
+  target.focus({ preventScroll: true });
+}
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  ...{ name: "RouteAnnouncer" },
+  __name: "RouteAnnouncer",
+  props: {
+    skipInitial: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const route = useRoute();
+    const message = shallowRef("");
+    let lastPath = null;
+    onMounted(() => {
+      lastPath = props.skipInitial ? route.path : null;
+      if (!props.skipInitial) announce(route.path);
+    });
+    watch(
+      () => route.path,
+      (path) => {
+        if (lastPath === path) return;
+        announce(path);
+      }
+    );
+    function announce(path) {
+      lastPath = path;
+      focusMainContent();
+      message.value = deepestHandleValue(route, (handle) => handle.title) ?? document.title;
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$2, toDisplayString(message.value), 1);
+    };
+  }
+});
+const _hoisted_1$1 = {
+  key: 3,
+  class: "flex min-h-svh flex-col items-center justify-center gap-3 bg-background p-8 text-center"
+};
+const _hoisted_2$1 = {
+  key: 0,
+  class: "font-mono text-sm text-muted-foreground"
+};
+const _hoisted_3 = { class: "max-w-md text-sm text-muted-foreground" };
+function readStatus(error) {
+  const status = error?.status;
+  return typeof status === "number" ? status : void 0;
+}
+function readMessage(error) {
+  if (error instanceof Error && error.message) return error.message;
+  return "Something went wrong.";
+}
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  ...{ name: "AppErrorBoundary" },
+  __name: "AppErrorBoundary",
+  props: {
+    homePath: { default: "/" },
+    resetOnNavigate: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const route = useRoute();
+    const router = useRouter();
+    const error = shallowRef(null);
+    onErrorCaptured((caught) => {
+      error.value = caught;
+      return false;
+    });
+    onScopeDispose(
+      router.onError((caught) => {
+        error.value = caught;
+      })
+    );
+    const reset = () => {
+      error.value = null;
+    };
+    watch(
+      () => route.fullPath,
+      () => {
+        if (props.resetOnNavigate) reset();
+      }
+    );
+    const status = computed(() => readStatus(error.value));
+    const message = computed(() => readMessage(error.value));
+    const routeErrorComponent = computed(() => {
+      for (let index = route.matched.length - 1; index >= 0; index -= 1) {
+        const component = toHandle(route.matched[index]?.meta)?.errorComponent;
+        if (component) return component;
+      }
+      return void 0;
+    });
+    return (_ctx, _cache) => {
+      return error.value === null ? renderSlot(_ctx.$slots, "default", {}, void 0, void 0, 0) : _ctx.$slots.fallback ? renderSlot(_ctx.$slots, "fallback", {
+        error: error.value,
+        reset
+      }, void 0, void 0, 1) : routeErrorComponent.value ? (openBlock(), createBlock(resolveDynamicComponent(routeErrorComponent.value), {
+        key: 2,
+        error: error.value,
+        reset
+      }, null, 8, ["error"])) : (openBlock(), createElementBlock("div", _hoisted_1$1, [
+        status.value !== void 0 ? (openBlock(), createElementBlock("p", _hoisted_2$1, toDisplayString(status.value), 1)) : createCommentVNode("", true),
+        _cache[1] || (_cache[1] = createElementVNode("h1", { class: "text-lg font-semibold text-foreground" }, "Something went wrong", -1)),
+        createElementVNode("p", _hoisted_3, toDisplayString(message.value), 1),
+        createVNode(unref(RouterLink), {
+          to: props.homePath,
+          class: "mt-2 text-sm font-medium text-primary hover:underline"
+        }, {
+          default: withCtx(() => [..._cache[0] || (_cache[0] = [
+            createTextVNode(" Back to start ", -1)
+          ])]),
+          _: 1
+        }, 8, ["to"])
+      ]));
+    };
+  }
+});
+const NavigationProgressVariant = {
+  /** Refers to a slim indeterminate top bar. */
+  Bar: "bar",
+  /** Refers to a pulsing heartbeat dot. */
+  Heartbeat: "heartbeat"
+};
+const NavigationProgressMode = {
+  /** Refers to route-navigation busy state (vue-router). */
+  Auto: "auto",
+  /** Refers to manual / backend busy spans. */
+  Manual: "manual",
+  /** Refers to either busy source. */
+  Both: "both"
+};
+const _hoisted_1 = ["aria-label", "data-variant"];
+const _hoisted_2 = {
+  key: 1,
+  class: "h-full w-1/3 bg-primary animate-indeterminate motion-reduce:w-full motion-reduce:animate-none"
+};
+const OWNED_ATTRS = /* @__PURE__ */ new Set(["class", "aria-label"]);
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  ...{ name: "NavigationProgress", inheritAttrs: false },
+  __name: "NavigationProgress",
+  props: {
+    variant: { default: NavigationProgressVariant.Bar },
+    mode: { default: NavigationProgressMode.Auto }
+  },
+  setup(__props) {
+    const props = __props;
+    const attrs = useAttrs();
+    const routeBusy = useRouteNavigating();
+    const progress = useOptionalNavigationProgress();
+    const isHeartbeat = computed(() => props.variant === NavigationProgressVariant.Heartbeat);
+    const isActive = computed(() => {
+      const manualBusy = progress?.isBusy ?? false;
+      if (props.mode === NavigationProgressMode.Manual) return manualBusy;
+      if (props.mode === NavigationProgressMode.Both) return routeBusy.value || manualBusy;
+      return routeBusy.value;
+    });
+    const ariaLabel = computed(() => attrs["aria-label"] ?? "Loading");
+    const classes = computed(
+      () => cn(
+        isHeartbeat.value ? "fixed right-4 top-4 z-toast inline-flex h-3 w-3 items-center justify-center" : "fixed inset-x-0 top-0 z-toast h-0.5 overflow-hidden",
+        attrs.class
+      )
+    );
+    const rest = computed(() => Object.fromEntries(Object.entries(attrs).filter(([key]) => !OWNED_ATTRS.has(key))));
+    return (_ctx, _cache) => {
+      return isActive.value ? (openBlock(), createElementBlock("div", mergeProps({
+        key: 0,
+        role: "progressbar",
+        "aria-busy": true,
+        "aria-label": ariaLabel.value,
+        "data-variant": props.variant
+      }, rest.value, { class: classes.value }), [
+        isHeartbeat.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          _cache[0] || (_cache[0] = createElementVNode("span", { class: "absolute inline-flex h-full w-full rounded-full bg-primary/60 animate-ping motion-reduce:hidden" }, null, -1)),
+          _cache[1] || (_cache[1] = createElementVNode("span", { class: "relative inline-flex h-2.5 w-2.5 rounded-full bg-primary" }, null, -1))
+        ], 64)) : (openBlock(), createElementBlock("div", _hoisted_2))
+      ], 16, _hoisted_1)) : createCommentVNode("", true);
+    };
+  }
+});
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  ...{ name: "ProgressProvider" },
+  __name: "ProgressProvider",
+  props: {
+    state: { default: void 0 }
+  },
+  setup(__props) {
+    const props = __props;
+    provideNavigationProgress(props.state);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+const ParamPattern = /:([A-Za-z0-9_]+)/g;
+function definePath(template) {
+  const build = (params = {}) => template.replace(ParamPattern, (_match, name) => encodeURIComponent(params[name] ?? ""));
+  return Object.assign(build, { pattern: template });
+}
+function useTypedSearchParams(defaults) {
+  const route = useRoute();
+  const router = useRouter();
+  const values = computed(() => {
+    const resolved = toValue(defaults);
+    const merged = { ...resolved };
+    for (const key of Object.keys(resolved)) {
+      const raw = route.query[key];
+      const value = Array.isArray(raw) ? raw[0] : raw;
+      if (typeof value === "string") merged[key] = value;
+    }
+    return merged;
+  });
+  const setValues = (patch) => {
+    const next = { ...route.query };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0) continue;
+      next[key] = value;
+    }
+    void router.replace({ query: next });
+  };
+  return { values, setValues };
+}
+const prefetched = /* @__PURE__ */ new WeakSet();
+function prefetch(importer) {
+  if (prefetched.has(importer)) return;
+  prefetched.add(importer);
+  void importer().catch(() => {
+  });
+}
+function prefetchProps(importer) {
+  const warm = () => prefetch(importer);
+  return { onMouseenter: warm, onFocus: warm };
+}
+function usePrefetch() {
+  return prefetch;
+}
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "AppNavLink", inheritAttrs: false },
+  __name: "AppNavLink",
+  props: {
+    to: {},
+    end: { type: Boolean, default: void 0 },
+    replace: { type: Boolean, default: void 0 },
+    viewTransition: { type: Boolean, default: void 0 },
+    prefetch: { type: Function, default: void 0 }
+  },
+  setup(__props) {
+    const props = __props;
+    const attrs = useAttrs();
+    const link = useLink({
+      to: computed(() => props.to),
+      replace: computed(() => props.replace)
+    });
+    const isActive = computed(() => props.end ? link.isExactActive.value : link.isActive.value);
+    const intent = computed(() => props.prefetch ? prefetchProps(props.prefetch) : void 0);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$6), mergeProps({
+        "as-child": "",
+        "is-active": isActive.value
+      }, unref(attrs)), createSlots({
+        default: withCtx(() => [
+          createVNode(unref(RouterLink), mergeProps({
+            to: props.to,
+            replace: props.replace,
+            "view-transition": props.viewTransition
+          }, intent.value), {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 16, ["to", "replace", "view-transition"])
+        ]),
+        _: 2
+      }, [
+        _ctx.$slots.icon ? {
+          name: "icon",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "icon")
+          ]),
+          key: "0"
+        } : void 0,
+        _ctx.$slots.trailing ? {
+          name: "trailing",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "trailing")
+          ]),
+          key: "1"
+        } : void 0
+      ]), 1040, ["is-active"]);
+    };
+  }
+});
+function useBreadcrumbs() {
+  const route = useRoute();
+  return computed(
+    () => route.matched.flatMap((record) => {
+      const crumb = toHandle(record.meta)?.crumb;
+      if (crumb == null) return [];
+      return [
+        {
+          crumb,
+          // React read a resolved `match.pathname`; a vue-router matched record carries its full
+          // path PATTERN, so the active params are substituted back in here.
+          pathname: resolveMatchedPath(record.path, route.params),
+          id: String(record.name ?? record.path)
+        }
+      ];
+    })
+  );
+}
+const UnsavedChangesMessage = "You have unsaved changes that may be lost.";
+const BlockerState = {
+  /** Refers to no navigation being held. */
+  Unblocked: "unblocked",
+  /** Refers to a navigation held pending a decision — render the confirm dialog. */
+  Blocked: "blocked",
+  /** Refers to a released navigation currently running. */
+  Proceeding: "proceeding"
+};
+function handleBeforeUnload(event) {
+  event.preventDefault();
+  event.returnValue = UnsavedChangesMessage;
+  return UnsavedChangesMessage;
+}
+function useNavigationBlocker(shouldBlock) {
+  const router = useRouter();
+  const state = shallowRef(BlockerState.Unblocked);
+  const location = shallowRef(null);
+  let releaseOnce = false;
+  const unregister = router.beforeEach((to) => {
+    if (releaseOnce) {
+      releaseOnce = false;
+      state.value = BlockerState.Unblocked;
+      location.value = null;
+      return true;
+    }
+    if (!toValue(shouldBlock)) return true;
+    location.value = to;
+    state.value = BlockerState.Blocked;
+    return false;
+  });
+  onScopeDispose(unregister);
+  watch(
+    () => toValue(shouldBlock),
+    (block, _previous, onCleanup) => {
+      if (typeof window === "undefined" || !block) return;
+      window.addEventListener("beforeunload", handleBeforeUnload);
+      onCleanup(() => window.removeEventListener("beforeunload", handleBeforeUnload));
+    },
+    { immediate: true }
+  );
+  const proceed = () => {
+    const target = location.value;
+    if (target === null) return;
+    releaseOnce = true;
+    state.value = BlockerState.Proceeding;
+    void router.push(target.fullPath);
+  };
+  const reset = () => {
+    state.value = BlockerState.Unblocked;
+    location.value = null;
+  };
+  return {
+    get state() {
+      return state.value;
+    },
+    get location() {
+      return location.value;
+    },
+    proceed,
+    reset
+  };
+}
+export {
+  _sfc_main$3 as AppErrorBoundary,
+  _sfc_main as AppNavLink,
+  BlockerState,
+  _sfc_main$2 as NavigationProgress,
+  N as NavigationProgressKey,
+  NavigationProgressMode,
+  NavigationProgressVariant,
+  _sfc_main$5 as NotFound,
+  _sfc_main$1 as ProgressProvider,
+  _sfc_main$4 as RouteAnnouncer,
+  RouterHistory,
+  RouterHistoryMode,
+  buildReturnTo,
+  createAppRouter,
+  c as createNavigationProgress,
+  definePath,
+  installDocumentMeta,
+  installDocumentTitle,
+  installPageViewTracker,
+  installRoutePersistence,
+  lazyRoute,
+  prefetch,
+  prefetchProps,
+  provideNavigationProgress,
+  reloadOnChunkError,
+  requireAuth,
+  resolveReturnTo,
+  useBreadcrumbs,
+  useNavigationBlocker,
+  u as useNavigationProgress,
+  usePrefetch,
+  useReturnTo,
+  useRouteNavigating,
+  useTypedSearchParams
+};
+//# sourceMappingURL=index.js.map