@vobs/router 0.3.0 → 1.1.0

package/dist/mount.d.ts

@@ -1,18 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type PageDefinition, type PageEnvironment, type PageInstance } from '@vobs/runtime-core';
-import { type RouteComponent } from './types.js';
-export interface MountedRouteChain {
-    readonly layouts: readonly RouteComponent[];
-    readonly instances: readonly PageInstance[];
-    readonly outlets: readonly Element[];
-    destroy(): void;
-}
-export declare function mountPageWithLayouts(page: PageDefinition, layouts: readonly RouteComponent[], container: Element, environment: PageEnvironment, cachedLeaf?: PageInstance): Promise<MountedRouteChain>;
-export declare function hydratePageWithLayouts(page: PageDefinition, layouts: readonly RouteComponent[], container: Element, environment: PageEnvironment): Promise<MountedRouteChain>;
-export declare function createMountedRouteChain(layouts: readonly RouteComponent[], instances: readonly PageInstance[], outlets: readonly Element[]): MountedRouteChain;
-export declare function errorLayoutsForFailure(layouts: readonly RouteComponent[], error: unknown): readonly RouteComponent[];
-export declare function unwrapRouteMountFailure(error: unknown): unknown;
-export declare function destroyPageInstances(instances: readonly PageInstance[]): void;

package/dist/mount.js

@@ -1,205 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { createRuntimeError, } from '@vobs/runtime-core';
-import {} from './types.js';
-import { loadRouteComponent } from './resolve.js';
-export async function mountPageWithLayouts(page, layouts, container, environment, cachedLeaf) {
-    if (layouts.length === 0) {
-        const instance = cachedLeaf ?? (await page.mount(environment));
-        if (cachedLeaf !== undefined)
-            cachedLeaf.activate();
-        container.append(instance.root);
-        return createMountedRouteChain(layouts, [instance], []);
-    }
-    const instances = [];
-    const outlets = [];
-    try {
-        let child;
-        try {
-            child = cachedLeaf ?? (await page.mount(environment));
-            if (cachedLeaf !== undefined)
-                cachedLeaf.activate();
-        }
-        catch (error) {
-            throw createRoutePageMountFailure(error);
-        }
-        instances.push(child);
-        for (let index = layouts.length - 1; index >= 0; index -= 1) {
-            const layoutComponent = layouts[index];
-            if (layoutComponent === undefined)
-                continue;
-            try {
-                const layout = await loadRouteComponent(layoutComponent);
-                const slottedChild = child;
-                child = await layout.mount(createLayoutPageEnvironment(environment, (_owner, parent) => {
-                    outlets[index] = parent;
-                    parent.append(slottedChild.root);
-                }));
-            }
-            catch (error) {
-                throw createRouteLayoutMountFailure(error, index);
-            }
-            instances.push(child);
-        }
-        container.append(child.root);
-        return createMountedRouteChain(layouts, [...instances].reverse(), outlets);
-    }
-    catch (error) {
-        destroyPageInstances(instances);
-        throw error;
-    }
-}
-export async function hydratePageWithLayouts(page, layouts, container, environment) {
-    if (layouts.length === 0) {
-        const instance = await page.hydrate(container, environment);
-        return createMountedRouteChain(layouts, [instance], []);
-    }
-    const pages = await Promise.all(layouts.map((layout) => loadRouteComponent(layout)));
-    const chain = await hydratePageChain([...pages, page], 0, container, container, environment);
-    return createMountedRouteChain(layouts, chain.instances, []);
-}
-class RoutePageMountFailure extends Error {
-    error;
-    kind = 'vobs.route-page-mount-failure';
-    constructor(error) {
-        super('Route page mount failed');
-        this.error = error;
-        this.name = 'RoutePageMountFailure';
-    }
-}
-class RouteLayoutMountFailure extends Error {
-    error;
-    layoutIndex;
-    kind = 'vobs.route-layout-mount-failure';
-    constructor(error, layoutIndex) {
-        super('Route layout mount failed');
-        this.error = error;
-        this.layoutIndex = layoutIndex;
-        this.name = 'RouteLayoutMountFailure';
-    }
-}
-function createLayoutPageEnvironment(environment, defaultSlot) {
-    return {
-        scheduler: environment.scheduler,
-        security: environment.security,
-        onError: environment.onError,
-        ...(environment.components === undefined ? {} : { components: environment.components }),
-        ...(environment.route === undefined ? {} : { route: environment.route }),
-        ...(environment.injections === undefined ? {} : { injections: environment.injections }),
-        slots: {
-            ...environment.slots,
-            default: defaultSlot,
-        },
-    };
-}
-async function hydratePageChain(pages, index, container, stateContainer, environment) {
-    const page = pages[index];
-    if (page === undefined) {
-        throw createRuntimeError('VOR603', 'Invalid layout PageDefinition');
-    }
-    if (index === pages.length - 1) {
-        const instance = await page.hydrate(container, environment);
-        return createMountedRouteChain([], [instance], []);
-    }
-    let childChain;
-    const instance = await page.hydrate(container, createLayoutPageEnvironment(environment, createHydrateLayoutSlot({
-        hydrateChild(childContainer) {
-            childChain = hydratePageChain(pages, index + 1, childContainer, stateContainer, environment);
-            return childChain.then((child) => child.instances[0]);
-        },
-        stateContainer,
-    })));
-    if (childChain === undefined) {
-        throw createRuntimeError('VOR605', 'Route layout hydration requires a hydratable slot');
-    }
-    const child = await childChain;
-    return createMountedRouteChain([], [instance, ...child.instances], []);
-}
-function createHydrateLayoutSlot(options) {
-    const slot = () => {
-        throw createRuntimeError('VOR605', 'Route layout hydration requires a hydratable slot');
-    };
-    slot.hydrate = (_owner, parent, cursor) => {
-        void options.hydrateChild(createSlotHydrationContainer(parent, cursor, options.stateContainer));
-        return cursor + 1;
-    };
-    return slot;
-}
-function createSlotHydrationContainer(parent, cursor, stateContainer) {
-    let insertionReference = null;
-    return {
-        get firstElementChild() {
-            const node = parent.childNodes[cursor];
-            return isElementNode(node) ? node : null;
-        },
-        querySelectorAll(selector) {
-            return stateContainer.querySelectorAll(selector);
-        },
-        replaceChildren(...nodes) {
-            const current = parent.childNodes[cursor];
-            insertionReference = current?.nextSibling ?? null;
-            current?.remove();
-            appendSlotNodes(parent, insertionReference, nodes);
-        },
-        append(...nodes) {
-            appendSlotNodes(parent, insertionReference, nodes);
-        },
-    };
-}
-function appendSlotNodes(parent, reference, nodes) {
-    for (const node of nodes) {
-        parent.insertBefore(typeof node === 'string' ? document.createTextNode(node) : node, reference);
-    }
-}
-function isElementNode(node) {
-    return node?.nodeType === 1;
-}
-export function createMountedRouteChain(layouts, instances, outlets) {
-    if (instances[0]?.root === undefined) {
-        throw createRuntimeError('VOR603', 'Invalid layout PageInstance');
-    }
-    return {
-        layouts,
-        instances,
-        outlets,
-        destroy() {
-            destroyPageInstances([...instances].reverse());
-        },
-    };
-}
-function createRoutePageMountFailure(error) {
-    return new RoutePageMountFailure(error);
-}
-function createRouteLayoutMountFailure(error, layoutIndex) {
-    return new RouteLayoutMountFailure(error, layoutIndex);
-}
-export function errorLayoutsForFailure(layouts, error) {
-    const failure = readRouteLayoutMountFailure(error);
-    return failure === undefined ? layouts : layouts.slice(0, failure.layoutIndex);
-}
-export function unwrapRouteMountFailure(error) {
-    return (readRoutePageMountFailure(error)?.error ?? readRouteLayoutMountFailure(error)?.error ?? error);
-}
-function readRoutePageMountFailure(error) {
-    return error instanceof RoutePageMountFailure ? error : undefined;
-}
-function readRouteLayoutMountFailure(error) {
-    return error instanceof RouteLayoutMountFailure ? error : undefined;
-}
-export function destroyPageInstances(instances) {
-    // A single page destroy failure must not interrupt the rest (avoids chained leaks); errors are aggregated and thrown together.
-    const errors = [];
-    for (const instance of instances) {
-        try {
-            instance.destroy();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-    }
-    if (errors.length > 0) {
-        throw new AggregateError(errors, 'Destroy page instances failed');
-    }
-}

package/dist/navigation.d.ts

@@ -1,9 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type PageSetupContext } from '@vobs/runtime-core';
-import { type CollectRouteNavigationOptions, type RouteLocation, type RouteNavigationItem, type RouteNavigationScope, type RouteNavigationScopeOptions, type RouteRecord } from './types.js';
-export declare function collectRouteNavigation(routes: readonly RouteRecord[], options?: CollectRouteNavigationOptions): readonly RouteNavigationItem[];
-export declare function resolveActiveRouteNavigationId(route: RouteLocation, items: readonly RouteNavigationItem[], fallback?: string): string | undefined;
-export declare function createRouteNavigationScope(context: PageSetupContext, options?: RouteNavigationScopeOptions): RouteNavigationScope;

package/dist/navigation.js

@@ -1,95 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { computed, signal } from '@vobs/reactivity';
-import {} from '@vobs/runtime-core';
-import { CurrentRouteKey, RouteRecordsKey, } from './types.js';
-import { isNestedRouteRecord, joinRouteRecordPath } from './match.js';
-export function collectRouteNavigation(routes, options = {}) {
-    const area = options.area;
-    const defaultArea = options.defaultArea ?? 'default';
-    return [...collectRouteNavigationItems(routes, { area, defaultArea, parentPath: '' })].sort((left, right) => left.order - right.order || left.label.localeCompare(right.label));
-}
-export function resolveActiveRouteNavigationId(route, items, fallback) {
-    const activeNav = route.meta?.activeNav;
-    if (typeof activeNav === 'string' && hasRouteNavigationItem(items, activeNav))
-        return activeNav;
-    const nav = readRouteNavigationMeta(route.meta?.nav);
-    if (nav !== undefined && hasRouteNavigationItem(items, nav.id))
-        return nav.id;
-    const matched = items.find((item) => route.path === item.href || route.path.startsWith(`${item.href}/`));
-    return matched?.id ?? fallback;
-}
-export function createRouteNavigationScope(context, options = {}) {
-    const currentRoute = context.maybeInject(CurrentRouteKey) ?? signal(context.route);
-    const routeRecords = context.inject(RouteRecordsKey, () => []);
-    const route = computed(() => currentRoute.value ?? context.route);
-    const items = computed(() => collectRouteNavigation(routeRecords, options));
-    const activeId = computed(() => resolveActiveRouteNavigationId(route.value, items.value, options.activeFallback));
-    return {
-        route,
-        items,
-        activeId,
-        title: computed(() => readRouteMetaString(route.value.meta, 'title') ?? options.titleFallback ?? ''),
-        description: computed(() => readRouteMetaString(route.value.meta, 'description') ?? options.descriptionFallback ?? ''),
-        status: computed(() => readRouteMetaString(route.value.meta, 'status') ?? options.statusFallback ?? ''),
-    };
-}
-function collectRouteNavigationItems(routes, state) {
-    return routes.flatMap((route) => {
-        const href = joinRouteRecordPath(state.parentPath, route.path);
-        const nav = readRouteNavigationMeta(route.meta?.nav);
-        const items = [];
-        if (nav !== undefined) {
-            const area = nav.area ?? state.defaultArea;
-            if (state.area === undefined || state.area === area) {
-                items.push({
-                    id: nav.id,
-                    label: nav.label ?? readRouteMetaString(route.meta, 'title') ?? nav.id,
-                    href,
-                    area,
-                    order: nav.order ?? 0,
-                    state: nav.state ?? 'ready',
-                    meta: route.meta ?? {},
-                    ...(nav.icon === undefined ? {} : { icon: nav.icon }),
-                });
-            }
-        }
-        if (isNestedRouteRecord(route)) {
-            items.push(...collectRouteNavigationItems(route.children, {
-                area: state.area,
-                defaultArea: state.defaultArea,
-                parentPath: href,
-            }));
-        }
-        return items;
-    });
-}
-function readRouteNavigationMeta(nav) {
-    if (typeof nav !== 'object' || nav === null)
-        return undefined;
-    const id = nav.id;
-    if (typeof id !== 'string')
-        return undefined;
-    const label = nav.label;
-    const icon = nav.icon;
-    const area = nav.area;
-    const order = nav.order;
-    const state = nav.state;
-    return {
-        id,
-        ...(typeof label === 'string' ? { label } : {}),
-        ...(typeof icon === 'string' ? { icon } : {}),
-        ...(typeof area === 'string' ? { area } : {}),
-        ...(typeof order === 'number' ? { order } : {}),
-        ...(typeof state === 'string' ? { state } : {}),
-    };
-}
-function readRouteMetaString(meta, key) {
-    const value = meta?.[key];
-    return typeof value === 'string' ? value : undefined;
-}
-function hasRouteNavigationItem(items, id) {
-    return items.some((item) => item.id === id);
-}

package/dist/resolve.d.ts

@@ -1,27 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type PageDefinition, type RouteResolver } from '@vobs/runtime-core';
-import { type ResolvedRoute, type ResolveRouteGuardOptions, type ResolveRouteInitialStateOptions, type ResolveRouteOptions, type RouteComponent, type RouteLoaderCache, type RouteLoaderCachePolicy, type RouteLocation } from './types.js';
-export declare const defaultRedirectLimit = 8;
-export declare function resolveRoute(options: ResolveRouteOptions): ResolvedRoute;
-export declare function resolveRouteGuard(route: ResolvedRoute, options?: ResolveRouteGuardOptions): string | undefined | Promise<string | undefined>;
-export declare function resolveRouteInitialState(route: ResolvedRoute, options?: ResolveRouteInitialStateOptions): unknown;
-export interface RouteLoaderCacheOptions {
-    /**
-     * Max entries; the least recently used entry is evicted when exceeded.
-     * Defaults to 100 so dynamic routes (/user/:id) cannot accumulate one entry per path.
-     */
-    readonly max?: number;
-}
-export declare function createRouteLoaderCache(options?: RouteLoaderCacheOptions): RouteLoaderCache;
-export declare function loadRouteComponent(component: RouteComponent): Promise<PageDefinition>;
-export declare function readLoaderCacheKey(policy: RouteLoaderCachePolicy | undefined, route: RouteLocation, options: ResolveRouteInitialStateOptions): string | undefined;
-/**
- * Adapter for the RouteResolver contract: maps @vobs/router's pure resolve functions
- * to the Core-defined SSR resolution contract for consumers like server-renderer,
- * keeping the framework core independent of plugin implementations
- * (dependency direction: server-renderer → contract ← router adapter).
- */
-export declare function createRouteResolver(): RouteResolver;

package/dist/resolve.js

@@ -1,272 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { createInjectionScope, createRuntimeError, runWithInjectionScope, } from '@vobs/runtime-core';
-import {} from './types.js';
-import { resolveRouteMatch } from './match.js';
-import { createRouteLocation } from './location.js';
-export const defaultRedirectLimit = 8;
-const routeComponentCache = new WeakMap();
-const pendingLoaderSignals = new WeakMap();
-export function resolveRoute(options) {
-    const match = resolveRouteMatch(options.routes, options.path, options.redirectLimit ?? defaultRedirectLimit, 0);
-    const component = match?.component ?? options.notFound;
-    const location = match?.location ?? createRouteLocation(options.path);
-    if (component === undefined) {
-        throw createRuntimeError('VOR601', `Route not found: ${options.path}`);
-    }
-    return {
-        status: match === undefined ? 'notFound' : 'matched',
-        route: location,
-        component,
-        ...(match?.layouts === undefined ? {} : { layouts: match.layouts }),
-        ...(match?.error === undefined ? {} : { error: match.error }),
-        ...(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 }),
-    };
-}
-export function resolveRouteGuard(route, options = {}) {
-    if (route.guard === undefined)
-        return undefined;
-    const context = createRouteGuardContext(route.route, options);
-    const result = runWithInjectionScope(context.injections, () => route.guard(context));
-    if (isPromiseLike(result)) {
-        return result.then((value) => readGuardRedirect(route.route, value));
-    }
-    return readGuardRedirect(route.route, result);
-}
-export function resolveRouteInitialState(route, options = {}) {
-    if (route.loader === undefined)
-        return route.initialState;
-    const context = createRouteLoaderContext(route.route, options);
-    const cacheKey = readLoaderCacheKey(route.loaderCache, route.route, options);
-    if (cacheKey !== undefined && options.loaderCache?.has(cacheKey) === true) {
-        const cached = options.loaderCache.get(cacheKey);
-        if (!isPromiseLike(cached))
-            return cached;
-        // A pending loader may belong to a superseded navigation. Keep prefetch deduplication,
-        // but do not hand a cancelled navigation's request to a new consumer.
-        if (pendingLoaderSignals.get(cached) === undefined ||
-            !pendingLoaderSignals.get(cached)?.aborted) {
-            return cached;
-        }
-        options.loaderCache.delete(cacheKey);
-    }
-    const loaded = runWithInjectionScope(context.injections, () => route.loader(context));
-    return cacheLoaderResult(loaded, cacheKey, context.signal, options.loaderCache);
-}
-export function createRouteLoaderCache(options = {}) {
-    const max = options.max ?? 100;
-    const entries = new Map();
-    const touch = (key) => {
-        const value = entries.get(key);
-        if (value !== undefined) {
-            entries.delete(key);
-            entries.set(key, value);
-        }
-    };
-    const evict = () => {
-        while (entries.size > max) {
-            const oldest = entries.keys().next().value;
-            if (oldest === undefined)
-                break;
-            entries.delete(oldest);
-        }
-    };
-    return {
-        has(key) {
-            return entries.has(key);
-        },
-        get(key) {
-            const value = entries.get(key);
-            if (value !== undefined)
-                touch(key);
-            return value;
-        },
-        set(key, value) {
-            entries.set(key, value);
-            evict();
-        },
-        delete(key) {
-            return entries.delete(key);
-        },
-        clear() {
-            entries.clear();
-        },
-    };
-}
-export async function loadRouteComponent(component) {
-    const page = typeof component === 'function' ? await loadLazyRouteComponentCached(component) : component;
-    if (page?.kind !== 'vobs.page' || typeof page.mount !== 'function') {
-        throw createRuntimeError('VOR603', 'Invalid PageDefinition');
-    }
-    return page;
-}
-function loadLazyRouteComponentCached(component) {
-    const cached = routeComponentCache.get(component);
-    if (cached !== undefined)
-        return cached;
-    const loaded = component().then((module) => module.default, (error) => {
-        routeComponentCache.delete(component);
-        throw error;
-    });
-    routeComponentCache.set(component, loaded);
-    return loaded;
-}
-function readRouteInjectionScope(options) {
-    return options.injections ?? createInjectionScope();
-}
-function createRouteInjectionContext(injections) {
-    return {
-        injections,
-        maybeInject(key) {
-            return injections.maybeInject(key);
-        },
-        inject(key, fallback) {
-            return arguments.length === 1
-                ? injections.inject(key)
-                : injections.inject(key, fallback);
-        },
-    };
-}
-function createRouteLoaderContext(route, options) {
-    const injections = readRouteInjectionScope(options);
-    return {
-        route,
-        signal: options.signal ?? new AbortController().signal,
-        ...(options.request === undefined ? {} : { request: options.request }),
-        ...createRouteInjectionContext(injections),
-    };
-}
-function createRouteGuardContext(route, options) {
-    const injections = readRouteInjectionScope(options);
-    return {
-        route,
-        signal: options.signal ?? new AbortController().signal,
-        ...(options.request === undefined ? {} : { request: options.request }),
-        ...createRouteInjectionContext(injections),
-    };
-}
-function readGuardRedirect(route, result) {
-    if (result === false) {
-        throw createRuntimeError('VOR606', `Route navigation blocked: ${route.path}`);
-    }
-    if (typeof result === 'string')
-        return result;
-    if (typeof result === 'object' && result !== null)
-        return result.redirect;
-    return undefined;
-}
-export function readLoaderCacheKey(policy, route, options) {
-    if (policy === undefined || policy === false || options.loaderCache === undefined)
-        return undefined;
-    if (options.request !== undefined)
-        return undefined;
-    const key = typeof policy === 'object' ? policy.key : undefined;
-    if (typeof key === 'function')
-        return key(route);
-    if (typeof key === 'string')
-        return key;
-    return route.path;
-}
-function cacheLoaderResult(loaded, cacheKey, signal, loaderCache) {
-    if (isPromiseLike(loaded)) {
-        const pending = loaded.then((value) => {
-            if (cacheKey !== undefined && loaderCache?.get(cacheKey) === pending) {
-                if (signal.aborted) {
-                    loaderCache.delete(cacheKey);
-                }
-                else {
-                    loaderCache.set(cacheKey, value);
-                }
-            }
-            else {
-                writeLoaderCache(cacheKey, value, signal, loaderCache);
-            }
-            return value;
-        }, (error) => {
-            if (cacheKey !== undefined && loaderCache?.get(cacheKey) === pending) {
-                loaderCache.delete(cacheKey);
-            }
-            throw error;
-        });
-        pendingLoaderSignals.set(pending, signal);
-        writeLoaderCache(cacheKey, pending, signal, loaderCache);
-        return pending;
-    }
-    writeLoaderCache(cacheKey, loaded, signal, loaderCache);
-    return loaded;
-}
-function writeLoaderCache(cacheKey, value, signal, loaderCache) {
-    if (cacheKey === undefined || signal.aborted || loaderCache === undefined)
-        return;
-    loaderCache.set(cacheKey, value);
-}
-function isPromiseLike(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'then' in value &&
-        typeof value.then === 'function');
-}
-/**
- * Adapter for the RouteResolver contract: maps @vobs/router's pure resolve functions
- * to the Core-defined SSR resolution contract for consumers like server-renderer,
- * keeping the framework core independent of plugin implementations
- * (dependency direction: server-renderer → contract ← router adapter).
- */
-export function createRouteResolver() {
-    return {
-        resolve(options) {
-            const resolved = resolveRoute({
-                routes: options.routes,
-                path: options.path,
-                ...(options.notFound === undefined ? {} : { notFound: options.notFound }),
-                ...(options.error === undefined ? {} : { error: options.error }),
-                ...(options.redirectLimit === undefined ? {} : { redirectLimit: options.redirectLimit }),
-            });
-            return toRouteResolution(resolved);
-        },
-        resolveGuard(resolution, options) {
-            return resolveRouteGuard(resolution, {
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-                ...(options.request === undefined ? {} : { request: options.request }),
-                ...(options.injections === undefined
-                    ? {}
-                    : { injections: options.injections }),
-            });
-        },
-        resolveInitialState(resolution, options) {
-            return resolveRouteInitialState(resolution, {
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-                ...(options.request === undefined ? {} : { request: options.request }),
-                ...(options.loaderCache === undefined
-                    ? {}
-                    : { loaderCache: options.loaderCache }),
-                ...(options.injections === undefined
-                    ? {}
-                    : { injections: options.injections }),
-            });
-        },
-        loadComponent(component) {
-            return loadRouteComponent(component);
-        },
-    };
-}
-function toRouteResolution(resolved) {
-    return {
-        status: resolved.status,
-        route: resolved.route,
-        component: resolved.component,
-        ...(resolved.layouts === undefined ? {} : { layouts: resolved.layouts }),
-        ...(resolved.error === undefined ? {} : { error: resolved.error }),
-        ...(resolved.initialState === undefined ? {} : { initialState: resolved.initialState }),
-        ...(resolved.guard === undefined ? {} : { guard: resolved.guard }),
-        ...(resolved.loader === undefined ? {} : { loader: resolved.loader }),
-        ...(resolved.loaderCache === undefined ? {} : { loaderCache: resolved.loaderCache }),
-        ...(resolved.meta === undefined ? {} : { meta: resolved.meta }),
-    };
-}

package/dist/router.d.ts

@@ -1,8 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type RouteRecord, type ValidatedRouteRecords, type Router, type RouterOptions } from './types.js';
-export declare function createRouter<const Routes extends readonly RouteRecord[]>(options: RouterOptions<Routes> & {
-    readonly routes: Routes & ValidatedRouteRecords<Routes>;
-}): Router;