vercel 59.11.2 → 59.11.7

package/dist/chunks/chunk-QOPTXV4G.js

@@ -0,0 +1,417 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  VERCEL_DIR
+} from "./chunk-2TSBB22D.js";
+import {
+  ConflictingConfigFiles,
+  DeprecatedNowJson
+} from "./chunk-CV5YC2EN.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../node_modules/.pnpm/dotenv@4.0.0/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/dotenv@4.0.0/node_modules/dotenv/lib/main.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    function parse(src) {
+      var obj = {};
+      src.toString().split("\n").forEach(function(line) {
+        var keyValueArr = line.match(/^\s*([\w\.\-]+)\s*=\s*(.*)?\s*$/);
+        if (keyValueArr != null) {
+          var key = keyValueArr[1];
+          var value = keyValueArr[2] ? keyValueArr[2] : "";
+          var len = value ? value.length : 0;
+          if (len > 0 && value.charAt(0) === '"' && value.charAt(len - 1) === '"') {
+            value = value.replace(/\\n/gm, "\n");
+          }
+          value = value.replace(/(^['"]|['"]$)/g, "").trim();
+          obj[key] = value;
+        }
+      });
+      return obj;
+    }
+    function config(options) {
+      var path = ".env";
+      var encoding = "utf8";
+      if (options) {
+        if (options.path) {
+          path = options.path;
+        }
+        if (options.encoding) {
+          encoding = options.encoding;
+        }
+      }
+      try {
+        var parsedObj = parse(fs.readFileSync(path, { encoding }));
+        Object.keys(parsedObj).forEach(function(key) {
+          process.env[key] = process.env[key] || parsedObj[key];
+        });
+        return { parsed: parsedObj };
+      } catch (e) {
+        return { error: e };
+      }
+    }
+    module.exports.config = config;
+    module.exports.load = config;
+    module.exports.parse = parse;
+  }
+});
+
+// src/util/compile-vercel-config.ts
+var import_dotenv = __toESM(require_main(), 1);
+import { mkdir, readFile, writeFile, unlink, access } from "fs/promises";
+import { join, basename } from "path";
+import { fork } from "child_process";
+import { parse as tomlParse } from "smol-toml";
+import { getNodeExecPath, NowBuildError } from "@vercel/build-utils";
+function toRouteFormat(item) {
+  if ("src" in item)
+    return item;
+  const { source, destination, headers, statusCode, permanent, ...rest } = item;
+  const route = {
+    src: source,
+    ...rest
+  };
+  if (destination)
+    route.dest = destination;
+  if (headers)
+    route.headers = Object.fromEntries(headers.map((h) => [h.key, h.value]));
+  if (statusCode !== void 0) {
+    route.status = statusCode;
+  } else if (permanent !== void 0) {
+    route.status = permanent ? 308 : 307;
+  }
+  return route;
+}
+function normalizeConfig(config) {
+  const normalized = { ...config };
+  const { rewrites, redirects, headers } = normalized;
+  let allRoutes = normalized.routes || [];
+  const hasRoutes = allRoutes.length > 0;
+  const hasRewrites = (rewrites?.length ?? 0) > 0;
+  const hasRedirects = (redirects?.length ?? 0) > 0;
+  const hasHeaders = (headers?.length ?? 0) > 0;
+  function hasRouteFormat(items) {
+    return items?.some((item) => "src" in item) ?? false;
+  }
+  if (hasRoutes && (hasRewrites || hasRedirects || hasHeaders)) {
+    return normalized;
+  }
+  const shouldConvertRewrites = hasRewrites && hasRouteFormat(rewrites);
+  const shouldConvertRedirects = hasRedirects && hasRouteFormat(redirects);
+  const shouldConvertHeaders = hasHeaders && hasRouteFormat(headers);
+  const someWillConvert = shouldConvertRewrites || shouldConvertRedirects || shouldConvertHeaders;
+  const someWontConvert = hasRewrites && !shouldConvertRewrites || hasRedirects && !shouldConvertRedirects || hasHeaders && !shouldConvertHeaders;
+  if (someWillConvert && someWontConvert) {
+    throw new NowBuildError({
+      code: "INVALID_VERCEL_CONFIG",
+      message: "Transforms (e.g., requestHeaders) require the `routes` format, which cannot be used alongside `rewrites`, `redirects`, or `headers`. Move everything into the `routes` array instead.",
+      link: "https://vercel.com/docs/projects/project-configuration#routes"
+    });
+  }
+  if (rewrites && shouldConvertRewrites) {
+    allRoutes = [...allRoutes, ...rewrites.map(toRouteFormat)];
+    delete normalized.rewrites;
+  }
+  if (redirects && shouldConvertRedirects) {
+    allRoutes = [...allRoutes, ...redirects.map(toRouteFormat)];
+    delete normalized.redirects;
+  }
+  if (headers && shouldConvertHeaders) {
+    allRoutes = [...allRoutes, ...headers.map(toRouteFormat)];
+    delete normalized.headers;
+  }
+  if (allRoutes.length > 0) {
+    normalized.routes = allRoutes.map(toRouteFormat);
+  }
+  return normalized;
+}
+var VERCEL_CONFIG_EXTENSIONS = [
+  "ts",
+  "mts",
+  "js",
+  "mjs",
+  "cjs"
+];
+var DEFAULT_VERCEL_CONFIG_FILENAME = "Vercel config";
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findAllVercelConfigFiles(workPath) {
+  const foundFiles = [];
+  for (const ext of VERCEL_CONFIG_EXTENSIONS) {
+    const configPath = join(workPath, `vercel.${ext}`);
+    if (await fileExists(configPath)) {
+      foundFiles.push(configPath);
+    }
+  }
+  return foundFiles;
+}
+async function findSourceVercelConfigFile(workPath) {
+  for (const ext of VERCEL_CONFIG_EXTENSIONS) {
+    const configPath = join(workPath, `vercel.${ext}`);
+    if (await fileExists(configPath)) {
+      return basename(configPath);
+    }
+  }
+  const tomlPath = join(workPath, "vercel.toml");
+  if (await fileExists(tomlPath)) {
+    return "vercel.toml";
+  }
+  return null;
+}
+async function findVercelConfigFile(workPath) {
+  const foundFiles = await findAllVercelConfigFiles(workPath);
+  if (foundFiles.length > 1) {
+    throw new ConflictingConfigFiles(
+      foundFiles,
+      "Multiple vercel config files found. Please use only one configuration file.",
+      "https://vercel.com/docs/projects/project-configuration"
+    );
+  }
+  return foundFiles[0] || null;
+}
+function parseConfigLoaderError(stderr) {
+  if (!stderr.trim()) {
+    return "";
+  }
+  const moduleNotFoundMatch = stderr.match(
+    /Error \[ERR_MODULE_NOT_FOUND\]: Cannot find package '([^']+)'/
+  );
+  if (moduleNotFoundMatch) {
+    const packageName = moduleNotFoundMatch[1];
+    return `Cannot find package '${packageName}'. Make sure it's installed in your project dependencies.`;
+  }
+  const syntaxErrorMatch = stderr.match(/SyntaxError: (.+?)(?:\n|$)/);
+  if (syntaxErrorMatch) {
+    return `Syntax error: ${syntaxErrorMatch[1]}`;
+  }
+  const errorMatch = stderr.match(
+    /^(?:Error|TypeError|ReferenceError): (.+?)(?:\n|$)/m
+  );
+  if (errorMatch) {
+    return errorMatch[1];
+  }
+  return stderr.trim();
+}
+async function compileVercelConfig(workPath) {
+  const vercelJsonPath = join(workPath, "vercel.json");
+  const nowJsonPath = join(workPath, "now.json");
+  const vercelTomlPath = join(workPath, "vercel.toml");
+  const hasVercelJson = await fileExists(vercelJsonPath);
+  const hasNowJson = await fileExists(nowJsonPath);
+  const hasVercelToml = await fileExists(vercelTomlPath);
+  const vercelConfigPath = await findVercelConfigFile(workPath);
+  const vercelDir = join(workPath, VERCEL_DIR);
+  const compiledConfigPath = join(vercelDir, "vercel.json");
+  if (hasNowJson) {
+    throw new DeprecatedNowJson(nowJsonPath);
+  }
+  const foundConfigs = [];
+  if (hasVercelJson)
+    foundConfigs.push(vercelJsonPath);
+  if (hasVercelToml)
+    foundConfigs.push(vercelTomlPath);
+  if (vercelConfigPath)
+    foundConfigs.push(vercelConfigPath);
+  if (foundConfigs.length > 1) {
+    throw new ConflictingConfigFiles(
+      foundConfigs,
+      `Multiple config files found: ${foundConfigs.map((f) => basename(f)).join(", ")}. Please use only one configuration method.`,
+      "https://vercel.com/docs/projects/project-configuration"
+    );
+  }
+  if (!vercelConfigPath && !hasVercelToml) {
+    if (hasVercelJson) {
+      return {
+        configPath: vercelJsonPath,
+        wasCompiled: false
+      };
+    }
+    if (await fileExists(compiledConfigPath)) {
+      return {
+        configPath: compiledConfigPath,
+        wasCompiled: true,
+        sourceFile: await findSourceVercelConfigFile(workPath) ?? void 0
+      };
+    }
+    return {
+      configPath: null,
+      wasCompiled: false
+    };
+  }
+  if (hasVercelToml) {
+    try {
+      const tomlContent = await readFile(vercelTomlPath, "utf8");
+      const config = tomlParse(tomlContent);
+      const normalizedConfig = normalizeConfig(config);
+      await mkdir(vercelDir, { recursive: true });
+      await writeFile(
+        compiledConfigPath,
+        JSON.stringify(normalizedConfig, null, 2),
+        "utf-8"
+      );
+      output_manager_default.debug(`Compiled ${vercelTomlPath} -> ${compiledConfigPath}`);
+      return {
+        configPath: compiledConfigPath,
+        wasCompiled: true,
+        sourceFile: "vercel.toml"
+      };
+    } catch (error) {
+      throw new NowBuildError({
+        code: error.code ?? "vercel_toml_parse_failed",
+        message: `Failed to parse vercel.toml: ${error.message}`,
+        link: error.link ?? "https://vercel.com/docs/projects/project-configuration"
+      });
+    }
+  }
+  const sourceConfigPath = vercelConfigPath;
+  (0, import_dotenv.config)({ path: join(workPath, ".env") });
+  (0, import_dotenv.config)({ path: join(workPath, ".env.local") });
+  const tempOutPath = join(vercelDir, "vercel-temp.mjs");
+  const loaderPath = join(vercelDir, "vercel-loader.mjs");
+  try {
+    const { build } = await import("esbuild");
+    await mkdir(vercelDir, { recursive: true });
+    await build({
+      entryPoints: [sourceConfigPath],
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      outfile: tempOutPath,
+      packages: "external",
+      target: "node20",
+      sourcemap: "inline"
+    });
+    const loaderScript = `
+      import { pathToFileURL } from 'url';
+      const configModule = await import(pathToFileURL(process.argv[2]).href);
+      const config = ('default' in configModule) ? configModule.default : ('config' in configModule) ? configModule.config : configModule;
+      process.send(config);
+    `;
+    await writeFile(loaderPath, loaderScript, "utf-8");
+    const config = await new Promise((resolve, reject) => {
+      const child = fork(loaderPath, [tempOutPath], {
+        execPath: getNodeExecPath(),
+        stdio: ["pipe", "pipe", "pipe", "ipc"]
+      });
+      let stderrOutput = "";
+      let stdoutOutput = "";
+      if (child.stderr) {
+        child.stderr.on("data", (data) => {
+          stderrOutput += data.toString();
+        });
+      }
+      if (child.stdout) {
+        child.stdout.on("data", (data) => {
+          stdoutOutput += data.toString();
+        });
+      }
+      const timeout = setTimeout(() => {
+        child.kill();
+        reject(new Error("Config loader timed out after 10 seconds"));
+      }, 1e4);
+      child.on("message", (message) => {
+        clearTimeout(timeout);
+        child.kill();
+        resolve(message);
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timeout);
+        if (code !== 0) {
+          if (stderrOutput.trim()) {
+            output_manager_default.log(stderrOutput);
+          }
+          if (stdoutOutput.trim()) {
+            output_manager_default.log(stdoutOutput);
+          }
+          const parsedError = parseConfigLoaderError(stderrOutput);
+          if (parsedError) {
+            reject(new Error(parsedError));
+          } else if (stdoutOutput.trim()) {
+            reject(new Error(stdoutOutput.trim()));
+          } else {
+            reject(new Error(`Config loader exited with code ${code}`));
+          }
+        }
+      });
+    });
+    const normalizedConfig = normalizeConfig(config);
+    await writeFile(
+      compiledConfigPath,
+      JSON.stringify(normalizedConfig, null, 2),
+      "utf-8"
+    );
+    output_manager_default.debug(`Compiled ${sourceConfigPath} -> ${compiledConfigPath}`);
+    return {
+      configPath: compiledConfigPath,
+      wasCompiled: true,
+      sourceFile: await findSourceVercelConfigFile(workPath) ?? void 0
+    };
+  } catch (error) {
+    throw new NowBuildError({
+      code: error.code ?? "vercel_ts_compilation_failed",
+      message: `Failed to compile ${basename(sourceConfigPath)}: ${error.message}`,
+      link: error.link ?? "https://vercel.com/docs/projects/project-configuration"
+    });
+  } finally {
+    await Promise.all([
+      unlink(tempOutPath).catch((err) => {
+        if (err.code !== "ENOENT") {
+          output_manager_default.debug(`Failed to cleanup temp file: ${err}`);
+        }
+      }),
+      unlink(loaderPath).catch((err) => {
+        if (err.code !== "ENOENT") {
+          output_manager_default.debug(`Failed to cleanup loader file: ${err}`);
+        }
+      })
+    ]);
+  }
+}
+async function getVercelConfigPath(workPath) {
+  const vercelJsonPath = join(workPath, "vercel.json");
+  const vercelTomlPath = join(workPath, "vercel.toml");
+  const compiledConfigPath = join(workPath, VERCEL_DIR, "vercel.json");
+  if (await fileExists(vercelJsonPath)) {
+    return vercelJsonPath;
+  }
+  if (await fileExists(vercelTomlPath)) {
+    return vercelTomlPath;
+  }
+  if (await fileExists(compiledConfigPath)) {
+    return compiledConfigPath;
+  }
+  return vercelJsonPath;
+}
+
+export {
+  require_main,
+  normalizeConfig,
+  VERCEL_CONFIG_EXTENSIONS,
+  DEFAULT_VERCEL_CONFIG_FILENAME,
+  findSourceVercelConfigFile,
+  compileVercelConfig,
+  getVercelConfigPath
+};

package/dist/chunks/chunk-RN6V5ODW.js

@@ -0,0 +1,114 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  CertConfigurationError,
+  CertError,
+  DeploymentNotFound,
+  DeploymentPermissionDenied,
+  DomainNotFound,
+  InvalidDeploymentId,
+  TooManyRequests,
+  isAPIError
+} from "./chunk-CV5YC2EN.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+
+// src/util/parse-target.ts
+function parseTarget({
+  flagName,
+  flags
+}) {
+  const targetFlagName = `--${flagName}`;
+  const targetFlagValue = flags[targetFlagName];
+  const prodFlagValue = flags["--prod"];
+  if (prodFlagValue && targetFlagValue) {
+    output_manager_default.warn(
+      `Both \`--prod\` and \`${targetFlagName}\` detected. Ignoring \`--prod\`.`
+    );
+  }
+  if (typeof targetFlagValue === "string") {
+    output_manager_default.debug(`Setting target to ${targetFlagValue}`);
+    return targetFlagValue;
+  }
+  if (prodFlagValue) {
+    output_manager_default.debug("Setting target to production");
+    return "production";
+  }
+  return void 0;
+}
+
+// src/util/to-host.ts
+function toHost(url) {
+  return url.replace(/^(?:.*?\/\/)?([^/]+).*/, "$1");
+}
+
+// src/util/certs/map-cert-error.ts
+function mapCertError(error, cns) {
+  const errorCode = error.code;
+  if (errorCode === "too_many_requests") {
+    const retryAfter = typeof error.retryAfterMs === "number" ? error.retryAfterMs : 0;
+    return new TooManyRequests("certificates", retryAfter);
+  }
+  if (errorCode === "not_found") {
+    return new DomainNotFound(error.domain);
+  }
+  if (errorCode === "configuration_error") {
+    return new CertConfigurationError({
+      cns: cns || error.cns || [],
+      message: error.message,
+      external: error.external,
+      helpUrl: error.helpUrl,
+      type: error.statusCode === 449 ? "http-01" : "dns-01"
+    });
+  }
+  if (errorCode === "bad_domains" || errorCode === "challenge_still_pending" || errorCode === "common_name_domain_name_mismatch" || errorCode === "conflicting_caa_record" || errorCode === "domain_not_verified" || errorCode === "invalid_cn" || errorCode === "invalid_domain" || errorCode === "rate_limited" || errorCode === "should_share_root_domain" || errorCode === "unauthorized_request_error" || errorCode === "unsupported_challenge_priority" || errorCode === "wildcard_not_allowed" || errorCode === "validation_running" || errorCode === "dns_error" || errorCode === "challenge_error" || errorCode === "txt_record_not_found") {
+    return new CertError({
+      cns: cns || error.cns || [],
+      code: errorCode,
+      message: error.message,
+      helpUrl: error.helpUrl
+    });
+  }
+  return null;
+}
+
+// src/util/get-deployment.ts
+async function getDeployment(client, contextName, hostOrId) {
+  if (hostOrId.includes(".")) {
+    hostOrId = toHost(hostOrId);
+  }
+  try {
+    return await client.fetch(
+      `/v13/deployments/${encodeURIComponent(hostOrId)}`
+    );
+  } catch (err) {
+    if (isAPIError(err)) {
+      if (err.status === 404) {
+        throw new DeploymentNotFound({ id: hostOrId, context: contextName });
+      }
+      if (err.status === 403) {
+        throw new DeploymentPermissionDenied(hostOrId, contextName);
+      }
+      if (err.status === 400 && err.message.includes("`id`")) {
+        throw new InvalidDeploymentId(hostOrId);
+      }
+      const certError = mapCertError(err);
+      if (certError) {
+        throw certError;
+      }
+    }
+    throw err;
+  }
+}
+
+export {
+  parseTarget,
+  mapCertError,
+  toHost,
+  getDeployment
+};

package/dist/chunks/chunk-RVBZ64EQ.js

@@ -0,0 +1,52 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  require_dist2 as require_dist
+} from "./chunk-332LMJLZ.js";
+import {
+  require_frameworks
+} from "./chunk-FRVG4OW3.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/util/projects/detect-projects.ts
+var import_frameworks = __toESM(require_frameworks(), 1);
+var import_fs_detectors = __toESM(require_dist(), 1);
+import { join } from "path";
+async function detectProjects(cwd) {
+  const fs = new import_fs_detectors.LocalFileSystemDetector(cwd);
+  const workspaces = await (0, import_fs_detectors.getWorkspaces)({ fs });
+  const detectedProjects = /* @__PURE__ */ new Map();
+  const packagePaths = (await Promise.all(
+    workspaces.map(
+      (workspace) => (0, import_fs_detectors.getWorkspacePackagePaths)({
+        fs,
+        workspace
+      })
+    )
+  )).flat();
+  if (packagePaths.length === 0) {
+    packagePaths.push("/");
+  }
+  await Promise.all(
+    packagePaths.map(async (p) => {
+      const frameworks = await (0, import_fs_detectors.detectFrameworks)({
+        fs: fs.chdir(join(".", p)),
+        frameworkList: import_frameworks.frameworkList
+      });
+      if (frameworks.length === 0)
+        return;
+      detectedProjects.set(p.slice(1), frameworks);
+    })
+  );
+  return detectedProjects;
+}
+
+export {
+  detectProjects
+};

package/dist/chunks/chunk-SHFNEZVI.js

@@ -0,0 +1,49 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  require_json_parse_better_errors
+} from "./chunk-6E6KPBXY.js";
+import {
+  require_lib
+} from "./chunk-2TSBB22D.js";
+import {
+  CantParseJSONFile
+} from "./chunk-CV5YC2EN.js";
+import {
+  require_dist
+} from "./chunk-ZW6HETRE.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/util/read-json-file.ts
+var import_fs_extra = __toESM(require_lib(), 1);
+var import_json_parse_better_errors = __toESM(require_json_parse_better_errors(), 1);
+var import_error_utils = __toESM(require_dist(), 1);
+async function readJSONFile(file) {
+  const content = await readFileSafe(file);
+  if (content === null) {
+    return content;
+  }
+  try {
+    const json = (0, import_json_parse_better_errors.default)(content);
+    return json;
+  } catch (error) {
+    return new CantParseJSONFile(file, (0, import_error_utils.errorToString)(error));
+  }
+}
+async function readFileSafe(file) {
+  try {
+    return await import_fs_extra.default.readFile(file, "utf8");
+  } catch (_) {
+    return null;
+  }
+}
+
+export {
+  readJSONFile
+};