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

package/dist/_chunks/_deps/pkg-types.mjs

@@ -0,0 +1,247 @@
+import { promises, statSync } from 'node:fs';
+import { a as resolvePath } from './mlly.mjs';
+import { x, h, a as x$1, b as h$1, S } from './confbox.mjs';
+import { i as isAbsolute, r as resolve, j as join, n as normalize, d as dirname } from './pathe.mjs';
+import { r as resolveModulePath } from './exsolve.mjs';
+import { fileURLToPath } from 'node:url';
+import { readFile } from 'node:fs/promises';
+
+const defaultFindOptions$1 = {
+  startingFrom: ".",
+  rootPattern: /^node_modules$/,
+  reverse: false,
+  test: (filePath) => {
+    try {
+      if (statSync(filePath).isFile()) {
+        return true;
+      }
+    } catch {
+    }
+  }
+};
+async function findFile$1(filename, _options = {}) {
+  const filenames = Array.isArray(filename) ? filename : [filename];
+  const options = { ...defaultFindOptions$1, ..._options };
+  const basePath = resolve(options.startingFrom);
+  const leadingSlash = basePath[0] === "/";
+  const segments = basePath.split("/").filter(Boolean);
+  if (leadingSlash) {
+    segments[0] = "/" + segments[0];
+  }
+  let root = segments.findIndex((r) => r.match(options.rootPattern));
+  if (root === -1) {
+    root = 0;
+  }
+  if (options.reverse) {
+    for (let index = root + 1; index <= segments.length; index++) {
+      for (const filename2 of filenames) {
+        const filePath = join(...segments.slice(0, index), filename2);
+        if (await options.test(filePath)) {
+          return filePath;
+        }
+      }
+    }
+  } else {
+    for (let index = segments.length; index > root; index--) {
+      for (const filename2 of filenames) {
+        const filePath = join(...segments.slice(0, index), filename2);
+        if (await options.test(filePath)) {
+          return filePath;
+        }
+      }
+    }
+  }
+  throw new Error(
+    `Cannot find matching ${filename} in ${options.startingFrom} or parent directories`
+  );
+}
+function findNearestFile$1(filename, _options = {}) {
+  return findFile$1(filename, _options);
+}
+const FileCache$1 = /* @__PURE__ */ new Map();
+async function readPackageJSON$1(id, options = {}) {
+  const resolvedPath = await resolvePackageJSON$1(id, options);
+  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache$1;
+  if (options.cache && cache.has(resolvedPath)) {
+    return cache.get(resolvedPath);
+  }
+  const blob = await promises.readFile(resolvedPath, "utf8");
+  let parsed;
+  try {
+    parsed = x(blob);
+  } catch {
+    parsed = h(blob);
+  }
+  cache.set(resolvedPath, parsed);
+  return parsed;
+}
+async function resolvePackageJSON$1(id = process.cwd(), options = {}) {
+  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
+  return findNearestFile$1("package.json", {
+    startingFrom: resolvedPath,
+    ...options
+  });
+}
+
+const defaultFindOptions = {
+  startingFrom: ".",
+  rootPattern: /^node_modules$/,
+  reverse: false,
+  test: (filePath) => {
+    try {
+      if (statSync(filePath).isFile()) {
+        return true;
+      }
+    } catch {
+    }
+  }
+};
+async function findFile(filename, _options = {}) {
+  const filenames = Array.isArray(filename) ? filename : [filename];
+  const options = { ...defaultFindOptions, ..._options };
+  const basePath = resolve(options.startingFrom);
+  const leadingSlash = basePath[0] === "/";
+  const segments = basePath.split("/").filter(Boolean);
+  if (filenames.includes(segments.at(-1)) && await options.test(basePath)) {
+    return basePath;
+  }
+  if (leadingSlash) {
+    segments[0] = "/" + segments[0];
+  }
+  let root = segments.findIndex((r) => r.match(options.rootPattern));
+  if (root === -1) {
+    root = 0;
+  }
+  if (options.reverse) {
+    for (let index = root + 1; index <= segments.length; index++) {
+      for (const filename2 of filenames) {
+        const filePath = join(...segments.slice(0, index), filename2);
+        if (await options.test(filePath)) {
+          return filePath;
+        }
+      }
+    }
+  } else {
+    for (let index = segments.length; index > root; index--) {
+      for (const filename2 of filenames) {
+        const filePath = join(...segments.slice(0, index), filename2);
+        if (await options.test(filePath)) {
+          return filePath;
+        }
+      }
+    }
+  }
+  throw new Error(
+    `Cannot find matching ${filename} in ${options.startingFrom} or parent directories`
+  );
+}
+function findNearestFile(filename, options = {}) {
+  return findFile(filename, options);
+}
+
+function _resolvePath(id, opts = {}) {
+  if (id instanceof URL || id.startsWith("file://")) {
+    return normalize(fileURLToPath(id));
+  }
+  if (isAbsolute(id)) {
+    return normalize(id);
+  }
+  return resolveModulePath(id, {
+    ...opts,
+    from: opts.from || opts.parent || opts.url
+  });
+}
+
+const lockFiles = [
+  "yarn.lock",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "npm-shrinkwrap.json",
+  "bun.lockb",
+  "bun.lock",
+  "deno.lock"
+];
+const packageFiles = ["package.json", "package.json5", "package.yaml"];
+const workspaceFiles = [
+  "pnpm-workspace.yaml",
+  "lerna.json",
+  "turbo.json",
+  "rush.json",
+  "deno.json",
+  "deno.jsonc"
+];
+const FileCache = /* @__PURE__ */ new Map();
+async function readPackageJSON(id, options = {}) {
+  const resolvedPath = await resolvePackageJSON(id, options);
+  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+  if (options.cache && cache.has(resolvedPath)) {
+    return cache.get(resolvedPath);
+  }
+  const blob = await promises.readFile(resolvedPath, "utf8");
+  let parsed;
+  try {
+    parsed = x$1(blob);
+  } catch {
+    parsed = h$1(blob);
+  }
+  cache.set(resolvedPath, parsed);
+  return parsed;
+}
+async function resolvePackageJSON(id = process.cwd(), options = {}) {
+  return findNearestFile("package.json", {
+    ...options,
+    startingFrom: _resolvePath(id, options)
+  });
+}
+const workspaceTests = {
+  workspaceFile: (opts) => findFile(workspaceFiles, opts).then((r) => dirname(r)),
+  gitConfig: (opts) => findFile(".git/config", opts).then((r) => resolve(r, "../..")),
+  lockFile: (opts) => findFile(lockFiles, opts).then((r) => dirname(r)),
+  packageJson: (opts) => findFile(packageFiles, opts).then((r) => dirname(r))
+};
+async function findWorkspaceDir(id = process.cwd(), options = {}) {
+  const startingFrom = _resolvePath(id, options);
+  const tests = options.tests || ["workspaceFile", "gitConfig", "lockFile", "packageJson"];
+  for (const testName of tests) {
+    const test = workspaceTests[testName];
+    if (options[testName] === false || !test) {
+      continue;
+    }
+    const direction = options[testName] || (testName === "gitConfig" ? "closest" : "furthest");
+    const detected = await test({
+      ...options,
+      startingFrom,
+      reverse: direction === "furthest"
+    }).catch(() => {
+    });
+    if (detected) {
+      return detected;
+    }
+  }
+  throw new Error(`Cannot detect workspace root from ${id}`);
+}
+async function resolveGitConfig(dir, opts) {
+  return findNearestFile(".git/config", { ...opts, startingFrom: dir });
+}
+async function readGitConfig(dir, opts) {
+  const path = await resolveGitConfig(dir, opts);
+  const ini = await readFile(path, "utf8");
+  return parseGitConfig(ini);
+}
+function parseGitConfig(ini) {
+  return S(ini.replaceAll(/^\[(\w+) "(.+)"\]$/gm, "[$1.$2]"));
+}
+
+const index = {
+  __proto__: null,
+  findFile: findFile,
+  findNearestFile: findNearestFile,
+  findWorkspaceDir: findWorkspaceDir,
+  parseGitConfig: parseGitConfig,
+  readGitConfig: readGitConfig,
+  readPackageJSON: readPackageJSON,
+  resolveGitConfig: resolveGitConfig,
+  resolvePackageJSON: resolvePackageJSON
+};
+
+export { readPackageJSON$1 as a, resolvePackageJSON as b, findNearestFile as c, readGitConfig as d, findFile as e, findWorkspaceDir as f, index as i, readPackageJSON as r };

package/dist/_chunks/{snapshot.mjs → _deps/pretty-bytes.mjs}

@@ -1,32 +1,3 @@
-import { upperFirst } from 'scule';
-import { promises } from 'node:fs';
-import { colors } from 'consola/utils';
-import { b as glob, c as snapshotStorage } from './index.mjs';
-import 'node:stream';
-import zlib from 'node:zlib';
-import { promisify } from 'node:util';
-import 'stream';
-import { isTest } from 'std-env';
-import { r as runParallel } from './index3.mjs';
-import { r as resolve, d as dirname, a as relative, j as join } from './pathe.M-eThtNZ.mjs';
-import { mkdir, writeFile } from 'node:fs/promises';
-
-function nitroServerName(nitro) {
-  return nitro.options.framework.name === "nitro" ? "Nitro Server" : `${upperFirst(nitro.options.framework.name)} Nitro server`;
-}
-
-const getOptions = options => ({level: 9, ...options});
-const gzip = promisify(zlib.gzip);
-
-async function gzipSize(input, options) {
-	if (!input) {
-		return 0;
-	}
-
-	const data = await gzip(input, getOptions(options));
-	return data.length;
-}
-
 const BYTE_UNITS = [
 	'B',
 	'kB',
@@ -206,79 +177,4 @@ function prettyBytes(number, options) {
 	return applyFixedWidth(result, options.fixedWidth);
 }
 
-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;
-}
-
-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, snapshot as s };
+export { prettyBytes as p };

package/dist/_chunks/_deps/quansync.mjs

@@ -0,0 +1,99 @@
+const GET_IS_ASYNC = Symbol.for("quansync.getIsAsync");
+class QuansyncError extends Error {
+  constructor(message = "Unexpected promise in sync context") {
+    super(message);
+    this.name = "QuansyncError";
+  }
+}
+function isThenable(value) {
+  return value && typeof value === "object" && typeof value.then === "function";
+}
+function isQuansyncGenerator(value) {
+  return value && typeof value === "object" && typeof value[Symbol.iterator] === "function" && "__quansync" in value;
+}
+function fromObject(options) {
+  const generator = function* (...args) {
+    const isAsync = yield GET_IS_ASYNC;
+    if (isAsync)
+      return yield options.async.apply(this, args);
+    return options.sync.apply(this, args);
+  };
+  function fn(...args) {
+    const iter = generator.apply(this, args);
+    iter.then = (...thenArgs) => options.async.apply(this, args).then(...thenArgs);
+    iter.__quansync = true;
+    return iter;
+  }
+  fn.sync = options.sync;
+  fn.async = options.async;
+  return fn;
+}
+function fromPromise(promise) {
+  return fromObject({
+    async: () => Promise.resolve(promise),
+    sync: () => {
+      if (isThenable(promise))
+        throw new QuansyncError();
+      return promise;
+    }
+  });
+}
+function unwrapYield(value, isAsync) {
+  if (value === GET_IS_ASYNC)
+    return isAsync;
+  if (isQuansyncGenerator(value))
+    return isAsync ? iterateAsync(value) : iterateSync(value);
+  if (!isAsync && isThenable(value))
+    throw new QuansyncError();
+  return value;
+}
+const DEFAULT_ON_YIELD = (value) => value;
+function iterateSync(generator, onYield = DEFAULT_ON_YIELD) {
+  let current = generator.next();
+  while (!current.done) {
+    try {
+      current = generator.next(unwrapYield(onYield(current.value, false)));
+    } catch (err) {
+      current = generator.throw(err);
+    }
+  }
+  return unwrapYield(current.value);
+}
+async function iterateAsync(generator, onYield = DEFAULT_ON_YIELD) {
+  let current = generator.next();
+  while (!current.done) {
+    try {
+      current = generator.next(await unwrapYield(onYield(current.value, true), true));
+    } catch (err) {
+      current = generator.throw(err);
+    }
+  }
+  return current.value;
+}
+function fromGeneratorFn(generatorFn, options) {
+  return fromObject({
+    name: generatorFn.name,
+    async(...args) {
+      return iterateAsync(generatorFn.apply(this, args), options?.onYield);
+    },
+    sync(...args) {
+      return iterateSync(generatorFn.apply(this, args), options?.onYield);
+    }
+  });
+}
+function quansync$1(input, options) {
+  if (isThenable(input))
+    return fromPromise(input);
+  if (typeof input === "function")
+    return fromGeneratorFn(input, options);
+  else
+    return fromObject(input);
+}
+quansync$1({
+  async: () => Promise.resolve(true),
+  sync: () => false
+});
+
+const quansync = quansync$1;
+
+export { quansync as q };

package/dist/_chunks/_deps/range-parser.mjs

@@ -0,0 +1,171 @@
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var rangeParser_1;
+var hasRequiredRangeParser;
+
+function requireRangeParser () {
+	if (hasRequiredRangeParser) return rangeParser_1;
+	hasRequiredRangeParser = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	rangeParser_1 = rangeParser;
+
+	/**
+	 * Parse "Range" header `str` relative to the given file `size`.
+	 *
+	 * @param {Number} size
+	 * @param {String} str
+	 * @param {Object} [options]
+	 * @return {Array}
+	 * @public
+	 */
+
+	function rangeParser (size, str, options) {
+	  if (typeof str !== 'string') {
+	    throw new TypeError('argument str must be a string')
+	  }
+
+	  var index = str.indexOf('=');
+
+	  if (index === -1) {
+	    return -2
+	  }
+
+	  // split the range string
+	  var arr = str.slice(index + 1).split(',');
+	  var ranges = [];
+
+	  // add ranges type
+	  ranges.type = str.slice(0, index);
+
+	  // parse all ranges
+	  for (var i = 0; i < arr.length; i++) {
+	    var range = arr[i].split('-');
+	    var start = parseInt(range[0], 10);
+	    var end = parseInt(range[1], 10);
+
+	    // -nnn
+	    if (isNaN(start)) {
+	      start = size - end;
+	      end = size - 1;
+	    // nnn-
+	    } else if (isNaN(end)) {
+	      end = size - 1;
+	    }
+
+	    // limit last-byte-pos to current length
+	    if (end > size - 1) {
+	      end = size - 1;
+	    }
+
+	    // invalid or unsatisifiable
+	    if (isNaN(start) || isNaN(end) || start > end || start < 0) {
+	      continue
+	    }
+
+	    // add range
+	    ranges.push({
+	      start: start,
+	      end: end
+	    });
+	  }
+
+	  if (ranges.length < 1) {
+	    // unsatisifiable
+	    return -1
+	  }
+
+	  return options && options.combine
+	    ? combineRanges(ranges)
+	    : ranges
+	}
+
+	/**
+	 * Combine overlapping & adjacent ranges.
+	 * @private
+	 */
+
+	function combineRanges (ranges) {
+	  var ordered = ranges.map(mapWithIndex).sort(sortByRangeStart);
+
+	  for (var j = 0, i = 1; i < ordered.length; i++) {
+	    var range = ordered[i];
+	    var current = ordered[j];
+
+	    if (range.start > current.end + 1) {
+	      // next range
+	      ordered[++j] = range;
+	    } else if (range.end > current.end) {
+	      // extend range
+	      current.end = range.end;
+	      current.index = Math.min(current.index, range.index);
+	    }
+	  }
+
+	  // trim ordered array
+	  ordered.length = j + 1;
+
+	  // generate combined range
+	  var combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex);
+
+	  // copy ranges type
+	  combined.type = ranges.type;
+
+	  return combined
+	}
+
+	/**
+	 * Map function to add index value to ranges.
+	 * @private
+	 */
+
+	function mapWithIndex (range, index) {
+	  return {
+	    start: range.start,
+	    end: range.end,
+	    index: index
+	  }
+	}
+
+	/**
+	 * Map function to remove index value from ranges.
+	 * @private
+	 */
+
+	function mapWithoutIndex (range) {
+	  return {
+	    start: range.start,
+	    end: range.end
+	  }
+	}
+
+	/**
+	 * Sort function to sort ranges by index.
+	 * @private
+	 */
+
+	function sortByRangeIndex (a, b) {
+	  return a.index - b.index
+	}
+
+	/**
+	 * Sort function to sort ranges by start position.
+	 * @private
+	 */
+
+	function sortByRangeStart (a, b) {
+	  return a.start - b.start
+	}
+	return rangeParser_1;
+}
+
+export { requireRangeParser as r };