nitro-nightly 3.1.0-20251028-004953-57503e42 → 3.1.0-20251028-090722-437659e4

package/dist/_build/types.mjs

@@ -0,0 +1,268 @@
+import { existsSync, promises } from 'node:fs';
+import { defu } from 'defu';
+import { p as parseNodeModulePath, l as lookupNodeModuleSubpath } from '../_deps/mlly.mjs';
+import { r as resolveModulePath } from '../_deps/exsolve.mjs';
+import { r as resolveNitroPath, i as isDirectory, w as writeFile } from './assets.mjs';
+import { runtimeDir } from 'nitro/runtime/meta';
+import { a as resolve, r as relative, b as resolveAlias, i as isAbsolute, j as join, d as dirname } from '../_deps/pathe.mjs';
+import { g as generateTypes, r as resolveSchema } from '../_deps/untyped.mjs';
+import { t as toExports } from '../_deps/unimport.mjs';
+
+async function writeTypes(nitro) {
+  const types = {
+    routes: {}
+  };
+  const typesDir = resolve(nitro.options.buildDir, "types");
+  const middleware = [...nitro.scannedHandlers, ...nitro.options.handlers];
+  for (const mw of middleware) {
+    if (typeof mw.handler !== "string" || !mw.route) {
+      continue;
+    }
+    const relativePath = relative(
+      typesDir,
+      resolveNitroPath(mw.handler, nitro.options)
+    ).replace(/\.(js|mjs|cjs|ts|mts|cts|tsx|jsx)$/, "");
+    const method = mw.method || "default";
+    types.routes[mw.route] ??= {};
+    types.routes[mw.route][method] ??= [];
+    types.routes[mw.route][method].push(
+      `Simplify<Serialize<Awaited<ReturnType<typeof import('${relativePath}').default>>>>`
+    );
+  }
+  let autoImportedTypes = [];
+  let autoImportExports = "";
+  if (nitro.unimport) {
+    await nitro.unimport.init();
+    const allImports = await nitro.unimport.getImports();
+    autoImportExports = toExports(allImports).replace(
+      /#internal\/nitro/g,
+      relative(typesDir, runtimeDir)
+    );
+    const resolvedImportPathMap = /* @__PURE__ */ new Map();
+    for (const i of allImports) {
+      const from = i.typeFrom || i.from;
+      if (resolvedImportPathMap.has(from)) {
+        continue;
+      }
+      let path = resolveAlias(from, nitro.options.alias);
+      if (!isAbsolute(path)) {
+        const resolvedPath = resolveModulePath(from, {
+          try: true,
+          from: nitro.options.nodeModulesDirs,
+          conditions: ["type", "node", "import"],
+          suffixes: ["", "/index"],
+          extensions: [".mjs", ".cjs", ".js", ".mts", ".cts", ".ts"]
+        });
+        if (resolvedPath) {
+          const { dir, name } = parseNodeModulePath(resolvedPath);
+          if (!dir || !name) {
+            path = resolvedPath;
+          } else {
+            const subpath = await lookupNodeModuleSubpath(resolvedPath);
+            path = join(dir, name, subpath || "");
+          }
+        }
+      }
+      if (existsSync(path) && !await isDirectory(path)) {
+        path = path.replace(/\.[a-z]+$/, "");
+      }
+      if (isAbsolute(path)) {
+        path = relative(typesDir, path);
+      }
+      resolvedImportPathMap.set(from, path);
+    }
+    autoImportedTypes = [
+      nitro.options.imports && nitro.options.imports.autoImport !== false ? (await nitro.unimport.generateTypeDeclarations({
+        exportHelper: false,
+        resolvePath: (i) => {
+          const from = i.typeFrom || i.from;
+          return resolvedImportPathMap.get(from) ?? from;
+        }
+      })).trim() : ""
+    ];
+  }
+  const generateRoutes = () => [
+    "// Generated by nitro",
+    'import type { Serialize, Simplify } from "nitro/types";',
+    'declare module "nitro/types" {',
+    "  type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T",
+    "  interface InternalApi {",
+    ...Object.entries(types.routes).map(
+      ([path, methods]) => [
+        `    '${path}': {`,
+        ...Object.entries(methods).map(
+          ([method, types2]) => `      '${method}': ${types2.join(" | ")}`
+        ),
+        "    }"
+      ].join("\n")
+    ),
+    "  }",
+    "}",
+    // Makes this a module for augmentation purposes
+    "export {}"
+  ];
+  const config = [
+    "// Generated by nitro",
+    /* ts */
+    `declare module "nitro/types" {`,
+    nitro.options.typescript.generateRuntimeConfigTypes ? generateTypes(
+      await resolveSchema(
+        Object.fromEntries(
+          Object.entries(nitro.options.runtimeConfig).filter(
+            ([key]) => !["app", "nitro"].includes(key)
+          )
+        )
+      ),
+      {
+        interfaceName: "NitroRuntimeConfig",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 2
+      }
+    ) : "",
+    `}`,
+    // Makes this a module for augmentation purposes
+    "export {}"
+  ];
+  const declarations = [
+    // local nitropack augmentations
+    '/// <reference path="./nitro-routes.d.ts" />',
+    '/// <reference path="./nitro-config.d.ts" />',
+    // global server auto-imports
+    '/// <reference path="./nitro-imports.d.ts" />'
+  ];
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(typesDir, "nitro-routes.d.ts"),
+    contents: () => generateRoutes().join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "nitro-config.d.ts"),
+    contents: config.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "nitro-imports.d.ts"),
+    contents: [...autoImportedTypes, autoImportExports || "export {}"].join(
+      "\n"
+    )
+  });
+  buildFiles.push({
+    path: join(typesDir, "nitro.d.ts"),
+    contents: declarations.join("\n")
+  });
+  if (nitro.options.typescript.generateTsConfig) {
+    const tsConfigPath = resolve(
+      nitro.options.buildDir,
+      nitro.options.typescript.tsconfigPath
+    );
+    const tsconfigDir = dirname(tsConfigPath);
+    const tsConfig = defu(nitro.options.typescript.tsConfig, {
+      compilerOptions: {
+        /* Base options: */
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+        skipLibCheck: true,
+        target: "ESNext",
+        allowJs: true,
+        resolveJsonModule: true,
+        moduleDetection: "force",
+        isolatedModules: true,
+        verbatimModuleSyntax: true,
+        allowImportingTsExtensions: true,
+        /* Strictness */
+        strict: nitro.options.typescript.strict,
+        noUncheckedIndexedAccess: true,
+        noImplicitOverride: true,
+        forceConsistentCasingInFileNames: true,
+        /* If NOT transpiling with TypeScript: */
+        module: "Preserve",
+        jsx: "preserve",
+        jsxFactory: "h",
+        jsxFragmentFactory: "Fragment",
+        paths: {
+          "#imports": [
+            relativeWithDot(tsconfigDir, join(typesDir, "nitro-imports"))
+          ],
+          ...nitro.options.typescript.internalPaths ? {
+            "nitro/runtime": [
+              relativeWithDot(tsconfigDir, join(runtimeDir, "index"))
+            ],
+            "#internal/nitro": [
+              relativeWithDot(tsconfigDir, join(runtimeDir, "index"))
+            ],
+            "nitro/runtime/*": [
+              relativeWithDot(tsconfigDir, join(runtimeDir, "*"))
+            ],
+            "#internal/nitro/*": [
+              relativeWithDot(tsconfigDir, join(runtimeDir, "*"))
+            ]
+          } : {}
+        }
+      },
+      include: [
+        relativeWithDot(tsconfigDir, join(typesDir, "nitro.d.ts")).replace(
+          /^(?=[^.])/,
+          "./"
+        ),
+        join(relativeWithDot(tsconfigDir, nitro.options.rootDir), "**/*"),
+        ...nitro.options.srcDir === nitro.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, nitro.options.srcDir), "**/*")]
+      ]
+    });
+    for (const alias in tsConfig.compilerOptions.paths) {
+      const paths = await Promise.all(
+        tsConfig.compilerOptions.paths[alias].map(async (path) => {
+          if (!isAbsolute(path)) {
+            return path;
+          }
+          const stats = await promises.stat(path).catch(
+            () => null
+            /* file does not exist */
+          );
+          return relativeWithDot(
+            tsconfigDir,
+            stats?.isFile() ? path.replace(/(?<=\w)\.\w+$/g, "") : path
+          );
+        })
+      );
+      tsConfig.compilerOptions.paths[alias] = [...new Set(paths)];
+    }
+    tsConfig.include = [
+      ...new Set(
+        tsConfig.include.map(
+          (p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p
+        )
+      )
+    ];
+    if (tsConfig.exclude) {
+      tsConfig.exclude = [
+        ...new Set(
+          tsConfig.exclude.map(
+            (p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p
+          )
+        )
+      ];
+    }
+    types.tsConfig = tsConfig;
+    buildFiles.push({
+      path: tsConfigPath,
+      contents: () => JSON.stringify(tsConfig, null, 2)
+    });
+  }
+  await nitro.hooks.callHook("types:extend", types);
+  await Promise.all(
+    buildFiles.map(async (file) => {
+      await writeFile(
+        resolve(nitro.options.buildDir, file.path),
+        typeof file.contents === "string" ? file.contents : file.contents()
+      );
+    })
+  );
+}
+const RELATIVE_RE = /^\.{1,2}\//;
+function relativeWithDot(from, to) {
+  const rel = relative(from, to);
+  return RELATIVE_RE.test(rel) ? rel : "./" + rel;
+}
+
+export { writeTypes as w };