sibujs 1.0.0-beta.1

package/dist/src/plugins/router.d.ts

@@ -0,0 +1,188 @@
+export type Component = () => HTMLElement;
+export type AsyncComponent = () => Promise<HTMLElement>;
+export type LazyComponent = () => Promise<{
+    default: Component;
+}>;
+export type Params = Record<string, string>;
+export interface RouteContext {
+    readonly path: string;
+    readonly params: Params;
+    readonly query: Params;
+    readonly hash: string;
+    readonly meta: RouteMeta;
+    readonly matched: RouteDef[];
+}
+export type GuardResult = boolean | string | Promise<boolean | string>;
+export type Guard = (to: RouteContext, from?: RouteContext) => GuardResult;
+export interface NavigationGuard {
+    (to: RouteContext, from: RouteContext, next: NavigationNext): void;
+}
+export interface NavigationNext {
+    (result?: boolean | string | Error): void;
+}
+export type RouteMeta = Record<string, any>;
+export interface RouteBase {
+    readonly path: string;
+    readonly name?: string;
+    readonly meta?: RouteMeta;
+    readonly children?: RouteDef[];
+    readonly beforeEnter?: Guard | Guard[];
+    readonly alias?: string | string[];
+}
+export interface ComponentRoute extends RouteBase {
+    readonly component: Component;
+}
+export interface AsyncRoute extends RouteBase {
+    readonly component: AsyncComponent | LazyComponent;
+}
+export interface RedirectRoute extends RouteBase {
+    readonly redirect: string | ((to: RouteContext) => string);
+}
+export type RouteDef = ComponentRoute | AsyncRoute | RedirectRoute;
+export interface RouterOptions {
+    readonly mode?: 'history' | 'hash';
+    readonly base?: string;
+    readonly linkActiveClass?: string;
+    readonly linkExactActiveClass?: string;
+    readonly fallback?: boolean;
+    readonly scrollBehavior?: ScrollBehavior;
+    readonly guardTimeout?: number;
+    readonly cacheSize?: number;
+    readonly errorRetryDelay?: number;
+    readonly preloadStrategy?: 'none' | 'hover' | 'visible';
+}
+export interface ScrollBehavior {
+    (to: RouteContext, from: RouteContext, savedPosition: ScrollPosition | null): ScrollPosition | null;
+}
+export interface ScrollPosition {
+    readonly x: number;
+    readonly y: number;
+}
+export interface NavigationFailure {
+    readonly type: 'aborted' | 'cancelled' | 'duplicated' | 'timeout';
+    readonly from: RouteContext;
+    readonly to: RouteContext;
+    readonly error?: Error;
+}
+export type NavigationResult = {
+    success: true;
+    route: RouteContext;
+} | {
+    success: false;
+    failure: NavigationFailure;
+};
+export type NavigationTarget = string | {
+    path?: string;
+    name?: string;
+    params?: Params;
+    query?: Params;
+    hash?: string;
+};
+export declare class SibuRouter {
+    private options;
+    private matcher;
+    private guards;
+    private loader;
+    private navigator;
+    private currentRouteGetter;
+    private currentRouteSetter;
+    private isReadyGetter;
+    private isReadySetter;
+    private cleanup;
+    constructor(routes: RouteDef[], options?: RouterOptions);
+    private initialize;
+    private createInitialRoute;
+    private handleLocationChange;
+    private getCurrentPath;
+    private createRouteContext;
+    navigate(to: NavigationTarget, options?: {
+        replace?: boolean;
+        state?: any;
+    }): Promise<NavigationResult>;
+    private performNavigation;
+    private resolvePath;
+    private isSameRoute;
+    private updateHistory;
+    private handleScrollBehavior;
+    loadComponent(route: RouteDef, routePath: string): Promise<Component>;
+    beforeEach(guard: NavigationGuard): () => void;
+    beforeResolve(guard: NavigationGuard): () => void;
+    afterEach(hook: (to: RouteContext, from: RouteContext) => void): () => void;
+    push(to: NavigationTarget): Promise<NavigationResult>;
+    replace(to: NavigationTarget): Promise<NavigationResult>;
+    go(delta: number): void;
+    back(): void;
+    forward(): void;
+    get currentRoute(): RouteContext;
+    get isReady(): boolean;
+    get isNavigating(): boolean;
+    destroy(): void;
+    clearCache(): void;
+    clearErrorCache(): void;
+    updateRoutes(routes: RouteDef[]): void;
+}
+export declare function createRouter(routes: RouteDef[], options?: RouterOptions): SibuRouter;
+export declare function useRoute(): RouteContext;
+export declare function useRouter(): {
+    currentRoute: RouteContext;
+    isReady: boolean;
+    isNavigating: boolean;
+    push: (to: NavigationTarget) => Promise<NavigationResult>;
+    replace: (to: NavigationTarget) => Promise<NavigationResult>;
+    go: (delta: number) => void;
+    back: () => void;
+    forward: () => void;
+    beforeEach: (guard: NavigationGuard) => () => void;
+    beforeResolve: (guard: NavigationGuard) => () => void;
+    afterEach: (hook: (to: RouteContext, from: RouteContext) => void) => () => void;
+};
+export declare function navigate(to: NavigationTarget, options?: {
+    replace?: boolean;
+    state?: any;
+}): Promise<NavigationResult>;
+export declare function push(to: NavigationTarget): Promise<NavigationResult>;
+export declare function replace(to: NavigationTarget): Promise<NavigationResult>;
+export declare function go(delta: number): void;
+export declare function back(): void;
+export declare function forward(): void;
+export declare function beforeEach(guard: NavigationGuard): () => void;
+export declare function beforeResolve(guard: NavigationGuard): () => void;
+export declare function afterEach(hook: (to: RouteContext, from: RouteContext) => void): () => void;
+export declare function Route(): Node;
+export declare function RouterLink(props: {
+    to: NavigationTarget;
+    replace?: boolean;
+    activeClass?: string;
+    exactActiveClass?: string;
+    children?: any;
+    target?: string;
+    rel?: string;
+    [key: string]: any;
+}): HTMLElement;
+export declare function Suspense(props: {
+    fallback?: () => HTMLElement | HTMLElement;
+    children: () => HTMLElement | Promise<HTMLElement>;
+}): Node;
+/**
+ * Creates a lazy-loaded component
+ */
+export declare function lazy(importFn: () => Promise<{
+    default: Component;
+}>): LazyComponent;
+/**
+ * Preloads a route component
+ */
+export declare function preloadRoute(to: NavigationTarget): Promise<void>;
+/**
+ * Validates if a route exists
+ */
+export declare function hasRoute(name: string): boolean;
+/**
+ * Gets route information by name
+ */
+export declare function getRouteInfo(name: string): RouteDef | null;
+/**
+ * Builds a URL for a route
+ */
+export declare function buildURL(to: NavigationTarget): string;
+export declare function destroyRouter(): void;