nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_build/snapshot.mjs

@@ -0,0 +1,185 @@
+import { promises } from 'node:fs';
+import { m as mime } from '../_chunks/_deps/mime.mjs';
+import { e as extname, r as resolve, d as dirname, a as relative, j as join } from '../_chunks/_deps/pathe.mjs';
+import { upperFirst } from 'scule';
+import { colors } from 'consola/utils';
+import { g as glob } from '../_chunks/_deps/tinyglobby.mjs';
+import { g as gzipSize } from '../_chunks/_deps/gzip-size.mjs';
+import { p as prettyBytes } from '../_chunks/_deps/pretty-bytes.mjs';
+import { a } from '../_chunks/_deps/std-env.mjs';
+import { r as runParallel } from '../_chunks/builder.mjs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { a as snapshotStorage } from './prepare.mjs';
+
+const HELPER_ID = "\0raw-helpers";
+function raw(opts = {}) {
+  const extensions = /* @__PURE__ */ new Set([
+    ".md",
+    ".mdx",
+    ".txt",
+    ".css",
+    ".htm",
+    ".html",
+    ".sql",
+    ...opts.extensions || []
+  ]);
+  return {
+    name: "raw",
+    async resolveId(id, importer, resolveOpts) {
+      if (id === HELPER_ID) {
+        return id;
+      }
+      if (id[0] === "\0") {
+        return;
+      }
+      const withRawSpecifier = id.startsWith("raw:");
+      if (withRawSpecifier) {
+        id = id.slice(4);
+      }
+      if (!withRawSpecifier && !extensions.has(extname(id))) {
+        return;
+      }
+      const resolvedId = (await this.resolve(id, importer, resolveOpts))?.id;
+      if (!resolvedId || resolvedId.startsWith("\0")) {
+        return resolvedId;
+      }
+      if (!withRawSpecifier && !extensions.has(extname(resolvedId))) {
+        return;
+      }
+      return { id: "\0raw:" + resolvedId };
+    },
+    load(id) {
+      if (id === HELPER_ID) {
+        return getHelpers();
+      }
+      if (id.startsWith("\0raw:")) {
+        return promises.readFile(id.slice(5), isBinary(id) ? "binary" : "utf8");
+      }
+    },
+    transform(code, id) {
+      if (!id.startsWith("\0raw:")) {
+        return;
+      }
+      if (isBinary(id)) {
+        const serialized = Buffer.from(code, "binary").toString("base64");
+        return {
+          code: `// ROLLUP_NO_REPLACE 
+ import {base64ToUint8Array } from "${HELPER_ID}" 
+ export default base64ToUint8Array("${serialized}")`,
+          map: null
+        };
+      }
+      return {
+        code: `// ROLLUP_NO_REPLACE 
+ export default ${JSON.stringify(code)}`,
+        map: null,
+        moduleType: "js"
+      };
+    }
+  };
+}
+function isBinary(id) {
+  const idMime = mime.getType(id) || "";
+  if (idMime.startsWith("text/")) {
+    return false;
+  }
+  if (/application\/(json|sql|xml|yaml)/.test(idMime)) {
+    return false;
+  }
+  return true;
+}
+function getHelpers() {
+  const js = String.raw;
+  return js`
+export function base64ToUint8Array(str) {
+  const data = atob(str);
+  const size = data.length;
+  const bytes = new Uint8Array(size);
+  for (let i = 0; i < size; i++) {
+    bytes[i] = data.charCodeAt(i);
+  }
+  return bytes;
+}
+  `;
+}
+
+function nitroServerName(nitro) {
+  return nitro.options.framework.name === "nitro" ? "Nitro Server" : `${upperFirst(nitro.options.framework.name)} Nitro server`;
+}
+
+async function generateFSTree(dir, options = {}) {
+  if (a) {
+    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;
+}
+
+async function snapshot(nitro) {
+  if (nitro.options.bundledStorage.length === 0 || nitro.options.preset === "nitro-prerender") {
+    return;
+  }
+  const storageDir = resolve(nitro.options.buildDir, "snapshot");
+  nitro.options.serverAssets.push({
+    baseName: "nitro:bundled",
+    dir: storageDir
+  });
+  const data = await snapshotStorage(nitro);
+  await Promise.all(
+    Object.entries(data).map(async ([path, contents]) => {
+      if (typeof contents !== "string") {
+        contents = JSON.stringify(contents);
+      }
+      const fsPath = join(storageDir, path.replace(/:/g, "/"));
+      await mkdir(dirname(fsPath), { recursive: true });
+      await writeFile(fsPath, contents, "utf8");
+    })
+  );
+}
+
+export { generateFSTree as g, nitroServerName as n, raw as r, snapshot as s };