nuxt-typed-router 2.1.0 → 2.1.2-beta.0

package/README.md

@@ -18,11 +18,11 @@
 
 ## Provide a type safe router to Nuxt with auto-generated typed definitions for route names and autocompletion for route params
 
-- Provides types check and autocomplete to `NuxtLink`
-  - Provides types check for `useRouter` and `useRoute` 
-  - Supports routes defined in `config.extendRoutes`
-  - Supports optional params and catchAll routes
-  - Infer route params based on route name
+- `NuxtLink` route autocomplete and params type-check 
+- `useRouter` and `useRoute`  route autocomplete and params type-check
+- Supports optional params and catchAll routes
+- Infer route params based on route name
+- Supports routes defined in `config.extendRoutes`
 
 <br/>
 
@@ -59,6 +59,8 @@ Demo repo 🧪 : [nuxt-typed-router-demo](https://github.com/victorgarciaesgi/nu
 yarn add -D nuxt-typed-router
 # or
 npm install -D nuxt-typed-router
+# or
+pnpm install -D nuxt-typed-router
 ```
 
 ### Nuxt 2 legacy
@@ -86,8 +88,8 @@ export default defineNuxtConfig({
 
 1. Clone this repository
 2. Install dependencies using `pnpm`
-3. Build project for local tests `pnpm build:local`
-4. Start dev playground `pnpm play`
+3. Build project for local tests `pnpm run test`
+4. Start dev playground `pnpm run prepack && pnpm run dev`
 5. Build project for deploy `pnpm prepack`
 
 ## 📑 License

package/dist/module.d.ts

@@ -1,2 +1,13 @@
-export * from "/Users/victorgarcia/Desktop/projects/nuxt-typed-router/src/module";
-export { default } from "/Users/victorgarcia/Desktop/projects/nuxt-typed-router/src/module";
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+    /**
+     * Set to false if you don't want a plugin generated
+     * @default false
+     */
+    plugin?: boolean;
+}
+
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { ModuleOptions, _default as default };

package/dist/module.json

@@ -5,5 +5,5 @@
     "nuxt": "^3.0.0-rc.1",
     "bridge": false
   },
-  "version": "2.1.0"
+  "version": "2.1.2-beta.0"
 }

package/dist/module.mjs

@@ -1,6 +1,681 @@
-import jiti from "file:///Users/victorgarcia/Desktop/projects/nuxt-typed-router/node_modules/.pnpm/jiti@1.16.2/node_modules/jiti/lib/index.js";
+import { extendPages, defineNuxtModule, createResolver } from '@nuxt/kit';
+import chalk from 'chalk';
+import logSymbols from 'log-symbols';
+import prettier from 'prettier';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'pathe';
+import mkdirp from 'mkdirp';
+import { camelCase } from 'lodash-es';
 
-/** @type {import("/Users/victorgarcia/Desktop/projects/nuxt-typed-router/src/module")} */
-const _module = jiti(null, { interopDefault: true, esmResolve: true })("/Users/victorgarcia/Desktop/projects/nuxt-typed-router/src/module.ts");
+const watermarkTemplate = `
+  // @ts-nocheck
+  // eslint-disable
+  /** 
+  * ---------------------------------------------------
+  * \u{1F697}\u{1F6A6} Generated by nuxt-typed-router. Do not modify !
+  * ---------------------------------------------------
+  * */
+ 
+`;
 
-export default _module;
+function createDeclarationRoutesFile(autoImport) {
+  return `
+    ${watermarkTemplate}
+    
+    import type { NuxtLinkProps } from '#app';
+    import type { DefineComponent } from 'vue';
+    import type { RouteLocationRaw } from 'vue-router';
+    import type { TypedRouteNamedMapper } from './__routes';
+    import { useRoute as _useRoute } from './__useTypedRoute';
+    import { useRouter as _useRouter } from './__useTypedRouter';
+
+    declare global {
+ 
+      ${autoImport ? `const useRoute: typeof _useRoute;
+         const useRouter: typeof _useRouter;` : ""}
+    }
+    
+    type TypedNuxtLinkProps = Omit<NuxtLinkProps, 'to'> & {
+      to: string | Omit<Exclude<RouteLocationRaw, string>, 'name'> & TypedRouteNamedMapper;
+    };
+    
+    export type _NuxtLink = 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>,
+      {}
+    >;
+    
+    declare module '@vue/runtime-core' {
+      export interface GlobalComponents {
+        NuxtLink: _NuxtLink;
+      }
+    }
+  `;
+}
+
+function createRuntimeIndexFile() {
+  return `
+  ${watermarkTemplate}
+  export { routesNames } from './__routes';
+  export type { TypedRouteList, TypedRouteNamedMapper, TypedRouteParams } from './__routes';
+  export {useRouter} from './__useTypedRouter';
+  export {useRoute} from './__useTypedRoute';
+  export type {TypedRoute, TypedRouter, TypedNamedRoute } from './__router'
+  `;
+}
+
+function createRuntimePluginFile(routesDeclTemplate) {
+  return `
+  ${watermarkTemplate}
+  import { defineNuxtPlugin } from '#app';
+  import {TypedRouter, TypedRoute} from '@typed-router';
+
+  export default defineNuxtPlugin(() => {
+    const router = useRouter();
+    const route = useRoute();
+    const routesNames = ${routesDeclTemplate};
+
+    return {
+      provide: {
+        typedRouter: router as TypedRouter,
+        typedRoute: route as TypedRoute,
+        routesNames,
+      },
+    };
+  });
+  `;
+}
+
+function createTypedRouteListExport(routesList) {
+  return `export type TypedRouteList = ${routesList.map((m) => `'${m}'`).join("|\n")}`;
+}
+function createTypedRouteParamsExport(routesParams) {
+  return `export type TypedRouteParams = {
+    ${routesParams.map(
+    ({ name, params }) => `"${name}": ${params.length ? `{
+                ${params.map(
+      ({ key, required, catchAll }) => `"${key}"${required ? "" : "?"}: (string | number)${catchAll ? "[]" : ""}`
+    ).join(",\n")}
+        }` : "never"}`
+  ).join(",\n")}
+  }`;
+}
+function createTypedRouteNamedMapperExport(routesParams) {
+  return `export type TypedRouteNamedMapper = 
+    ${routesParams.map(
+    ({ name, params }) => `{name: "${name}" ${params.length ? `, params${params.some((s) => s.required) ? "" : "?"}: {
+          ${params.map(
+      ({ key, required, catchAll }) => `"${key}"${required ? "" : "?"}: (string | number)${catchAll ? "[]" : ""}`
+    ).join(",\n")}
+        }` : ""}}`
+  ).join("|\n")}
+  `;
+}
+function createResolvedTypedRouteNamedMapperExport(routesParams) {
+  return `export type ResolvedTypedRouteNamedMapper = 
+  {
+    name: TypedRouteList;
+    params: unknown;
+  } & (
+    ${routesParams.map(
+    ({ name, params }) => `{name: "${name}" ${params.length ? `, params: {
+                ${params.map(
+      ({ key, notRequiredOnPage, catchAll }) => `"${key}"${notRequiredOnPage ? "?" : ""}: string${catchAll ? "[]" : ""}`
+    ).join(",\n")}
+        }` : ""}}`
+  ).join("|\n")}
+      )
+  `;
+}
+
+function createRuntimeRoutesFile({
+  routesList,
+  routesObjectTemplate,
+  routesDeclTemplate,
+  routesParams
+}) {
+  return `
+    ${watermarkTemplate}
+
+    export const routesNames = ${routesObjectTemplate};
+
+    ${createTypedRouteListExport(routesList)}
+
+    export type RouteListDecl = ${routesDeclTemplate};
+
+    /** 
+     * Routes params are only required for the exact targeted route name,
+     * vue-router behaviour allow to navigate between children routes without the need to provide all the params every time.
+     * So we can't enforce params when navigating between routes, only a \`[xxx].vue\` page will have required params in the type definition
+     * 
+     * 
+     * */
+    ${createTypedRouteParamsExport(routesParams)}
+
+    ${createTypedRouteNamedMapperExport(routesParams)}
+
+    ${createResolvedTypedRouteNamedMapperExport(routesParams)}
+  `;
+}
+
+function createUseTypedRouteFile(routesDeclTemplate) {
+  return `
+  ${watermarkTemplate}
+  import { useRoute as defaultRoute } from '#app';
+  import type { TypedRouteList } from './__routes';
+  import type {TypedRoute, TypedNamedRoute} from './__router'
+
+  /** Acts the same as \`useRoute\`, but typed.
+ *
+ * @exemple
+ *
+ * \`\`\`ts
+ * const route = useRoute();
+ * \`\`\`
+ *
+ * \`\`\`ts
+ * const route = useRoute('my-route-with-param-id');
+ * route.params.id // autocompletes!
+ * \`\`\`
+ *
+ * \`\`\`ts
+ * const route = useRoute();
+ * if (route.name === 'my-route-with-param-id') {
+ *    route.params.id // autocompletes!
+ * }
+ * \`\`\`
+ */
+export function useRoute<T extends TypedRouteList = never>(
+  name?: T
+): [T] extends [never] ? TypedRoute : TypedNamedRoute<T> {
+  const route = defaultRoute();
+
+  return route as any;
+}
+
+
+`;
+}
+
+function createRuntimeUseTypedRouterFile(routesDeclTemplate) {
+  return `
+  ${watermarkTemplate}
+  import { useRouter as defaultRouter } from '#app';
+  import type { TypedRouter } from './__router';
+
+  /** Returns instances of $typedRouter and $routesList fully typed to use in your components or your Vuex/Pinia store
+   * 
+   * @exemple
+   * 
+   * \`\`\`ts
+   * const router = useRouter();
+   * \`\`\`
+   */
+  export function useRouter(): TypedRouter {
+    const router = defaultRouter();
+
+    return router;
+  };
+
+  `;
+}
+
+function createRuntimeRouterTypes() {
+  return `
+  import type {
+    NavigationFailure,
+    RouteLocation,
+    RouteLocationNormalizedLoaded,
+    RouteLocationOptions,
+    RouteLocationRaw,
+    RouteQueryAndHash,
+    Router,
+  } from 'vue-router';
+  import type {
+    ResolvedTypedRouteNamedMapper,
+    TypedRouteList,
+    TypedRouteNamedMapper,
+    TypedRouteParams,
+  } from './__routes';
+
+  // Type utils
+  type ExtractRequiredParameters<T extends Record<string, any>> = Pick<
+    T,
+    { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T]
+  >;
+  
+  type HasOneRequiredParameter<T extends TypedRouteList> = [TypedRouteParams[T]] extends [never]
+    ? false
+    : [keyof ExtractRequiredParameters<TypedRouteParams[T]>] extends [undefined]
+    ? false
+    : true;
+  
+  type TypedLocationAsRelativeRaw<T extends TypedRouteList> = {
+    name?: T;
+  } & ([TypedRouteParams[T]] extends [never]
+    ? {}
+    : HasOneRequiredParameter<T> extends false
+    ? { params?: TypedRouteParams[T] }
+    : { params: TypedRouteParams[T] });
+  
+  type ResolvedTypedLocationAsRelativeRaw<T extends TypedRouteList> = {
+    name?: T;
+  } & ([TypedRouteParams[T]] extends [never] ? {} : { params: TypedRouteParams[T] });
+  
+  type TypedRouteLocationRaw = RouteQueryAndHash & TypedRouteNamedMapper & RouteLocationOptions;
+  
+  type _TypedRoute = Omit<RouteLocationNormalizedLoaded, 'name' | 'params'> &
+    ResolvedTypedRouteNamedMapper;
+  type _TypedNamedRoute<T extends TypedRouteList> = Omit<
+    RouteLocationNormalizedLoaded,
+    'name' | 'params'
+  > &
+    ResolvedTypedLocationAsRelativeRaw<T>;
+  
+  /** Augmented Router interface */
+  interface _TypedRouter
+    extends Omit<Router, 'removeRoute' | 'hasRoute' | 'resolve' | 'push' | 'replace' | 'currentRoute'> {
+    readonly currentRoute: _TypedRoute;
+    /**
+     * Remove an existing route by its name.
+     *
+     * @param name - Name of the route to remove
+     */
+    removeRoute(name: TypedRouteList): void;
+    /**
+     * Checks if a route with a given name exists
+     *
+     * @param name - Name of the route to check
+     */
+    hasRoute(name: TypedRouteList): boolean;
+    /**
+     * Returns the {@link RouteLocation | normalized version} of a
+     * {@link RouteLocationRaw | route location}. Also includes an \`href\` property
+     * that includes any existing \`base\`. By default the \`currentLocation\` used is
+     * \`route.currentRoute\` and should only be overriden in advanced use cases.
+     *
+     * @param to - Raw route location to resolve
+     * @param currentLocation - Optional current location to resolve against
+     */
+    resolve(
+      to: TypedRouteLocationRaw,
+      currentLocation?: RouteLocationNormalizedLoaded
+    ): RouteLocation & {
+      href: string;
+    };
+    /**
+     * 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>;
+    /**
+     * 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>;
+  }
+  
+  export interface TypedRouter extends _TypedRouter {}
+  export type TypedRoute = _TypedRoute;
+  export type TypedNamedRoute<T extends TypedRouteList> = _TypedNamedRoute<T>;
+  `;
+}
+
+const { resolveConfig, format } = prettier;
+const defaultPrettierOptions = {
+  printWidth: 100,
+  tabWidth: 2,
+  trailingComma: "es5",
+  singleQuote: true,
+  semi: true,
+  bracketSpacing: true,
+  htmlWhitespaceSensitivity: "strict"
+};
+async function formatOutputWithPrettier(template) {
+  try {
+    let prettierFoundOptions = await resolveConfig(process.cwd());
+    if (!prettierFoundOptions) {
+      prettierFoundOptions = defaultPrettierOptions;
+    }
+    const formatedTemplate = format(template, {
+      ...prettierFoundOptions,
+      parser: "typescript"
+    });
+    return formatedTemplate;
+  } catch (e) {
+    console.error(logSymbols.error, chalk.red("Error while formatting the output"), "\n" + e);
+    return Promise.reject(e);
+  }
+}
+
+dirname(fileURLToPath(import.meta.url));
+async function processPathAndWriteFile({
+  content,
+  fileName,
+  rootDir,
+  outDir
+}) {
+  try {
+    const finalOutDir = outDir ?? `.nuxt/typed-router`;
+    const processedOutDir = resolve(rootDir, finalOutDir);
+    const outputFile = resolve(process.cwd(), `${processedOutDir}/${fileName}`);
+    const formatedContent = await formatOutputWithPrettier(content);
+    if (fs.existsSync(outputFile)) {
+      await writeFile(outputFile, formatedContent);
+    } else {
+      let dirList = outputFile.split("/");
+      dirList.pop();
+      const dirPath = dirList.join("/");
+      await mkdirp(dirPath);
+      await writeFile(outputFile, formatedContent);
+    }
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+async function writeFile(path, content) {
+  try {
+    await fs.writeFileSync(path, content);
+  } catch (e) {
+    console.log(logSymbols.error, chalk.red(`Error while saving file at ${path}`, e));
+    return Promise.reject(e);
+  }
+}
+
+function handlePluginFileSave({
+  nuxt,
+  rootDir,
+  routesDeclTemplate
+}) {
+  const pluginName = "__typed-router.ts";
+  nuxt.hook("build:done", async () => {
+    const pluginFolder = `${rootDir}/plugins`;
+    await processPathAndWriteFile({
+      outDir: pluginFolder,
+      rootDir,
+      fileName: pluginName,
+      content: createRuntimePluginFile(routesDeclTemplate)
+    });
+  });
+}
+
+let previousGeneratedRoutes = "";
+async function saveGeneratedFiles({
+  rootDir,
+  autoImport,
+  outputData: { routesDeclTemplate, routesList, routesObjectTemplate, routesParams }
+}) {
+  const filesMap = [
+    {
+      fileName: "__useTypedRouter.ts",
+      content: createRuntimeUseTypedRouterFile()
+    },
+    {
+      fileName: "__useTypedRoute.ts",
+      content: createUseTypedRouteFile()
+    },
+    {
+      fileName: `__routes.ts`,
+      content: createRuntimeRoutesFile({
+        routesList,
+        routesObjectTemplate,
+        routesDeclTemplate,
+        routesParams
+      })
+    },
+    {
+      fileName: `__router.d.ts`,
+      content: createRuntimeRouterTypes()
+    },
+    {
+      fileName: `typed-router.d.ts`,
+      content: createDeclarationRoutesFile(autoImport)
+    },
+    {
+      fileName: "index.ts",
+      content: createRuntimeIndexFile()
+    }
+  ];
+  await Promise.all(
+    filesMap.map(({ content, fileName }) => processPathAndWriteFile({ rootDir, content, fileName }))
+  );
+  if (previousGeneratedRoutes !== routesList.join(",")) {
+    previousGeneratedRoutes = routesList.join(",");
+    console.log(logSymbols.success, `Router autocompletions generated \u{1F6A6}`);
+  }
+}
+
+function isItemLast(array, index) {
+  return array ? index === array.length - 1 : false;
+}
+
+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;
+    }
+  }
+  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);
+    if (chunkName) {
+      const siblingChunkName = extractChunkMain(s.file);
+      if (!siblingChunkName)
+        return false;
+      return chunkName !== siblingChunkName;
+    }
+    return false;
+  });
+}
+function extractChunkMain(chunkName) {
+  let chunkArray = chunkName?.split("/");
+  return chunkArray?.join("/");
+}
+
+function walkThoughRoutes({
+  route,
+  level,
+  siblings,
+  parentName,
+  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;
+    const splittedPaths = route.path.split("/");
+    const parentPath = splittedPaths[splittedPaths.length - 1];
+    const nameKey = camelCase(parentPath || "index");
+    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 splitted = [];
+    splitted = route.name.split("-");
+    splitted = splitted.slice(level, splitted.length);
+    if (splitted[0] === parentName) {
+      splitted.splice(0, 1);
+    }
+    const keyName = route.path === "" ? "index" : camelCase(splitted.join("-")) || "index";
+    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
+    });
+  }
+}
+
+function constructRouteMap(routesConfig) {
+  try {
+    let routesObjectTemplate = "{";
+    let routesDeclTemplate = "{";
+    let routesList = [];
+    let routesParams = [];
+    const output = { routesObjectTemplate, routesDeclTemplate, routesList, routesParams };
+    startGenerator({
+      output,
+      routesConfig
+    });
+    return output;
+  } catch (e) {
+    throw new Error("Generation failed");
+  }
+}
+function startGenerator({ output, routesConfig }) {
+  routesConfig.forEach((route, index) => {
+    const rootSiblingsRoutes = routesConfig.filter((rt) => rt.chunkName !== route.chunkName);
+    walkThoughRoutes({
+      route,
+      level: 0,
+      output,
+      siblings: rootSiblingsRoutes,
+      isLast: isItemLast(routesConfig, index)
+    });
+  });
+  output.routesObjectTemplate += "}";
+  output.routesDeclTemplate += "}";
+}
+
+function createTypedRouter({ plugin, nuxt }) {
+  try {
+    const rootDir = nuxt.options.rootDir;
+    const autoImport = nuxt.options.imports.autoImport ?? true;
+    extendPages(async (routes) => {
+      if (routes.length) {
+        const outputData = constructRouteMap(routes);
+        if (plugin) {
+          handlePluginFileSave({
+            nuxt,
+            routesDeclTemplate: outputData.routesDeclTemplate,
+            rootDir
+          });
+        }
+        await saveGeneratedFiles({
+          autoImport,
+          rootDir,
+          outputData
+        });
+      } else {
+        console.log(
+          logSymbols.warning,
+          chalk.yellow(
+            `[typed-router] No routes defined. Check if your ${chalk.underline(
+              chalk.bold("pages")
+            )} folder exists and remove ${chalk.underline(chalk.bold("app.vue"))}`
+          )
+        );
+      }
+    });
+  } catch (e) {
+    console.error(chalk.red("Error while generating routes definitions model"), "\n" + e);
+  }
+}
+
+const module = defineNuxtModule({
+  meta: {
+    name: "nuxt-typed-router",
+    configKey: "nuxtTypedRouter",
+    compatibility: { nuxt: "^3.0.0-rc.1", bridge: false }
+  },
+  defaults: {
+    plugin: false
+  },
+  setup(moduleOptions, nuxt) {
+    const rootDir = nuxt.options.rootDir;
+    const { plugin } = moduleOptions;
+    const { resolve } = createResolver(import.meta.url);
+    nuxt.options.alias = {
+      ...nuxt.options.alias,
+      "@typed-router": resolve(`${rootDir}/.nuxt/typed-router`)
+    };
+    nuxt.options.typescript.tsConfig = {
+      include: ["./typed-router/typed-router.d.ts"]
+    };
+    const typedRouterOptions = { nuxt, plugin };
+    nuxt.hook("pages:extend", () => createTypedRouter(typedRouterOptions));
+    createTypedRouter(typedRouterOptions);
+  }
+});
+
+export { module as default };

package/dist/types.d.ts

@@ -1,13 +1,10 @@
 
-import { ModuleOptions, ModuleHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module'
+import { ModuleOptions } from './module'
 
 declare module '@nuxt/schema' {
   interface NuxtConfig { ['nuxtTypedRouter']?: Partial<ModuleOptions> }
   interface NuxtOptions { ['nuxtTypedRouter']?: ModuleOptions }
-  interface NuxtHooks extends ModuleHooks {}
-  interface RuntimeConfig extends ModuleRuntimeConfig {}
-  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
 }
 
 
-export { default } from './module'
+export { ModuleOptions, default } from './module'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-typed-router",
-  "version": "2.1.0",
+  "version": "2.1.2-beta.0",
   "description": "Provide autocompletion for pages route names generated by Nuxt router",
   "type": "module",
   "main": "./dist/module.cjs",
@@ -19,14 +19,15 @@
     "prepack": "nuxt-module-build",
     "dev": "nuxi dev playground",
     "dev:build": "nuxi build playground",
-    "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
+    "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:fixtures": "nuxt-module-build --stub && nuxi prepare test/fixtures/simple && vitest run --dir test",
-    "test:types": "nuxi prepare test/fixtures/simple && cd test/fixtures/simple && vue-tsc --noEmit",
-    "test": "pnpm run test:fixtures && pnpm run test:types",
+    "test:prepare-fixtures": "nuxi prepare test/fixtures/simple",
+    "test:fixtures": " vitest run --dir test",
+    "test:types": "pnpm run test:vue && vitest typecheck --run --dir test",
+    "test:vue": "vue-tsc -p test/fixtures/simple/tsconfig.json --noEmit && vue-tsc -p test/fixtures/complex/tsconfig.json --noEmit",
+    "test": "pnpm run dev:prepare && pnpm run test:fixtures && pnpm run test:types",
     "docs:dev": "cd docs && pnpm run dev",
-    "docs:build": "npm run dev:prepare && cd docs && nuxi generate",
-    "prepare": "pnpm run dev:prepare"
+    "docs:build": "npm run dev:prepare && cd docs && nuxi generate"
   },
   "publishConfig": {
     "access": "public"