nitro-nightly 3.1.0-20251028-090722-437659e4 → 3.1.0-20251028-131831-fe9fd554

package/dist/_build/snapshot.mjs

@@ -1,39 +1,163 @@
+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/index.mjs';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { klona } from 'klona';
-import { createStorage as createStorage$1, builtinDrivers } from 'unstorage';
-import { a as resolve, j as join, d as dirname } from '../_deps/pathe.mjs';
+import { a as snapshotStorage } from './prepare.mjs';
 
-async function createStorage(nitro) {
-  const storage = createStorage$1();
-  const mounts = klona({
-    ...nitro.options.storage,
-    ...nitro.options.devStorage
-  });
-  for (const [path, opts] of Object.entries(mounts)) {
-    if (opts.driver) {
-      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
-      storage.mount(path, driver(opts));
-    } else {
-      nitro.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
+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 storage;
+  return true;
 }
-async function snapshotStorage(nitro) {
-  const data = {};
-  const allKeys = [
-    ...new Set(
-      await Promise.all(
-        nitro.options.bundledStorage.map((base) => nitro.storage.getKeys(base))
-      ).then((r) => r.flat())
-    )
-  ];
-  await Promise.all(
-    allKeys.map(async (key) => {
-      data[key] = await nitro.storage.getItem(key);
-    })
+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 }
   );
-  return data;
+  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) {
@@ -58,4 +182,4 @@ async function snapshot(nitro) {
   );
 }
 
-export { createStorage as c, snapshot as s };
+export { generateFSTree as g, nitroServerName as n, raw as r, snapshot as s };