nuxt-typed-router 2.3.4 → 3.0.0-beta.0

package/README.md

@@ -24,9 +24,6 @@
 - Out of the box `i18n` support
 - Supports routes extended by config and modules
 
-> ⚠️ Since `v2.1.x`, `useTypedRouter` and `useTypedRoute` are no longer exported.   
-The package can now override types from `useRouter`, `useRoute` and `navigateTo`
-
 <br/>
 
 <br/>

package/dist/module.d.ts

@@ -1,6 +1,14 @@
 import * as _nuxt_schema from '@nuxt/schema';
 
 interface ModuleOptions {
+    /**
+     * ⛔️ Experimental, disable it if you encounter problems
+     *
+     * Enables path autocomplete and path validity for programmatic validation
+     *
+     *  @default true
+     */
+    experimentalPathCheck?: boolean;
     /**
      * Set to false if you don't want a plugin generated
      * @default false

package/dist/module.json

@@ -5,5 +5,5 @@
     "nuxt": "^3.0.0",
     "bridge": false
   },
-  "version": "2.3.4"
+  "version": "3.0.0-beta.0"
 }

package/dist/module.mjs

@@ -2,6 +2,7 @@ import { addPluginTemplate, extendPages, defineNuxtModule, createResolver } from
 import chalk from 'chalk';
 import logSymbols from 'log-symbols';
 import { defu } from 'defu';
+import { customAlphabet, nanoid as nanoid$1 } from 'nanoid';
 import prettier from 'prettier';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
@@ -13,6 +14,7 @@ class ModuleOptionsStore {
   constructor() {
     this.plugin = false;
     this.strict = false;
+    this.experimentalPathCheck = true;
     this.autoImport = false;
     this.rootDir = "";
     this.i18n = false;
@@ -31,6 +33,8 @@ class ModuleOptionsStore {
       this.i18n = options.i18n;
     if (options.i18nLocales != null)
       this.i18nLocales = options.i18nLocales;
+    if (options.experimentalPathCheck != null)
+      this.experimentalPathCheck = options.experimentalPathCheck;
   }
   getResolvedStrictOptions() {
     let resolved;
@@ -158,24 +162,111 @@ function createRoutesParamsRecordResolvedExport(routesParams) {
   }`;
 }
 
+const nanoid = customAlphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 10);
+function createRoutePathSchema(routePaths) {
+  return `export type RoutePathSchema = 
+    ${routePaths.filter((f) => !!f.path).map((route) => `"${route.path}"`).join("|")}
+  `;
+}
+function createValidatePathTypes(pathElements) {
+  let pathConditions = pathElements.map(createTypeValidatePathCondition);
+  const conditionsList = pathConditions.map((m) => m.condition);
+  return `
+    ${pathConditions.length ? conditionsList.join("\n\n") : ""}
+
+    export type ValidatePath<T extends string> = T extends string 
+      ? T extends '/' 
+        ? T 
+        : ${pathConditions.length ? pathConditions.map((t) => `${t.typeName}<T> extends true ? T`).join(": ") : "never"} 
+      : string extends T
+      ? T
+      : \`Error: \${${pathConditions.map((t) => `${t.typeName}<T>`).join("|")}}\` : 'Type should be a string';
+  
+  
+    export type RouteNameFromPath<T extends string> = T extends string 
+      ? T extends '/' 
+        ? "index"
+        : ${pathConditions.length ? pathConditions.map((t) => `${t.typeName}<T> extends true ? "${t.routeName}"`).join(": ") : "never"} 
+      : never : never;
+  
+        `;
+}
+function createTypeValidatePathCondition(elements) {
+  const typeName = `Validate${nanoid(7)}`;
+  const params = /* @__PURE__ */ new Map();
+  const routeName = elements.flat()[0].routeName;
+  const hasOnlyNames = elements.flat().every((elem) => elem.type === "name");
+  const condition = `type ${typeName}<T> = T extends \`/${elements.map((elementArray, index) => {
+    return elementArray.map((elem) => {
+      const isLast = index === elements.flat().length - 1;
+      if (elem.type === "name" && isLast && !hasOnlyNames) {
+        const id = nanoid(6);
+        params.set(elem.id, id);
+        return `${elem.content}\${infer ${id}}`;
+      } else if (elem.type === "name") {
+        return elem.content;
+      } else if (elem.type === "param" || elem.type === "optionalParam") {
+        const id = nanoid(6);
+        params.set(elem.id, id);
+        return `\${infer ${id}}`;
+      } else if (elem.type === "catchAll") {
+        return `\${string}`;
+      }
+    }).join("");
+  }).join("/")}\`
+    ? ${hasOnlyNames ? `true :` : elements.flat().map((elem, index) => {
+    let output = "";
+    const isLast = index === elements.flat().length - 1;
+    const isName = elem.type === "name";
+    const isOptional = elem.type === "optionalParam";
+    const isParam = elem.type === "param";
+    elem.type === "catchAll";
+    if (isName && isLast) {
+      output = `ValidEndOfPath<${params.get(elem.id)}> extends false ? "End of path '${elem.fullPath}' is invalid" : true :`;
+    } else if (isParam && isLast) {
+      output = `ValidParam<${params.get(elem.id)}> extends false ? "Parameter {${elem.content}} of path '${elem.fullPath}' is invalid" : true :`;
+    } else if (isParam) {
+      output = `ValidStringPath<${params.get(elem.id)}> extends false ? "Parameter {${elem.content}} of path '${elem.fullPath}' is required" : `;
+    } else if (isOptional && isLast) {
+      output = `ValidParam<${params.get(elem.id)}, false> extends false ? "Parameter {${elem.content}} of path '${elem.fullPath}' is invalid" : true :`;
+    } else if (isLast) {
+      output += "true :";
+    }
+    return output;
+  }).join("")} false ;`;
+  return {
+    typeName,
+    condition,
+    routeName
+  };
+}
+
 function createRoutesTypesFile({
   routesList,
   routesObjectTemplate,
   routesDeclTemplate,
-  routesParams
+  routesParams,
+  routesPaths
 }) {
+  const filteredRoutesList = routesList.filter(
+    (routeName, index) => routesList.indexOf(routeName) === index
+  );
+  const filteredRoutesParams = routesParams.filter(
+    (route, index) => routesParams.findIndex((r) => route.name === r.name) === index
+  );
   return (
     /* typescript */
     `
-    ${createRoutesNamesListExport(routesList)}
+    ${createRoutesNamesListExport(filteredRoutesList)}
+    export type WithoutBracket<T extends string> = T extends \`:\${string}\` ? never : T;
 
-    ${createRoutesParamsRecordExport(routesParams)}
+    ${createRoutesParamsRecordExport(filteredRoutesParams)}
     
-    ${createRoutesParamsRecordResolvedExport(routesParams)}
+    ${createRoutesParamsRecordResolvedExport(filteredRoutesParams)}
 
-    ${createRoutesNamedLocationsExport(routesParams)}
+    ${createRoutesNamedLocationsExport(filteredRoutesParams)}
 
-    ${createRoutesNamedLocationsResolvedExport(routesParams)}
+    ${createRoutesNamedLocationsResolvedExport(filteredRoutesParams)}
 
     export type RoutesNamesListRecord = ${routesDeclTemplate};
 
@@ -193,15 +284,10 @@ function returnIfTrue(condition, template, otherwise) {
   }
   return otherwise ?? "";
 }
-function returnIfFalse(condition, template, otherwise) {
-  if (!condition) {
-    return template;
-  }
-  return otherwise ?? "";
-}
 
 function createTypedRouterFile() {
   const strictOptions = moduleOptionStore.getResolvedStrictOptions();
+  const { i18n, experimentalPathCheck } = moduleOptionStore;
   return (
     /* typescript */
     `
@@ -220,8 +306,12 @@ function createTypedRouterFile() {
     RoutesNamedLocationsResolved,
     RoutesNamesList,
     RoutesParamsRecord,
-    RoutesParamsRecordResolved
+    RoutesParamsRecordResolved,
   } from './__routes';
+  ${returnIfTrue(
+      experimentalPathCheck,
+      `import type {TypedPathParameter, RouteNameFromPath} from './__paths';`
+    )}
   import type { HasOneRequiredParameter } from './__types_utils';
 
 
@@ -231,28 +321,28 @@ function createTypedRouterFile() {
    * RouteLocationRaw with discrimanated name and params properties 
    * {@link RouteLocationRaw}
    * */
-  export type TypedRouteLocationRaw =
+  export type TypedRouteLocationRaw<T extends string = string> =
   | (Omit<Exclude<RouteLocationRaw, string>, 'name' | 'params'> & RoutesNamedLocations)
-  ${returnIfFalse(strictOptions.router.strictToArgument, "| string")}
+  | Omit<RouteLocationPathRaw, 'path'>
   ${returnIfTrue(
-      strictOptions.router.strictRouteLocation,
-      `| Omit<RouteLocationPathRaw, 'path'>`,
-      "| RouteLocationPathRaw"
+      experimentalPathCheck && !strictOptions.router.strictRouteLocation,
+      `& {path?: TypedPathParameter<T>}`
     )}
+  ${returnIfTrue(!experimentalPathCheck && !strictOptions.router.strictToArgument, ` | string`)}
   ;
   
 
   /**
    * Alternative version of {@link TypedRouteLocationRaw} but with a name generic
    */
-  export type TypedRouteLocationRawFromName<T extends RoutesNamesList> =
+  export type TypedRouteLocationRawFromName<T extends RoutesNamesList, P extends string = string> =
   | (Omit<Exclude<RouteLocationRaw, string>, 'name' | 'params'> & TypedLocationAsRelativeRaw<T>)
-  ${returnIfFalse(strictOptions.router.strictToArgument, "| string")}
+  | Omit<RouteLocationPathRaw, 'path'>
   ${returnIfTrue(
-      strictOptions.router.strictRouteLocation,
-      `| Omit<RouteLocationPathRaw, 'path'>`,
-      "| RouteLocationPathRaw"
+      experimentalPathCheck && !strictOptions.router.strictRouteLocation,
+      `& {path?: TypedPathParameter<P>}`
     )}
+  ${returnIfTrue(!experimentalPathCheck && !strictOptions.router.strictToArgument, ` | string`)}
 
   /** 
    * Generic providing inference and dynamic inclusion of \`params\` property
@@ -294,24 +384,36 @@ function createTypedRouterFile() {
      * @param to - Raw route location to resolve
      * @param currentLocation - Optional current location to resolve against
      */
-    resolve<T extends RoutesNamesList>(
-      to: TypedRouteLocationRawFromName<T>,
-      currentLocation?: TypedRoute
+    resolve<T extends RoutesNamesList, P extends string>(
+      to: TypedRouteLocationRawFromName<T, P>,
+      currentLocation?: TypedRouteLocationRaw
     ): TypedRouteLocationFromName<T>;
+    ${returnIfTrue(
+      experimentalPathCheck && !strictOptions.router.strictToArgument,
+      `resolve<T extends string>(to: TypedPathParameter<T>, currentLocation?: TypedRouteLocationRaw): TypedRouteLocationFromName<RouteNameFromPath<T>>;`
+    )}
     /**
      * Programmatically navigate to a new URL by pushing an entry in the history
      * stack.
      *
      * @param to - Route location to navigate to
      */
-    push(to: TypedRouteLocationRaw): Promise<NavigationFailure | void | undefined>;
+    push<T extends RoutesNamesList, P extends string>(to: TypedRouteLocationRawFromName<T, P>): Promise<NavigationFailure | void | undefined>;
+    ${returnIfTrue(
+      experimentalPathCheck && !strictOptions.router.strictToArgument,
+      `push<T extends string>(to: TypedPathParameter<T>): Promise<NavigationFailure | void | undefined>;`
+    )}
     /**
      * Programmatically navigate to a new URL by replacing the current entry in
      * the history stack.
      *
      * @param to - Route location to navigate to
      */
-    replace(to: TypedRouteLocationRaw): Promise<NavigationFailure | void | undefined>;
+    replace<T extends RoutesNamesList, P extends string>(to: TypedRouteLocationRawFromName<T, P>): Promise<NavigationFailure | void | undefined>;
+    ${returnIfTrue(
+      experimentalPathCheck && !strictOptions.router.strictToArgument,
+      `replace<T extends string>(to: TypedPathParameter<T>): Promise<NavigationFailure | void | undefined>;`
+    )}
   }
 
 
@@ -354,21 +456,25 @@ function createTypedRouterFile() {
 }
 
 function createTypedRouterDefinitionFile() {
-  const { plugin, autoImport, i18n } = moduleOptionStore;
   const strictOptions = moduleOptionStore.getResolvedStrictOptions();
+  const { plugin, autoImport, i18n, experimentalPathCheck } = moduleOptionStore;
   return (
     /* typescript */
     `
     
-    import type { NuxtLinkProps } from '#app';
-    import type { DefineComponent } from 'vue';
+    import type { NuxtLinkProps, PageMeta } from '#app';
+    import NuxtLink from 'nuxt/dist/app/components/nuxt-link';
     import type { RouteLocationRaw, RouteLocationPathRaw } from 'vue-router';
-    import type { RoutesNamesList, RoutesNamedLocations, RoutesNamesListRecord } from './__routes';
-    import type {TypedRouter, TypedRoute} from './__router';
+    import type { RoutesNamedLocations, RoutesNamesListRecord, RoutesNamesList } from './__routes';
+    import type {TypedRouter, TypedRoute, TypedRouteLocationRawFromName, TypedLocationAsRelativeRaw} from './__router';
     import { useRoute as _useRoute } from './__useTypedRoute';
     import { useRouter as _useRouter } from './__useTypedRouter';
     import { navigateTo as _navigateTo } from './__navigateTo';
     import { useLocalePath as _useLocalePath, useLocaleRoute as _useLocaleRoute} from './__i18n-router';
+    import {definePageMeta as _definePageMeta} from './__definePageMeta';
+
+    ${returnIfTrue(experimentalPathCheck, `import type {TypedPathParameter} from './__paths';`)}
+
 
     declare global {
  
@@ -379,6 +485,8 @@ function createTypedRouterDefinitionFile() {
             const useRoute: typeof _useRoute;
             const useRouter: typeof _useRouter;
             const navigateTo: typeof _navigateTo;
+            const definePageMeta: typeof _definePageMeta;
+            
             ${returnIfTrue(
         i18n,
         /* typescript */
@@ -391,33 +499,33 @@ function createTypedRouterDefinitionFile() {
     )}
     }
     
-    type TypedNuxtLinkProps = Omit<NuxtLinkProps, 'to'> & {
+    type TypedNuxtLinkProps<T extends string> = Omit<NuxtLinkProps, 'to'> &
+     {
       to: 
-      Omit<Exclude<RouteLocationRaw, string>, 'name' | 'params'> & RoutesNamedLocations
-      ${returnIfFalse(strictOptions.NuxtLink.strictToArgument, "| string")}
-      ${returnIfTrue(
-      strictOptions.NuxtLink.strictRouteLocation,
-      `| Omit<RouteLocationPathRaw, 'path'>`,
-      "| RouteLocationPathRaw"
+        | Omit<Exclude<RouteLocationRaw, string>, 'name' | 'params'> & RoutesNamedLocations
+        | Omit<RouteLocationPathRaw, 'path'>
+        ${returnIfTrue(
+      experimentalPathCheck && !strictOptions.NuxtLink.strictRouteLocation,
+      `& {path?: TypedPathParameter<T>}`
     )}
-    };
+        ${returnIfTrue(
+      !experimentalPathCheck && !strictOptions.NuxtLink.strictToArgument,
+      ` | string`
+    )}
+        ${returnIfTrue(
+      experimentalPathCheck && !strictOptions.NuxtLink.strictToArgument,
+      ` | TypedPathParameter<T>`
+    )}
+      }
     
-    export type TypedNuxtLink = DefineComponent<
-      TypedNuxtLinkProps,
-      {},
-      {},
-      import('vue').ComputedOptions,
-      import('vue').MethodOptions,
-      import('vue').ComponentOptionsMixin,
-      import('vue').ComponentOptionsMixin,
-      {},
-      string,
-      import('vue').VNodeProps &
-        import('vue').AllowedComponentProps &
-        import('vue').ComponentCustomProps,
-      Readonly<TypedNuxtLinkProps>,
-      {}
-    >;
+        
+          
+    export type TypedNuxtLink = new <P extends string>(props: TypedNuxtLinkProps<P>) => Omit<
+      typeof NuxtLink,
+      '$props'
+    > & {
+      $props: TypedNuxtLinkProps<P>;
+    };
     
     declare module '@vue/runtime-core' {
       export interface GlobalComponents {
@@ -447,7 +555,7 @@ function createTypedRouterDefinitionFile() {
 }
 
 function createIndexFile() {
-  const { i18n } = moduleOptionStore;
+  const { i18n, experimentalPathCheck } = moduleOptionStore;
   return (
     /* typescript */
     `
@@ -469,11 +577,34 @@ function createIndexFile() {
       RoutesNamesList,
       RoutesNamesListRecord,
       RoutesParamsRecord,
+      RoutePath,
+      RoutePathByName
     } from './__routes';
     export { useRoute } from './__useTypedRoute';
     export { useRouter } from './__useTypedRouter';
     export { navigateTo } from './__navigateTo';
-    ${returnIfTrue(i18n, `export {useLocalePath, useLocaleRoute} from './__i18n-router.ts';`)}
+    export { definePageMeta } from './__definePageMeta';
+    
+    ${returnIfTrue(
+      experimentalPathCheck,
+      `export type { ValidatePath, RoutePathSchema, TypedPathParameter, RouteNameFromPath } from './__paths';`
+    )}
+    ${returnIfTrue(i18n, `export {useLocalePath, useLocaleRoute} from './__i18n-router';`)}
+
+    export const helpers = {
+      route(
+        to: TypedRouteLocationRawFromName<T, P>,
+      ): [T] extends [never] ? string : Required<
+        (Omit<Exclude<RouteLocationRaw, string>, 'name' | 'params'> & TypedLocationAsRelativeRaw<T>)
+      > {
+        return to;
+      },
+      path(
+        to: TypedPathParameter<T>,
+      ) : [T] extends [never] ? string : Required<TypedRouteLocationRawFromName<RouteNameFromPath<T>, T>> {
+        return to;
+      }
+    } 
   `
   );
 }
@@ -502,7 +633,7 @@ function createPluginFile() {
   );
 }
 
-function createUseTypedRouteFile(routesDeclTemplate) {
+function createUseTypedRouteFile() {
   return (
     /* typescript */
     `
@@ -542,7 +673,7 @@ function createUseTypedRouteFile(routesDeclTemplate) {
   );
 }
 
-function createUseTypedRouterFile(routesDeclTemplate) {
+function createUseTypedRouterFile() {
   return (
     /* typescript */
     `
@@ -570,14 +701,20 @@ function createUseTypedRouterFile(routesDeclTemplate) {
 }
 
 function createNavigateToFile() {
+  const { router } = moduleOptionStore.getResolvedStrictOptions();
+  const { experimentalPathCheck } = moduleOptionStore;
   return (
     /* typescript */
     `
     import { navigateTo as defaultNavigateTo } from '#app';
     import type { NavigateToOptions } from 'nuxt/dist/app/composables/router';
     import type { NavigationFailure } from 'vue-router';
-    import type { TypedRouteLocationRawFromName, TypedRouteFromName } from './__router';
+    import type { TypedRouteLocationRawFromName, TypedRouteFromName, TypedRoute } from './__router';
     import type { RoutesNamesList } from './__routes';
+    ${returnIfTrue(
+      experimentalPathCheck,
+      `import type {TypedPathParameter, RouteNameFromPath} from './__paths';`
+    )}
 
     /** 
    * Typed clone of \`navigateTo\`
@@ -588,10 +725,22 @@ function createNavigateToFile() {
    * const resolved = navigateTo({name: 'foo', params: {foo: 'bar'}});
    * \`\`\`
    */
-    export const navigateTo: <T extends RoutesNamesList>(
-      to: TypedRouteLocationRawFromName<T>,
+  
+
+  interface NavigateToFunction {
+    <T extends RoutesNamesList, P extends string>(
+      to: TypedRouteLocationRawFromName<T, P>,
       options?: NavigateToOptions
-    ) => Promise<void | NavigationFailure | TypedRouteFromName<T>> = defaultNavigateTo as any;
+    ) : Promise<void | NavigationFailure | TypedRouteFromName<T>>
+    ${returnIfTrue(
+      experimentalPathCheck && !router.strictToArgument,
+      `<T extends string>(
+        to: TypedPathParameter<T>,
+        options?: NavigateToOptions
+      ) : Promise<void | NavigationFailure | TypedRouteFromName<RouteNameFromPath<T>>>`
+    )}
+  }
+    export const navigateTo: NavigateToFunction = defaultNavigateTo as any;
 
   `
   );
@@ -622,27 +771,49 @@ function createTypeUtilsRuntimeFile() {
 }
 
 function createi18nRouterFile() {
-  const { i18nLocales } = moduleOptionStore;
+  const { router } = moduleOptionStore.getResolvedStrictOptions();
+  const { i18nLocales, experimentalPathCheck } = moduleOptionStore;
   return (
     /* typescript */
     `
-
+  import type { RouteLocationRaw } from 'vue-router';
   import { useLocalePath as _useLocalePath, useLocaleRoute as _useLocaleRoute} from 'vue-i18n-routing';
-  import type {TypedRouteLocationRawFromName, TypedRouteFromName, TypedLocationAsRelativeRaw} from './__router';
+  import type {TypedRouteLocationRawFromName, TypedLocationAsRelativeRaw, TypedRouteFromName} from './__router';
   import type {RoutesNamesList} from './__routes';
+  ${returnIfTrue(
+      experimentalPathCheck,
+      `import type {TypedPathParameter, RouteNameFromPath} from './__paths';`
+    )}
 
   export type I18nLocales = ${i18nLocales.length ? i18nLocales.map((loc) => `"${loc}"`).join("|") : "string"};
 
-  export type TypedToLocalePath = <T extends RoutesNamesList = never>(
-    to: TypedRouteLocationRawFromName<T>,
-    locale?: I18nLocales | undefined
-  ) => [T] extends [never] ? string : Required<TypedLocationAsRelativeRaw<T>>;
+  export interface TypedToLocalePath {
+    <T extends RoutesNamesList, P extends string>(
+      to: TypedRouteLocationRawFromName<T, P>,
+      locale?: I18nLocales | undefined
+    ) : [T] extends [never] ? string : Required<
+    (Omit<Exclude<RouteLocationRaw, string>, 'name' | 'params'> & TypedLocationAsRelativeRaw<T>)
+    >
+    ${returnIfTrue(
+      experimentalPathCheck && !router.strictToArgument,
+      `<T extends string>(
+      to: TypedPathParameter<T>,
+      locale?: I18nLocales | undefined
+    ) : [T] extends [never] ? string : Required<TypedRouteLocationRawFromName<RouteNameFromPath<T>, T>>;`
+    )}
+  }
 
   export function useLocalePath(options?: Pick<NonNullable<Parameters<typeof _useLocalePath>[0]>, 'i18n'>): TypedToLocalePath {
      return _useLocalePath(options) as any;
   }
   
-  export type TypedLocaleRoute = <T extends RoutesNamesList>(to: TypedRouteLocationRawFromName<T>, locale?: I18nLocales | undefined) => TypedRouteFromName<T>;
+  export interface TypedLocaleRoute {
+    <T extends RoutesNamesList, P extends string>(to: TypedRouteLocationRawFromName<T, P>, locale?: I18nLocales | undefined) : TypedRouteFromName<T>
+    ${returnIfTrue(
+      experimentalPathCheck && !router.strictToArgument,
+      ` <T extends string>(to: TypedPathParameter<T>, locale?: I18nLocales | undefined) : TypedRouteFromName<RouteNameFromPath<T>>;`
+    )}
+  }
 
 
   export function useLocaleRoute(options?: Pick<NonNullable<Parameters<typeof _useLocaleRoute>[0]>, 'i18n'>): TypedLocaleRoute {
@@ -653,6 +824,283 @@ function createi18nRouterFile() {
   );
 }
 
+const routeParamExtractRegxp = /(:(\w+)(\(.+\)[*+]?)?(\?)?)+/g;
+function extractParamsFromPathDecl(path) {
+  let params = [];
+  let matches;
+  do {
+    matches = routeParamExtractRegxp.exec(path);
+    if (matches) {
+      const [_, mtch, key, catchAll, optional] = matches;
+      if (mtch) {
+        const _param = {
+          name: key,
+          optional: !!optional,
+          catchAll: !!catchAll
+        };
+        params.push(_param);
+      }
+    }
+  } while (matches);
+  return params;
+}
+function replaceParamsFromPathDecl(path) {
+  const replacedPath = path.replace(routeParamExtractRegxp, (_, mtch, key, catchAll, optional) => {
+    return catchAll ? `\${((string | ''))}` : `\${(string ${optional ? "| ''" : ""})}`;
+  });
+  return replacedPath;
+}
+
+function extractRouteParamsFromPath(path, isIndexFileForRouting, previousParams) {
+  const params = extractParamsFromPathDecl(path);
+  let allMergedParams = params.map(
+    ({ name, optional, catchAll }) => ({
+      key: name,
+      required: !optional,
+      notRequiredOnPage: optional,
+      catchAll
+    })
+  );
+  if (previousParams?.length) {
+    allMergedParams = previousParams.map((m) => ({ ...m, required: false })).concat(allMergedParams);
+  }
+  if (!params.length && isIndexFileForRouting) {
+    const lastItem = allMergedParams[allMergedParams.length - 1];
+    if (lastItem) {
+      lastItem.required = true;
+    }
+  }
+  return allMergedParams;
+}
+
+const ExtractRegex = /(^(\/)?([^:/]+)?(:(\w+)(\(.+\)[*+]?)?(\?)?)*([^:/]+)?)+/g;
+function destructurePath(path, fullPath, routeName) {
+  let allPathElements = [];
+  let _path = `${path}`;
+  do {
+    const { pathElements, strippedPath } = extractPathElements(_path, fullPath, routeName);
+    allPathElements = allPathElements.concat(pathElements);
+    _path = _path.replace(strippedPath, "");
+  } while (_path.length);
+  return allPathElements;
+}
+function extractPathElements(partOfPath, fullPath, routeName) {
+  let pathElements = [];
+  let strippedPath = "";
+  let matches;
+  matches = ExtractRegex.exec(partOfPath);
+  if (matches) {
+    const [_, mtch, slash, path1, paramDef, key, catchAll, optional, path2] = matches;
+    if (mtch) {
+      strippedPath = mtch;
+      if (path1) {
+        pathElements.push({ type: "name", content: path1, fullPath, id: nanoid$1(6), routeName });
+      }
+      if (key) {
+        pathElements.push({
+          type: catchAll ? "catchAll" : optional ? "optionalParam" : "param",
+          content: key,
+          fullPath,
+          id: nanoid$1(6),
+          routeName
+        });
+      }
+      if (path2) {
+        pathElements.push({ type: "name", content: path2, fullPath, id: nanoid$1(6), routeName });
+      }
+    }
+  }
+  return { pathElements, strippedPath };
+}
+
+function createPathsFiles({ routesPaths }) {
+  const filteredRoutesPaths = routesPaths.filter(
+    (route, index) => routesPaths.findIndex((r) => route.name === r.name) === index && !routesPaths.find((r) => `${route.path}/` === r.path)
+  ).sort((a, b) => {
+    const pathCountA = a.path.split("/");
+    const pathCountB = b.path.split("/");
+    pathCountA.splice(0, 1);
+    pathCountB.splice(0, 1);
+    const maxIndex = Math.max(pathCountA.length, pathCountB.length) - 1;
+    let order = 0;
+    let index = 0;
+    let alphabetOrder;
+    let hasElement;
+    let hasParam;
+    let indexOfParam;
+    do {
+      alphabetOrder = pathCountA[index]?.localeCompare(pathCountB[index]);
+      hasElement = (pathCountA[index] != null ? 1 : 0) - (pathCountB[index] != null ? 1 : 0);
+      hasParam = (pathCountA[index]?.includes(":") ? 1 : 0) - (pathCountB[index]?.includes(":") ? 1 : 0);
+      indexOfParam = pathCountB[index]?.indexOf(":") - pathCountA[index]?.indexOf(":");
+      if (alphabetOrder !== 0 && index === 0) {
+        order = alphabetOrder;
+        break;
+      } else {
+        if (hasElement !== 0) {
+          order = hasElement;
+          break;
+        } else if (hasParam !== 0) {
+          order = hasParam;
+          break;
+        } else if (hasParam === 0 && indexOfParam !== 0) {
+          order = indexOfParam;
+          break;
+        } else if (alphabetOrder !== 0) {
+          order = alphabetOrder;
+          break;
+        }
+      }
+      index = index + 1;
+    } while (index < maxIndex);
+    return order;
+  });
+  const pathElements = filteredRoutesPaths.filter((f) => f.path && f.path !== "/").map((route) => {
+    return route.path.split("/").filter((f) => f.length).map((m) => destructurePath(m, route.path, route.name));
+  });
+  const validatePathTypes = createValidatePathTypes(pathElements);
+  return (
+    /* typescript */
+    `
+    
+  ${createRoutePathSchema(filteredRoutesPaths)};
+
+  type ValidStringPath<T> = T extends \`\${string} \${string}\` ? false : T extends '' ? false : true;
+
+  type ValidParam<T, R extends boolean = true> = T extends \`\${infer A}/\${infer B}\`
+  ? A extends \`\${string} \${string}\`
+    ? false
+    : A extends \`?\${string}\`
+    ? false
+    : A extends \`\${string} \${string}\`
+    ? false
+    : A extends ''
+    ? B extends ''
+      ? true
+      : false
+    : B extends \`?\${string}\`
+    ? false
+    : B extends \`#\${string}\`
+    ? true
+    : B extends ''
+    ? true
+    : false
+  : R extends true
+  ? T extends ''
+    ? false
+    : ValidParam<T, false>
+  : T extends \`?\${string}\`
+  ? false
+  : T extends \`\${string} \${string}\`
+  ? false
+  : true;
+
+  type ValidEndOfPath<T> = T extends \`/\`
+    ? true
+    : T extends ''
+    ? true
+    : T extends \`\${string} \${string}\`
+    ? false 
+    : T extends \`?\${string}\`
+    ? true
+    : T extends \`#\${string}\`
+    ? true
+    : false;
+
+  ${validatePathTypes}
+
+
+  export type TypedPathParameter<T extends string> = ValidatePath<T> | RoutePathSchema
+
+  `
+  );
+}
+
+function createDefinePageMetaFile() {
+  const strictOptions = moduleOptionStore.getResolvedStrictOptions();
+  const { experimentalPathCheck } = moduleOptionStore;
+  return (
+    /* typescript */
+    `
+  
+  import { definePageMeta as defaultDefinePageMeta } from '#imports';
+  import type {PageMeta, NuxtError} from '#app'
+  import type {TypedRouteFromName, TypedRoute, TypedRouteLocationRawFromName} from './__router';
+  import type {RoutesNamesList, RoutesNamedLocations} from './__routes';
+  ${returnIfTrue(experimentalPathCheck, `import type {TypedPathParameter} from './__paths';`)}
+
+  type FilteredPageMeta = {
+    [T in keyof PageMeta as [unknown] extends [PageMeta[T]] ? never : T]: PageMeta[T];
+  }
+
+  export type TypedPageMeta<T extends RoutesNamesList, P extends string, U extends RoutesNamesList> = Omit<FilteredPageMeta, 'redirect' | 'validate' | 'key'> & {
+    /**
+     * Validate whether a given route can validly be rendered with this page.
+     *
+     * Return true if it is valid, or false if not. If another match can't be found,
+     * this will mean a 404. You can also directly return an object with
+     * statusCode/statusMessage to respond immediately with an error (other matches
+     * will not be checked).
+     */
+    validate?: (route: [T] extends [never] ? TypedRoute : TypedRouteFromName<T>) => boolean | Promise<boolean> | Partial<NuxtError> | Promise<Partial<NuxtError>>;
+    /**
+     * Where to redirect if the route is directly matched. The redirection happens
+     * before any navigation guard and triggers a new navigation with the new
+     * target location.
+     */
+    redirect?: 
+     | TypedRouteLocationRawFromName<U, P>
+     | ((to: [T] extends [never] ? TypedRoute : TypedRouteFromName<T>) 
+          => TypedRouteLocationRawFromName<any, P> ${returnIfTrue(
+      experimentalPathCheck && !strictOptions.router.strictToArgument,
+      ` | TypedPathParameter<P>`
+    )})
+     ${returnIfTrue(
+      experimentalPathCheck && !strictOptions.router.strictToArgument,
+      ` | TypedPathParameter<P>`
+    )}
+    key?: false | string | ((route: [T] extends [never] ? TypedRoute : TypedRouteFromName<T>) => string);
+  }
+
+
+  /** 
+   * Typed clone of \`definePageMeta\`
+   * 
+   * \u26A0\uFE0F Types for the redirect function may be buggy or not display autocomplete
+   * 
+   * @exemple
+   * 
+   * \`\`\`ts
+   * definePageMeta('current-location-name', {
+   *   validate(route) {
+   * });
+   * // or
+   * definePageMeta({
+   *   validate(route) {
+   * });
+   * \`\`\`
+   */
+  export function definePageMeta<
+    P extends string,
+    U extends RoutesNamesList
+  >(meta: TypedPageMeta<never, P, U>): void;
+  export function definePageMeta<
+    T extends RoutesNamesList,
+    P extends string,
+    U extends RoutesNamesList
+  >(routeName: T, meta: TypedPageMeta<T, P, U>): void;
+  export function definePageMeta(metaOrName: any, meta?: any): void {
+    if (typeof metaOrName === 'string') {
+      return defaultDefinePageMeta(meta as any);
+    } else {
+      return defaultDefinePageMeta(metaOrName as any);
+    }
+  }
+   
+  `
+  );
+}
+
 async function handleAddPlugin() {
   const pluginName = "__typed-router.plugin.ts";
   addPluginTemplate({
@@ -735,9 +1183,8 @@ const watermarkTemplate = `
 `;
 
 let previousGeneratedRoutes = "";
-async function saveGeneratedFiles({
-  outputData: { routesDeclTemplate, routesList, routesObjectTemplate, routesParams }
-}) {
+let firstRun = false;
+async function saveGeneratedFiles({ outputData }) {
   const { i18n } = moduleOptionStore;
   const filesMap = [
     {
@@ -748,19 +1195,22 @@ async function saveGeneratedFiles({
       fileName: "__useTypedRoute.ts",
       content: createUseTypedRouteFile()
     },
+    {
+      fileName: "__paths.d.ts",
+      content: createPathsFiles(outputData)
+    },
     {
       fileName: `__routes.ts`,
-      content: createRoutesTypesFile({
-        routesList,
-        routesObjectTemplate,
-        routesDeclTemplate,
-        routesParams
-      })
+      content: createRoutesTypesFile(outputData)
     },
     {
       fileName: "__navigateTo.ts",
       content: createNavigateToFile()
     },
+    {
+      fileName: "__definePageMeta.ts",
+      content: createDefinePageMetaFile()
+    },
     {
       fileName: `__router.d.ts`,
       content: createTypedRouterFile()
@@ -794,57 +1244,21 @@ async function saveGeneratedFiles({
       return processPathAndWriteFile({ content: waterMakeredContent, fileName });
     })
   );
-  if (previousGeneratedRoutes !== routesList.join(",")) {
-    previousGeneratedRoutes = routesList.join(",");
+  if (previousGeneratedRoutes !== outputData.routesList.join(",")) {
+    previousGeneratedRoutes = outputData.routesList.join(",");
     console.log(logSymbols.success, `Router autocompletions generated \u{1F6A6}`);
-  }
-}
-
-const routeParamExtractRegxp = /(:(\w+)(\(.+\)[*+]?)?(\?)?)+/g;
-function extractRouteParamsFromPath(path, isIndexFileForRouting, previousParams) {
-  let params = [];
-  let matches;
-  do {
-    matches = routeParamExtractRegxp.exec(path);
-    if (matches) {
-      const [_, mtch, key, catchAll, optional] = matches;
-      if (mtch) {
-        params.push({ name: key, optional: !!optional, catchAll: !!catchAll });
-      }
-    }
-  } while (matches);
-  let allMergedParams = params.map(
-    ({ name, optional, catchAll }) => ({
-      key: name,
-      required: !optional,
-      notRequiredOnPage: optional,
-      catchAll
-    })
-  );
-  if (previousParams?.length) {
-    allMergedParams = previousParams.map((m) => ({ ...m, required: false })).concat(allMergedParams);
-  }
-  if (!params.length && isIndexFileForRouting) {
-    const lastItem = allMergedParams[allMergedParams.length - 1];
-    if (lastItem) {
-      lastItem.required = true;
+    if (!firstRun) {
+      firstRun = true;
+      console.log(
+        logSymbols.warning,
+        chalk.yellow(
+          `Route path autocomplete is still experimental. You can disable it with the "nuxtTypedRouter.experimentalPathCheck: false" option`
+        )
+      );
     }
   }
-  return allMergedParams;
 }
 
-function extractMatchingSiblings(mainRoute, siblingRoutes) {
-  return siblingRoutes?.filter((s) => {
-    const chunkName = extractChunkMain(mainRoute.file);
-    if (chunkName && s.name) {
-      const siblingChunkName = extractChunkMain(s.file);
-      if (!siblingChunkName)
-        return false;
-      return chunkName === siblingChunkName;
-    }
-    return false;
-  });
-}
 function extractUnMatchingSiblings(mainRoute, siblingRoutes) {
   return siblingRoutes?.filter((s) => {
     const chunkName = extractChunkMain(mainRoute.file);
@@ -862,11 +1276,14 @@ function extractChunkMain(chunkName) {
   return chunkArray?.join("/");
 }
 
-function createKeyedName(route) {
+function createKeyedName(route, parent) {
   const splittedPaths = route.path.split("/");
   const parentPath = splittedPaths[splittedPaths.length - 1];
-  const nameKey = camelCase(parentPath || "index");
-  return nameKey;
+  if (parent) {
+    return camelCase(parentPath || "index");
+  } else {
+    return camelCase(route.path.split("/").join("-") || "index");
+  }
 }
 function createNameKeyFromFullName(route, level, parentName) {
   let splitted = [];
@@ -878,68 +1295,65 @@ function createNameKeyFromFullName(route, level, parentName) {
   const keyName = route.path === "" ? "index" : camelCase(splitted.join("-")) || "index";
   return keyName;
 }
+function hasi18nSibling(source, route) {
+  return source.some((rt) => {
+    return route.name?.match(new RegExp(`^(${rt.name})___[a-zA-Z]+`, "g")) || rt.path !== "/" && route.path?.match(new RegExp(`/?[a-zA-Z]+${rt.path}`, "g"));
+  });
+}
 function walkThoughRoutes({
   route,
   level,
   siblings,
-  parentName,
+  parent,
   previousParams,
   output,
   isLast
 }) {
-  const matchingSiblings = extractMatchingSiblings(route, siblings);
-  const haveMatchingSiblings = !!matchingSiblings?.length && route.path !== "/";
   const chunkArray = route.file?.split("/") ?? [];
-  const lastChunkArray = chunkArray[chunkArray?.length - 1].split(".vue")[0];
-  const isRootSibling = lastChunkArray === "index";
-  if (route.children?.length && !haveMatchingSiblings || !route.children?.length && haveMatchingSiblings && isRootSibling) {
-    let childrenChunks = haveMatchingSiblings ? matchingSiblings : route.children;
-    let nameKey = createKeyedName(route);
-    const hasSamePathI18nSibling = siblings?.some((sibling) => {
-      const _name = createKeyedName(sibling);
-      return _name === nameKey;
-    });
-    if (hasSamePathI18nSibling) {
-      nameKey = camelCase(route.path.split("/").join("-"));
-    }
-    output.routesObjectTemplate += `${nameKey}:{`;
-    output.routesDeclTemplate += `"${nameKey}":{`;
-    const allRouteParams = extractRouteParamsFromPath(route.path, false, previousParams);
-    childrenChunks?.map(
-      (routeConfig, index) => walkThoughRoutes({
-        route: routeConfig,
-        level: level + 1,
-        siblings: extractUnMatchingSiblings(route, siblings),
-        parentName: nameKey,
-        previousParams: allRouteParams,
-        output,
-        isLast: isItemLast(childrenChunks, index)
-      })
-    );
-    output.routesObjectTemplate += "},";
-    output.routesDeclTemplate += `}${isLast ? "" : ","}`;
-  } else if (route.name) {
-    let keyName = createNameKeyFromFullName(route, level, parentName);
-    const hasSameNameI18nSibling = siblings?.some((sibling) => {
-      const _name = createNameKeyFromFullName(sibling, level, parentName);
-      return _name === keyName;
-    });
-    if (hasSameNameI18nSibling) {
-      keyName = camelCase(route.name);
-    }
-    output.routesObjectTemplate += `'${keyName}': '${route.name}' as const,`;
-    output.routesDeclTemplate += `"${keyName}": "${route.name}"${isLast ? "" : ","}`;
-    output.routesList.push(route.name);
-    const isIndexFileForRouting = route.path === "";
-    const allRouteParams = extractRouteParamsFromPath(
-      route.path,
-      isIndexFileForRouting,
-      previousParams
-    );
-    output.routesParams.push({
+  chunkArray[chunkArray?.length - 1].split(".vue")[0];
+  if (!hasi18nSibling(output.routesPaths, route)) {
+    const newPath = `${parent?.path ?? ""}${route.path.startsWith("/") ? route.path : `/${route.path}`}`;
+    output.routesPaths.push({
       name: route.name,
-      params: allRouteParams
+      typePath: replaceParamsFromPathDecl(newPath),
+      path: newPath
     });
+    if (route.children?.length) {
+      let childrenChunks = route.children;
+      let nameKey = createKeyedName(route, parent);
+      const allRouteParams = extractRouteParamsFromPath(route.path, false, previousParams);
+      const newRoute = { ...route, name: nameKey, path: newPath };
+      output.routesObjectTemplate += `${nameKey}:{`;
+      output.routesDeclTemplate += `"${nameKey}":{`;
+      childrenChunks?.map(
+        (routeConfig, index) => walkThoughRoutes({
+          route: routeConfig,
+          level: level + 1,
+          siblings: extractUnMatchingSiblings(route, siblings),
+          parent: newRoute,
+          previousParams: allRouteParams,
+          output,
+          isLast: isItemLast(childrenChunks, index)
+        })
+      );
+      output.routesObjectTemplate += "},";
+      output.routesDeclTemplate += `}${isLast ? "" : ","}`;
+    } else if (route.name) {
+      let keyName = createNameKeyFromFullName(route, level, parent?.name);
+      output.routesObjectTemplate += `'${keyName}': '${route.name}' as const,`;
+      output.routesDeclTemplate += `"${keyName}": "${route.name}"${isLast ? "" : ","}`;
+      output.routesList.push(route.name);
+      const isIndexFileForRouting = route.path === "";
+      const allRouteParams = extractRouteParamsFromPath(
+        route.path,
+        isIndexFileForRouting,
+        previousParams
+      );
+      output.routesParams.push({
+        name: route.name,
+        params: allRouteParams
+      });
+    }
   }
 }
 
@@ -949,14 +1363,23 @@ function constructRouteMap(routesConfig) {
     let routesDeclTemplate = "{";
     let routesList = [];
     let routesParams = [];
-    const output = { routesObjectTemplate, routesDeclTemplate, routesList, routesParams };
+    let routesPaths = [];
+    let routesPathsTree = "{";
+    const output = {
+      routesObjectTemplate,
+      routesDeclTemplate,
+      routesList,
+      routesParams,
+      routesPaths,
+      routesPathsTree
+    };
     startGenerator({
       output,
       routesConfig
     });
     return output;
   } catch (e) {
-    throw new Error("Generation failed");
+    throw new Error("Generation failed", e);
   }
 }
 function startGenerator({ output, routesConfig }) {
@@ -1034,7 +1457,8 @@ const module = defineNuxtModule({
   },
   defaults: {
     plugin: false,
-    strict: false
+    strict: false,
+    experimentalPathCheck: true
   },
   setup(moduleOptions, nuxt) {
     const { resolve } = createResolver(import.meta.url);
@@ -1066,8 +1490,28 @@ const module = defineNuxtModule({
       "@typed-router": resolve(`${rootDir}/.nuxt/typed-router`)
     };
     nuxt.options.typescript.tsConfig = {
-      include: ["./typed-router/typed-router.d.ts"]
+      include: ["./typed-router/typed-router.d.ts"],
+      ...moduleOptions.experimentalPathCheck && {
+        // Enable Volar components generics https://github.com/vuejs/rfcs/discussions/436
+        vueCompilerOptions: {
+          jsxTemplates: true,
+          experimentalRfc436: true
+        }
+      }
     };
+    if (nuxt.options.dev) {
+      nuxt.hook("devtools:customTabs", (tabs) => {
+        tabs.push({
+          name: "nuxt-typed-router",
+          title: "Nuxt Typed Router",
+          icon: "https://github.com/victorgarciaesgi/nuxt-typed-router/blob/master/.github/images/logo.png?raw=true",
+          view: {
+            type: "iframe",
+            src: "https://nuxt-typed-router.vercel.app/"
+          }
+        });
+      });
+    }
     createTypedRouter({ nuxt });
   }
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-typed-router",
-  "version": "2.3.4",
-  "description": "Provide autocompletion for pages route names generated by Nuxt router",
+  "version": "3.0.0-beta.0",
+  "description": "Provide autocompletion for paths, routes names and params in Nuxt apps",
   "type": "module",
   "main": "./dist/module.cjs",
   "types": "./dist/types.d.ts",
@@ -22,13 +22,15 @@
     "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground && pnpm run test:prepare-fixtures",
     "build:test": "cross-env NUXT_BUILD_TYPE=stub pnpm run prepack && pnpm run dev:build",
     "test:prepare-fixtures": "nuxi prepare test/fixtures/simple && nuxi prepare test/fixtures/withOptions && nuxi prepare test/fixtures/complex",
-    "test:fixtures": " vitest run --dir test",
-    "test:types": "pnpm run typecheck && pnpm run test:vue && vitest typecheck --run --dir test",
+    "test:fixtures": "vitest run --dir test",
+    "test:types": "pnpm run typecheck && pnpm run test:vue",
     "test:vue": "vue-tsc -p test/fixtures/simple/tsconfig.json --noEmit && vue-tsc -p test/fixtures/complex/tsconfig.json --noEmit && vue-tsc -p test/fixtures/withOptions/tsconfig.json --noEmit",
     "test": "pnpm run dev:prepare && pnpm run test:types && pnpm run test:fixtures",
+    "lint": "eslint --ext .ts --ext .vue .",
     "docs:dev": "cd docs && pnpm run dev",
     "docs:build": "npm run dev:prepare && cd docs && nuxi generate",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "release": "pnpm test && standard-version && git push --follow-tags && npm publish"
   },
   "publishConfig": {
     "access": "public"
@@ -57,37 +59,41 @@
     "url": "https://github.com/victorgarciaesgi/nuxt-typed-router/issues"
   },
   "dependencies": {
-    "@nuxt/kit": "3.1.1",
+    "@nuxt/kit": "^3.2.0",
     "chalk": "^5.2.0",
     "defu": "^6.1.2",
     "lodash-es": "^4.17.21",
     "log-symbols": "^5.1.0",
-    "mkdirp": "^1.0.4",
+    "mkdirp": "^2.1.3",
+    "nanoid": "^4.0.1",
     "pathe": "1.1.0",
-    "prettier": "2.8.3"
+    "prettier": "2.8.4"
   },
   "devDependencies": {
+    "@nuxt/devtools": "^0.1.0",
     "@nuxt/module-builder": "^0.2.1",
-    "@nuxt/test-utils": "^3.1.1",
-    "@nuxt/types": "^2.15.8",
+    "@nuxt/test-utils": "^3.2.0",
+    "@nuxt/types": "^2.16.0",
     "@nuxtjs/eslint-config-typescript": "^12.0.0",
-    "@nuxtjs/web-vitals": "^0.2.2",
     "@nuxtjs/i18n": "8.0.0-beta.9",
+    "@nuxtjs/web-vitals": "^0.2.2",
     "@types/lodash-es": "^4.17.6",
     "@types/mkdirp": "^1.0.2",
-    "@types/node": "^17.0.23",
+    "@types/node": "^18.13.0",
     "@types/prettier": "^2.7.2",
-    "@typescript-eslint/eslint-plugin": "^5.50.0",
-    "@typescript-eslint/parser": "^5.50.0",
-    "@vue/test-utils": "^2.2.8",
+    "@typescript-eslint/eslint-plugin": "^5.51.0",
+    "@typescript-eslint/parser": "^5.51.0",
+    "@vue/test-utils": "^2.2.10",
     "cross-env": "^7.0.3",
     "eslint": "8.33.0",
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-vue": "^9.9.0",
-    "nuxt": "3.1.1",
+    "nuxt": "3.2.0",
     "playwright": "1.30.0",
+    "standard-version": "^9.5.0",
+    "tsd": "^0.25.0",
     "typescript": "^4.9.5",
-    "vitest": "^0.28.3",
+    "vitest": "^0.28.2",
     "vue-eslint-parser": "^9.1.0",
     "vue-router": "^4.1.6",
     "vue-tsc": "^1.0.24"