olova-router 1.0.19 → 1.0.21

package/dist/breadcrumbs.d.ts

@@ -0,0 +1,272 @@
+import { OlovaComponent, OlovaProps } from 'olova/runtime';
+import './history.js';
+import './lazy.js';
+
+declare const _default: OlovaComponent;
+
+type Breadcrumb = {
+    label: string;
+    path: string;
+    name?: string;
+};
+declare function generateBreadcrumbs(location: RouteLocation, labelMap?: Record<string, string>): Breadcrumb[];
+declare function generateBreadcrumbsFromMatches(matches: RouteMatchInfo[], labelMap?: Record<string, string>): Breadcrumb[];
+
+type GuardCondition = (context: RouteGuardContext) => boolean | Promise<boolean>;
+declare function createConditionalGuard(condition: GuardCondition, redirectTo?: RouteTarget): (context: RouteGuardContext) => Promise<RouteGuardResult>;
+declare function createParamGuard(paramName: string, validator: (value: string) => boolean | Promise<boolean>, redirectTo?: RouteTarget): (context: RouteGuardContext) => Promise<RouteGuardResult>;
+declare function createQueryGuard(queryKey: string, validator: (value: string | string[] | undefined) => boolean | Promise<boolean>, redirectTo?: RouteTarget): (context: RouteGuardContext) => Promise<RouteGuardResult>;
+declare function createCompositeGuard(guards: Array<(context: RouteGuardContext) => RouteGuardResult | Promise<RouteGuardResult>>): (context: RouteGuardContext) => Promise<RouteGuardResult>;
+declare function createDebounceGuard(guard: (context: RouteGuardContext) => RouteGuardResult | Promise<RouteGuardResult>, delayMs?: number): (context: RouteGuardContext) => Promise<RouteGuardResult>;
+
+type Middleware = (context: RouteGuardContext) => RouteGuardResult | Promise<RouteGuardResult>;
+type MiddlewareChain = {
+    use: (middleware: Middleware) => MiddlewareChain;
+    execute: (context: RouteGuardContext) => Promise<RouteGuardResult>;
+};
+declare function createMiddlewareChain(): MiddlewareChain;
+declare function createAuthMiddleware(isAuthenticated: () => boolean, redirectTo?: string): Middleware;
+declare function createRoleMiddleware(userRole: () => string | null, allowedRoles: string[], redirectTo?: string): Middleware;
+declare function createAnalyticsMiddleware(trackPageView: (path: string) => void): Middleware;
+declare function createScrollMiddleware(scrollToTop?: boolean): Middleware;
+
+type PrefetchOptions = {
+    priority?: "high" | "low";
+};
+declare function prefetchRoute(to: RouteTarget, options?: PrefetchOptions): void;
+declare function isPrefetched(to: RouteTarget): boolean;
+declare function clearPrefetchCache(): void;
+
+declare function useSearchParams(): {
+    get: (name: string) => string | null;
+    getAll: (name: string) => string[];
+    has: (name: string) => boolean;
+    keys: () => string[];
+    values: () => string[];
+    entries: () => Array<[string, string]>;
+    toString: () => string;
+};
+declare function usePathname(): string;
+declare function useHash(): string;
+declare function clearSearchParamsCache(): void;
+
+type TransitionState = "idle" | "pending" | "success" | "error";
+type TransitionOptions = {
+    onStart?: () => void;
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+};
+declare function useTransition(): {
+    isPending: boolean;
+    state: TransitionState;
+    error: Error | null;
+};
+declare function startTransition(callback: () => void | Promise<void>, options?: TransitionOptions): void;
+declare function resetTransition(): void;
+
+type ErrorBoundaryState = {
+    hasError: boolean;
+    error: Error | null;
+};
+declare function captureError(error: Error): void;
+declare function clearError(): void;
+declare function getErrorBoundaryState(): ErrorBoundaryState;
+declare function hasError(): boolean;
+declare function getError(): Error | null;
+
+type RouteMetadata = {
+    title?: string;
+    description?: string;
+    keywords?: string[];
+    author?: string;
+    robots?: string;
+    viewport?: string;
+    charset?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImage?: string;
+    ogUrl?: string;
+    ogType?: string;
+    twitterCard?: string;
+    twitterTitle?: string;
+    twitterDescription?: string;
+    twitterImage?: string;
+    twitterCreator?: string;
+    canonical?: string;
+    [key: string]: unknown;
+};
+type MetadataGenerator = (location: RouteLocation) => RouteMetadata | Promise<RouteMetadata>;
+declare function registerRouteMetadata(path: string, metadata: RouteMetadata | MetadataGenerator): void;
+declare function getRouteMetadata(location: RouteLocation): Promise<RouteMetadata>;
+declare function applyMetadata(metadata: RouteMetadata): void;
+declare function clearMetadataCache(): void;
+
+type RoutePattern = {
+    pattern: string;
+    isDynamic: boolean;
+    isCatchAll: boolean;
+    isOptionalCatchAll: boolean;
+    paramNames: string[];
+};
+declare function parseRoutePattern(path: string): RoutePattern;
+declare function matchDynamicRoute(pattern: string, pathname: string): RouteParams | null;
+declare function buildDynamicPath(pattern: string, params: RouteParams): string;
+
+type RouteGroup = {
+    name: string;
+    routes: RouteObject[];
+    layout?: OlovaComponent;
+    metadata?: Record<string, unknown>;
+};
+declare function createRouteGroup(name: string, routes: RouteObject[], options?: {
+    layout?: OlovaComponent;
+    metadata?: Record<string, unknown>;
+}): RouteGroup;
+declare function getRouteGroup(name: string): RouteGroup | undefined;
+declare function getAllRouteGroups(): RouteGroup[];
+declare function removeRouteGroup(name: string): boolean;
+declare function mergeRouteGroups(...groupNames: string[]): RouteObject[];
+declare function clearRouteGroups(): void;
+
+type Slot = {
+    name: string;
+    component: OlovaComponent;
+    props?: OlovaProps;
+};
+type ParallelRoutesConfig = {
+    slots: Record<string, OlovaComponent>;
+    defaultSlots?: Record<string, OlovaComponent>;
+};
+declare function createParallelRoutes(config: ParallelRoutesConfig): OlovaComponent;
+declare function useSlot(slotName: string): OlovaComponent | null;
+declare function renderSlot(slot: Slot): OlovaComponent;
+declare function conditionalSlot(condition: boolean, trueSlot: OlovaComponent, falseSlot?: OlovaComponent): OlovaComponent;
+
+type InterceptRule = {
+    pattern: string;
+    interceptor: string;
+    level: "same" | "parent" | "grandparent" | "root";
+};
+type InterceptConfig = {
+    rules: InterceptRule[];
+};
+declare function registerInterceptRule(id: string, rule: InterceptRule): void;
+declare function getInterceptRule(id: string): InterceptRule | undefined;
+declare function findInterceptor(pathname: string, currentPath: string): InterceptRule | null;
+declare function removeInterceptRule(id: string): boolean;
+declare function clearInterceptRules(): void;
+declare function getAllInterceptRules(): InterceptRule[];
+
+type RouterMode = "auto" | "history" | "hash";
+type ResolvedMode = "history" | "hash";
+type Primitive = string | number | boolean;
+type RouteParams = Record<string, string>;
+type RouteQueryValue = string | string[];
+type RouteQuery = Record<string, RouteQueryValue>;
+type RouteQueryInputValue = Primitive | Primitive[] | null | undefined;
+type RouteQueryInput = Record<string, RouteQueryInputValue>;
+type RouteTarget = string | {
+    name?: string;
+    path?: string;
+    params?: Record<string, Primitive>;
+    query?: RouteQueryInput;
+    hash?: string;
+};
+type NavigateOptions = {
+    replace?: boolean;
+    scroll?: boolean;
+};
+type MatchOptions = {
+    exact?: boolean;
+};
+type RouteMatchInfo = {
+    name?: string;
+    path: string;
+    meta?: unknown;
+};
+type RouteLocation = {
+    name?: string;
+    path: string;
+    fullPath: string;
+    href: string;
+    params: RouteParams;
+    query: RouteQuery;
+    hash: string;
+    meta?: unknown;
+    matchedPath: string;
+    matches: RouteMatchInfo[];
+};
+type RouteGuardContext = {
+    to: RouteLocation;
+    from: RouteLocation | null;
+    params: RouteParams;
+    query: RouteQuery;
+};
+type RouteGuardResult = boolean | string | RouteTarget | void;
+type RouteGuard = (context: RouteGuardContext) => RouteGuardResult;
+type RouteRedirect = RouteTarget | ((context: RouteGuardContext) => RouteTarget | null | undefined);
+type RoutePropsFactory = OlovaProps | ((context: RouteGuardContext) => OlovaProps);
+type RouteObject = {
+    path?: string;
+    index?: boolean;
+    component?: OlovaComponent;
+    redirect?: RouteRedirect;
+    props?: RoutePropsFactory;
+    beforeEnter?: RouteGuard;
+    name?: string;
+    meta?: unknown;
+    children?: RouteObject[];
+};
+type RouteDefinition = OlovaComponent | (Omit<RouteObject, "path" | "index"> & {
+    children?: RouteObject[];
+});
+type RouterRoutes = Record<string, RouteDefinition> | RouteObject[];
+type RouterProps = {
+    routes: RouterRoutes;
+    mode?: RouterMode;
+    base?: string;
+    scroll?: boolean;
+};
+type RouteResolution = {
+    mode: ResolvedMode;
+    location: RouteLocation;
+    component: OlovaComponent;
+    props: OlovaProps;
+};
+type RouterApi = {
+    current: () => RouteResolution;
+    readonly mode: ResolvedMode;
+    readonly location: RouteLocation;
+    readonly path: string;
+    readonly fullPath: string;
+    readonly params: RouteParams;
+    readonly query: RouteQuery;
+    readonly hash: string;
+    readonly matchedPath: string;
+    readonly matches: RouteMatchInfo[];
+    push: (to: RouteTarget, options?: NavigateOptions) => void;
+    navigate: (to: RouteTarget, options?: NavigateOptions) => void;
+    replace: (to: RouteTarget, options?: Omit<NavigateOptions, "replace">) => void;
+    back: () => void;
+    forward: () => void;
+    refresh: () => void;
+    resolve: (to: RouteTarget) => string;
+    href: (to: RouteTarget) => string;
+    isActive: (to: RouteTarget, options?: MatchOptions) => boolean;
+};
+
+declare function matchPath(pattern: string, path: string): RouteParams | null;
+declare function navigate(to: RouteTarget, options?: NavigateOptions): void;
+declare function link(toOrEvent?: RouteTarget | Event, options?: NavigateOptions): ((event?: Event) => void) | void;
+declare function useRouter(): RouterApi;
+declare function useRoute(): RouteLocation;
+declare function useParams(): RouteParams;
+declare function useQuery(): RouteQuery;
+declare function resolveHref(to: RouteTarget): string;
+declare function isActiveHref(to: RouteTarget, options?: MatchOptions): boolean;
+declare const Outlet: OlovaComponent;
+declare const Router: OlovaComponent;
+declare const BrowserRouter: OlovaComponent;
+declare const HashRouter: OlovaComponent;
+
+export { getRouteGroup as $, buildDynamicPath as A, BrowserRouter as B, type Breadcrumb, captureError as C, clearError as D, clearInterceptRules as E, clearMetadataCache as F, type GuardCondition as G, HashRouter as H, type InterceptConfig as I, clearPrefetchCache as J, clearRouteGroups as K, clearSearchParamsCache as L, type Middleware as M, type NavigateOptions as N, Outlet as O, conditionalSlot as P, createParallelRoutes as Q, type RouteDefinition as R, createRouteGroup as S, Router as T, findInterceptor as U, getAllInterceptRules as V, getAllRouteGroups as W, getError as X, getErrorBoundaryState as Y, getInterceptRule as Z, _default as _, createConditionalGuard as a, getRouteMetadata as a0, hasError as a1, isActiveHref as a2, isPrefetched as a3, link as a4, matchDynamicRoute as a5, matchPath as a6, mergeRouteGroups as a7, navigate as a8, parseRoutePattern as a9, prefetchRoute as aa, registerInterceptRule as ab, registerRouteMetadata as ac, removeInterceptRule as ad, removeRouteGroup as ae, renderSlot as af, resetTransition as ag, resolveHref as ah, startTransition as ai, useHash as aj, useParams as ak, usePathname as al, useQuery as am, useRoute as an, useRouter as ao, useSearchParams as ap, useSlot as aq, useTransition as ar, createDebounceGuard as b, createCompositeGuard as c, createParamGuard as d, createQueryGuard as e, type MiddlewareChain as f, createAnalyticsMiddleware as g, generateBreadcrumbs, generateBreadcrumbsFromMatches, createAuthMiddleware as h, createMiddlewareChain as i, createRoleMiddleware as j, createScrollMiddleware as k, type InterceptRule as l, type MatchOptions as m, type RouteGuardContext as n, type RouteGuardResult as o, type RouteLocation as p, type RouteMatchInfo as q, type RouteObject as r, type RouteParams as s, type RouteQuery as t, type RouteQueryInput as u, type RouteTarget as v, type RouterMode as w, type RouterProps as x, type RouterRoutes as y, applyMetadata as z };

package/dist/breadcrumbs.js

@@ -0,0 +1,36 @@
+// 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;
+}
+
+export { generateBreadcrumbs, generateBreadcrumbsFromMatches };
+//# sourceMappingURL=breadcrumbs.js.map
+//# sourceMappingURL=breadcrumbs.js.map

package/dist/breadcrumbs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/breadcrumbs.ts"],"names":[],"mappings":";AAQO,SAAS,mBAAA,CAAoB,UAAyB,QAAA,EAAiD;AAC5G,EAAA,MAAM,cAA4B,EAAC;AACnC,EAAA,MAAM,WAAW,QAAA,CAAS,IAAA,CAAK,MAAM,GAAG,CAAA,CAAE,OAAO,OAAO,CAAA;AAExD,EAAA,WAAA,CAAY,IAAA,CAAK;AAAA,IACf,KAAA,EAAO,UAAU,IAAA,IAAQ,MAAA;AAAA,IACzB,IAAA,EAAM,GAAA;AAAA,IACN,IAAA,EAAM;AAAA,GACP,CAAA;AAED,EAAA,IAAI,WAAA,GAAc,EAAA;AAClB,EAAA,KAAA,MAAW,WAAW,QAAA,EAAU;AAC9B,IAAA,WAAA,IAAe,IAAI,OAAO,CAAA,CAAA;AAC1B,IAAA,MAAM,KAAA,GAAQ,QAAA,GAAW,OAAO,CAAA,IAAK,OAAA,CAAQ,MAAA,CAAO,CAAC,CAAA,CAAE,WAAA,EAAY,GAAI,OAAA,CAAQ,KAAA,CAAM,CAAC,CAAA;AAEtF,IAAA,WAAA,CAAY,IAAA,CAAK;AAAA,MACf,KAAA;AAAA,MACA,IAAA,EAAM;AAAA,KACP,CAAA;AAAA,EACH;AAEA,EAAA,OAAO,WAAA;AACT;AAEO,SAAS,8BAAA,CACd,SACA,QAAA,EACc;AACd,EAAA,MAAM,cAA4B,EAAC;AAEnC,EAAA,KAAA,MAAW,SAAS,OAAA,EAAS;AAC3B,IAAA,MAAM,KAAA,GAAQ,WAAW,KAAA,CAAM,IAAA,IAAQ,EAAE,CAAA,IAAK,KAAA,CAAM,QAAQ,KAAA,CAAM,IAAA;AAClE,IAAA,WAAA,CAAY,IAAA,CAAK;AAAA,MACf,KAAA;AAAA,MACA,MAAM,KAAA,CAAM,IAAA;AAAA,MACZ,MAAM,KAAA,CAAM;AAAA,KACb,CAAA;AAAA,EACH;AAEA,EAAA,OAAO,WAAA;AACT","file":"breadcrumbs.js","sourcesContent":["import type { RouteLocation, RouteMatchInfo } from \"./index\";\r\n\r\nexport type Breadcrumb = {\r\n  label: string;\r\n  path: string;\r\n  name?: string;\r\n};\r\n\r\nexport function generateBreadcrumbs(location: RouteLocation, labelMap?: Record<string, string>): Breadcrumb[] {\r\n  const breadcrumbs: Breadcrumb[] = [];\r\n  const segments = location.path.split(\"/\").filter(Boolean);\r\n\r\n  breadcrumbs.push({\r\n    label: labelMap?.home ?? \"Home\",\r\n    path: \"/\",\r\n    name: \"home\",\r\n  });\r\n\r\n  let currentPath = \"\";\r\n  for (const segment of segments) {\r\n    currentPath += `/${segment}`;\r\n    const label = labelMap?.[segment] ?? segment.charAt(0).toUpperCase() + segment.slice(1);\r\n\r\n    breadcrumbs.push({\r\n      label,\r\n      path: currentPath,\r\n    });\r\n  }\r\n\r\n  return breadcrumbs;\r\n}\r\n\r\nexport function generateBreadcrumbsFromMatches(\r\n  matches: RouteMatchInfo[],\r\n  labelMap?: Record<string, string>,\r\n): Breadcrumb[] {\r\n  const breadcrumbs: Breadcrumb[] = [];\r\n\r\n  for (const match of matches) {\r\n    const label = labelMap?.[match.name ?? \"\"] ?? match.name ?? match.path;\r\n    breadcrumbs.push({\r\n      label,\r\n      path: match.path,\r\n      name: match.name,\r\n    });\r\n  }\r\n\r\n  return breadcrumbs;\r\n}\r\n"]}

package/dist/guards.d.ts

@@ -0,0 +1,4 @@
+export { G as GuardCondition, c as createCompositeGuard, a as createConditionalGuard, b as createDebounceGuard, d as createParamGuard, e as createQueryGuard } from './breadcrumbs.js';
+import 'olova/runtime';
+import './history.js';
+import './lazy.js';

package/dist/guards.js

@@ -0,0 +1,66 @@
+// 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);
+    });
+  };
+}
+
+export { createCompositeGuard, createConditionalGuard, createDebounceGuard, createParamGuard, createQueryGuard };
+//# sourceMappingURL=guards.js.map
+//# sourceMappingURL=guards.js.map

package/dist/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/guards.ts"],"names":[],"mappings":";AAIO,SAAS,sBAAA,CACd,WACA,UAAA,EAC2D;AAC3D,EAAA,OAAO,OAAO,OAAA,KAAY;AACxB,IAAA,MAAM,OAAA,GAAU,MAAM,SAAA,CAAU,OAAO,CAAA;AACvC,IAAA,IAAI,CAAC,WAAW,UAAA,EAAY;AAC1B,MAAA,OAAO,UAAA;AAAA,IACT;AACA,IAAA,OAAO,OAAA;AAAA,EACT,CAAA;AACF;AAEO,SAAS,gBAAA,CACd,SAAA,EACA,SAAA,EACA,UAAA,EAC2D;AAC3D,EAAA,OAAO,OAAO,OAAA,KAAY;AACxB,IAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,MAAA,CAAO,SAAS,CAAA;AACtC,IAAA,IAAI,CAAC,KAAA,EAAO;AACV,MAAA,OAAO,aAAa,UAAA,GAAa,KAAA;AAAA,IACnC;AACA,IAAA,MAAM,KAAA,GAAQ,MAAM,SAAA,CAAU,KAAK,CAAA;AACnC,IAAA,IAAI,CAAC,SAAS,UAAA,EAAY;AACxB,MAAA,OAAO,UAAA;AAAA,IACT;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AACF;AAEO,SAAS,gBAAA,CACd,QAAA,EACA,SAAA,EACA,UAAA,EAC2D;AAC3D,EAAA,OAAO,OAAO,OAAA,KAAY;AACxB,IAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,KAAA,CAAM,QAAQ,CAAA;AACpC,IAAA,MAAM,KAAA,GAAQ,MAAM,SAAA,CAAU,KAAK,CAAA;AACnC,IAAA,IAAI,CAAC,SAAS,UAAA,EAAY;AACxB,MAAA,OAAO,UAAA;AAAA,IACT;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AACF;AAEO,SAAS,qBACd,MAAA,EAC2D;AAC3D,EAAA,OAAO,OAAO,OAAA,KAAY;AACxB,IAAA,KAAA,MAAW,SAAS,MAAA,EAAQ;AAC1B,MAAA,MAAM,MAAA,GAAS,MAAM,KAAA,CAAM,OAAO,CAAA;AAClC,MAAA,IAAI,MAAA,KAAW,IAAA,IAAQ,MAAA,KAAW,MAAA,EAAW;AAC3C,QAAA,OAAO,MAAA;AAAA,MACT;AAAA,IACF;AACA,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AACF;AAEO,SAAS,mBAAA,CACd,KAAA,EACA,OAAA,GAAU,GAAA,EACiD;AAC3D,EAAA,IAAI,SAAA,GAAkD,IAAA;AACtD,EAAA,IAAI,WAAA,GAAwC,IAAA;AAE5C,EAAA,OAAO,OAAO,OAAA,KAAY;AACxB,IAAA,WAAA,GAAc,OAAA;AAEd,IAAA,OAAO,IAAI,OAAA,CAAQ,CAAC,OAAA,KAAY;AAC9B,MAAA,IAAI,SAAA,EAAW;AACb,QAAA,YAAA,CAAa,SAAS,CAAA;AAAA,MACxB;AAEA,MAAA,SAAA,GAAY,WAAW,YAAY;AACjC,QAAA,IAAI,gBAAgB,OAAA,EAAS;AAC3B,UAAA,MAAM,MAAA,GAAS,MAAM,KAAA,CAAM,OAAO,CAAA;AAClC,UAAA,OAAA,CAAQ,MAAM,CAAA;AAAA,QAChB;AAAA,MACF,GAAG,OAAO,CAAA;AAAA,IACZ,CAAC,CAAA;AAAA,EACH,CAAA;AACF","file":"guards.js","sourcesContent":["import type { RouteGuardContext, RouteGuardResult, RouteTarget } from \"./index\";\r\n\r\nexport type GuardCondition = (context: RouteGuardContext) => boolean | Promise<boolean>;\r\n\r\nexport function createConditionalGuard(\r\n  condition: GuardCondition,\r\n  redirectTo?: RouteTarget,\r\n): (context: RouteGuardContext) => Promise<RouteGuardResult> {\r\n  return async (context) => {\r\n    const allowed = await condition(context);\r\n    if (!allowed && redirectTo) {\r\n      return redirectTo;\r\n    }\r\n    return allowed;\r\n  };\r\n}\r\n\r\nexport function createParamGuard(\r\n  paramName: string,\r\n  validator: (value: string) => boolean | Promise<boolean>,\r\n  redirectTo?: RouteTarget,\r\n): (context: RouteGuardContext) => Promise<RouteGuardResult> {\r\n  return async (context) => {\r\n    const value = context.params[paramName];\r\n    if (!value) {\r\n      return redirectTo ? redirectTo : false;\r\n    }\r\n    const valid = await validator(value);\r\n    if (!valid && redirectTo) {\r\n      return redirectTo;\r\n    }\r\n    return valid;\r\n  };\r\n}\r\n\r\nexport function createQueryGuard(\r\n  queryKey: string,\r\n  validator: (value: string | string[] | undefined) => boolean | Promise<boolean>,\r\n  redirectTo?: RouteTarget,\r\n): (context: RouteGuardContext) => Promise<RouteGuardResult> {\r\n  return async (context) => {\r\n    const value = context.query[queryKey];\r\n    const valid = await validator(value);\r\n    if (!valid && redirectTo) {\r\n      return redirectTo;\r\n    }\r\n    return valid;\r\n  };\r\n}\r\n\r\nexport function createCompositeGuard(\r\n  guards: Array<(context: RouteGuardContext) => RouteGuardResult | Promise<RouteGuardResult>>,\r\n): (context: RouteGuardContext) => Promise<RouteGuardResult> {\r\n  return async (context) => {\r\n    for (const guard of guards) {\r\n      const result = await guard(context);\r\n      if (result !== true && result !== undefined) {\r\n        return result;\r\n      }\r\n    }\r\n    return true;\r\n  };\r\n}\r\n\r\nexport function createDebounceGuard(\r\n  guard: (context: RouteGuardContext) => RouteGuardResult | Promise<RouteGuardResult>,\r\n  delayMs = 300,\r\n): (context: RouteGuardContext) => Promise<RouteGuardResult> {\r\n  let timeoutId: ReturnType<typeof setTimeout> | null = null;\r\n  let lastContext: RouteGuardContext | null = null;\r\n\r\n  return async (context) => {\r\n    lastContext = context;\r\n\r\n    return new Promise((resolve) => {\r\n      if (timeoutId) {\r\n        clearTimeout(timeoutId);\r\n      }\r\n\r\n      timeoutId = setTimeout(async () => {\r\n        if (lastContext === context) {\r\n          const result = await guard(context);\r\n          resolve(result);\r\n        }\r\n      }, delayMs);\r\n    });\r\n  };\r\n}\r\n"]}

package/dist/history.d.ts

@@ -0,0 +1,17 @@
+type HistoryEntry = {
+    path: string;
+    timestamp: number;
+};
+type RouterHistory = {
+    entries: HistoryEntry[];
+    current: number;
+    push: (path: string) => void;
+    back: () => HistoryEntry | null;
+    forward: () => HistoryEntry | null;
+    go: (delta: number) => HistoryEntry | null;
+    clear: () => void;
+    getHistory: () => HistoryEntry[];
+};
+declare function createRouterHistory(maxSize?: number): RouterHistory;
+
+export { type HistoryEntry, type RouterHistory, createRouterHistory };

package/dist/history.js

@@ -0,0 +1,51 @@
+// 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];
+    }
+  };
+}
+
+export { createRouterHistory };
+//# sourceMappingURL=history.js.map
+//# sourceMappingURL=history.js.map

package/dist/history.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/history.ts"],"names":[],"mappings":";AAgBO,SAAS,mBAAA,CAAoB,UAAU,EAAA,EAAmB;AAC/D,EAAA,MAAM,UAA0B,EAAC;AACjC,EAAA,IAAI,OAAA,GAAU,EAAA;AAEd,EAAA,OAAO;AAAA,IACL,OAAA;AAAA,IACA,OAAA;AAAA,IACA,KAAK,IAAA,EAAc;AACjB,MAAA,OAAA,CAAQ,MAAA,CAAO,UAAU,CAAC,CAAA;AAC1B,MAAA,OAAA,CAAQ,KAAK,EAAE,IAAA,EAAM,WAAW,IAAA,CAAK,GAAA,IAAO,CAAA;AAC5C,MAAA,IAAI,OAAA,CAAQ,SAAS,OAAA,EAAS;AAC5B,QAAA,OAAA,CAAQ,KAAA,EAAM;AAAA,MAChB,CAAA,MAAO;AACL,QAAA,OAAA,EAAA;AAAA,MACF;AAAA,IACF,CAAA;AAAA,IACA,IAAA,GAAO;AACL,MAAA,IAAI,UAAU,CAAA,EAAG;AACf,QAAA,OAAA,EAAA;AACA,QAAA,OAAO,QAAQ,OAAO,CAAA;AAAA,MACxB;AACA,MAAA,OAAO,IAAA;AAAA,IACT,CAAA;AAAA,IACA,OAAA,GAAU;AACR,MAAA,IAAI,OAAA,GAAU,OAAA,CAAQ,MAAA,GAAS,CAAA,EAAG;AAChC,QAAA,OAAA,EAAA;AACA,QAAA,OAAO,QAAQ,OAAO,CAAA;AAAA,MACxB;AACA,MAAA,OAAO,IAAA;AAAA,IACT,CAAA;AAAA,IACA,GAAG,KAAA,EAAe;AAChB,MAAA,MAAM,OAAO,OAAA,GAAU,KAAA;AACvB,MAAA,IAAI,IAAA,IAAQ,CAAA,IAAK,IAAA,GAAO,OAAA,CAAQ,MAAA,EAAQ;AACtC,QAAA,OAAA,GAAU,IAAA;AACV,QAAA,OAAO,QAAQ,OAAO,CAAA;AAAA,MACxB;AACA,MAAA,OAAO,IAAA;AAAA,IACT,CAAA;AAAA,IACA,KAAA,GAAQ;AACN,MAAA,OAAA,CAAQ,MAAA,GAAS,CAAA;AACjB,MAAA,OAAA,GAAU,EAAA;AAAA,IACZ,CAAA;AAAA,IACA,UAAA,GAAa;AACX,MAAA,OAAO,CAAC,GAAG,OAAO,CAAA;AAAA,IACpB;AAAA,GACF;AACF","file":"history.js","sourcesContent":["export type HistoryEntry = {\r\n  path: string;\r\n  timestamp: number;\r\n};\r\n\r\nexport type RouterHistory = {\r\n  entries: HistoryEntry[];\r\n  current: number;\r\n  push: (path: string) => void;\r\n  back: () => HistoryEntry | null;\r\n  forward: () => HistoryEntry | null;\r\n  go: (delta: number) => HistoryEntry | null;\r\n  clear: () => void;\r\n  getHistory: () => HistoryEntry[];\r\n};\r\n\r\nexport function createRouterHistory(maxSize = 50): RouterHistory {\r\n  const entries: HistoryEntry[] = [];\r\n  let current = -1;\r\n\r\n  return {\r\n    entries,\r\n    current,\r\n    push(path: string) {\r\n      entries.splice(current + 1);\r\n      entries.push({ path, timestamp: Date.now() });\r\n      if (entries.length > maxSize) {\r\n        entries.shift();\r\n      } else {\r\n        current++;\r\n      }\r\n    },\r\n    back() {\r\n      if (current > 0) {\r\n        current--;\r\n        return entries[current];\r\n      }\r\n      return null;\r\n    },\r\n    forward() {\r\n      if (current < entries.length - 1) {\r\n        current++;\r\n        return entries[current];\r\n      }\r\n      return null;\r\n    },\r\n    go(delta: number) {\r\n      const next = current + delta;\r\n      if (next >= 0 && next < entries.length) {\r\n        current = next;\r\n        return entries[current];\r\n      }\r\n      return null;\r\n    },\r\n    clear() {\r\n      entries.length = 0;\r\n      current = -1;\r\n    },\r\n    getHistory() {\r\n      return [...entries];\r\n    },\r\n  };\r\n}\r\n"]}

package/dist/index.d.ts

@@ -1,117 +1,4 @@
-import { OlovaComponent, OlovaProps } from 'olova/runtime';
-
-declare const _default: OlovaComponent;
-
-type RouterMode = "auto" | "history" | "hash";
-type ResolvedMode = "history" | "hash";
-type Primitive = string | number | boolean;
-type RouteParams = Record<string, string>;
-type RouteQueryValue = string | string[];
-type RouteQuery = Record<string, RouteQueryValue>;
-type RouteQueryInputValue = Primitive | Primitive[] | null | undefined;
-type RouteQueryInput = Record<string, RouteQueryInputValue>;
-type RouteTarget = string | {
-    name?: string;
-    path?: string;
-    params?: Record<string, Primitive>;
-    query?: RouteQueryInput;
-    hash?: string;
-};
-type NavigateOptions = {
-    replace?: boolean;
-    scroll?: boolean;
-};
-type MatchOptions = {
-    exact?: boolean;
-};
-type RouteMatchInfo = {
-    name?: string;
-    path: string;
-    meta?: unknown;
-};
-type RouteLocation = {
-    name?: string;
-    path: string;
-    fullPath: string;
-    href: string;
-    params: RouteParams;
-    query: RouteQuery;
-    hash: string;
-    meta?: unknown;
-    matchedPath: string;
-    matches: RouteMatchInfo[];
-};
-type RouteGuardContext = {
-    to: RouteLocation;
-    from: RouteLocation | null;
-    params: RouteParams;
-    query: RouteQuery;
-};
-type RouteGuardResult = boolean | string | RouteTarget | void;
-type RouteGuard = (context: RouteGuardContext) => RouteGuardResult;
-type RouteRedirect = RouteTarget | ((context: RouteGuardContext) => RouteTarget | null | undefined);
-type RoutePropsFactory = OlovaProps | ((context: RouteGuardContext) => OlovaProps);
-type RouteObject = {
-    path?: string;
-    index?: boolean;
-    component?: OlovaComponent;
-    redirect?: RouteRedirect;
-    props?: RoutePropsFactory;
-    beforeEnter?: RouteGuard;
-    name?: string;
-    meta?: unknown;
-    children?: RouteObject[];
-};
-type RouteDefinition = OlovaComponent | (Omit<RouteObject, "path" | "index"> & {
-    children?: RouteObject[];
-});
-type RouterRoutes = Record<string, RouteDefinition> | RouteObject[];
-type RouterProps = {
-    routes: RouterRoutes;
-    mode?: RouterMode;
-    base?: string;
-    scroll?: boolean;
-};
-type RouteResolution = {
-    mode: ResolvedMode;
-    location: RouteLocation;
-    component: OlovaComponent;
-    props: OlovaProps;
-};
-type RouterApi = {
-    current: () => RouteResolution;
-    readonly mode: ResolvedMode;
-    readonly location: RouteLocation;
-    readonly path: string;
-    readonly fullPath: string;
-    readonly params: RouteParams;
-    readonly query: RouteQuery;
-    readonly hash: string;
-    readonly matchedPath: string;
-    readonly matches: RouteMatchInfo[];
-    push: (to: RouteTarget, options?: NavigateOptions) => void;
-    navigate: (to: RouteTarget, options?: NavigateOptions) => void;
-    replace: (to: RouteTarget, options?: Omit<NavigateOptions, "replace">) => void;
-    back: () => void;
-    forward: () => void;
-    refresh: () => void;
-    resolve: (to: RouteTarget) => string;
-    href: (to: RouteTarget) => string;
-    isActive: (to: RouteTarget, options?: MatchOptions) => boolean;
-};
-
-declare function matchPath(pattern: string, path: string): RouteParams | null;
-declare function navigate(to: RouteTarget, options?: NavigateOptions): void;
-declare function link(toOrEvent?: RouteTarget | Event, options?: NavigateOptions): ((event?: Event) => void) | void;
-declare function useRouter(): RouterApi;
-declare function useRoute(): RouteLocation;
-declare function useParams(): RouteParams;
-declare function useQuery(): RouteQuery;
-declare function resolveHref(to: RouteTarget): string;
-declare function isActiveHref(to: RouteTarget, options?: MatchOptions): boolean;
-declare const Outlet: OlovaComponent;
-declare const Router: OlovaComponent;
-declare const BrowserRouter: OlovaComponent;
-declare const HashRouter: OlovaComponent;
-
-export { BrowserRouter, HashRouter, _default as Link, type MatchOptions, type NavigateOptions, Outlet, type RouteDefinition, type RouteGuardContext, type RouteLocation, type RouteMatchInfo, type RouteObject, type RouteParams, type RouteQuery, type RouteQueryInput, type RouteTarget, type RouterMode, type RouterProps, type RouterRoutes, Router as default, isActiveHref, link, matchPath, navigate, resolveHref, useParams, useQuery, useRoute, useRouter };
+import 'olova/runtime';
+export { Breadcrumb, B as BrowserRouter, G as GuardCondition, H as HashRouter, I as InterceptConfig, l as InterceptRule, _ as Link, m as MatchOptions, M as Middleware, f as MiddlewareChain, N as NavigateOptions, O as Outlet, R as RouteDefinition, n as RouteGuardContext, o as RouteGuardResult, p as RouteLocation, q as RouteMatchInfo, r as RouteObject, s as RouteParams, t as RouteQuery, u as RouteQueryInput, v as RouteTarget, w as RouterMode, x as RouterProps, y as RouterRoutes, z as applyMetadata, A as buildDynamicPath, C as captureError, D as clearError, E as clearInterceptRules, F as clearMetadataCache, J as clearPrefetchCache, K as clearRouteGroups, L as clearSearchParamsCache, P as conditionalSlot, g as createAnalyticsMiddleware, h as createAuthMiddleware, c as createCompositeGuard, a as createConditionalGuard, b as createDebounceGuard, i as createMiddlewareChain, Q as createParallelRoutes, d as createParamGuard, e as createQueryGuard, j as createRoleMiddleware, S as createRouteGroup, k as createScrollMiddleware, T as default, U as findInterceptor, generateBreadcrumbs, generateBreadcrumbsFromMatches, V as getAllInterceptRules, W as getAllRouteGroups, X as getError, Y as getErrorBoundaryState, Z as getInterceptRule, $ as getRouteGroup, a0 as getRouteMetadata, a1 as hasError, a2 as isActiveHref, a3 as isPrefetched, a4 as link, a5 as matchDynamicRoute, a6 as matchPath, a7 as mergeRouteGroups, a8 as navigate, a9 as parseRoutePattern, aa as prefetchRoute, ab as registerInterceptRule, ac as registerRouteMetadata, ad as removeInterceptRule, ae as removeRouteGroup, af as renderSlot, ag as resetTransition, ah as resolveHref, ai as startTransition, aj as useHash, ak as useParams, al as usePathname, am as useQuery, an as useRoute, ao as useRouter, ap as useSearchParams, aq as useSlot, ar as useTransition } from './breadcrumbs.js';
+export { HistoryEntry, RouterHistory, createRouterHistory } from './history.js';
+export { LazyComponentLoader, lazyComponent, lazyComponentWithFallback } from './lazy.js';