@vercel/client 17.6.0 → 17.6.2

package/dist/collect-deployment-files.d.ts

@@ -0,0 +1,14 @@
+import type { VercelClientOptions } from './types';
+import { type Debug } from './utils';
+import { type FilesMap } from './utils/hashes';
+type CollectDeploymentFilesOptions = Pick<VercelClientOptions, 'archive' | 'bulkRedirectsPath' | 'isDirectory' | 'prebuilt' | 'projectName' | 'rootDirectory' | 'vercelOutputDir'>;
+export interface CollectedDeploymentFiles {
+    fileList: string[];
+    filesMap: FilesMap;
+    workPath: string;
+    isDirectory: boolean;
+    ignoreList: string[];
+}
+export declare function assertDeploymentPath(path: VercelClientOptions['path'] | undefined, debug: Debug): asserts path is VercelClientOptions['path'];
+export declare function collectDeploymentFiles(path: VercelClientOptions['path'] | undefined, clientOptions: CollectDeploymentFilesOptions, debug: Debug): Promise<CollectedDeploymentFiles>;
+export {};

package/dist/collect-deployment-files.js

@@ -0,0 +1,95 @@
+"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 collect_deployment_files_exports = {};
+__export(collect_deployment_files_exports, {
+  assertDeploymentPath: () => assertDeploymentPath,
+  collectDeploymentFiles: () => collectDeploymentFiles
+});
+module.exports = __toCommonJS(collect_deployment_files_exports);
+var import_error_utils = require("@vercel/error-utils");
+var import_fs_extra = require("fs-extra");
+var import_path = require("path");
+var import_errors = require("./errors");
+var import_utils = require("./utils");
+var import_archive = require("./utils/archive");
+var import_hashes = require("./utils/hashes");
+function assertDeploymentPath(path, debug) {
+  if (typeof path !== "string" && !Array.isArray(path)) {
+    debug(
+      `Error: 'path' is expected to be a string or an array. Received ${typeof path}`
+    );
+    throw new import_errors.DeploymentError({
+      code: "missing_path",
+      message: "Path not provided"
+    });
+  }
+}
+async function collectDeploymentFiles(path, clientOptions, debug) {
+  assertDeploymentPath(path, debug);
+  const isDirectory = !Array.isArray(path) && (0, import_fs_extra.lstatSync)(path).isDirectory();
+  clientOptions.isDirectory = isDirectory;
+  if (Array.isArray(path)) {
+    for (const filePath of path) {
+      if (!(0, import_path.isAbsolute)(filePath)) {
+        throw new import_errors.DeploymentError({
+          code: "invalid_path",
+          message: `Provided path ${filePath} is not absolute`
+        });
+      }
+    }
+  } else if (!(0, import_path.isAbsolute)(path)) {
+    throw new import_errors.DeploymentError({
+      code: "invalid_path",
+      message: `Provided path ${path} is not absolute`
+    });
+  }
+  if (isDirectory && !Array.isArray(path)) {
+    debug(`Provided 'path' is a directory.`);
+  } else if (Array.isArray(path)) {
+    debug(`Provided 'path' is an array of file paths`);
+  } else {
+    debug(`Provided 'path' is a single file`);
+  }
+  const { fileList, ignoreList } = await (0, import_utils.buildFileTree)(
+    path,
+    clientOptions,
+    debug
+  );
+  const workPath = typeof path === "string" ? path : path[0];
+  let filesMap;
+  try {
+    filesMap = clientOptions.archive === "tgz" ? await (0, import_archive.createTgzFiles)(workPath, fileList, debug) : await (0, import_hashes.hashes)(fileList);
+  } catch (err) {
+    if (clientOptions.prebuilt && (0, import_error_utils.isErrnoException)(err) && err.code === "ENOENT" && err.path) {
+      const errPath = (0, import_path.relative)(workPath, err.path);
+      err.message = `File does not exist: "${(0, import_path.relative)(workPath, errPath)}"`;
+      if (errPath.split(import_path.sep).includes("node_modules")) {
+        err.message = `Please ensure project dependencies have been installed:
+${err.message}`;
+      }
+    }
+    throw err;
+  }
+  return { fileList, filesMap, workPath, isDirectory, ignoreList };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertDeploymentPath,
+  collectDeploymentFiles
+});

package/dist/create-deployment.js

@@ -21,29 +21,18 @@ __export(create_deployment_exports, {
   default: () => buildCreateDeployment
 });
 module.exports = __toCommonJS(create_deployment_exports);
-var import_fs_extra = require("fs-extra");
-var import_path = require("path");
 var import_hashes = require("./utils/hashes");
 var import_deploy = require("./deploy");
 var import_upload = require("./upload");
 var import_utils = require("./utils");
 var import_errors = require("./errors");
-var import_error_utils = require("@vercel/error-utils");
-var import_archive = require("./utils/archive");
+var import_collect_deployment_files = require("./collect-deployment-files");
 function buildCreateDeployment() {
   return async function* createDeployment(clientOptions, deploymentOptions = {}) {
     const { path } = clientOptions;
     const debug = (0, import_utils.createDebug)(clientOptions.debug);
     debug("Creating deployment...");
-    if (typeof path !== "string" && !Array.isArray(path)) {
-      debug(
-        `Error: 'path' is expected to be a string or an array. Received ${typeof path}`
-      );
-      throw new import_errors.DeploymentError({
-        code: "missing_path",
-        message: "Path not provided"
-      });
-    }
+    (0, import_collect_deployment_files.assertDeploymentPath)(path, debug);
     if (typeof clientOptions.token !== "string") {
       debug(
         `Error: 'token' is expected to be a string. Received ${typeof clientOptions.token}`
@@ -69,30 +58,11 @@ function buildCreateDeployment() {
       yield* (0, import_deploy.deploy)(/* @__PURE__ */ new Map(), clientOptions, deploymentOptions);
       return;
     }
-    clientOptions.isDirectory = !Array.isArray(path) && (0, import_fs_extra.lstatSync)(path).isDirectory();
-    if (Array.isArray(path)) {
-      for (const filePath of path) {
-        if (!(0, import_path.isAbsolute)(filePath)) {
-          throw new import_errors.DeploymentError({
-            code: "invalid_path",
-            message: `Provided path ${filePath} is not absolute`
-          });
-        }
-      }
-    } else if (!(0, import_path.isAbsolute)(path)) {
-      throw new import_errors.DeploymentError({
-        code: "invalid_path",
-        message: `Provided path ${path} is not absolute`
-      });
-    }
-    if (clientOptions.isDirectory && !Array.isArray(path)) {
-      debug(`Provided 'path' is a directory.`);
-    } else if (Array.isArray(path)) {
-      debug(`Provided 'path' is an array of file paths`);
-    } else {
-      debug(`Provided 'path' is a single file`);
-    }
-    const { fileList } = await (0, import_utils.buildFileTree)(path, clientOptions, debug);
+    const { fileList, filesMap: files } = await (0, import_collect_deployment_files.collectDeploymentFiles)(
+      path,
+      clientOptions,
+      debug
+    );
     if (fileList.length === 0) {
       debug("Deployment path has no files. Yielding a warning event");
       yield {
@@ -100,25 +70,6 @@ function buildCreateDeployment() {
         payload: "There are no files inside your deployment."
       };
     }
-    const workPath = typeof path === "string" ? path : path[0];
-    let files;
-    try {
-      if (clientOptions.archive === "tgz") {
-        files = await (0, import_archive.createTgzFiles)(workPath, fileList, debug);
-      } else {
-        files = await (0, import_hashes.hashes)(fileList);
-      }
-    } catch (err) {
-      if (clientOptions.prebuilt && (0, import_error_utils.isErrnoException)(err) && err.code === "ENOENT" && err.path) {
-        const errPath = (0, import_path.relative)(workPath, err.path);
-        err.message = `File does not exist: "${(0, import_path.relative)(workPath, errPath)}"`;
-        if (errPath.split(import_path.sep).includes("node_modules")) {
-          err.message = `Please ensure project dependencies have been installed:
-${err.message}`;
-        }
-      }
-      throw err;
-    }
     debug(`Yielding a 'hashes-calculated' event with ${files.size} hashes`);
     yield { type: "hashes-calculated", payload: (0, import_hashes.mapToObject)(files) };
     if (clientOptions.apiUrl) {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { continueDeployment } from './continue';
 export { checkDeploymentStatus } from './check-deployment-status';
+export { inspectDeploymentFiles } from './inspect-deployment-files';
 export { getVercelIgnore, buildFileTree } from './utils/index';
 export declare const createDeployment: (clientOptions: import("./types").VercelClientOptions, deploymentOptions?: import("./types").DeploymentOptions) => AsyncIterableIterator<{
     type: import("./types").DeploymentEventType;

package/dist/index.js

@@ -33,12 +33,14 @@ __export(src_exports, {
   checkDeploymentStatus: () => import_check_deployment_status.checkDeploymentStatus,
   continueDeployment: () => import_continue.continueDeployment,
   createDeployment: () => createDeployment,
-  getVercelIgnore: () => import_utils.getVercelIgnore
+  getVercelIgnore: () => import_utils.getVercelIgnore,
+  inspectDeploymentFiles: () => import_inspect_deployment_files.inspectDeploymentFiles
 });
 module.exports = __toCommonJS(src_exports);
 var import_create_deployment = __toESM(require("./create-deployment"));
 var import_continue = require("./continue");
 var import_check_deployment_status = require("./check-deployment-status");
+var import_inspect_deployment_files = require("./inspect-deployment-files");
 var import_utils = require("./utils/index");
 __reExport(src_exports, require("./errors"), module.exports);
 __reExport(src_exports, require("./types"), module.exports);
@@ -50,6 +52,7 @@ const createDeployment = (0, import_create_deployment.default)();
   continueDeployment,
   createDeployment,
   getVercelIgnore,
+  inspectDeploymentFiles,
   ...require("./errors"),
   ...require("./types")
 });

package/dist/inspect-deployment-files.d.ts

@@ -0,0 +1,16 @@
+import type { VercelClientOptions } from './types';
+export interface DeploymentFileItem {
+    path: string;
+    size: number;
+    mode: number;
+    sha?: string;
+}
+export interface DeploymentFileSummary {
+    basePath: string;
+    fileCount: number;
+    totalSize: number;
+    ignoredCount: number;
+    files: DeploymentFileItem[];
+    ignored: string[];
+}
+export declare function inspectDeploymentFiles(clientOptions: Pick<VercelClientOptions, 'archive' | 'bulkRedirectsPath' | 'debug' | 'path' | 'prebuilt' | 'projectName' | 'rootDirectory' | 'vercelOutputDir'>): Promise<DeploymentFileSummary>;

package/dist/inspect-deployment-files.js

@@ -0,0 +1,63 @@
+"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 inspect_deployment_files_exports = {};
+__export(inspect_deployment_files_exports, {
+  inspectDeploymentFiles: () => inspectDeploymentFiles
+});
+module.exports = __toCommonJS(inspect_deployment_files_exports);
+var import_path = require("path");
+var import_collect_deployment_files = require("./collect-deployment-files");
+var import_utils = require("./utils");
+async function inspectDeploymentFiles(clientOptions) {
+  const { path } = clientOptions;
+  const debug = (0, import_utils.createDebug)(clientOptions.debug);
+  const { filesMap, workPath, isDirectory, ignoreList } = await (0, import_collect_deployment_files.collectDeploymentFiles)(path, { ...clientOptions }, debug);
+  const files = [];
+  let totalSize = 0;
+  for (const [sha, file] of filesMap) {
+    const size = file.data?.byteLength || file.data?.length || 0;
+    for (const name of file.names) {
+      const pathName = isDirectory ? (0, import_path.relative)(workPath, name) : name.split(import_path.sep).at(-1) || name;
+      const normalizedPath = pathName.split(import_path.sep).join("/");
+      const deploymentFile = {
+        path: normalizedPath,
+        size,
+        mode: file.mode
+      };
+      if (typeof sha !== "undefined") {
+        deploymentFile.sha = sha;
+      }
+      files.push(deploymentFile);
+      totalSize += size;
+    }
+  }
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return {
+    basePath: workPath,
+    fileCount: files.length,
+    totalSize,
+    ignoredCount: ignoreList.length,
+    files,
+    ignored: ignoreList.sort()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inspectDeploymentFiles
+});

package/dist/upload.js

@@ -35,6 +35,7 @@ __export(upload_exports, {
 module.exports = __toCommonJS(upload_exports);
 var import_http = __toESM(require("http"));
 var import_https = __toESM(require("https"));
+var import_fs = require("fs");
 var import_stream = require("stream");
 var import_node_events = require("node:events");
 var import_async_retry = __toESM(require("async-retry"));
@@ -137,27 +138,46 @@ async function* uploadFiles(options) {
           semaphore.release();
           return bail(new Error("Upload aborted"));
         }
-        const { data } = file;
-        if (typeof data === "undefined") {
-          return;
-        }
+        const { data, size, names } = file;
         uploadProgress.bytesUploaded = 0;
-        const body = new import_stream.Readable();
-        const originalRead = body.read.bind(body);
-        body.read = function(...args) {
-          const chunk = originalRead(...args);
-          if (chunk) {
-            uploadProgress.bytesUploaded += chunk.length;
-            uploadProgress.emit("progress");
+        let body;
+        let contentLength;
+        if (typeof data !== "undefined") {
+          contentLength = data.length;
+          const buffered = new import_stream.Readable();
+          const originalRead = buffered.read.bind(buffered);
+          buffered.read = function(...args) {
+            const chunk = originalRead(...args);
+            if (chunk) {
+              uploadProgress.bytesUploaded += chunk.length;
+              uploadProgress.emit("progress");
+            }
+            return chunk;
+          };
+          const chunkSize = 16384;
+          for (let i = 0; i < data.length; i += chunkSize) {
+            const chunk = data.slice(i, i + chunkSize);
+            buffered.push(chunk);
           }
-          return chunk;
-        };
-        const chunkSize = 16384;
-        for (let i = 0; i < data.length; i += chunkSize) {
-          const chunk = data.slice(i, i + chunkSize);
-          body.push(chunk);
+          buffered.push(null);
+          body = buffered;
+        } else if (typeof size === "number") {
+          contentLength = size;
+          const fileStream = (0, import_fs.createReadStream)(names[0]);
+          const counter = new import_stream.Transform({
+            transform(chunk, _encoding, callback) {
+              uploadProgress.bytesUploaded += chunk.length;
+              uploadProgress.emit("progress");
+              callback(null, chunk);
+            }
+          });
+          fileStream.on("error", (err2) => counter.destroy(err2));
+          counter.on("close", () => fileStream.destroy());
+          body = fileStream.pipe(counter);
+        } else {
+          semaphore.release();
+          return;
         }
-        body.push(null);
         let err;
         let result;
         const abortController = new AbortController();
@@ -171,9 +191,9 @@ async function* uploadFiles(options) {
               method: "POST",
               headers: {
                 "Content-Type": "application/octet-stream",
-                "Content-Length": data.length,
+                "Content-Length": contentLength,
                 "x-now-digest": sha,
-                "x-now-size": data.length
+                "x-now-size": contentLength
               },
               body,
               teamId: options.teamId,

package/dist/utils/hashes.d.ts

@@ -2,6 +2,11 @@ export interface DeploymentFile {
     names: string[];
     data?: Buffer;
     mode: number;
+    /**
+     * Byte length of the file's content. Always set for real files; used to send
+     * `Content-Length` when a file is streamed (i.e. has no in-memory `data`).
+     */
+    size?: number;
 }
 export type FilesMap = Map<string | undefined, DeploymentFile>;
 /**

package/dist/utils/hashes.js

@@ -36,9 +36,17 @@ module.exports = __toCommonJS(hashes_exports);
 var import_crypto = require("crypto");
 var import_fs_extra = __toESM(require("fs-extra"));
 var import_async_sema = require("async-sema");
+const MAX_BUFFER_FILE_SIZE = 2 ** 31 - 1;
 function hash(buf) {
   return (0, import_crypto.createHash)("sha1").update(Uint8Array.from(buf)).digest("hex");
 }
+async function hashFile(path) {
+  const digest = (0, import_crypto.createHash)("sha1");
+  for await (const chunk of import_fs_extra.default.createReadStream(path)) {
+    digest.update(Uint8Array.from(chunk));
+  }
+  return digest.digest("hex");
+}
 const mapToObject = (map) => {
   const obj = {};
   for (const [key, value] of map) {
@@ -56,16 +64,23 @@ async function hashes(files, map = /* @__PURE__ */ new Map()) {
       const stat = await import_fs_extra.default.lstat(name);
       const mode = stat.mode;
       let data;
+      let size;
       const isDirectory = stat.isDirectory();
       let h;
       if (!isDirectory) {
         if (stat.isSymbolicLink()) {
           const link = await import_fs_extra.default.readlink(name);
           data = Buffer.from(link, "utf8");
+          size = data.length;
+          h = hash(data);
+        } else if (stat.size > MAX_BUFFER_FILE_SIZE) {
+          size = stat.size;
+          h = await hashFile(name);
         } else {
           data = await import_fs_extra.default.readFile(name);
+          size = data.length;
+          h = hash(data);
         }
-        h = hash(data);
       }
       const entry = map.get(h);
       if (entry) {
@@ -73,7 +88,7 @@ async function hashes(files, map = /* @__PURE__ */ new Map()) {
         names.add(name);
         entry.names = [...names];
       } else {
-        map.set(h, { names: [name], data, mode });
+        map.set(h, { names: [name], data, mode, size });
       }
       semaphore.release();
     })

package/dist/utils/index.d.ts

@@ -35,5 +35,5 @@ export interface PreparedFile {
 }
 export declare const prepareFiles: (files: FilesMap, clientOptions: VercelClientOptions) => PreparedFile[];
 export declare function createDebug(debug?: boolean): (...logs: string[]) => void;
-type Debug = ReturnType<typeof createDebug>;
+export type Debug = ReturnType<typeof createDebug>;
 export {};

package/dist/utils/index.js

@@ -341,7 +341,7 @@ const prepareFiles = (files, clientOptions) => {
       }
       preparedFiles.push({
         file: isWin ? fileName.replace(/\\/g, "/") : fileName,
-        size: file.data?.byteLength || file.data?.length,
+        size: file.data?.byteLength ?? file.size,
         mode: file.mode,
         sha: sha || void 0
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/client",
-  "version": "17.6.0",
+  "version": "17.6.2",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "homepage": "https://vercel.com",
@@ -39,9 +39,9 @@
     "querystring": "^0.2.0",
     "sleep-promise": "8.0.1",
     "tar-fs": "1.16.3",
-    "@vercel/build-utils": "13.32.0",
-    "@vercel/error-utils": "2.2.0",
-    "@vercel/routing-utils": "6.3.1"
+    "@vercel/routing-utils": "6.4.0",
+    "@vercel/build-utils": "13.32.1",
+    "@vercel/error-utils": "2.2.0"
   },
   "scripts": {
     "build": "node ../../utils/build.mjs",