mikuru 1.0.14 → 1.0.16

package/dist/router/index.d.ts

@@ -1,17 +1,38 @@
 import type { Ref } from "../runtime/index.js";
-export type RouteParams = Record<string, string>;
-export type RouteQuery = Record<string, string | string[] | undefined>;
+export type RouteParams = Record<string, string | string[]>;
+export type RouteParamsRaw = Record<string, string | number | boolean | Array<string | number | boolean>>;
+export type RouteQueryValue = string | string[] | undefined;
+export type RouteQuery = Record<string, RouteQueryValue>;
 export type RouteComponent = {
     mount(target: Element | DocumentFragment, props?: Record<string, unknown>): {
         element: Element | Comment;
         unmount(): void;
     };
 };
+export type LazyRouteComponent = () => Promise<RouteComponent | {
+    default: RouteComponent;
+}>;
+export type RoutePropsOption = boolean | Record<string, unknown> | ((route: RouteLocation) => Record<string, unknown> | undefined);
+export type RouteRecordInput = Omit<RouteRecord, "children" | "__mikuru_resolvedComponent"> & {
+    children?: readonly RouteRecordInput[];
+};
 export type RouteRecord = {
     path: string;
     name?: string;
-    component?: RouteComponent;
+    component?: RouteComponent | LazyRouteComponent;
+    loadingComponent?: RouteComponent;
+    errorComponent?: RouteComponent;
+    redirect?: RouteLocationRaw | ((to: RouteLocation) => RouteLocationRaw);
+    alias?: string | string[];
     meta?: Record<string, unknown>;
+    beforeEnter?: NavigationGuard | NavigationGuard[];
+    props?: RoutePropsOption;
+    children?: RouteRecord[];
+    __mikuru_resolvedComponent?: RouteComponent;
+};
+export type QueryCodec = {
+    parseQuery?(query: string): RouteQuery;
+    stringifyQuery?(query: RouteQuery): string;
 };
 export type RouteLocation = {
     path: string;
@@ -20,6 +41,7 @@ export type RouteLocation = {
     hash: string;
     params: RouteParams;
     matched?: RouteRecord;
+    matchedRecords: RouteRecord[];
     name?: string;
     meta: Record<string, unknown>;
 };
@@ -27,10 +49,34 @@ export type RouteLocationRaw = string | {
     path: string;
     query?: RouteQuery;
     hash?: string;
+} | {
+    name: string;
+    params?: RouteParamsRaw;
+    query?: RouteQuery;
+    hash?: string;
 };
 export type NavigationGuardResult = void | boolean | string | RouteLocationRaw;
 export type NavigationGuard = (to: RouteLocation, from: RouteLocation) => NavigationGuardResult | Promise<NavigationGuardResult>;
-export type AfterNavigationHook = (to: RouteLocation, from: RouteLocation) => void;
+export declare const NavigationFailureType: {
+    readonly aborted: "aborted";
+    readonly cancelled: "cancelled";
+    readonly duplicated: "duplicated";
+};
+export type NavigationFailureType = (typeof NavigationFailureType)[keyof typeof NavigationFailureType];
+export type NavigationFailure = {
+    type: NavigationFailureType;
+    to: RouteLocation;
+    from: RouteLocation;
+    message: string;
+};
+export type NavigationResult = RouteLocation | NavigationFailure;
+export type AfterNavigationHook = (to: RouteLocation, from: RouteLocation, failure?: NavigationFailure) => void;
+export type RouterErrorHandler = (error: unknown, to: RouteLocation, from?: RouteLocation) => void;
+export type ScrollPosition = ScrollToOptions;
+export type ScrollBehavior = (to: RouteLocation, from: RouteLocation) => ScrollPosition | false | void | Promise<ScrollPosition | false | void>;
+export type ScrollMeta = {
+    scroll?: ScrollPosition | false | ((to: RouteLocation, from: RouteLocation) => ScrollPosition | false | void | Promise<ScrollPosition | false | void>);
+};
 export type RouterHistory = {
     mode: "hash" | "history" | "memory";
     location(): string;
@@ -43,25 +89,140 @@ export type RouterHistory = {
 };
 export type RouterOptions = {
     history?: RouterHistory;
-    routes: RouteRecord[];
+    routes: readonly RouteRecord[];
     notFound?: RouteComponent;
+    scrollBehavior?: ScrollBehavior;
+    parseQuery?: QueryCodec["parseQuery"];
+    stringifyQuery?: QueryCodec["stringifyQuery"];
+    loadingComponent?: RouteComponent;
+    errorComponent?: RouteComponent;
 };
 export type Router = {
     currentRoute: Ref<RouteLocation>;
     routes: RouteRecord[];
-    push(to: RouteLocationRaw): Promise<RouteLocation>;
-    replace(to: RouteLocationRaw): Promise<RouteLocation>;
+    push(to: RouteLocationRaw): Promise<NavigationResult>;
+    replace(to: RouteLocationRaw): Promise<NavigationResult>;
     back(): void;
     forward(): void;
     resolve(to: RouteLocationRaw): RouteLocation;
+    preload(to: RouteLocationRaw): Promise<RouteLocation>;
+    isReady(): Promise<void>;
     beforeEach(guard: NavigationGuard): () => void;
     afterEach(hook: AfterNavigationHook): () => void;
+    onError(handler: RouterErrorHandler): () => void;
+    addRoute(record: RouteRecord): () => void;
+    addRoute(parentName: string, record: RouteRecord): () => void;
+    removeRoute(name: string): boolean;
+    hasRoute(name: string): boolean;
     listen(): () => void;
     createHref(to: RouteLocationRaw): string;
+    loadingComponent?: RouteComponent;
+    errorComponent?: RouteComponent;
+};
+type RouteRecordTree = {
+    path: string;
+    name?: string;
+    children?: readonly RouteRecordTree[];
+};
+type JoinRouteLiteral<Parent extends string, Path extends string> = Path extends `/${string}` ? Path : Parent extends "" | "/" ? Path extends "" ? "/" : `/${Path}` : Path extends "" ? Parent : `${Parent}/${Path}`;
+type RouteEntries<Routes extends readonly RouteRecordTree[], Parent extends string = ""> = Routes[number] extends infer Record ? Record extends RouteRecordTree ? (Record extends {
+    name: infer Name extends string;
+} ? {
+    name: Name;
+    path: JoinRouteLiteral<Parent, Record["path"]>;
+} : never) | (Record extends {
+    children: infer Children extends readonly RouteRecordTree[];
+} ? RouteEntries<Children, JoinRouteLiteral<Parent, Record["path"]>> : never) : never : never;
+type RoutePathByName<Routes extends readonly RouteRecordTree[], Name extends string> = Extract<RouteEntries<Routes>, {
+    name: Name;
+}> extends {
+    path: infer Path extends string;
+} ? Path : never;
+type RouteParamInfo<Segment extends string> = Segment extends `:${infer Name}(${string})*` ? {
+    name: Name;
+    optional: true;
+    repeat: true;
+} : Segment extends `:${infer Name}(${string})+` ? {
+    name: Name;
+    optional: false;
+    repeat: true;
+} : Segment extends `:${infer Name}(${string})?` ? {
+    name: Name;
+    optional: true;
+    repeat: false;
+} : Segment extends `:${infer Name}(${string})` ? {
+    name: Name;
+    optional: false;
+    repeat: false;
+} : Segment extends `:${infer Name}?` ? {
+    name: Name;
+    optional: true;
+    repeat: false;
+} : Segment extends `:${infer Name}+` ? {
+    name: Name;
+    optional: false;
+    repeat: true;
+} : Segment extends `:${infer Name}*` ? {
+    name: Name;
+    optional: true;
+    repeat: true;
+} : Segment extends `:${infer Name}` ? {
+    name: Name;
+    optional: false;
+    repeat: false;
+} : never;
+type RouteParamInfosFromPath<Path extends string> = Path extends `${infer Segment}/${infer Rest}` ? RouteParamInfo<Segment> | RouteParamInfosFromPath<Rest> : RouteParamInfo<Path>;
+type RequiredRouteParams<Path extends string> = {
+    [Param in RouteParamInfosFromPath<Path> as Param extends {
+        optional: false;
+        name: infer Name extends string;
+    } ? Name : never]: Param extends {
+        repeat: true;
+    } ? string[] : string;
+};
+type OptionalRouteParams<Path extends string> = {
+    [Param in RouteParamInfosFromPath<Path> as Param extends {
+        optional: true;
+        name: infer Name extends string;
+    } ? Name : never]?: Param extends {
+        repeat: true;
+    } ? string[] : string;
+};
+type RouteParamsForPath<Path extends string> = RequiredRouteParams<Path> & OptionalRouteParams<Path>;
+type HasRouteParams<Path extends string> = keyof RouteParamsForPath<Path> extends never ? false : true;
+type HasRequiredRouteParams<Path extends string> = keyof RequiredRouteParams<Path> extends never ? false : true;
+export type RouteNames<Routes extends readonly RouteRecordTree[]> = RouteEntries<Routes> extends {
+    name: infer Name extends string;
+} ? Name : never;
+export type RouteParamNames<Path extends string> = RouteParamInfosFromPath<Path> extends {
+    name: infer Name extends string;
+} ? Name : never;
+export type RouteLocationForName<Routes extends readonly RouteRecordTree[], Name extends RouteNames<Routes>> = HasRouteParams<RoutePathByName<Routes, Name>> extends false ? {
+    name: Name;
+    query?: RouteQuery;
+    hash?: string;
+} : HasRequiredRouteParams<RoutePathByName<Routes, Name>> extends true ? {
+    name: Name;
+    params: RouteParamsForPath<RoutePathByName<Routes, Name>>;
+    query?: RouteQuery;
+    hash?: string;
+} : {
+    name: Name;
+    params?: RouteParamsForPath<RoutePathByName<Routes, Name>>;
+    query?: RouteQuery;
+    hash?: string;
 };
+export declare function defineRoutes<const Routes extends readonly RouteRecordInput[]>(routes: Routes): Routes;
+export declare function provideRouter(router: Router): void;
+export declare function useRouter(): Router;
+export declare function useRoute(): RouteLocation;
+export declare function isNavigationFailure(value: unknown, type?: NavigationFailureType): value is NavigationFailure;
 export declare function createRouter(options: RouterOptions): Router;
 export declare function createWebHistory(base?: string): RouterHistory;
 export declare function createWebHashHistory(base?: string): RouterHistory;
 export declare function createMemoryHistory(initial?: string): RouterHistory;
 export declare const RouterView: RouteComponent;
 export declare const RouterLink: RouteComponent;
+export declare function parseRouteQuery(raw: string): RouteQuery;
+export declare function stringifyRouteQuery(query: RouteQuery): string;
+export {};