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

package/dist/_build/prepare.mjs

@@ -0,0 +1,17 @@
+import fsp from 'node:fs/promises';
+
+async function prepare(nitro) {
+  await prepareDir(nitro.options.output.dir);
+  if (!nitro.options.noPublicDir) {
+    await prepareDir(nitro.options.output.publicDir);
+  }
+  if (!nitro.options.static) {
+    await prepareDir(nitro.options.output.serverDir);
+  }
+}
+async function prepareDir(dir) {
+  await fsp.rm(dir, { recursive: true, force: true });
+  await fsp.mkdir(dir, { recursive: true });
+}
+
+export { prepare as p };

package/dist/{_chunks/build2.mjs → _build/rolldown.mjs}

@@ -1,69 +1,238 @@
-import { r as resolveModulePath, s as sanitizeFilePath, a as scanHandlers, f as formatCompatibilityDate } from './index.mjs';
+import { s as sanitizeFilePath } from '../_deps/mlly.mjs';
+import { r as resolveModulePath } from '../_deps/exsolve.mjs';
 import { runtimeDir } from 'nitro/runtime/meta';
-import { b as baseBuildConfig, d as baseBuildPlugins, r as replace, e as writeBuildInfo } from './info.mjs';
+import { b as baseBuildConfig } from './config.mjs';
+import { b as baseBuildPlugins, r as replace, a as raw } from './plugins.mjs';
 import { builtinModules } from 'node:module';
 import { defu } from 'defu';
-import { r as raw, n as nitroServerName, s as snapshot, g as generateFSTree } from './snapshot.mjs';
-import { n as normalize, j as join, a as relative } from './pathe.M-eThtNZ.mjs';
-import { d as debounce, w as watch } from './app.mjs';
-import { watch as watch$1 } from 'node:fs';
-import { w as writeTypes } from './index3.mjs';
-import 'consola';
-import 'hookable';
-import 'node:fs/promises';
-import 'node:url';
-import 'node:os';
-import 'node:path';
-import 'node:assert';
-import 'node:process';
-import 'node:v8';
-import 'node:util';
-import 'jiti';
-import 'destr';
-import 'fs';
-import 'path';
-import 'os';
-import 'crypto';
-import 'klona/full';
-import 'std-env';
-import 'ufo';
-import 'ofetch';
-import 'klona';
-import 'unstorage';
-import 'ohash';
-import 'scule';
-import 'url';
-import 'module';
-import 'consola/utils';
-import 'node:zlib';
-import 'unenv';
-import 'node:buffer';
-import 'node:querystring';
-import 'constants';
-import 'node:crypto';
-import 'db0';
-import 'esbuild';
-import 'nf3';
-import 'rendu';
-import 'nitro/meta';
-import 'node:stream';
-import 'stream';
-import 'node:worker_threads';
-import 'fs/promises';
-import 'events';
-import 'h3';
-import 'tty';
-import 'util';
-import 'node:http';
-import 'node:https';
-import 'node:events';
-import 'undici';
-import 'youch-core';
-import 'youch';
-import 'source-map';
-import 'srvx';
-import './server.mjs';
-import 'srvx/node';
+import { j as join, r as relative, a as resolve, d as dirname, n as normalize } from '../_deps/pathe.mjs';
+import { watch } from '../_deps/chokidar.mjs';
+import { promises, watch as watch$1 } from 'node:fs';
+import { d as debounce } from '../_deps/perfect-debounce.mjs';
+import { g as glob } from '../_deps/tinyglobby.mjs';
+import { withLeadingSlash, withoutTrailingSlash, withBase } from 'ufo';
+import { upperFirst } from 'scule';
+import { w as writeTypes } from './types.mjs';
+import { f as formatCompatibilityDate } from '../_deps/compatx.mjs';
+import { colors } from 'consola/utils';
+import { g as gzipSize } from '../_deps/gzip-size.mjs';
+import { p as prettyBytes } from '../_deps/pretty-bytes.mjs';
+import { isTest } from 'std-env';
+import { s as snapshot } from './snapshot.mjs';
+import { w as writeBuildInfo } from './info.mjs';
+
+const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+const suffixRegex = /(\.(?<method>connect|delete|get|head|options|patch|post|put|trace))?(\.(?<env>dev|prod|prerender))?$/;
+async function scanAndSyncOptions(nitro) {
+  const scannedPlugins = await scanPlugins(nitro);
+  for (const plugin of scannedPlugins) {
+    if (!nitro.options.plugins.includes(plugin)) {
+      nitro.options.plugins.push(plugin);
+    }
+  }
+  if (nitro.options.experimental.tasks) {
+    const scannedTasks = await scanTasks(nitro);
+    for (const scannedTask of scannedTasks) {
+      if (scannedTask.name in nitro.options.tasks) {
+        if (!nitro.options.tasks[scannedTask.name].handler) {
+          nitro.options.tasks[scannedTask.name].handler = scannedTask.handler;
+        }
+      } else {
+        nitro.options.tasks[scannedTask.name] = {
+          handler: scannedTask.handler,
+          description: ""
+        };
+      }
+    }
+  }
+  const scannedModules = await scanModules(nitro);
+  nitro.options.modules = nitro.options.modules || [];
+  for (const modPath of scannedModules) {
+    if (!nitro.options.modules.includes(modPath)) {
+      nitro.options.modules.push(modPath);
+    }
+  }
+}
+async function scanHandlers(nitro) {
+  const middleware = await scanMiddleware(nitro);
+  const handlers = await Promise.all([
+    scanServerRoutes(
+      nitro,
+      nitro.options.apiDir || "api",
+      nitro.options.apiBaseURL || "/api"
+    ),
+    scanServerRoutes(nitro, nitro.options.routesDir || "routes")
+  ]).then((r) => r.flat());
+  nitro.scannedHandlers = [
+    ...middleware,
+    ...handlers.filter((h, index, array) => {
+      return array.findIndex(
+        (h2) => h.route === h2.route && h.method === h2.method && h.env === h2.env
+      ) === index;
+    })
+  ];
+  return handlers;
+}
+async function scanMiddleware(nitro) {
+  const files = await scanFiles(nitro, "middleware");
+  return files.map((file) => {
+    return {
+      route: "/**",
+      middleware: true,
+      handler: file.fullPath
+    };
+  });
+}
+async function scanServerRoutes(nitro, dir, prefix = "/") {
+  const files = await scanFiles(nitro, dir);
+  return files.map((file) => {
+    let route = file.path.replace(/\.[A-Za-z]+$/, "").replace(/\(([^(/\\]+)\)[/\\]/g, "").replace(/\[\.{3}]/g, "**").replace(/\[\.{3}(\w+)]/g, "**:$1").replace(/\[([^/\]]+)]/g, ":$1");
+    route = withLeadingSlash(withoutTrailingSlash(withBase(route, prefix)));
+    const suffixMatch = route.match(suffixRegex);
+    let method;
+    let env;
+    if (suffixMatch?.index && suffixMatch?.index >= 0) {
+      route = route.slice(0, suffixMatch.index);
+      method = suffixMatch.groups?.method;
+      env = suffixMatch.groups?.env;
+    }
+    route = route.replace(/\/index$/, "") || "/";
+    return {
+      handler: file.fullPath,
+      lazy: true,
+      middleware: false,
+      route,
+      method,
+      env
+    };
+  });
+}
+async function scanPlugins(nitro) {
+  const files = await scanFiles(nitro, "plugins");
+  return files.map((f) => f.fullPath);
+}
+async function scanTasks(nitro) {
+  const files = await scanFiles(nitro, "tasks");
+  return files.map((f) => {
+    const name = f.path.replace(/\/index$/, "").replace(/\.[A-Za-z]+$/, "").replace(/\//g, ":");
+    return { name, handler: f.fullPath };
+  });
+}
+async function scanModules(nitro) {
+  const files = await scanFiles(nitro, "modules");
+  return files.map((f) => f.fullPath);
+}
+async function scanFiles(nitro, name) {
+  const files = await Promise.all(
+    nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name))
+  ).then((r) => r.flat());
+  return files;
+}
+async function scanDir(nitro, dir, name) {
+  const fileNames = await glob(join(name, GLOB_SCAN_PATTERN), {
+    cwd: dir,
+    dot: true,
+    ignore: nitro.options.ignore,
+    absolute: true
+  }).catch((error) => {
+    if (error?.code === "ENOTDIR") {
+      nitro.logger.warn(
+        `Ignoring \`${join(dir, name)}\`. It must be a directory.`
+      );
+      return [];
+    }
+    throw error;
+  });
+  return fileNames.map((fullPath) => {
+    return {
+      fullPath,
+      path: relative(join(dir, name), fullPath)
+    };
+  }).sort((a, b) => a.path.localeCompare(b.path));
+}
+
+async function runParallel(inputs, cb, opts) {
+  const tasks = /* @__PURE__ */ new Set();
+  function queueNext() {
+    const route = inputs.values().next().value;
+    if (!route) {
+      return;
+    }
+    inputs.delete(route);
+    const task = (opts.interval ? new Promise((resolve) => setTimeout(resolve, opts.interval)) : Promise.resolve()).then(() => cb(route)).catch((error) => {
+      console.error(error);
+    });
+    tasks.add(task);
+    return task.then(() => {
+      tasks.delete(task);
+      if (inputs.size > 0) {
+        return refillQueue();
+      }
+    });
+  }
+  function refillQueue() {
+    const workers = Math.min(opts.concurrency - tasks.size, inputs.size);
+    return Promise.all(Array.from({ length: workers }, () => queueNext()));
+  }
+  await refillQueue();
+}
+
+function nitroServerName(nitro) {
+  return nitro.options.framework.name === "nitro" ? "Nitro Server" : `${upperFirst(nitro.options.framework.name)} Nitro server`;
+}
+
+async function generateFSTree(dir, options = {}) {
+  if (isTest) {
+    return;
+  }
+  const files = await glob("**/*.*", { cwd: dir, ignore: ["*.map"] });
+  const items = [];
+  await runParallel(
+    new Set(files),
+    async (file) => {
+      const path = resolve(dir, file);
+      const src = await promises.readFile(path);
+      const size = src.byteLength;
+      const gzip = options.compressedSizes ? await gzipSize(src) : 0;
+      items.push({ file, path, size, gzip });
+    },
+    { concurrency: 10 }
+  );
+  items.sort((a, b) => a.path.localeCompare(b.path));
+  let totalSize = 0;
+  let totalGzip = 0;
+  let totalNodeModulesSize = 0;
+  let totalNodeModulesGzip = 0;
+  let treeText = "";
+  for (const [index, item] of items.entries()) {
+    dirname(item.file);
+    const rpath = relative(process.cwd(), item.path);
+    const treeChar = index === items.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
+    const isNodeModules = item.file.includes("node_modules");
+    if (isNodeModules) {
+      totalNodeModulesSize += item.size;
+      totalNodeModulesGzip += item.gzip;
+      continue;
+    }
+    treeText += colors.gray(
+      `  ${treeChar} ${rpath} (${prettyBytes(item.size)})`
+    );
+    if (options.compressedSizes) {
+      treeText += colors.gray(` (${prettyBytes(item.gzip)} gzip)`);
+    }
+    treeText += "\n";
+    totalSize += item.size;
+    totalGzip += item.gzip;
+  }
+  treeText += `${colors.cyan("\u03A3 Total size:")} ${prettyBytes(
+    totalSize + totalNodeModulesSize
+  )}`;
+  if (options.compressedSizes) {
+    treeText += ` (${prettyBytes(totalGzip + totalNodeModulesGzip)} gzip)`;
+  }
+  treeText += "\n";
+  return treeText;
+}
 
 const getRolldownConfig = (nitro) => {
   const base = baseBuildConfig(nitro);
@@ -317,4 +486,9 @@ async function rolldownBuild(nitro) {
   return nitro.options.dev ? watchDev(nitro, config) : buildProduction(nitro, config);
 }
 
-export { rolldownBuild };
+const build = {
+  __proto__: null,
+  rolldownBuild: rolldownBuild
+};
+
+export { scanAndSyncOptions as a, build as b, generateFSTree as g, nitroServerName as n, runParallel as r, scanHandlers as s };