@vobs/router 0.3.0 → 1.0.0

package/dist/router.js

@@ -1,406 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { batch, signal } from '@vobs/reactivity';
-import { createInjectionScope, createRuntimeError, isVobsError, toErrorEvent, } from '@vobs/runtime-core';
-import { CurrentRouteKey, PendingRouteKey, RouteRecordsKey, } from './types.js';
-import { createRouteLoaderCache, defaultRedirectLimit, loadRouteComponent, readLoaderCacheKey, resolveRoute, resolveRouteGuard, resolveRouteInitialState, } from './resolve.js';
-import { createMountedRouteChain, errorLayoutsForFailure, hydratePageWithLayouts, mountPageWithLayouts, unwrapRouteMountFailure, } from './mount.js';
-import { createKeepAliveCache, disposeChainInstances, readKeepAliveKey } from './keep-alive.js';
-import { createHistoryBinding, createScrollRestoration, defaultRouterWindow, resolveHistoryWindow, } from './history.js';
-import { createRouteHref, createRouteLocation } from './location.js';
-import { matchRoute } from './match.js';
-export function createRouter(options) {
-    const routes = [...options.routes];
-    const current = signal(null);
-    const pending = signal(null);
-    let container;
-    let environment;
-    let currentPage;
-    let navigationToken = 0;
-    let mounted = false;
-    let historyBinding;
-    let loaderAbortController;
-    let routerInjectionScope;
-    const loaderCache = createRouteLoaderCache();
-    // keep-alive cache is bounded by default (10) so long-running SPAs cannot accumulate page instances; overridable via keepAliveMax.
-    const keepAliveCache = createKeepAliveCache(options.keepAliveMax ?? 10);
-    let scrollRestoration;
-    async function mount(nextContainer, nextEnvironment) {
-        if (mounted) {
-            throw createRuntimeError('VOR602', 'Router is already mounted');
-        }
-        container = nextContainer;
-        routerInjectionScope = createInjectionScope(nextEnvironment.injections ?? null);
-        routerInjectionScope.provide(CurrentRouteKey, current);
-        routerInjectionScope.provide(PendingRouteKey, pending);
-        routerInjectionScope.provide(RouteRecordsKey, routes);
-        environment = {
-            ...nextEnvironment,
-            injections: routerInjectionScope,
-        };
-        mounted = true;
-        historyBinding = createHistoryBinding(options.history);
-        scrollRestoration =
-            options.scrollRestoration === true
-                ? createScrollRestoration(resolveHistoryWindow(options.history) ?? defaultRouterWindow(), options.scrollRestorationMaxEntries)
-                : undefined;
-        try {
-            await commitNavigation(options.initialPath ?? historyBinding?.readPath() ?? '/', historyBinding === undefined ? 'none' : 'replace', 0, options.hydrate === true ? 'hydrate' : 'mount', undefined);
-            historyBinding?.install({
-                onLink(path) {
-                    void commitNavigation(path, 'push', 0, 'mount', undefined).catch(nextEnvironment.onError);
-                },
-                onPop(path, historyEntryKey) {
-                    void commitNavigation(path, 'none', 0, 'mount', historyEntryKey).catch(nextEnvironment.onError);
-                },
-            });
-        }
-        catch (error) {
-            mounted = false;
-            container = undefined;
-            environment = undefined;
-            routerInjectionScope?.dispose();
-            routerInjectionScope = undefined;
-            historyBinding?.destroy();
-            historyBinding = undefined;
-            scrollRestoration?.destroy();
-            scrollRestoration = undefined;
-            current.value = null;
-            pending.value = null;
-            throw error;
-        }
-    }
-    async function navigate(path) {
-        await commitNavigation(path, 'push', 0, 'mount', undefined);
-    }
-    async function prefetch(path, prefetchOptions = {}) {
-        await prefetchRoute(path, prefetchOptions, 0);
-    }
-    async function prefetchRoute(path, prefetchOptions, redirects) {
-        if (redirects > defaultRedirectLimit) {
-            throw createRuntimeError('VOR604', `Redirect limit exceeded: ${path}`);
-        }
-        const signal = prefetchOptions.signal;
-        if (signal?.aborted)
-            return;
-        const route = resolveRoute({ routes, path, notFound: options.notFound });
-        if (prefetchOptions.data === true && route.guard !== undefined) {
-            try {
-                // Same guard semantics as navigation (resolveRouteGuard): guard false → VOR606.
-                const guardRedirect = await Promise.resolve(resolveRouteGuard(route, {
-                    ...(signal === undefined ? {} : { signal }),
-                    ...(environment?.injections === undefined
-                        ? {}
-                        : { injections: environment.injections }),
-                }));
-                if (signal?.aborted)
-                    return;
-                if (guardRedirect !== undefined) {
-                    await prefetchRoute(guardRedirect, prefetchOptions, redirects + 1);
-                    return;
-                }
-            }
-            catch (error) {
-                // Prefetch is optional: a guard rejection does not throw into the error boundary; stop prefetching and report cancelled (observable).
-                if (isVobsError(error) && error.code === 'VOR606') {
-                    reportNavigation('cancelled', path);
-                    return;
-                }
-                throw error;
-            }
-        }
-        for (const component of [
-            route.component,
-            ...(route.layouts ?? []),
-            route.error ?? options.error,
-        ]) {
-            if (signal?.aborted)
-                return;
-            if (component === undefined)
-                continue;
-            await loadRouteComponent(component);
-        }
-        if (prefetchOptions.data !== true || signal?.aborted)
-            return;
-        await Promise.resolve(resolveRouteInitialState(route, {
-            ...(signal === undefined ? {} : { signal }),
-            loaderCache,
-            ...(environment?.injections === undefined ? {} : { injections: environment.injections }),
-        }));
-    }
-    function reportNavigation(status, path, error) {
-        const observability = environment?.observability;
-        if (observability === undefined)
-            return;
-        const event = {
-            kind: 'navigation',
-            timestamp: Date.now(),
-            navigation: {
-                status,
-                path,
-                ...(error === undefined ? {} : { error: toErrorEvent(error) }),
-            },
-        };
-        observability.report(event);
-    }
-    async function commitNavigation(path, historyAction, redirects, renderMode, historyEntryKey) {
-        if (!mounted || container === undefined || environment === undefined) {
-            throw createRuntimeError('VOR602', 'Router is not mounted');
-        }
-        if (redirects > defaultRedirectLimit) {
-            pending.value = null;
-            throw createRuntimeError('VOR604', `Redirect limit exceeded: ${path}`);
-        }
-        reportNavigation('start', path);
-        const token = ++navigationToken;
-        loaderAbortController?.abort();
-        const abortController = new AbortController();
-        loaderAbortController = abortController;
-        const match = matchRoute(routes, path);
-        const historyPath = match?.href ?? createRouteHref(path);
-        if (match?.redirect !== undefined) {
-            await commitNavigation(match.redirect, historyAction, redirects + 1, renderMode, historyEntryKey);
-            return;
-        }
-        const component = match?.component ?? options.notFound;
-        if (component === undefined) {
-            pending.value = null;
-            throw createRuntimeError('VOR601', `Route not found: ${path}`);
-        }
-        const layouts = match?.layouts ?? [];
-        const errorComponent = match?.error ?? options.error;
-        const location = match?.location ?? createRouteLocation(path);
-        pending.value = location;
-        try {
-            if (match?.guard !== undefined) {
-                const guardRedirect = await Promise.resolve(resolveRouteGuard({
-                    status: match === undefined ? 'notFound' : 'matched',
-                    route: location,
-                    component,
-                    ...(layouts.length === 0 ? {} : { layouts }),
-                    ...(errorComponent === undefined ? {} : { error: errorComponent }),
-                    ...(match.meta === undefined ? {} : { meta: match.meta }),
-                    guard: match.guard,
-                    ...(match.initialState === undefined ? {} : { initialState: match.initialState }),
-                    ...(match.loader === undefined ? {} : { loader: match.loader }),
-                    ...(match.loaderCache === undefined ? {} : { loaderCache: match.loaderCache }),
-                }, {
-                    signal: abortController.signal,
-                    ...(environment.injections === undefined
-                        ? {}
-                        : { injections: environment.injections }),
-                }));
-                if (token !== navigationToken || !mounted) {
-                    reportNavigation('cancelled', location.path);
-                    return;
-                }
-                if (guardRedirect !== undefined) {
-                    await commitNavigation(guardRedirect, historyAction, redirects + 1, renderMode, historyEntryKey);
-                    return;
-                }
-            }
-            const initialState = await Promise.resolve(resolveRouteInitialState({
-                status: match === undefined ? 'notFound' : 'matched',
-                route: location,
-                component,
-                ...(layouts.length === 0 ? {} : { layouts }),
-                ...(errorComponent === undefined ? {} : { error: errorComponent }),
-                ...(match?.meta === undefined ? {} : { meta: match.meta }),
-                ...(match?.guard === undefined ? {} : { guard: match.guard }),
-                ...(match?.initialState === undefined ? {} : { initialState: match.initialState }),
-                ...(match?.loader === undefined ? {} : { loader: match.loader }),
-                ...(match?.loaderCache === undefined ? {} : { loaderCache: match.loaderCache }),
-            }, {
-                signal: abortController.signal,
-                loaderCache,
-                ...(environment.injections === undefined ? {} : { injections: environment.injections }),
-            }));
-            if (token !== navigationToken || !mounted) {
-                reportNavigation('cancelled', location.path);
-                return;
-            }
-            await mountPage(component, layouts, location, initialState, token, historyAction, renderMode, historyPath, historyEntryKey);
-            reportNavigation('success', location.path);
-        }
-        catch (error) {
-            if (token !== navigationToken || !mounted)
-                return;
-            reportNavigation('error', location.path, error);
-            await mountErrorPage(error, errorComponent, layouts, location, token, historyAction, historyPath, historyEntryKey);
-        }
-    }
-    async function mountPage(component, layouts, location, initialState, token, historyAction, renderMode, historyPath, historyEntryKey) {
-        const page = await loadRouteComponent(component);
-        if (token !== navigationToken || !mounted) {
-            reportNavigation('cancelled', location.path);
-            return;
-        }
-        scrollRestoration?.saveCurrent();
-        const previous = currentPage;
-        const previousRoute = current.value;
-        const reusedLayouts = renderMode === 'mount' ? commonLayoutPrefix(previous, layouts) : 0;
-        const keepAlive = location.meta?.keepAlive === true;
-        const cachedLeaf = renderMode === 'mount' && keepAlive
-            ? keepAliveCache.take(readKeepAliveKey(location))
-            : undefined;
-        if (reusedLayouts === 0) {
-            await disposeChainInstances(previous?.instances ?? [], previousRoute, keepAliveCache);
-            currentPage = undefined;
-            current.value = null;
-        }
-        try {
-            const pageEnvironment = {
-                ...environment,
-                route: location,
-                initialState,
-            };
-            const nextPage = renderMode === 'hydrate'
-                ? await hydratePageWithLayouts(page, layouts, container, pageEnvironment)
-                : await mountPageWithLayouts(page, layouts.slice(reusedLayouts), reusedLayouts === 0 ? container : previous.outlets[reusedLayouts - 1], pageEnvironment, cachedLeaf);
-            if (token !== navigationToken || !mounted) {
-                nextPage.destroy();
-                return;
-            }
-            currentPage =
-                reusedLayouts === 0
-                    ? nextPage
-                    : createMountedRouteChain(layouts, [...previous.instances.slice(0, reusedLayouts), ...nextPage.instances], [...previous.outlets.slice(0, reusedLayouts), ...nextPage.outlets]);
-            // Commit: current + pending update together in one batch, so observers
-            // (menu highlighting / page-level pending state) receive a single notification.
-            batch(() => {
-                current.value = location;
-                pending.value = null;
-            });
-            const committedHistoryEntryKey = historyBinding?.commit(historyPath, historyAction, historyEntryKey) ?? historyEntryKey;
-            options.navigation?.onNavigate?.({
-                route: location,
-                historyAction,
-                preservedLayouts: reusedLayouts,
-                ...(previousRoute === null ? {} : { previousRoute }),
-                ...(committedHistoryEntryKey === undefined
-                    ? {}
-                    : { historyEntryKey: committedHistoryEntryKey }),
-            });
-            scrollRestoration?.settle(historyAction, committedHistoryEntryKey);
-            if (reusedLayouts > 0) {
-                await disposeChainInstances(previous.instances.slice(reusedLayouts), previousRoute, keepAliveCache);
-            }
-        }
-        catch (error) {
-            if (token === navigationToken) {
-                current.value = null;
-                pending.value = null;
-            }
-            throw error;
-        }
-    }
-    async function mountErrorPage(error, errorComponent, layouts, location, token, historyAction, historyPath, historyEntryKey) {
-        if (errorComponent === undefined) {
-            if (token === navigationToken) {
-                currentPage?.destroy();
-                currentPage = undefined;
-                current.value = null;
-                pending.value = null;
-            }
-            throw error;
-        }
-        if (token !== navigationToken || !mounted)
-            return;
-        await mountPage(errorComponent, errorLayoutsForFailure(layouts, error), location, {
-            error: unwrapRouteMountFailure(error),
-            route: location,
-        }, token, historyAction, 'mount', historyPath, historyEntryKey);
-    }
-    function invalidateLoaderCache(path) {
-        if (path === undefined) {
-            loaderCache.clear();
-            return;
-        }
-        const match = matchRoute(routes, path);
-        if (match?.loaderCache === undefined)
-            return;
-        const cacheKey = readLoaderCacheKey(match.loaderCache, match.location, { loaderCache });
-        if (cacheKey !== undefined)
-            loaderCache.delete(cacheKey);
-    }
-    function invalidateKeepAlive(path) {
-        if (path === undefined) {
-            keepAliveCache.destroyAll();
-            return;
-        }
-        keepAliveCache.remove(path);
-    }
-    function destroy() {
-        navigationToken += 1;
-        loaderAbortController?.abort();
-        loaderAbortController = undefined;
-        mounted = false;
-        container = undefined;
-        environment = undefined;
-        const errors = [];
-        try {
-            historyBinding?.destroy();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-        historyBinding = undefined;
-        const page = currentPage;
-        currentPage = undefined;
-        current.value = null;
-        pending.value = null;
-        try {
-            page?.destroy();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-        try {
-            keepAliveCache.destroyAll();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-        try {
-            scrollRestoration?.destroy();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-        scrollRestoration = undefined;
-        try {
-            routerInjectionScope?.dispose();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-        routerInjectionScope = undefined;
-        if (errors.length > 0) {
-            throw new AggregateError(errors, 'Router destroy failed');
-        }
-    }
-    return {
-        current,
-        pending,
-        mount,
-        navigate,
-        prefetch,
-        invalidateLoaderCache,
-        invalidateKeepAlive,
-        destroy,
-    };
-}
-function commonLayoutPrefix(current, layouts) {
-    if (current === undefined)
-        return 0;
-    let index = 0;
-    while (index < layouts.length &&
-        index < current.layouts.length &&
-        index < current.outlets.length &&
-        current.layouts[index] === layouts[index]) {
-        index += 1;
-    }
-    return index;
-}

package/dist/types.d.ts

@@ -1,272 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type ReadonlySignal } from '@vobs/reactivity';
-import { type InjectionKey, type InjectionScope, type PAGE_INITIAL_STATE, type ComponentRegistry, type PageDefinition, type PageEnvironment, type RouteLocation, type RouteMeta, type RouteQuery, type RouteQueryValue } from '@vobs/runtime-core';
-export type { RouteLocation, RouteMeta, RouteQuery, RouteQueryValue };
-export declare const CurrentRouteKey: InjectionKey<ReadonlySignal<RouteLocation | null>>;
-export declare const PendingRouteKey: InjectionKey<ReadonlySignal<RouteLocation | null>>;
-export declare const RouteRecordsKey: InjectionKey<readonly RouteRecord<RouteComponent>[]>;
-export type RoutablePageDefinition = Omit<PageDefinition<object, ComponentRegistry, never>, typeof PAGE_INITIAL_STATE> & {
-    readonly [PAGE_INITIAL_STATE]?: unknown;
-};
-export type RouteComponent = RoutablePageDefinition | (() => Promise<{
-    readonly default: RoutablePageDefinition;
-}>);
-type PageInitialState<Page> = Page extends {
-    readonly [PAGE_INITIAL_STATE]?: infer InitialState;
-} ? InitialState : unknown;
-export type RouteInitialState<Component extends RouteComponent> = Component extends () => Promise<{
-    readonly default: infer Page;
-}> ? PageInitialState<Page> : PageInitialState<Component>;
-export interface RouteLoaderContext {
-    readonly route: RouteLocation;
-    readonly signal: AbortSignal;
-    readonly request?: unknown;
-    readonly injections: InjectionScope;
-    maybeInject<T>(key: InjectionKey<T>): T | undefined;
-    inject<T>(key: InjectionKey<T>): T;
-    inject<T>(key: InjectionKey<T>, fallback: T | (() => T)): T;
-}
-export interface RouteGuardContext {
-    readonly route: RouteLocation;
-    readonly signal: AbortSignal;
-    readonly request?: unknown;
-    readonly injections: InjectionScope;
-    maybeInject<T>(key: InjectionKey<T>): T | undefined;
-    inject<T>(key: InjectionKey<T>): T;
-    inject<T>(key: InjectionKey<T>, fallback: T | (() => T)): T;
-}
-export interface RouteErrorState {
-    readonly error: unknown;
-    readonly route: RouteLocation;
-}
-export type RouteLoader<Component extends RouteComponent = RouteComponent> = (context: RouteLoaderContext) => RouteInitialState<Component> | Promise<RouteInitialState<Component>>;
-export type RouteGuardResult = void | true | false | string | {
-    readonly redirect: string;
-};
-export type RouteGuard = (context: RouteGuardContext) => RouteGuardResult | Promise<RouteGuardResult>;
-export type RouteLoaderCacheKey = string | ((route: RouteLocation) => string);
-export type RouteLoaderCachePolicy = boolean | {
-    readonly key?: RouteLoaderCacheKey;
-};
-export interface RouteLoaderCache {
-    has(key: string): boolean;
-    get(key: string): unknown;
-    set(key: string, value: unknown): void;
-    delete(key: string): boolean;
-    clear(): void;
-}
-export type RouteRecord<Component extends RouteComponent = RouteComponent> = PageRouteRecord<Component> | NestedRouteRecord<Component> | RedirectRouteRecord;
-type RouteRecordForValue<Route> = Route extends RouteRecord ? Route extends {
-    readonly children: infer Children extends readonly RouteRecord[];
-} ? Omit<Route, 'children'> & {
-    readonly children: {
-        readonly [Key in keyof Children]: RouteRecordForValue<Children[Key]>;
-    };
-} : Route extends {
-    readonly component: infer Component extends RouteComponent;
-} ? Route & PageRouteRecord<Component> : Route : never;
-export type ValidatedRouteRecords<Routes extends readonly RouteRecord[]> = {
-    readonly [Key in keyof Routes]: RouteRecordForValue<Routes[Key]>;
-};
-export type PageRouteRecord<Component extends RouteComponent = RouteComponent> = PageRouteRecordWithoutInitialState<Component> | PageRouteRecordWithInitialState<Component> | PageRouteRecordWithLoader<Component>;
-export interface PageRouteRecordWithoutInitialState<Component extends RouteComponent = RouteComponent> {
-    readonly path: string;
-    readonly component: Component;
-    readonly layouts?: readonly RouteComponent[];
-    readonly error?: RouteComponent;
-    readonly meta?: RouteMeta;
-    readonly guard?: RouteGuard;
-    readonly initialState?: never;
-    readonly loader?: never;
-    readonly loaderCache?: never;
-    readonly children?: never;
-    readonly redirect?: never;
-}
-export interface PageRouteRecordWithInitialState<Component extends RouteComponent = RouteComponent> {
-    readonly path: string;
-    readonly component: Component;
-    readonly layouts?: readonly RouteComponent[];
-    readonly error?: RouteComponent;
-    readonly meta?: RouteMeta;
-    readonly guard?: RouteGuard;
-    readonly initialState: RouteInitialState<Component>;
-    readonly loader?: never;
-    readonly loaderCache?: never;
-    readonly children?: never;
-    readonly redirect?: never;
-}
-export interface PageRouteRecordWithLoader<Component extends RouteComponent = RouteComponent> {
-    readonly path: string;
-    readonly component: Component;
-    readonly layouts?: readonly RouteComponent[];
-    readonly error?: RouteComponent;
-    readonly meta?: RouteMeta;
-    readonly guard?: RouteGuard;
-    readonly loader: RouteLoader<Component>;
-    readonly loaderCache?: RouteLoaderCachePolicy;
-    readonly initialState?: never;
-    readonly children?: never;
-    readonly redirect?: never;
-}
-export interface NestedRouteRecord<Component extends RouteComponent = RouteComponent> {
-    readonly path: string;
-    readonly component?: Component;
-    readonly children: readonly RouteRecord<Component>[];
-    readonly layouts?: readonly RouteComponent[];
-    readonly error?: RouteComponent;
-    readonly meta?: RouteMeta;
-    readonly guard?: RouteGuard;
-    readonly initialState?: never;
-    readonly loader?: never;
-    readonly loaderCache?: never;
-    readonly redirect?: never;
-}
-export interface RedirectRouteRecord {
-    readonly path: string;
-    readonly redirect: string;
-    readonly component?: never;
-    readonly initialState?: never;
-    readonly loader?: never;
-    readonly loaderCache?: never;
-    readonly meta?: never;
-    readonly guard?: never;
-    readonly children?: never;
-}
-export interface RouteNavigationMeta {
-    readonly id: string;
-    readonly label?: string;
-    readonly icon?: string;
-    readonly area?: string;
-    readonly order?: number;
-    readonly state?: string;
-}
-export interface RouteNavigationItem {
-    readonly id: string;
-    readonly label: string;
-    readonly href: string;
-    readonly area: string;
-    readonly order: number;
-    readonly icon?: string;
-    readonly state: string;
-    readonly meta: RouteMeta;
-}
-export interface CollectRouteNavigationOptions {
-    readonly area?: string;
-    readonly defaultArea?: string;
-}
-export interface RouteNavigationScopeOptions extends CollectRouteNavigationOptions {
-    readonly activeFallback?: string;
-    readonly titleFallback?: string;
-    readonly descriptionFallback?: string;
-    readonly statusFallback?: string;
-}
-export interface RouteNavigationScope {
-    readonly route: ReadonlySignal<RouteLocation>;
-    readonly items: ReadonlySignal<readonly RouteNavigationItem[]>;
-    readonly activeId: ReadonlySignal<string | undefined>;
-    readonly title: ReadonlySignal<string>;
-    readonly description: ReadonlySignal<string>;
-    readonly status: ReadonlySignal<string>;
-}
-export interface RouterOptions<Routes extends readonly RouteRecord[] = readonly RouteRecord[]> {
-    readonly routes: Routes;
-    readonly notFound?: RouteComponent | undefined;
-    readonly error?: RouteComponent | undefined;
-    readonly initialPath?: string;
-    readonly history?: boolean | RouterHistoryOptions;
-    readonly hydrate?: boolean;
-    readonly navigation?: RouterNavigationOptions;
-    readonly scrollRestoration?: boolean;
-    /** Maximum number of saved history-entry scroll positions. Defaults to 100. */
-    readonly scrollRestorationMaxEntries?: number;
-    readonly keepAliveMax?: number;
-}
-export interface RouterNavigationOptions {
-    onNavigate?(context: RouterNavigationContext): void;
-}
-export interface RouterNavigationContext {
-    readonly route: RouteLocation;
-    readonly historyAction: 'none' | 'push' | 'replace';
-    readonly preservedLayouts: number;
-    readonly previousRoute?: RouteLocation;
-    readonly historyEntryKey?: string;
-}
-export interface RouterHistoryOptions {
-    readonly window?: RouterWindow;
-    readonly interceptLinks?: boolean;
-}
-export interface RouterWindow {
-    readonly location: {
-        readonly href: string;
-        readonly origin: string;
-        readonly pathname: string;
-        readonly search?: string;
-        readonly hash?: string;
-    };
-    readonly history: {
-        readonly state?: unknown;
-        scrollRestoration?: 'auto' | 'manual';
-        pushState(data: unknown, title: string, url?: string | URL | null): void;
-        replaceState?(data: unknown, title: string, url?: string | URL | null): void;
-    };
-    readonly document?: RouterDocument;
-    readonly scrollX?: number;
-    readonly scrollY?: number;
-    scrollTo?(x: number, y: number): void;
-    addEventListener(type: 'popstate', listener: (event: RouterPopStateEvent) => void): void;
-    removeEventListener(type: 'popstate', listener: (event: RouterPopStateEvent) => void): void;
-}
-export interface RouterDocument {
-    addEventListener(type: 'click', listener: (event: Event) => void): void;
-    removeEventListener(type: 'click', listener: (event: Event) => void): void;
-}
-export interface RouterPopStateEvent {
-    readonly state?: unknown;
-}
-export interface Router {
-    readonly current: ReadonlySignal<RouteLocation | null>;
-    readonly pending: ReadonlySignal<RouteLocation | null>;
-    mount(container: Element, environment: PageEnvironment): Promise<void>;
-    navigate(path: string): Promise<void>;
-    prefetch(path: string, options?: RouterPrefetchOptions): Promise<void>;
-    invalidateLoaderCache(path?: string): void;
-    invalidateKeepAlive(path?: string): void;
-    destroy(): void;
-}
-export interface RouterPrefetchOptions {
-    readonly data?: boolean;
-    readonly signal?: AbortSignal;
-}
-export type ResolvedRouteStatus = 'matched' | 'notFound';
-export interface ResolvedRoute {
-    readonly status: ResolvedRouteStatus;
-    readonly route: RouteLocation;
-    readonly component: RouteComponent;
-    readonly layouts?: readonly RouteComponent[];
-    readonly error?: RouteComponent;
-    readonly meta?: RouteMeta;
-    readonly guard?: RouteGuard;
-    readonly initialState?: unknown;
-    readonly loader?: RouteLoader | undefined;
-    readonly loaderCache?: RouteLoaderCachePolicy | undefined;
-}
-export interface ResolveRouteInitialStateOptions {
-    readonly signal?: AbortSignal;
-    readonly request?: unknown;
-    readonly loaderCache?: RouteLoaderCache;
-    readonly injections?: InjectionScope;
-}
-export interface ResolveRouteGuardOptions {
-    readonly signal?: AbortSignal;
-    readonly request?: unknown;
-    readonly injections?: InjectionScope;
-}
-export interface ResolveRouteOptions {
-    readonly routes: readonly RouteRecord[];
-    readonly path: string;
-    readonly notFound?: RouteComponent | undefined;
-    readonly redirectLimit?: number;
-}

package/dist/types.js

@@ -1,9 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import {} from '@vobs/reactivity';
-import { createInjectionKey, } from '@vobs/runtime-core';
-export const CurrentRouteKey = createInjectionKey('vobs.router.currentRoute');
-export const PendingRouteKey = createInjectionKey('vobs.router.pendingRoute');
-export const RouteRecordsKey = createInjectionKey('vobs.router.routeRecords');