nitro 2.2.28 → 3.0.0-alpha.0

package/dist/_chunks/build.mjs

@@ -0,0 +1,84 @@
+import { n as nitro } from './plugin.mjs';
+import './index.mjs';
+import 'consola';
+import 'hookable';
+import 'nitro/runtime/meta';
+import 'node:fs';
+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 'defu';
+import './pathe.M-eThtNZ.mjs';
+import 'fs';
+import 'path';
+import 'os';
+import 'crypto';
+import './app.mjs';
+import 'node:worker_threads';
+import 'std-env';
+import 'fs/promises';
+import 'events';
+import 'node:stream';
+import 'h3';
+import 'url';
+import 'tty';
+import 'util';
+import 'stream';
+import 'ufo';
+import 'node:http';
+import 'node:https';
+import 'node:events';
+import 'undici';
+import 'youch-core';
+import 'youch';
+import 'source-map';
+import 'srvx';
+import 'klona/full';
+import 'node:module';
+import 'ofetch';
+import 'klona';
+import 'unstorage';
+import 'ohash';
+import 'scule';
+import 'module';
+import 'consola/utils';
+import 'node:zlib';
+import 'nitro/meta';
+import 'srvx/node';
+import './index2.mjs';
+import './info.mjs';
+import 'unenv';
+import 'node:buffer';
+import 'node:querystring';
+import 'constants';
+import 'node:crypto';
+import 'db0';
+import 'esbuild';
+import 'nf3';
+import 'rendu';
+import 'vite';
+import 'get-port-please';
+import 'node:child_process';
+
+async function viteBuild(nitro$1) {
+  if (nitro$1.options.dev) {
+    throw new Error(
+      "Nitro vite builder is not supported in development mode. Please use `vite dev` instead."
+    );
+  }
+  const { createBuilder } = await import('vite');
+  const builder = await createBuilder({
+    base: nitro$1.options.rootDir,
+    plugins: [nitro({ _nitro: nitro$1 })]
+  });
+  await builder.buildApp();
+}
+
+export { viteBuild };

package/dist/_chunks/build2.mjs

@@ -0,0 +1,318 @@
+import { r as resolveModulePath, s as sanitizeFilePath, a as scanHandlers, f as formatCompatibilityDate } from './index.mjs';
+import { runtimeDir } from 'nitro/runtime/meta';
+import { b as baseBuildConfig, d as baseBuildPlugins, r as replace, e as writeBuildInfo } from './info.mjs';
+import { builtinModules } from 'node:module';
+import { defu } from 'defu';
+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 { n as nitroServerName, s as snapshot, g as generateFSTree } from './snapshot.mjs';
+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:worker_threads';
+import 'fs/promises';
+import 'events';
+import 'node:stream';
+import 'h3';
+import 'tty';
+import 'util';
+import 'stream';
+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';
+
+const getRolldownConfig = (nitro) => {
+  const base = baseBuildConfig(nitro);
+  const chunkNamePrefixes = [
+    [nitro.options.buildDir, "build"],
+    [base.buildServerDir, "app"],
+    [runtimeDir, "nitro"],
+    [base.presetsDir, "nitro"],
+    ["\0raw:", "raw"],
+    ["\0nitro-wasm:", "wasm"],
+    ["\0", "virtual"]
+  ];
+  let config = {
+    cwd: nitro.options.rootDir,
+    input: nitro.options.entry,
+    external: [
+      ...base.env.external,
+      ...builtinModules,
+      ...builtinModules.map((m) => `node:${m}`)
+    ],
+    plugins: [
+      ...baseBuildPlugins(nitro, base),
+      // https://github.com/rolldown/rolldown/issues/4257
+      replace({
+        preventAssignment: true,
+        values: base.replacements
+      })
+    ],
+    resolve: {
+      alias: base.aliases,
+      extensions: base.extensions,
+      mainFields: ["main"],
+      // "module" is intentionally not supported because of externals
+      conditionNames: nitro.options.exportConditions
+    },
+    // @ts-expect-error (readonly values)
+    inject: base.env.inject,
+    jsx: {
+      mode: "classic",
+      factory: nitro.options.esbuild?.options?.jsxFactory,
+      fragment: nitro.options.esbuild?.options?.jsxFragment
+    },
+    onwarn(warning, warn) {
+      if (!["CIRCULAR_DEPENDENCY", "EVAL"].includes(warning.code || "") && !warning.message.includes("Unsupported source map comment")) {
+        warn(warning);
+      }
+    },
+    treeshake: {
+      moduleSideEffects(id) {
+        const normalizedId = normalize(id);
+        const idWithoutNodeModules = normalizedId.split("node_modules/").pop();
+        if (!idWithoutNodeModules) {
+          return false;
+        }
+        if (normalizedId.startsWith(runtimeDir) || idWithoutNodeModules.startsWith(runtimeDir)) {
+          return true;
+        }
+        return nitro.options.moduleSideEffects.some(
+          (m) => normalizedId.startsWith(m) || idWithoutNodeModules.startsWith(m)
+        );
+      }
+    },
+    output: {
+      dir: nitro.options.output.serverDir,
+      entryFileNames: "index.mjs",
+      chunkFileNames(chunk) {
+        const id = normalize(chunk.moduleIds.at(-1) || "");
+        for (const [dir, name] of chunkNamePrefixes) {
+          if (id.startsWith(dir)) {
+            return `chunks/${name}/[name].mjs`;
+          }
+        }
+        const routeHandler = nitro.options.handlers.find(
+          (h) => id.startsWith(h.handler)
+        ) || nitro.scannedHandlers.find((h) => id.startsWith(h.handler));
+        if (routeHandler?.route) {
+          const path = routeHandler.route.replace(/:([^/]+)/g, "_$1").replace(/\/[^/]+$/g, "") || "/";
+          return `chunks/routes${path}/[name].mjs`;
+        }
+        const taskHandler = Object.entries(nitro.options.tasks).find(
+          ([_, task]) => task.handler === id
+        );
+        if (taskHandler) {
+          return `chunks/tasks/[name].mjs`;
+        }
+        return `chunks/_/[name].mjs`;
+      },
+      inlineDynamicImports: nitro.options.inlineDynamicImports,
+      format: "esm",
+      exports: "auto",
+      intro: "",
+      outro: "",
+      sanitizeFileName: sanitizeFilePath,
+      sourcemap: nitro.options.sourceMap,
+      sourcemapIgnoreList(relativePath) {
+        return relativePath.includes("node_modules");
+      }
+    }
+  };
+  config.plugins.push({
+    name: "nitro:rolldown-resolves",
+    async resolveId(id, parent, options) {
+      if (parent?.startsWith("\0virtual:#nitro-internal-virtual")) {
+        const internalRes = await this.resolve(id, import.meta.url, {
+          ...options,
+          custom: { ...options.custom, skipNoExternals: true }
+        });
+        if (internalRes) {
+          return internalRes;
+        }
+        return resolveModulePath(id, {
+          from: [nitro.options.rootDir, import.meta.url],
+          try: true
+        }) || resolveModulePath("./" + id, {
+          from: [nitro.options.rootDir, import.meta.url],
+          try: true
+        });
+      }
+    }
+  });
+  config = defu(nitro.options.rollupConfig, config);
+  return config;
+};
+
+async function watchDev(nitro, config) {
+  const rolldown = await import('rolldown');
+  let watcher;
+  async function load() {
+    if (watcher) {
+      await watcher.close();
+    }
+    await scanHandlers(nitro);
+    nitro.routing.sync();
+    watcher = startWatcher(nitro, config);
+    await writeTypes(nitro);
+  }
+  const reload = debounce(load);
+  const scanDirs = nitro.options.scanDirs.flatMap((dir) => [
+    join(dir, nitro.options.apiDir || "api"),
+    join(dir, nitro.options.routesDir || "routes"),
+    join(dir, "middleware"),
+    join(dir, "plugins"),
+    join(dir, "modules")
+  ]);
+  const watchReloadEvents = /* @__PURE__ */ new Set(["add", "addDir", "unlink", "unlinkDir"]);
+  const scanDirsWatcher = watch(scanDirs, {
+    ignoreInitial: true
+  }).on("all", (event) => {
+    if (watchReloadEvents.has(event)) {
+      reload();
+    }
+  });
+  const srcDirWatcher = watch$1(
+    nitro.options.srcDir,
+    { persistent: false },
+    (_event, filename) => {
+      if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) {
+        reload();
+      }
+    }
+  );
+  nitro.hooks.hook("close", () => {
+    watcher.close();
+    scanDirsWatcher.close();
+    srcDirWatcher.close();
+  });
+  nitro.hooks.hook("rollup:reload", () => reload());
+  await load();
+  function startWatcher(nitro2, config2) {
+    const watcher2 = rolldown.watch(config2);
+    let start;
+    watcher2.on("event", (event) => {
+      switch (event.code) {
+        case "START": {
+          start = Date.now();
+          nitro2.hooks.callHook("dev:start");
+          break;
+        }
+        case "BUNDLE_END": {
+          nitro2.hooks.callHook("compiled", nitro2);
+          if (nitro2.options.logging.buildSuccess) {
+            nitro2.logger.success(
+              `${nitroServerName(nitro2)} built with rolldown`,
+              start ? `in ${Date.now() - start}ms` : ""
+            );
+          }
+          nitro2.hooks.callHook("dev:reload");
+          break;
+        }
+        case "ERROR": {
+          nitro2.hooks.callHook("dev:error", event.error);
+        }
+      }
+    });
+    return watcher2;
+  }
+}
+
+async function buildProduction(nitro, config) {
+  const rolldown = await import('rolldown');
+  await scanHandlers(nitro);
+  await writeTypes(nitro);
+  await snapshot(nitro);
+  if (!nitro.options.static) {
+    nitro.logger.info(
+      `Building ${nitroServerName(nitro)} (rolldown, preset: \`${nitro.options.preset}\`, compatibility date: \`${formatCompatibilityDate(nitro.options.compatibilityDate)}\`)`
+    );
+    const build = await rolldown.rolldown(config);
+    await build.write(config.output);
+  }
+  const buildInfo = await writeBuildInfo(nitro);
+  if (!nitro.options.static) {
+    if (nitro.options.logging.buildSuccess) {
+      nitro.logger.success(`${nitroServerName(nitro)} built`);
+    }
+    if (nitro.options.logLevel > 1) {
+      process.stdout.write(
+        await generateFSTree(nitro.options.output.serverDir, {
+          compressedSizes: nitro.options.logging.compressedSizes
+        }) || ""
+      );
+    }
+  }
+  await nitro.hooks.callHook("compiled", nitro);
+  const rOutput = relative(process.cwd(), nitro.options.output.dir);
+  const rewriteRelativePaths = (input) => {
+    return input.replace(/([\s:])\.\/(\S*)/g, `$1${rOutput}/$2`);
+  };
+  if (buildInfo.commands.preview) {
+    nitro.logger.success(
+      `You can preview this build using \`${rewriteRelativePaths(
+        buildInfo.commands.preview
+      )}\``
+    );
+  }
+  if (buildInfo.commands.deploy) {
+    nitro.logger.success(
+      `You can deploy this build using \`${rewriteRelativePaths(
+        buildInfo.commands.deploy
+      )}\``
+    );
+  }
+}
+
+async function rolldownBuild(nitro) {
+  await nitro.hooks.callHook("build:before", nitro);
+  const config = getRolldownConfig(nitro);
+  await nitro.hooks.callHook("rollup:before", nitro, config);
+  return nitro.options.dev ? watchDev(nitro, config) : buildProduction(nitro, config);
+}
+
+export { rolldownBuild };