olova-router 1.0.19 → 1.0.21

package/dist/index.js

@@ -33,6 +33,913 @@ var Link = defineComponent((incomingProps) => {
 });
 var Link_default = Link;
 
+// src/breadcrumbs.ts
+function generateBreadcrumbs(location, labelMap) {
+  const breadcrumbs = [];
+  const segments = location.path.split("/").filter(Boolean);
+  breadcrumbs.push({
+    label: labelMap?.home ?? "Home",
+    path: "/",
+    name: "home"
+  });
+  let currentPath = "";
+  for (const segment of segments) {
+    currentPath += `/${segment}`;
+    const label = labelMap?.[segment] ?? segment.charAt(0).toUpperCase() + segment.slice(1);
+    breadcrumbs.push({
+      label,
+      path: currentPath
+    });
+  }
+  return breadcrumbs;
+}
+function generateBreadcrumbsFromMatches(matches, labelMap) {
+  const breadcrumbs = [];
+  for (const match of matches) {
+    const label = labelMap?.[match.name ?? ""] ?? match.name ?? match.path;
+    breadcrumbs.push({
+      label,
+      path: match.path,
+      name: match.name
+    });
+  }
+  return breadcrumbs;
+}
+
+// src/guards.ts
+function createConditionalGuard(condition, redirectTo) {
+  return async (context) => {
+    const allowed = await condition(context);
+    if (!allowed && redirectTo) {
+      return redirectTo;
+    }
+    return allowed;
+  };
+}
+function createParamGuard(paramName, validator, redirectTo) {
+  return async (context) => {
+    const value = context.params[paramName];
+    if (!value) {
+      return redirectTo ? redirectTo : false;
+    }
+    const valid = await validator(value);
+    if (!valid && redirectTo) {
+      return redirectTo;
+    }
+    return valid;
+  };
+}
+function createQueryGuard(queryKey, validator, redirectTo) {
+  return async (context) => {
+    const value = context.query[queryKey];
+    const valid = await validator(value);
+    if (!valid && redirectTo) {
+      return redirectTo;
+    }
+    return valid;
+  };
+}
+function createCompositeGuard(guards) {
+  return async (context) => {
+    for (const guard of guards) {
+      const result = await guard(context);
+      if (result !== true && result !== void 0) {
+        return result;
+      }
+    }
+    return true;
+  };
+}
+function createDebounceGuard(guard, delayMs = 300) {
+  let timeoutId = null;
+  let lastContext = null;
+  return async (context) => {
+    lastContext = context;
+    return new Promise((resolve) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(async () => {
+        if (lastContext === context) {
+          const result = await guard(context);
+          resolve(result);
+        }
+      }, delayMs);
+    });
+  };
+}
+
+// src/history.ts
+function createRouterHistory(maxSize = 50) {
+  const entries = [];
+  let current = -1;
+  return {
+    entries,
+    current,
+    push(path) {
+      entries.splice(current + 1);
+      entries.push({ path, timestamp: Date.now() });
+      if (entries.length > maxSize) {
+        entries.shift();
+      } else {
+        current++;
+      }
+    },
+    back() {
+      if (current > 0) {
+        current--;
+        return entries[current];
+      }
+      return null;
+    },
+    forward() {
+      if (current < entries.length - 1) {
+        current++;
+        return entries[current];
+      }
+      return null;
+    },
+    go(delta) {
+      const next = current + delta;
+      if (next >= 0 && next < entries.length) {
+        current = next;
+        return entries[current];
+      }
+      return null;
+    },
+    clear() {
+      entries.length = 0;
+      current = -1;
+    },
+    getHistory() {
+      return [...entries];
+    }
+  };
+}
+
+// src/middleware.ts
+function createMiddlewareChain() {
+  const middlewares = [];
+  return {
+    use(middleware) {
+      middlewares.push(middleware);
+      return this;
+    },
+    async execute(context) {
+      for (const middleware of middlewares) {
+        const result = await middleware(context);
+        if (result !== void 0 && result !== true) {
+          return result;
+        }
+      }
+      return true;
+    }
+  };
+}
+function createAuthMiddleware(isAuthenticated, redirectTo = "/login") {
+  return (context) => {
+    if (!isAuthenticated()) {
+      return redirectTo;
+    }
+    return true;
+  };
+}
+function createRoleMiddleware(userRole, allowedRoles, redirectTo = "/unauthorized") {
+  return (context) => {
+    const role = userRole();
+    if (!role || !allowedRoles.includes(role)) {
+      return redirectTo;
+    }
+    return true;
+  };
+}
+function createAnalyticsMiddleware(trackPageView) {
+  return (context) => {
+    trackPageView(context.to.path);
+    return true;
+  };
+}
+function createScrollMiddleware(scrollToTop2 = true) {
+  return () => {
+    if (scrollToTop2 && typeof window !== "undefined") {
+      window.scrollTo({ top: 0, left: 0, behavior: "auto" });
+    }
+    return true;
+  };
+}
+function lazyComponent(loader) {
+  let component = null;
+  let loading = false;
+  let error = null;
+  return defineComponent(() => {
+    if (!component && !loading && !error) {
+      loading = true;
+      loader().then((module) => {
+        component = module.default;
+        loading = false;
+      }).catch((err) => {
+        error = err;
+        loading = false;
+      });
+    }
+    if (error) {
+      return {
+        template: '<div class="router-error">Failed to load component</div>',
+        textBindings: [],
+        htmlBindings: [],
+        attrBindings: [],
+        eventBindings: [],
+        slotBindings: [],
+        componentBindings: []
+      };
+    }
+    if (loading || !component) {
+      return {
+        template: '<div class="router-loading">Loading...</div>',
+        textBindings: [],
+        htmlBindings: [],
+        attrBindings: [],
+        eventBindings: [],
+        slotBindings: [],
+        componentBindings: []
+      };
+    }
+    return {
+      template: "__O_COMP_lazy_component__",
+      textBindings: [],
+      htmlBindings: [],
+      attrBindings: [],
+      eventBindings: [],
+      slotBindings: [],
+      componentBindings: [
+        {
+          id: "lazy_component",
+          getComponent: () => component,
+          getProps: () => ({})
+        }
+      ]
+    };
+  });
+}
+function lazyComponentWithFallback(loader, fallback, errorComponent) {
+  let component = null;
+  let loading = false;
+  let error = null;
+  return defineComponent(() => {
+    if (!component && !loading && !error) {
+      loading = true;
+      loader().then((module) => {
+        component = module.default;
+        loading = false;
+      }).catch((err) => {
+        error = err;
+        loading = false;
+      });
+    }
+    if (error && errorComponent) {
+      return {
+        template: "__O_COMP_error_component__",
+        textBindings: [],
+        htmlBindings: [],
+        attrBindings: [],
+        eventBindings: [],
+        slotBindings: [],
+        componentBindings: [
+          {
+            id: "error_component",
+            getComponent: () => errorComponent,
+            getProps: () => ({ error })
+          }
+        ]
+      };
+    }
+    if (loading || !component) {
+      return {
+        template: "__O_COMP_fallback_component__",
+        textBindings: [],
+        htmlBindings: [],
+        attrBindings: [],
+        eventBindings: [],
+        slotBindings: [],
+        componentBindings: [
+          {
+            id: "fallback_component",
+            getComponent: () => fallback,
+            getProps: () => ({})
+          }
+        ]
+      };
+    }
+    return {
+      template: "__O_COMP_lazy_component__",
+      textBindings: [],
+      htmlBindings: [],
+      attrBindings: [],
+      eventBindings: [],
+      slotBindings: [],
+      componentBindings: [
+        {
+          id: "lazy_component",
+          getComponent: () => component,
+          getProps: () => ({})
+        }
+      ]
+    };
+  });
+}
+
+// src/prefetch.ts
+var prefetchedRoutes = /* @__PURE__ */ new Set();
+var prefetchQueue = [];
+var isPrefetching = false;
+function stringifyTarget(target) {
+  if (typeof target === "string") {
+    return target;
+  }
+  const path = target.path ?? "/";
+  const query = target.query ? Object.entries(target.query).flatMap(([key, value]) => {
+    if (value === null || value === void 0) {
+      return [];
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => `${key}=${encodeURIComponent(String(v))}`);
+    }
+    return `${key}=${encodeURIComponent(String(value))}`;
+  }).join("&") : "";
+  const hash = target.hash ? `#${target.hash}` : "";
+  return `${path}${query ? `?${query}` : ""}${hash}`;
+}
+async function processPrefetchQueue() {
+  if (isPrefetching || prefetchQueue.length === 0) {
+    return;
+  }
+  isPrefetching = true;
+  while (prefetchQueue.length > 0) {
+    const item = prefetchQueue.shift();
+    if (!item) continue;
+    const { href } = item;
+    if (prefetchedRoutes.has(href)) {
+      continue;
+    }
+    try {
+      await fetch(href, { method: "HEAD" });
+      prefetchedRoutes.add(href);
+    } catch {
+    }
+  }
+  isPrefetching = false;
+}
+function prefetchRoute(to, options = {}) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const href = stringifyTarget(to);
+  if (prefetchedRoutes.has(href)) {
+    return;
+  }
+  const priority = options.priority ?? "low";
+  prefetchQueue.push({ href, priority });
+  prefetchQueue.sort((a, b) => {
+    if (!a || !b) return 0;
+    if (a.priority === "high" && b.priority === "low") return -1;
+    if (a.priority === "low" && b.priority === "high") return 1;
+    return 0;
+  });
+  processPrefetchQueue();
+}
+function isPrefetched(to) {
+  const href = stringifyTarget(to);
+  return prefetchedRoutes.has(href);
+}
+function clearPrefetchCache() {
+  prefetchedRoutes.clear();
+  prefetchQueue.length = 0;
+}
+
+// src/search-params.ts
+var searchParamsCache = /* @__PURE__ */ new Map();
+function parseSearchParams(search) {
+  const params = new URLSearchParams(search);
+  const query = {};
+  for (const [key, value] of params.entries()) {
+    const existing = query[key];
+    if (existing === void 0) {
+      query[key] = value;
+      continue;
+    }
+    query[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+  }
+  return query;
+}
+function useSearchParams() {
+  if (typeof window === "undefined") {
+    return {
+      get: () => null,
+      getAll: () => [],
+      has: () => false,
+      keys: () => [],
+      values: () => [],
+      entries: () => [],
+      toString: () => ""
+    };
+  }
+  const search = window.location.search;
+  const cached = searchParamsCache.get(search);
+  if (cached) {
+    return {
+      get: (name) => cached.params.get(name),
+      getAll: (name) => cached.params.getAll(name),
+      has: (name) => cached.params.has(name),
+      keys: () => Array.from(cached.params.keys()),
+      values: () => Array.from(cached.params.values()),
+      entries: () => Array.from(cached.params.entries()),
+      toString: () => cached.params.toString()
+    };
+  }
+  const params = new URLSearchParams(search);
+  const query = parseSearchParams(search);
+  searchParamsCache.set(search, { params, query });
+  return {
+    get: (name) => params.get(name),
+    getAll: (name) => params.getAll(name),
+    has: (name) => params.has(name),
+    keys: () => Array.from(params.keys()),
+    values: () => Array.from(params.values()),
+    entries: () => Array.from(params.entries()),
+    toString: () => params.toString()
+  };
+}
+function usePathname() {
+  if (typeof window === "undefined") {
+    return "/";
+  }
+  return window.location.pathname;
+}
+function useHash() {
+  if (typeof window === "undefined") {
+    return "";
+  }
+  return window.location.hash.replace(/^#/, "");
+}
+function clearSearchParamsCache() {
+  searchParamsCache.clear();
+}
+var transitionState = state("idle");
+var isPendingNavigation = state(false);
+var currentTransitionError = state(null);
+function useTransition() {
+  return {
+    isPending: isPendingNavigation.value,
+    state: transitionState.value,
+    error: currentTransitionError.value
+  };
+}
+function startTransition(callback, options = {}) {
+  isPendingNavigation.value = true;
+  transitionState.value = "pending";
+  options.onStart?.();
+  try {
+    const result = callback();
+    if (result instanceof Promise) {
+      result.then(() => {
+        isPendingNavigation.value = false;
+        transitionState.value = "success";
+        options.onSuccess?.();
+      }).catch((error) => {
+        isPendingNavigation.value = false;
+        transitionState.value = "error";
+        currentTransitionError.value = error;
+        options.onError?.(error);
+      });
+    } else {
+      isPendingNavigation.value = false;
+      transitionState.value = "success";
+      options.onSuccess?.();
+    }
+  } catch (error) {
+    isPendingNavigation.value = false;
+    transitionState.value = "error";
+    const err = error instanceof Error ? error : new Error(String(error));
+    currentTransitionError.value = err;
+    options.onError?.(err);
+  }
+}
+function resetTransition() {
+  isPendingNavigation.value = false;
+  transitionState.value = "idle";
+  currentTransitionError.value = null;
+}
+
+// src/error-boundary.ts
+var errorBoundaryState = {
+  hasError: false,
+  error: null
+};
+function captureError(error) {
+  errorBoundaryState = {
+    hasError: true,
+    error
+  };
+}
+function clearError() {
+  errorBoundaryState = {
+    hasError: false,
+    error: null
+  };
+}
+function getErrorBoundaryState() {
+  return { ...errorBoundaryState };
+}
+function hasError() {
+  return errorBoundaryState.hasError;
+}
+function getError() {
+  return errorBoundaryState.error;
+}
+
+// src/metadata.ts
+var metadataRegistry = /* @__PURE__ */ new Map();
+var metadataCache = /* @__PURE__ */ new Map();
+function registerRouteMetadata(path, metadata) {
+  metadataRegistry.set(path, metadata);
+}
+async function getRouteMetadata(location) {
+  const cached = metadataCache.get(location.path);
+  if (cached) {
+    return cached;
+  }
+  const metadata = metadataRegistry.get(location.path);
+  if (!metadata) {
+    return {};
+  }
+  const resolved = typeof metadata === "function" ? await metadata(location) : metadata;
+  metadataCache.set(location.path, resolved);
+  return resolved;
+}
+function applyMetadata(metadata) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  if (metadata.title) {
+    document.title = metadata.title;
+  }
+  const metaTags = [
+    { name: "description", content: metadata.description },
+    { name: "keywords", content: Array.isArray(metadata.keywords) ? metadata.keywords.join(", ") : metadata.keywords },
+    { name: "author", content: metadata.author },
+    { name: "robots", content: metadata.robots },
+    { name: "viewport", content: metadata.viewport },
+    { name: "og:title", content: metadata.ogTitle },
+    { name: "og:description", content: metadata.ogDescription },
+    { name: "og:image", content: metadata.ogImage },
+    { name: "og:url", content: metadata.ogUrl },
+    { name: "og:type", content: metadata.ogType },
+    { name: "twitter:card", content: metadata.twitterCard },
+    { name: "twitter:title", content: metadata.twitterTitle },
+    { name: "twitter:description", content: metadata.twitterDescription },
+    { name: "twitter:image", content: metadata.twitterImage },
+    { name: "twitter:creator", content: metadata.twitterCreator }
+  ];
+  for (const tag of metaTags) {
+    if (!tag.content) continue;
+    let element = document.querySelector(`meta[name="${tag.name}"]`);
+    if (!element) {
+      element = document.createElement("meta");
+      element.setAttribute("name", tag.name);
+      document.head.appendChild(element);
+    }
+    element.setAttribute("content", String(tag.content));
+  }
+  if (metadata.canonical) {
+    let canonical = document.querySelector('link[rel="canonical"]');
+    if (!canonical) {
+      canonical = document.createElement("link");
+      canonical.setAttribute("rel", "canonical");
+      document.head.appendChild(canonical);
+    }
+    canonical.setAttribute("href", metadata.canonical);
+  }
+  if (metadata.charset) {
+    let charsetMeta = document.querySelector("meta[charset]");
+    if (!charsetMeta) {
+      charsetMeta = document.createElement("meta");
+      document.head.insertBefore(charsetMeta, document.head.firstChild);
+    }
+    charsetMeta.setAttribute("charset", String(metadata.charset));
+  }
+}
+function clearMetadataCache() {
+  metadataCache.clear();
+}
+
+// src/dynamic-routes.ts
+function parseRoutePattern(path) {
+  const segments = path.split("/").filter(Boolean);
+  const paramNames = [];
+  let isDynamic = false;
+  let isCatchAll = false;
+  let isOptionalCatchAll = false;
+  for (const segment of segments) {
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+      isOptionalCatchAll = true;
+      paramNames.push(segment.slice(5, -2));
+      isDynamic = true;
+    } else if (segment.startsWith("[...") && segment.endsWith("]")) {
+      isCatchAll = true;
+      paramNames.push(segment.slice(4, -1));
+      isDynamic = true;
+    } else if (segment.startsWith("[") && segment.endsWith("]")) {
+      paramNames.push(segment.slice(1, -1));
+      isDynamic = true;
+    }
+  }
+  return {
+    pattern: path,
+    isDynamic,
+    isCatchAll,
+    isOptionalCatchAll,
+    paramNames
+  };
+}
+function matchOptionalCatchAll(pattern, pathname) {
+  const patternSegments = pattern.split("/").filter(Boolean);
+  const pathSegments = pathname.split("/").filter(Boolean);
+  const params = {};
+  let catchAllParam = null;
+  let catchAllValues = [];
+  for (let i = 0; i < patternSegments.length; i++) {
+    const segment = patternSegments[i];
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+      catchAllParam = segment.slice(5, -2);
+      catchAllValues = pathSegments.slice(i);
+      break;
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      const paramName = segment.slice(1, -1);
+      if (i < pathSegments.length) {
+        params[paramName] = decodeURIComponent(pathSegments[i]);
+      } else {
+        return null;
+      }
+    } else if (segment !== pathSegments[i]) {
+      return null;
+    }
+  }
+  if (catchAllParam) {
+    if (catchAllValues.length > 0) {
+      params[catchAllParam] = catchAllValues.map(decodeURIComponent).join("/");
+    }
+  }
+  return params;
+}
+function matchCatchAll(pattern, pathname) {
+  const patternSegments = pattern.split("/").filter(Boolean);
+  const pathSegments = pathname.split("/").filter(Boolean);
+  const params = {};
+  let catchAllParam = null;
+  let catchAllValues = [];
+  for (let i = 0; i < patternSegments.length; i++) {
+    const segment = patternSegments[i];
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      catchAllParam = segment.slice(4, -1);
+      catchAllValues = pathSegments.slice(i);
+      break;
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      const paramName = segment.slice(1, -1);
+      if (i < pathSegments.length) {
+        params[paramName] = decodeURIComponent(pathSegments[i]);
+      } else {
+        return null;
+      }
+    } else if (segment !== pathSegments[i]) {
+      return null;
+    }
+  }
+  if (catchAllParam && catchAllValues.length === 0) {
+    return null;
+  }
+  if (catchAllParam) {
+    params[catchAllParam] = catchAllValues.map(decodeURIComponent).join("/");
+  }
+  return params;
+}
+function matchDynamicRoute(pattern, pathname) {
+  const parsed = parseRoutePattern(pattern);
+  if (parsed.isOptionalCatchAll) {
+    return matchOptionalCatchAll(pattern, pathname);
+  }
+  if (parsed.isCatchAll) {
+    return matchCatchAll(pattern, pathname);
+  }
+  const patternSegments = pattern.split("/").filter(Boolean);
+  const pathSegments = pathname.split("/").filter(Boolean);
+  if (patternSegments.length !== pathSegments.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternSegments.length; i++) {
+    const segment = patternSegments[i];
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      const paramName = segment.slice(1, -1);
+      params[paramName] = decodeURIComponent(pathSegments[i]);
+    } else if (segment !== pathSegments[i]) {
+      return null;
+    }
+  }
+  return params;
+}
+function buildDynamicPath(pattern, params) {
+  const segments = pattern.split("/").map((segment) => {
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+      const paramName = segment.slice(5, -2);
+      const value = params[paramName];
+      return value ? encodeURIComponent(String(value)) : "";
+    }
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      const paramName = segment.slice(4, -1);
+      const value = params[paramName];
+      return value ? encodeURIComponent(String(value)) : "";
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      const paramName = segment.slice(1, -1);
+      const value = params[paramName];
+      return value ? encodeURIComponent(String(value)) : segment;
+    }
+    return segment;
+  });
+  return "/" + segments.filter(Boolean).join("/");
+}
+
+// src/route-groups.ts
+var routeGroups = /* @__PURE__ */ new Map();
+function createRouteGroup(name, routes, options) {
+  const group = {
+    name,
+    routes,
+    layout: options?.layout,
+    metadata: options?.metadata
+  };
+  routeGroups.set(name, group);
+  return group;
+}
+function getRouteGroup(name) {
+  return routeGroups.get(name);
+}
+function getAllRouteGroups() {
+  return Array.from(routeGroups.values());
+}
+function removeRouteGroup(name) {
+  return routeGroups.delete(name);
+}
+function mergeRouteGroups(...groupNames) {
+  const merged = [];
+  for (const groupName of groupNames) {
+    const group = routeGroups.get(groupName);
+    if (group) {
+      merged.push(...group.routes);
+    }
+  }
+  return merged;
+}
+function clearRouteGroups() {
+  routeGroups.clear();
+}
+function createParallelRoutes(config) {
+  return defineComponent((incomingProps) => {
+    const props = incomingProps;
+    const slots = props.slots ?? config.slots;
+    props.defaultSlots ?? config.defaultSlots ?? {};
+    const slotEntries = Object.entries(slots);
+    const componentBindings = slotEntries.map(([slotName, component]) => ({
+      id: `slot_${slotName}`,
+      getComponent: () => component,
+      getProps: () => ({})
+    }));
+    return {
+      template: "__O_COMP_parallel_routes__",
+      textBindings: [],
+      htmlBindings: [],
+      attrBindings: [],
+      eventBindings: [],
+      slotBindings: slotEntries.map(([slotName]) => ({
+        id: `slot_${slotName}`,
+        name: slotName
+      })),
+      componentBindings
+    };
+  });
+}
+function useSlot(slotName) {
+  return null;
+}
+function renderSlot(slot) {
+  return defineComponent(() => ({
+    template: "__O_COMP_slot__",
+    textBindings: [],
+    htmlBindings: [],
+    attrBindings: [],
+    eventBindings: [],
+    slotBindings: [],
+    componentBindings: [
+      {
+        id: "slot_content",
+        getComponent: () => slot.component,
+        getProps: () => slot.props ?? {}
+      }
+    ]
+  }));
+}
+function conditionalSlot(condition, trueSlot, falseSlot) {
+  return condition ? trueSlot : falseSlot ?? defineComponent(() => ({
+    template: "",
+    textBindings: [],
+    htmlBindings: [],
+    attrBindings: [],
+    eventBindings: [],
+    slotBindings: [],
+    componentBindings: []
+  }));
+}
+
+// src/intercepting-routes.ts
+var interceptRules = /* @__PURE__ */ new Map();
+function levelToDepth(level) {
+  switch (level) {
+    case "same":
+      return 0;
+    case "parent":
+      return 1;
+    case "grandparent":
+      return 2;
+    case "root":
+      return Infinity;
+    default:
+      return 0;
+  }
+}
+function getSegmentDepth(path) {
+  return path.split("/").filter(Boolean).length;
+}
+function matchPattern(pattern, pathname) {
+  const patternSegments = pattern.split("/").filter(Boolean);
+  const pathSegments = pathname.split("/").filter(Boolean);
+  if (patternSegments.length > pathSegments.length) {
+    return false;
+  }
+  for (let i = 0; i < patternSegments.length; i++) {
+    const segment = patternSegments[i];
+    if (segment === "*") {
+      return true;
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      continue;
+    }
+    if (segment !== pathSegments[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function registerInterceptRule(id, rule) {
+  interceptRules.set(id, rule);
+}
+function getInterceptRule(id) {
+  return interceptRules.get(id);
+}
+function findInterceptor(pathname, currentPath) {
+  const currentDepth = getSegmentDepth(currentPath);
+  for (const rule of interceptRules.values()) {
+    if (!matchPattern(rule.pattern, pathname)) {
+      continue;
+    }
+    const interceptorDepth = getSegmentDepth(rule.interceptor);
+    const levelDepth = levelToDepth(rule.level);
+    if (rule.level === "same" && interceptorDepth === currentDepth) {
+      return rule;
+    }
+    if (rule.level === "parent" && interceptorDepth === currentDepth - levelDepth) {
+      return rule;
+    }
+    if (rule.level === "grandparent" && interceptorDepth === currentDepth - levelDepth) {
+      return rule;
+    }
+    if (rule.level === "root" && interceptorDepth === 0) {
+      return rule;
+    }
+  }
+  return null;
+}
+function removeInterceptRule(id) {
+  return interceptRules.delete(id);
+}
+function clearInterceptRules() {
+  interceptRules.clear();
+}
+function getAllInterceptRules() {
+  return Array.from(interceptRules.values());
+}
+
 // src/index.ts
 var ROUTER_CONTEXT = /* @__PURE__ */ Symbol.for("olova.router");
 var OUTLET_CONTEXT = /* @__PURE__ */ Symbol.for("olova.router.outlet");
@@ -363,7 +1270,7 @@ function resolveTarget(to, mode, base, named) {
     hash: to.hash ? `#${String(to.hash).replace(/^#/, "")}` : ""
   };
 }
-function stringifyTarget(target, base) {
+function stringifyTarget2(target, base) {
   if (target.mode === "hash") {
     const root = base === "/" ? "" : base;
     return `${root}/#${target.path}${target.search}`;
@@ -705,7 +1612,7 @@ var Router = defineComponent((incomingProps) => {
     push(to, options = {}) {
       const parsed = resolveTarget(to, props.mode ?? "auto", base, config.named);
       const next = resolveRoute(config, parsed, currentRoute.location, base);
-      const href = stringifyTarget(parsed, base);
+      const href = stringifyTarget2(parsed, base);
       const method = options.replace ? "replaceState" : "pushState";
       if (parsed.mode === "hash") {
         const targetHash = href.includes("#") ? href.slice(href.indexOf("#")) : "";
@@ -737,7 +1644,7 @@ var Router = defineComponent((incomingProps) => {
       syncFromWindow(false);
     },
     resolve(to) {
-      return stringifyTarget(resolveTarget(to, props.mode ?? "auto", base, config.named), base);
+      return stringifyTarget2(resolveTarget(to, props.mode ?? "auto", base, config.named), base);
     },
     href(to) {
       return this.resolve(to);
@@ -756,7 +1663,7 @@ var Router = defineComponent((incomingProps) => {
     const next = resolveRoute(config, target, currentRoute.location ?? null, base);
     setCurrentRoute(next);
     if (replace) {
-      const href = stringifyTarget(target, base);
+      const href = stringifyTarget2(target, base);
       window.history.replaceState({}, "", href);
     }
     applyScroll(target.hash, props.scroll ?? true);
@@ -818,6 +1725,6 @@ var BrowserRouter = createRouterVariant("history");
 var HashRouter = createRouterVariant("hash");
 var src_default = Router;
 
-export { BrowserRouter, HashRouter, Link_default as Link, Outlet, src_default as default, isActiveHref, link, matchPath, navigate, resolveHref, useParams, useQuery, useRoute, useRouter };
+export { BrowserRouter, HashRouter, Link_default as Link, Outlet, applyMetadata, buildDynamicPath, captureError, clearError, clearInterceptRules, clearMetadataCache, clearPrefetchCache, clearRouteGroups, clearSearchParamsCache, conditionalSlot, createAnalyticsMiddleware, createAuthMiddleware, createCompositeGuard, createConditionalGuard, createDebounceGuard, createMiddlewareChain, createParallelRoutes, createParamGuard, createQueryGuard, createRoleMiddleware, createRouteGroup, createRouterHistory, createScrollMiddleware, src_default as default, findInterceptor, generateBreadcrumbs, generateBreadcrumbsFromMatches, getAllInterceptRules, getAllRouteGroups, getError, getErrorBoundaryState, getInterceptRule, getRouteGroup, getRouteMetadata, hasError, isActiveHref, isPrefetched, lazyComponent, lazyComponentWithFallback, link, matchDynamicRoute, matchPath, mergeRouteGroups, navigate, parseRoutePattern, prefetchRoute, registerInterceptRule, registerRouteMetadata, removeInterceptRule, removeRouteGroup, renderSlot, resetTransition, resolveHref, startTransition, useHash, useParams, usePathname, useQuery, useRoute, useRouter, useSearchParams, useSlot, useTransition };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map