@lytjs/router 6.4.0 → 6.6.0

package/dist/index.d.ts

@@ -0,0 +1,284 @@
+import * as _lytjs_reactivity from '@lytjs/reactivity';
+import { Signal } from '@lytjs/reactivity';
+
+/**
+ * @lytjs/router - Core type definitions
+ */
+
+type App = {
+    provide?: unknown;
+    config?: {
+        globalProperties?: Record<string, unknown>;
+    };
+};
+type Component = unknown;
+type RouteRecordName = string | symbol;
+type RouteParams = Record<string, string | string[]>;
+type LocationQuery = Record<string, string | string[] | null>;
+type RouteMeta = Record<string | number | symbol, unknown>;
+interface RouteRecordRaw {
+    path: string;
+    name?: RouteRecordName;
+    component?: Component | (() => Promise<Component>);
+    children?: RouteRecordRaw[];
+    redirect?: string | RouteLocationRaw | ((to: RouteLocationNormalized) => RouteLocationRaw);
+    alias?: string | string[];
+    meta?: RouteMeta;
+    beforeEnter?: NavigationGuard;
+    props?: boolean | Record<string, unknown> | ((to: RouteLocationNormalized) => Record<string, unknown>);
+}
+interface RouteRecordNormalized {
+    path: string;
+    name: RouteRecordName | null;
+    meta: RouteMeta;
+    children: RouteRecordNormalized[];
+    aliasOf?: RouteRecordNormalized;
+    beforeEnter?: NavigationGuard | undefined;
+    props: boolean | Record<string, unknown> | ((to: RouteLocationNormalized) => Record<string, unknown>);
+    component?: Component | (() => Promise<Component>);
+    components?: Record<string, Component | (() => Promise<Component>)>;
+}
+interface RouteLocationNormalized {
+    name: RouteRecordName | null;
+    path: string;
+    fullPath: string;
+    query: LocationQuery;
+    hash: string;
+    params: RouteParams;
+    matched: RouteRecordNormalized[];
+    meta: RouteMeta;
+    redirectedFrom?: RouteLocationNormalized;
+}
+type RouteLocationRaw = string | {
+    path?: string;
+    name?: RouteRecordName | null;
+    params?: RouteParams;
+    query?: LocationQuery;
+    hash?: string;
+};
+interface NavigationGuardNext {
+    (): void;
+    (error: Error): void;
+    (location: RouteLocationRaw): void;
+    (valid: boolean): void;
+}
+type NavigationGuardReturn = void | Error | RouteLocationRaw | boolean | undefined;
+type NavigationGuard = (to: RouteLocationNormalized, from: RouteLocationNormalized, next: NavigationGuardNext) => NavigationGuardReturn;
+interface NavigationFailure {
+    type: NavigationFailureType;
+    from: RouteLocationNormalized;
+    to: RouteLocationNormalized;
+}
+declare enum NavigationFailureType {
+    aborted = 1,
+    cancelled = 2,
+    duplicated = 4
+}
+type RouterScrollBehavior = (to: RouteLocationNormalized, from: RouteLocationNormalized, savedPosition: {
+    left: number;
+    top: number;
+} | null) => {
+    left: number;
+    top: number;
+} | void | false;
+interface RouterOptions {
+    history: RouterHistory;
+    routes: RouteRecordRaw[];
+    scrollBehavior?: RouterScrollBehavior;
+    strict?: boolean;
+}
+interface Router {
+    readonly currentRoute: Signal<RouteLocationNormalized>;
+    readonly options: RouterOptions;
+    push(to: RouteLocationRaw): Promise<NavigationFailure | void>;
+    replace(to: RouteLocationRaw): Promise<NavigationFailure | void>;
+    go(delta: number): void;
+    back(): void;
+    forward(): void;
+    beforeEach(guard: NavigationGuard): () => void;
+    afterEach(hook: (to: RouteLocationNormalized, from: RouteLocationNormalized, failure?: NavigationFailure) => void): () => void;
+    beforeResolve(guard: NavigationGuard): () => void;
+    install(app: App): void;
+    isReady(): Promise<void>;
+    resolveName(name: string | symbol, params?: RouteParams): {
+        path: string;
+    } | null;
+}
+type HistoryState = Record<string, unknown>;
+interface NavigationInfo {
+    type: 'push' | 'replace' | 'pop';
+    direction: 'back' | 'forward' | 'unknown';
+    delta: number;
+}
+interface RouterHistory {
+    readonly location: RouteLocationNormalized;
+    readonly state: HistoryState | null;
+    base: string;
+    push(to: RouteLocationRaw): Promise<NavigationFailure | void>;
+    replace(to: RouteLocationRaw): Promise<NavigationFailure | void>;
+    go(delta: number): void;
+    listen(callback: (to: RouteLocationNormalized, from: RouteLocationNormalized, info: NavigationInfo) => void): () => void;
+    destroy(): void;
+}
+
+/**
+ * @lytjs/router - createRouter implementation
+ *
+ * Core router with navigation, guard pipeline, and route matching.
+ */
+
+/**
+ * Create a router instance
+ */
+declare function createRouter(options: RouterOptions): Router;
+
+/**
+ * @lytjs/router - History implementations
+ *
+ * Provides three history modes:
+ * - createWebHistory: HTML5 History API
+ * - createWebHashHistory: hash-based routing
+ * - createMemoryHistory: in-memory (SSR/testing)
+ */
+
+/**
+ * Create a Web History implementation using the HTML5 History API
+ */
+declare function createWebHistory(base?: string): RouterHistory;
+/**
+ * Create a Hash History implementation using hashchange events
+ */
+declare function createWebHashHistory(base?: string): RouterHistory;
+/**
+ * Create an in-memory history implementation for SSR and testing
+ */
+declare function createMemoryHistory(initial?: string): RouterHistory;
+
+/**
+ * @lytjs/router - useRouter composable
+ */
+
+/**
+ * Set the active router instance (called during install)
+ */
+declare function setCurrentRouter(router: Router): void;
+/**
+ * Get the current router instance
+ */
+declare function useRouter(): Router;
+
+/**
+ * @lytjs/router - useRoute composable
+ */
+
+/**
+ * Get the current route location (reactive)
+ * Returns a Signal that can be called to get the current route value
+ */
+declare function useRoute(): Signal<RouteLocationNormalized>;
+
+interface UseLinkOptions {
+    to: RouteLocationRaw;
+    replace?: boolean;
+    activeClass?: string;
+    exactActiveClass?: string;
+}
+declare function useLink(options: UseLinkOptions): {
+    route: _lytjs_reactivity.ComputedSignal<{
+        path: string;
+        query: LocationQuery;
+        hash: string;
+        params?: RouteParams;
+    }>;
+    href: _lytjs_reactivity.ComputedSignal<string>;
+    isActive: _lytjs_reactivity.ComputedSignal<boolean>;
+    isExactActive: _lytjs_reactivity.ComputedSignal<boolean>;
+    navigate: (e?: MouseEvent) => void;
+};
+
+/**
+ * @lytjs/router - RouterView component
+ *
+ * Renders the matched component for the current route.
+ * Supports nested routes by rendering child RouterView.
+ */
+
+interface RouterViewProps {
+    name?: string;
+    route?: RouteLocationNormalized;
+}
+/**
+ * RouterView component
+ * Renders the matched component for the current route.
+ * Supports named views via the `name` prop and props passing from route records.
+ */
+declare const RouterView: {
+    name: string;
+    props: {
+        name: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    setup(props: RouterViewProps): () => any;
+};
+
+/**
+ * @lytjs/router - RouterLink component
+ *
+ * Renders an anchor tag that navigates to the target route.
+ */
+interface RouterLinkProps {
+    to: string;
+    replace?: boolean;
+    activeClass?: string;
+    exactActiveClass?: string;
+    ariaCurrentValue?: string;
+}
+/**
+ * RouterLink component
+ * Renders an anchor tag that navigates to the target route.
+ * Supports active state detection and aria-current attribute.
+ */
+declare const RouterLink: {
+    name: string;
+    props: {
+        to: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        replace: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        activeClass: {
+            type: StringConstructor;
+            default: string;
+        };
+        exactActiveClass: {
+            type: StringConstructor;
+            default: string;
+        };
+        ariaCurrentValue: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    setup(props: RouterLinkProps, { slots, }: {
+        slots?: {
+            default?: (props?: unknown) => unknown;
+            [key: string]: ((props?: unknown) => unknown) | undefined;
+        };
+    }): () => {
+        tag: string;
+        props: {
+            href: string;
+            class: string;
+            'aria-current': string | undefined;
+            onClick: (event: MouseEvent) => void;
+        };
+        children: unknown;
+    };
+};
+
+export { type LocationQuery, type NavigationFailure, NavigationFailureType, type NavigationGuard, type NavigationGuardNext, type NavigationGuardReturn, type NavigationInfo, type RouteLocationNormalized, type RouteLocationRaw, type RouteMeta, type RouteParams, type RouteRecordName, type RouteRecordNormalized, type RouteRecordRaw, type Router, type RouterHistory, RouterLink, type RouterLinkProps, type RouterOptions, type RouterScrollBehavior, RouterView, type RouterViewProps, type UseLinkOptions, createMemoryHistory, createRouter, createWebHashHistory, createWebHistory, setCurrentRouter, useLink, useRoute, useRouter };