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

package/dist/_build/assets.mjs

@@ -0,0 +1,235 @@
+import { existsSync, promises } from 'node:fs';
+import { g as glob } from '../_deps/tinyglobby.mjs';
+import fsp, { stat, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
+import consola from 'consola';
+import { colors } from 'consola/utils';
+import { g as getProperty } from '../_deps/dot-prop.mjs';
+import { r as relative, a as resolve, d as dirname, j as join } from '../_deps/pathe.mjs';
+import zlib from 'node:zlib';
+import { m as mime } from '../_deps/mime.mjs';
+
+function prettyPath(p, highlight = true) {
+  p = relative(process.cwd(), p);
+  return highlight ? colors.cyan(p) : p;
+}
+function resolveNitroPath(path, nitroOptions, base) {
+  if (typeof path !== "string") {
+    throw new TypeError("Invalid path: " + path);
+  }
+  path = _compilePathTemplate(path)(nitroOptions);
+  for (const base2 in nitroOptions.alias) {
+    if (path.startsWith(base2)) {
+      path = nitroOptions.alias[base2] + path.slice(base2.length);
+    }
+  }
+  return resolve(base || nitroOptions.srcDir, path);
+}
+function _compilePathTemplate(contents) {
+  return (params) => contents.replace(/{{ ?([\w.]+) ?}}/g, (_, match) => {
+    const val = getProperty(params, match);
+    if (!val) {
+      consola.warn(
+        `cannot resolve template param '${match}' in ${contents.slice(0, 20)}`
+      );
+    }
+    return val || `${match}`;
+  });
+}
+async function writeFile(file, contents, log = false) {
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile$1(
+    file,
+    contents,
+    typeof contents === "string" ? "utf8" : void 0
+  );
+  if (log) {
+    consola.info("Generated", prettyPath(file));
+  }
+}
+async function isDirectory(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function compressPublicAssets(nitro) {
+  const publicFiles = await glob("**", {
+    cwd: nitro.options.output.publicDir,
+    absolute: false,
+    dot: true,
+    ignore: ["**/*.gz", "**/*.br"]
+  });
+  await Promise.all(
+    publicFiles.map(async (fileName) => {
+      const filePath = resolve(nitro.options.output.publicDir, fileName);
+      if (existsSync(filePath + ".gz") || existsSync(filePath + ".br")) {
+        return;
+      }
+      const mimeType = mime.getType(fileName) || "text/plain";
+      const fileContents = await fsp.readFile(filePath);
+      if (fileContents.length < 1024 || fileName.endsWith(".map") || !isCompressibleMime(mimeType)) {
+        return;
+      }
+      const { gzip, brotli } = nitro.options.compressPublicAssets || {};
+      const encodings = [
+        gzip !== false && "gzip",
+        brotli !== false && "br"
+      ].filter(Boolean);
+      await Promise.all(
+        encodings.map(async (encoding) => {
+          const suffix = "." + (encoding === "gzip" ? "gz" : "br");
+          const compressedPath = filePath + suffix;
+          if (existsSync(compressedPath)) {
+            return;
+          }
+          const gzipOptions = { level: zlib.constants.Z_BEST_COMPRESSION };
+          const brotliOptions = {
+            [zlib.constants.BROTLI_PARAM_MODE]: isTextMime(mimeType) ? zlib.constants.BROTLI_MODE_TEXT : zlib.constants.BROTLI_MODE_GENERIC,
+            [zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY,
+            [zlib.constants.BROTLI_PARAM_SIZE_HINT]: fileContents.length
+          };
+          const compressedBuff = await new Promise(
+            (resolve2, reject) => {
+              const cb = (error, result) => error ? reject(error) : resolve2(result);
+              if (encoding === "gzip") {
+                zlib.gzip(fileContents, gzipOptions, cb);
+              } else {
+                zlib.brotliCompress(fileContents, brotliOptions, cb);
+              }
+            }
+          );
+          await fsp.writeFile(compressedPath, compressedBuff);
+        })
+      );
+    })
+  );
+}
+function isTextMime(mimeType) {
+  return /text|javascript|json|xml/.test(mimeType);
+}
+const COMPRESSIBLE_MIMES_RE = /* @__PURE__ */ new Set([
+  "application/dash+xml",
+  "application/eot",
+  "application/font",
+  "application/font-sfnt",
+  "application/javascript",
+  "application/json",
+  "application/opentype",
+  "application/otf",
+  "application/pdf",
+  "application/pkcs7-mime",
+  "application/protobuf",
+  "application/rss+xml",
+  "application/truetype",
+  "application/ttf",
+  "application/vnd.apple.mpegurl",
+  "application/vnd.mapbox-vector-tile",
+  "application/vnd.ms-fontobject",
+  "application/wasm",
+  "application/xhtml+xml",
+  "application/xml",
+  "application/x-font-opentype",
+  "application/x-font-truetype",
+  "application/x-font-ttf",
+  "application/x-httpd-cgi",
+  "application/x-javascript",
+  "application/x-mpegurl",
+  "application/x-opentype",
+  "application/x-otf",
+  "application/x-perl",
+  "application/x-ttf",
+  "font/eot",
+  "font/opentype",
+  "font/otf",
+  "font/ttf",
+  "image/svg+xml",
+  "text/css",
+  "text/csv",
+  "text/html",
+  "text/javascript",
+  "text/js",
+  "text/plain",
+  "text/richtext",
+  "text/tab-separated-values",
+  "text/xml",
+  "text/x-component",
+  "text/x-java-source",
+  "text/x-script",
+  "vnd.apple.mpegurl"
+]);
+function isCompressibleMime(mimeType) {
+  return COMPRESSIBLE_MIMES_RE.has(mimeType);
+}
+
+const NEGATION_RE = /^(!?)(.*)$/;
+const PARENT_DIR_GLOB_RE = /!?\.\.\//;
+async function scanUnprefixedPublicAssets(nitro) {
+  const scannedPaths = [];
+  for (const asset of nitro.options.publicAssets) {
+    if (asset.baseURL && asset.baseURL !== "/" && !asset.fallthrough) {
+      continue;
+    }
+    if (!await isDirectory(asset.dir)) {
+      continue;
+    }
+    const includePatterns = getIncludePatterns(nitro, asset.dir);
+    const publicAssets = await glob(includePatterns, {
+      cwd: asset.dir,
+      absolute: false,
+      dot: true
+    });
+    scannedPaths.push(
+      ...publicAssets.map((file) => join(asset.baseURL || "/", file))
+    );
+  }
+  return scannedPaths;
+}
+async function copyPublicAssets(nitro) {
+  if (nitro.options.noPublicDir) {
+    return;
+  }
+  for (const asset of nitro.options.publicAssets) {
+    const srcDir = asset.dir;
+    const dstDir = join(nitro.options.output.publicDir, asset.baseURL);
+    if (await isDirectory(srcDir)) {
+      const includePatterns = getIncludePatterns(nitro, srcDir);
+      const publicAssets = await glob(includePatterns, {
+        cwd: srcDir,
+        absolute: false,
+        dot: true
+      });
+      await Promise.all(
+        publicAssets.map(async (file) => {
+          const src = join(srcDir, file);
+          const dst = join(dstDir, file);
+          if (!existsSync(dst)) {
+            await promises.cp(src, dst);
+          }
+        })
+      );
+    }
+  }
+  if (nitro.options.compressPublicAssets) {
+    await compressPublicAssets(nitro);
+  }
+  nitro.logger.success(
+    "Generated public " + prettyPath(nitro.options.output.publicDir)
+  );
+}
+function getIncludePatterns(nitro, srcDir) {
+  return [
+    "**",
+    ...nitro.options.ignore.map((p) => {
+      const [_, negation, pattern] = p.match(NEGATION_RE) || [];
+      return (
+        // Convert ignore to include patterns
+        (negation ? "" : "!") + // Make non-glob patterns relative to publicAssetDir
+        (pattern.startsWith("*") ? pattern : relative(srcDir, resolve(nitro.options.srcDir, pattern)))
+      );
+    })
+  ].filter((p) => !PARENT_DIR_GLOB_RE.test(p));
+}
+
+export { copyPublicAssets as a, compressPublicAssets as c, isDirectory as i, prettyPath as p, resolveNitroPath as r, scanUnprefixedPublicAssets as s, writeFile as w };

package/dist/_build/build.mjs

@@ -0,0 +1,21 @@
+async function build(nitro) {
+  switch (nitro.options.builder) {
+    case "rollup": {
+      const { rollupBuild } = await import('./rollup.mjs');
+      return rollupBuild(nitro);
+    }
+    case "rolldown": {
+      const { rolldownBuild } = await import('./rolldown.mjs').then(function (n) { return n.b; });
+      return rolldownBuild(nitro);
+    }
+    case "vite": {
+      const { viteBuild } = await import('./vite.mjs').then(function (n) { return n.d; });
+      return viteBuild(nitro);
+    }
+    default: {
+      throw new Error(`Unknown builder: ${nitro.options.builder}`);
+    }
+  }
+}
+
+export { build as b };

package/dist/_build/config.mjs

@@ -0,0 +1,124 @@
+import { defineEnv } from 'unenv';
+import { runtimeDir } from 'nitro/runtime/meta';
+import { j as join, a as resolve } from '../_deps/pathe.mjs';
+
+function baseBuildConfig(nitro) {
+  const buildServerDir = join(nitro.options.buildDir, "dist/server");
+  const presetsDir = resolve(runtimeDir, "../presets");
+  const extensions = [".ts", ".mjs", ".js", ".json", ".node", ".tsx", ".jsx"];
+  const isNodeless = nitro.options.node === false;
+  let NODE_ENV = nitro.options.dev ? "development" : "production";
+  if (nitro.options.preset === "nitro-prerender") {
+    NODE_ENV = "prerender";
+  }
+  const buildEnvVars = {
+    NODE_ENV,
+    prerender: nitro.options.preset === "nitro-prerender",
+    server: true,
+    client: false,
+    dev: String(nitro.options.dev),
+    DEBUG: nitro.options.dev
+  };
+  const staticFlags = {
+    dev: nitro.options.dev,
+    preset: nitro.options.preset,
+    prerender: nitro.options.preset === "nitro-prerender",
+    server: true,
+    client: false,
+    nitro: true,
+    baseURL: nitro.options.baseURL,
+    // @ts-expect-error
+    "versions.nitro": "",
+    "versions?.nitro": "",
+    // Internal
+    _asyncContext: nitro.options.experimental.asyncContext,
+    _websocket: nitro.options.experimental.websocket,
+    _tasks: nitro.options.experimental.tasks
+  };
+  const replaceDelimiters = [
+    String.raw`\b`,
+    String.raw`(?![\w.$])`
+  ];
+  const replacements = {
+    "typeof window": '"undefined"',
+    _import_meta_url_: "import.meta.url",
+    "globalThis.process.": "process.",
+    "process.env.RUNTIME_CONFIG": () => JSON.stringify(nitro.options.runtimeConfig, null, 2),
+    ...Object.fromEntries(
+      Object.entries(buildEnvVars).map(([key, val]) => [
+        `process.env.${key}`,
+        JSON.stringify(val)
+      ])
+    ),
+    ...Object.fromEntries(
+      Object.entries(buildEnvVars).map(([key, val]) => [
+        `import.meta.env.${key}`,
+        JSON.stringify(val)
+      ])
+    ),
+    ...Object.fromEntries(
+      Object.entries(staticFlags).map(([key, val]) => [
+        `process.${key}`,
+        JSON.stringify(val)
+      ])
+    ),
+    ...Object.fromEntries(
+      Object.entries(staticFlags).map(([key, val]) => [
+        `import.meta.${key}`,
+        JSON.stringify(val)
+      ])
+    ),
+    ...nitro.options.replace
+  };
+  const { env } = defineEnv({
+    nodeCompat: isNodeless,
+    npmShims: true,
+    resolve: true,
+    presets: nitro.options.unenv,
+    overrides: {
+      alias: nitro.options.alias
+    }
+  });
+  const aliases = resolveAliases({
+    "#internal/nitro": runtimeDir,
+    "nitro/runtime": runtimeDir,
+    "nitropack/runtime": runtimeDir,
+    // Backwards compatibility
+    ...env.alias
+  });
+  return {
+    buildServerDir,
+    presetsDir,
+    extensions,
+    isNodeless,
+    buildEnvVars,
+    staticFlags,
+    replaceDelimiters,
+    replacements,
+    env,
+    aliases
+  };
+}
+function resolveAliases(_aliases) {
+  const aliases = Object.fromEntries(
+    Object.entries(_aliases).sort(
+      ([a], [b]) => b.split("/").length - a.split("/").length || b.length - a.length
+    )
+  );
+  for (const key in aliases) {
+    for (const alias in aliases) {
+      if (!["~", "@", "#"].includes(alias[0])) {
+        continue;
+      }
+      if (alias === "@" && !aliases[key].startsWith("@/")) {
+        continue;
+      }
+      if (aliases[key].startsWith(alias)) {
+        aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
+      }
+    }
+  }
+  return aliases;
+}
+
+export { baseBuildConfig as b };

package/dist/_build/info.mjs

@@ -0,0 +1,39 @@
+import { version } from 'nitro/meta';
+import { p as presetsWithConfig } from '../_presets/_types.mjs';
+import { w as writeFile } from './assets.mjs';
+import { mkdir, unlink, symlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { a as resolve } from '../_deps/pathe.mjs';
+
+async function writeBuildInfo(nitro) {
+  const buildInfoPath = resolve(nitro.options.output.dir, "nitro.json");
+  const buildInfo = {
+    date: (/* @__PURE__ */ new Date()).toJSON(),
+    preset: nitro.options.preset,
+    framework: nitro.options.framework,
+    versions: {
+      nitro: version
+    },
+    commands: {
+      preview: nitro.options.commands.preview,
+      deploy: nitro.options.commands.deploy
+    },
+    config: {
+      ...Object.fromEntries(
+        presetsWithConfig.map((key) => [key, nitro.options[key]])
+      )
+    }
+  };
+  await writeFile(buildInfoPath, JSON.stringify(buildInfo, null, 2), true);
+  const lastBuild = resolve(
+    nitro.options.rootDir,
+    "node_modules/.nitro/last-build"
+  );
+  await mkdir(dirname(lastBuild), { recursive: true });
+  await unlink(lastBuild).catch(() => {
+  });
+  await symlink(nitro.options.output.dir, lastBuild).catch(console.warn);
+  return buildInfo;
+}
+
+export { writeBuildInfo as w };