vercel-cli 41.1.0__py3-none-any.whl

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/node-version.js

@@ -0,0 +1,180 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_version_exports = {};
+__export(node_version_exports, {
+  NODE_VERSIONS: () => NODE_VERSIONS,
+  getAvailableNodeVersions: () => getAvailableNodeVersions,
+  getDiscontinuedNodeVersions: () => getDiscontinuedNodeVersions,
+  getLatestNodeVersion: () => getLatestNodeVersion,
+  getSupportedNodeVersion: () => getSupportedNodeVersion
+});
+module.exports = __toCommonJS(node_version_exports);
+var import_fs = require("fs");
+var import_semver = require("semver");
+var import_types = require("../types");
+var import_errors = require("../errors");
+var import_debug = __toESM(require("../debug"));
+const NODE_VERSIONS = [
+  new import_types.NodeVersion({
+    major: 22,
+    range: "22.x",
+    runtime: "nodejs22.x"
+  }),
+  new import_types.NodeVersion({
+    major: 20,
+    range: "20.x",
+    runtime: "nodejs20.x"
+  }),
+  new import_types.NodeVersion({
+    major: 18,
+    range: "18.x",
+    runtime: "nodejs18.x"
+  }),
+  new import_types.NodeVersion({
+    major: 16,
+    range: "16.x",
+    runtime: "nodejs16.x",
+    discontinueDate: /* @__PURE__ */ new Date("2025-02-03")
+  }),
+  new import_types.NodeVersion({
+    major: 14,
+    range: "14.x",
+    runtime: "nodejs14.x",
+    discontinueDate: /* @__PURE__ */ new Date("2023-08-15")
+  }),
+  new import_types.NodeVersion({
+    major: 12,
+    range: "12.x",
+    runtime: "nodejs12.x",
+    discontinueDate: /* @__PURE__ */ new Date("2022-10-03")
+  }),
+  new import_types.NodeVersion({
+    major: 10,
+    range: "10.x",
+    runtime: "nodejs10.x",
+    discontinueDate: /* @__PURE__ */ new Date("2021-04-20")
+  }),
+  new import_types.NodeVersion({
+    major: 8,
+    range: "8.10.x",
+    runtime: "nodejs8.10",
+    discontinueDate: /* @__PURE__ */ new Date("2020-01-06")
+  })
+];
+function getOptions() {
+  return NODE_VERSIONS;
+}
+function isNodeVersionAvailable(version) {
+  try {
+    return (0, import_fs.statSync)(`/node${version.major}`).isDirectory();
+  } catch {
+  }
+  return false;
+}
+function getAvailableNodeVersions() {
+  return getOptions().filter(isNodeVersionAvailable).map((n) => n.major);
+}
+function getHint(isAuto = false, availableVersions) {
+  const { major, range } = getLatestNodeVersion(availableVersions);
+  return isAuto ? `Please set Node.js Version to ${range} in your Project Settings to use Node.js ${major}.` : `Please set "engines": { "node": "${range}" } in your \`package.json\` file to use Node.js ${major}.`;
+}
+function getLatestNodeVersion(availableVersions) {
+  const all = getOptions();
+  if (availableVersions) {
+    for (const version of all) {
+      for (const major of availableVersions) {
+        if (version.major === major) {
+          return version;
+        }
+      }
+    }
+  }
+  return all[0];
+}
+function getDiscontinuedNodeVersions() {
+  return getOptions().filter((version) => {
+    return version.state === "discontinued";
+  });
+}
+async function getSupportedNodeVersion(engineRange, isAuto = false, availableVersions) {
+  let selection;
+  if (engineRange) {
+    const found = (0, import_semver.validRange)(engineRange) && getOptions().some((o) => {
+      selection = o;
+      return (0, import_semver.intersects)(o.range, engineRange) && (availableVersions?.length ? availableVersions.includes(o.major) : true);
+    });
+    if (!found) {
+      throw new import_errors.NowBuildError({
+        code: "BUILD_UTILS_NODE_VERSION_INVALID",
+        link: "http://vercel.link/node-version",
+        message: `Found invalid Node.js Version: "${engineRange}". ${getHint(
+          isAuto,
+          availableVersions
+        )}`
+      });
+    }
+  }
+  if (!selection) {
+    selection = getLatestNodeVersion(availableVersions);
+  }
+  if (selection.state === "discontinued") {
+    const intro = `Node.js Version "${selection.range}" is discontinued and must be upgraded.`;
+    throw new import_errors.NowBuildError({
+      code: "BUILD_UTILS_NODE_VERSION_DISCONTINUED",
+      link: "http://vercel.link/node-version",
+      message: `${intro} ${getHint(isAuto)}`
+    });
+  }
+  (0, import_debug.default)(`Selected Node.js ${selection.range}`);
+  if (selection.state === "deprecated") {
+    const d = selection.formattedDate;
+    if (d) {
+      console.warn(
+        `Error: Node.js version ${selection.range} is deprecated. Deployments created on or after ${d} will fail to build. ${getHint(
+          isAuto
+        )}`
+      );
+    } else {
+      console.warn(
+        `Error: Node.js version ${selection.range} is deprecated. ${getHint(
+          isAuto
+        )}`
+      );
+    }
+  }
+  return selection;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NODE_VERSIONS,
+  getAvailableNodeVersions,
+  getDiscontinuedNodeVersions,
+  getLatestNodeVersion,
+  getSupportedNodeVersion
+});

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/normalize-path.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Convert Windows separators to Unix separators.
+ */
+export declare function normalizePath(p: string): string;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/normalize-path.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var normalize_path_exports = {};
+__export(normalize_path_exports, {
+  normalizePath: () => normalizePath
+});
+module.exports = __toCommonJS(normalize_path_exports);
+const isWin = process.platform === "win32";
+function normalizePath(p) {
+  return isWin ? p.replace(/\\/g, "/") : p;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizePath
+});

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/read-config-file.d.ts

@@ -0,0 +1 @@
+export declare function readConfigFile<T>(files: string | string[]): Promise<T | null>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/read-config-file.js

@@ -0,0 +1,76 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var read_config_file_exports = {};
+__export(read_config_file_exports, {
+  readConfigFile: () => readConfigFile
+});
+module.exports = __toCommonJS(read_config_file_exports);
+var import_js_yaml = __toESM(require("js-yaml"));
+var import_toml = __toESM(require("@iarna/toml"));
+var import_fs_extra = require("fs-extra");
+var import_error_utils = require("@vercel/error-utils");
+async function readFileOrNull(file) {
+  try {
+    const data = await (0, import_fs_extra.readFile)(file);
+    return data;
+  } catch (error) {
+    if (!(0, import_error_utils.isErrnoException)(error)) {
+      throw error;
+    }
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return null;
+}
+async function readConfigFile(files) {
+  files = Array.isArray(files) ? files : [files];
+  for (const name of files) {
+    const data = await readFileOrNull(name);
+    if (data) {
+      const str = data.toString("utf8");
+      try {
+        if (name.endsWith(".json")) {
+          return JSON.parse(str);
+        } else if (name.endsWith(".toml")) {
+          return import_toml.default.parse(str);
+        } else if (name.endsWith(".yaml") || name.endsWith(".yml")) {
+          return import_js_yaml.default.safeLoad(str, { filename: name });
+        }
+      } catch (error) {
+        console.log(`Error while parsing config file: "${name}"`);
+      }
+    }
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readConfigFile
+});

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/rename.d.ts

@@ -0,0 +1,11 @@
+import { Files } from '../types';
+type Delegate = (name: string) => string;
+/**
+ * Renames the keys of a `Files` map.
+ *
+ * @param files A map of filenames to `File` instances
+ * @param delegate A function that returns the new filename
+ * @returns A new file map with the renamed filenames
+ */
+export default function rename(files: Files, delegate: Delegate): Files;
+export {};

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/rename.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rename_exports = {};
+__export(rename_exports, {
+  default: () => rename
+});
+module.exports = __toCommonJS(rename_exports);
+function rename(files, delegate) {
+  const result = {};
+  for (const [name, file] of Object.entries(files)) {
+    result[delegate(name)] = file;
+  }
+  return result;
+}

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/run-user-scripts.d.ts

@@ -0,0 +1,206 @@
+/// <reference types="node" />
+import { SpawnOptions } from 'child_process';
+import { Meta, PackageJson, NodeVersion, Config } from '../types';
+export type CliType = 'yarn' | 'npm' | 'pnpm' | 'bun';
+export interface ScanParentDirsResult {
+    /**
+     * "yarn", "npm", or "pnpm" depending on the presence of lockfiles.
+     */
+    cliType: CliType;
+    /**
+     * The file path of found `package.json` file, or `undefined` if not found.
+     */
+    packageJsonPath?: string;
+    /**
+     * The contents of found `package.json` file, when the `readPackageJson`
+     * option is enabled.
+     */
+    packageJson?: PackageJson;
+    /**
+     * The file path of the lockfile (`yarn.lock`, `package-lock.json`, or `pnpm-lock.yaml`)
+     * or `undefined` if not found.
+     */
+    lockfilePath?: string;
+    /**
+     * The `lockfileVersion` number from lockfile (`package-lock.json` or `pnpm-lock.yaml`),
+     * or `undefined` if not found.
+     */
+    lockfileVersion?: number;
+    /**
+     * The contents of the `packageManager` field from `package.json` if found.
+     * The value may come from a different `package.json` file than the one
+     * specified by `packageJsonPath`, in the case of a monorepo.
+     */
+    packageJsonPackageManager?: string;
+    /**
+     * Whether Turborepo supports the `COREPACK_HOME` environment variable.
+     * `undefined` if not a Turborepo project.
+     */
+    turboSupportsCorepackHome?: boolean;
+}
+export interface TraverseUpDirectoriesProps {
+    /**
+     * The directory to start iterating from, typically the same directory of the entrypoint.
+     */
+    start: string;
+    /**
+     * The highest directory, typically the workPath root of the project.
+     */
+    base?: string;
+}
+export interface WalkParentDirsProps extends Required<TraverseUpDirectoriesProps> {
+    /**
+     * The name of the file to search for, typically `package.json` or `Gemfile`.
+     */
+    filename: string;
+}
+export interface WalkParentDirsMultiProps extends Required<TraverseUpDirectoriesProps> {
+    /**
+     * The name of the file to search for, typically `package.json` or `Gemfile`.
+     */
+    filenames: string[];
+}
+export interface SpawnOptionsExtended extends SpawnOptions {
+    /**
+     * Pretty formatted command that is being spawned for logging purposes.
+     */
+    prettyCommand?: string;
+    /**
+     * Returns instead of throwing an error when the process exits with a
+     * non-0 exit code. When relevant, the returned object will include
+     * the error code, stdout and stderr.
+     */
+    ignoreNon0Exit?: boolean;
+}
+export declare function spawnAsync(command: string, args: string[], opts?: SpawnOptionsExtended): Promise<void>;
+export declare function spawnCommand(command: string, options?: SpawnOptions): import("child_process").ChildProcess;
+export declare function execCommand(command: string, options?: SpawnOptions): Promise<boolean>;
+export declare function traverseUpDirectories({ start, base, }: TraverseUpDirectoriesProps): Generator<string, void, unknown>;
+/**
+ * @deprecated Use `getNodeBinPaths()` instead.
+ */
+export declare function getNodeBinPath({ cwd, }: {
+    cwd: string;
+}): Promise<string>;
+export declare function getNodeBinPaths({ start, base, }: TraverseUpDirectoriesProps): string[];
+export declare function runShellScript(fsPath: string, args?: string[], spawnOpts?: SpawnOptions): Promise<boolean>;
+export declare function getSpawnOptions(meta: Meta, nodeVersion: NodeVersion): SpawnOptions;
+export declare function getNodeVersion(destPath: string, fallbackVersion?: string | undefined, config?: Config, meta?: Meta, availableVersions?: number[]): Promise<NodeVersion>;
+export declare function scanParentDirs(destPath: string, readPackageJson?: boolean, base?: string): Promise<ScanParentDirsResult>;
+export declare function turboVersionSpecifierSupportsCorepack(turboVersionSpecifier: string): boolean;
+export declare function usingCorepack(env: {
+    [x: string]: string | undefined;
+}, packageJsonPackageManager: string | undefined, turboSupportsCorepackHome: boolean | undefined): boolean;
+export declare function walkParentDirs({ base, start, filename, }: WalkParentDirsProps): Promise<string | null>;
+export declare function runNpmInstall(destPath: string, args?: string[], spawnOpts?: SpawnOptions, meta?: Meta, nodeVersion?: NodeVersion): Promise<boolean>;
+/**
+ * Prepares the input environment based on the used package manager and lockfile
+ * versions.
+ */
+export declare function getEnvForPackageManager({ cliType, lockfileVersion, packageJsonPackageManager, nodeVersion, env, packageJsonEngines, turboSupportsCorepackHome, }: {
+    cliType: CliType;
+    lockfileVersion: number | undefined;
+    packageJsonPackageManager?: string | undefined;
+    nodeVersion: NodeVersion | undefined;
+    env: {
+        [x: string]: string | undefined;
+    };
+    packageJsonEngines?: PackageJson.Engines;
+    turboSupportsCorepackHome?: boolean | undefined;
+}): {
+    [x: string]: string | undefined;
+};
+/**
+ * Helper to get the binary paths that link to the used package manager.
+ * Note: Make sure it doesn't contain any `console.log` calls.
+ */
+export declare function getPathOverrideForPackageManager({ cliType, lockfileVersion, corepackPackageManager, corepackEnabled, packageJsonEngines, }: {
+    cliType: CliType;
+    lockfileVersion: number | undefined;
+    corepackPackageManager: string | undefined;
+    nodeVersion: NodeVersion | undefined;
+    corepackEnabled?: boolean;
+    packageJsonEngines?: PackageJson.Engines;
+}): {
+    /**
+     * Which lockfile was detected.
+     */
+    detectedLockfile: string | undefined;
+    /**
+     * Detected package manager that generated the found lockfile.
+     */
+    detectedPackageManager: string | undefined;
+    /**
+     * Value of $PATH that includes the binaries for the detected package manager.
+     * Undefined if no $PATH are necessary.
+     */
+    path: string | undefined;
+};
+export declare function detectPackageManager(cliType: CliType, lockfileVersion: number | undefined): {
+    path: string;
+    detectedLockfile: string;
+    detectedPackageManager: string;
+    pnpmVersionRange: string;
+} | {
+    path: undefined;
+    detectedLockfile: string;
+    detectedPackageManager: string;
+    pnpmVersionRange: string;
+} | {
+    path: string;
+    detectedLockfile: string;
+    detectedPackageManager: string;
+    pnpmVersionRange?: undefined;
+} | {
+    path: undefined;
+    detectedLockfile: string;
+    detectedPackageManager: string;
+    pnpmVersionRange?: undefined;
+} | undefined;
+/**
+ * Helper to get the binary paths that link to the used package manager.
+ * Note: Make sure it doesn't contain any `console.log` calls.
+ * @deprecated use `getEnvForPackageManager` instead
+ */
+export declare function getPathForPackageManager({ cliType, lockfileVersion, nodeVersion, env, }: {
+    cliType: CliType;
+    lockfileVersion: number | undefined;
+    nodeVersion: NodeVersion | undefined;
+    env: {
+        [x: string]: string | undefined;
+    };
+}): {
+    /**
+     * Which lockfile was detected.
+     */
+    detectedLockfile: string | undefined;
+    /**
+     * Detected package manager that generated the found lockfile.
+     */
+    detectedPackageManager: string | undefined;
+    /**
+     * Value of $PATH that includes the binaries for the detected package manager.
+     * Undefined if no $PATH are necessary.
+     */
+    path: string | undefined;
+    /**
+     * Set if yarn was identified as package manager and `YARN_NODE_LINKER`
+     * environment variable was not found on the input environment.
+     */
+    yarnNodeLinker: string | undefined;
+};
+export declare function runCustomInstallCommand({ destPath, installCommand, nodeVersion, spawnOpts, }: {
+    destPath: string;
+    installCommand: string;
+    nodeVersion: NodeVersion;
+    spawnOpts?: SpawnOptions;
+}): Promise<void>;
+export declare function runPackageJsonScript(destPath: string, scriptNames: string | Iterable<string>, spawnOpts?: SpawnOptions): Promise<boolean>;
+export declare function runBundleInstall(destPath: string, args?: string[], spawnOpts?: SpawnOptions, meta?: Meta): Promise<void>;
+export declare function runPipInstall(destPath: string, args?: string[], spawnOpts?: SpawnOptions, meta?: Meta): Promise<void>;
+export declare function getScriptName(pkg: Pick<PackageJson, 'scripts'> | null | undefined, possibleNames: Iterable<string>): string | undefined;
+/**
+ * @deprecate installDependencies() is deprecated.
+ * Please use runNpmInstall() instead.
+ */
+export declare const installDependencies: typeof runNpmInstall;