@vercel/build-utils 7.1.0 → 7.1.1

package/dist/lambda.js

@@ -1,160 +1,224 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLambdaOptionsFromFunction = exports.createZip = exports.createLambda = exports.Lambda = void 0;
-const assert_1 = __importDefault(require("assert"));
-const async_sema_1 = __importDefault(require("async-sema"));
-const yazl_1 = require("yazl");
-const minimatch_1 = __importDefault(require("minimatch"));
-const fs_extra_1 = require("fs-extra");
-const download_1 = require("./fs/download");
-const stream_to_buffer_1 = __importDefault(require("./fs/stream-to-buffer"));
+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 lambda_exports = {};
+__export(lambda_exports, {
+  Lambda: () => Lambda,
+  createLambda: () => createLambda,
+  createZip: () => createZip,
+  getLambdaOptionsFromFunction: () => getLambdaOptionsFromFunction
+});
+module.exports = __toCommonJS(lambda_exports);
+var import_assert = __toESM(require("assert"));
+var import_async_sema = __toESM(require("async-sema"));
+var import_yazl = require("yazl");
+var import_minimatch = __toESM(require("minimatch"));
+var import_fs_extra = require("fs-extra");
+var import_download = require("./fs/download");
+var import_stream_to_buffer = __toESM(require("./fs/stream-to-buffer"));
 class Lambda {
-    constructor(opts) {
-        const { handler, runtime, maxDuration, architecture, memory, environment = {}, allowQuery, regions, supportsMultiPayloads, supportsWrapper, supportsResponseStreaming, experimentalResponseStreaming, operationType, framework, } = opts;
-        if ('files' in opts) {
-            (0, assert_1.default)(typeof opts.files === 'object', '"files" must be an object');
-        }
-        if ('zipBuffer' in opts) {
-            (0, assert_1.default)(Buffer.isBuffer(opts.zipBuffer), '"zipBuffer" must be a Buffer');
-        }
-        (0, assert_1.default)(typeof handler === 'string', '"handler" is not a string');
-        (0, assert_1.default)(typeof runtime === 'string', '"runtime" is not a string');
-        (0, assert_1.default)(typeof environment === 'object', '"environment" is not an object');
-        if (architecture !== undefined) {
-            (0, assert_1.default)(architecture === 'x86_64' || architecture === 'arm64', '"architecture" must be either "x86_64" or "arm64"');
-        }
-        if (memory !== undefined) {
-            (0, assert_1.default)(typeof memory === 'number', '"memory" is not a number');
-        }
-        if (maxDuration !== undefined) {
-            (0, assert_1.default)(typeof maxDuration === 'number', '"maxDuration" is not a number');
-        }
-        if (allowQuery !== undefined) {
-            (0, assert_1.default)(Array.isArray(allowQuery), '"allowQuery" is not an Array');
-            (0, assert_1.default)(allowQuery.every(q => typeof q === 'string'), '"allowQuery" is not a string Array');
-        }
-        if (supportsMultiPayloads !== undefined) {
-            (0, assert_1.default)(typeof supportsMultiPayloads === 'boolean', '"supportsMultiPayloads" is not a boolean');
-        }
-        if (supportsWrapper !== undefined) {
-            (0, assert_1.default)(typeof supportsWrapper === 'boolean', '"supportsWrapper" is not a boolean');
-        }
-        if (regions !== undefined) {
-            (0, assert_1.default)(Array.isArray(regions), '"regions" is not an Array');
-            (0, assert_1.default)(regions.every(r => typeof r === 'string'), '"regions" is not a string Array');
-        }
-        if (framework !== undefined) {
-            (0, assert_1.default)(typeof framework === 'object', '"framework" is not an object');
-            (0, assert_1.default)(typeof framework.slug === 'string', '"framework.slug" is not a string');
-            if (framework.version !== undefined) {
-                (0, assert_1.default)(typeof framework.version === 'string', '"framework.version" is not a string');
-            }
-        }
-        this.type = 'Lambda';
-        this.operationType = operationType;
-        this.files = 'files' in opts ? opts.files : undefined;
-        this.handler = handler;
-        this.runtime = runtime;
-        this.architecture = architecture;
-        this.memory = memory;
-        this.maxDuration = maxDuration;
-        this.environment = environment;
-        this.allowQuery = allowQuery;
-        this.regions = regions;
-        this.zipBuffer = 'zipBuffer' in opts ? opts.zipBuffer : undefined;
-        this.supportsMultiPayloads = supportsMultiPayloads;
-        this.supportsWrapper = supportsWrapper;
-        this.supportsResponseStreaming =
-            supportsResponseStreaming ?? experimentalResponseStreaming;
-        this.framework = framework;
+  constructor(opts) {
+    const {
+      handler,
+      runtime,
+      maxDuration,
+      architecture,
+      memory,
+      environment = {},
+      allowQuery,
+      regions,
+      supportsMultiPayloads,
+      supportsWrapper,
+      supportsResponseStreaming,
+      experimentalResponseStreaming,
+      operationType,
+      framework
+    } = opts;
+    if ("files" in opts) {
+      (0, import_assert.default)(typeof opts.files === "object", '"files" must be an object');
+    }
+    if ("zipBuffer" in opts) {
+      (0, import_assert.default)(Buffer.isBuffer(opts.zipBuffer), '"zipBuffer" must be a Buffer');
+    }
+    (0, import_assert.default)(typeof handler === "string", '"handler" is not a string');
+    (0, import_assert.default)(typeof runtime === "string", '"runtime" is not a string');
+    (0, import_assert.default)(typeof environment === "object", '"environment" is not an object');
+    if (architecture !== void 0) {
+      (0, import_assert.default)(
+        architecture === "x86_64" || architecture === "arm64",
+        '"architecture" must be either "x86_64" or "arm64"'
+      );
+    }
+    if (memory !== void 0) {
+      (0, import_assert.default)(typeof memory === "number", '"memory" is not a number');
+    }
+    if (maxDuration !== void 0) {
+      (0, import_assert.default)(typeof maxDuration === "number", '"maxDuration" is not a number');
+    }
+    if (allowQuery !== void 0) {
+      (0, import_assert.default)(Array.isArray(allowQuery), '"allowQuery" is not an Array');
+      (0, import_assert.default)(
+        allowQuery.every((q) => typeof q === "string"),
+        '"allowQuery" is not a string Array'
+      );
     }
-    async createZip() {
-        let { zipBuffer } = this;
-        if (!zipBuffer) {
-            if (!this.files) {
-                throw new Error('`files` is not defined');
-            }
-            await sema.acquire();
-            try {
-                zipBuffer = await createZip(this.files);
-            }
-            finally {
-                sema.release();
-            }
-        }
-        return zipBuffer;
+    if (supportsMultiPayloads !== void 0) {
+      (0, import_assert.default)(
+        typeof supportsMultiPayloads === "boolean",
+        '"supportsMultiPayloads" is not a boolean'
+      );
     }
-    /**
-     * @deprecated Use the `supportsResponseStreaming` property instead.
-     */
-    get experimentalResponseStreaming() {
-        return this.supportsResponseStreaming;
+    if (supportsWrapper !== void 0) {
+      (0, import_assert.default)(
+        typeof supportsWrapper === "boolean",
+        '"supportsWrapper" is not a boolean'
+      );
     }
-    set experimentalResponseStreaming(v) {
-        this.supportsResponseStreaming = v;
+    if (regions !== void 0) {
+      (0, import_assert.default)(Array.isArray(regions), '"regions" is not an Array');
+      (0, import_assert.default)(
+        regions.every((r) => typeof r === "string"),
+        '"regions" is not a string Array'
+      );
     }
+    if (framework !== void 0) {
+      (0, import_assert.default)(typeof framework === "object", '"framework" is not an object');
+      (0, import_assert.default)(
+        typeof framework.slug === "string",
+        '"framework.slug" is not a string'
+      );
+      if (framework.version !== void 0) {
+        (0, import_assert.default)(
+          typeof framework.version === "string",
+          '"framework.version" is not a string'
+        );
+      }
+    }
+    this.type = "Lambda";
+    this.operationType = operationType;
+    this.files = "files" in opts ? opts.files : void 0;
+    this.handler = handler;
+    this.runtime = runtime;
+    this.architecture = architecture;
+    this.memory = memory;
+    this.maxDuration = maxDuration;
+    this.environment = environment;
+    this.allowQuery = allowQuery;
+    this.regions = regions;
+    this.zipBuffer = "zipBuffer" in opts ? opts.zipBuffer : void 0;
+    this.supportsMultiPayloads = supportsMultiPayloads;
+    this.supportsWrapper = supportsWrapper;
+    this.supportsResponseStreaming = supportsResponseStreaming ?? experimentalResponseStreaming;
+    this.framework = framework;
+  }
+  async createZip() {
+    let { zipBuffer } = this;
+    if (!zipBuffer) {
+      if (!this.files) {
+        throw new Error("`files` is not defined");
+      }
+      await sema.acquire();
+      try {
+        zipBuffer = await createZip(this.files);
+      } finally {
+        sema.release();
+      }
+    }
+    return zipBuffer;
+  }
+  /**
+   * @deprecated Use the `supportsResponseStreaming` property instead.
+   */
+  get experimentalResponseStreaming() {
+    return this.supportsResponseStreaming;
+  }
+  set experimentalResponseStreaming(v) {
+    this.supportsResponseStreaming = v;
+  }
 }
-exports.Lambda = Lambda;
-const sema = new async_sema_1.default(10);
-const mtime = new Date(1540000000000);
-/**
- * @deprecated Use `new Lambda()` instead.
- */
+const sema = new import_async_sema.default(10);
+const mtime = /* @__PURE__ */ new Date(154e10);
 async function createLambda(opts) {
-    const lambda = new Lambda(opts);
-    // backwards compat
-    lambda.zipBuffer = await lambda.createZip();
-    return lambda;
+  const lambda = new Lambda(opts);
+  lambda.zipBuffer = await lambda.createZip();
+  return lambda;
 }
-exports.createLambda = createLambda;
 async function createZip(files) {
-    const names = Object.keys(files).sort();
-    const symlinkTargets = new Map();
+  const names = Object.keys(files).sort();
+  const symlinkTargets = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const file = files[name];
+    if (file.mode && (0, import_download.isSymbolicLink)(file.mode) && file.type === "FileFsRef") {
+      const symlinkTarget = await (0, import_fs_extra.readlink)(file.fsPath);
+      symlinkTargets.set(name, symlinkTarget);
+    }
+  }
+  const zipFile = new import_yazl.ZipFile();
+  const zipBuffer = await new Promise((resolve, reject) => {
     for (const name of names) {
-        const file = files[name];
-        if (file.mode && (0, download_1.isSymbolicLink)(file.mode) && file.type === 'FileFsRef') {
-            const symlinkTarget = await (0, fs_extra_1.readlink)(file.fsPath);
-            symlinkTargets.set(name, symlinkTarget);
-        }
+      const file = files[name];
+      const opts = { mode: file.mode, mtime };
+      const symlinkTarget = symlinkTargets.get(name);
+      if (typeof symlinkTarget === "string") {
+        zipFile.addBuffer(Buffer.from(symlinkTarget, "utf8"), name, opts);
+      } else if (file.mode && (0, import_download.isDirectory)(file.mode)) {
+        zipFile.addEmptyDirectory(name, opts);
+      } else {
+        const stream = file.toStream();
+        stream.on("error", reject);
+        zipFile.addReadStream(stream, name, opts);
+      }
     }
-    const zipFile = new yazl_1.ZipFile();
-    const zipBuffer = await new Promise((resolve, reject) => {
-        for (const name of names) {
-            const file = files[name];
-            const opts = { mode: file.mode, mtime };
-            const symlinkTarget = symlinkTargets.get(name);
-            if (typeof symlinkTarget === 'string') {
-                zipFile.addBuffer(Buffer.from(symlinkTarget, 'utf8'), name, opts);
-            }
-            else if (file.mode && (0, download_1.isDirectory)(file.mode)) {
-                zipFile.addEmptyDirectory(name, opts);
-            }
-            else {
-                const stream = file.toStream();
-                stream.on('error', reject);
-                zipFile.addReadStream(stream, name, opts);
-            }
-        }
-        zipFile.end();
-        (0, stream_to_buffer_1.default)(zipFile.outputStream).then(resolve).catch(reject);
-    });
-    return zipBuffer;
+    zipFile.end();
+    (0, import_stream_to_buffer.default)(zipFile.outputStream).then(resolve).catch(reject);
+  });
+  return zipBuffer;
 }
-exports.createZip = createZip;
-async function getLambdaOptionsFromFunction({ sourceFile, config, }) {
-    if (config?.functions) {
-        for (const [pattern, fn] of Object.entries(config.functions)) {
-            if (sourceFile === pattern || (0, minimatch_1.default)(sourceFile, pattern)) {
-                return {
-                    memory: fn.memory,
-                    maxDuration: fn.maxDuration,
-                };
-            }
-        }
+async function getLambdaOptionsFromFunction({
+  sourceFile,
+  config
+}) {
+  if (config?.functions) {
+    for (const [pattern, fn] of Object.entries(config.functions)) {
+      if (sourceFile === pattern || (0, import_minimatch.default)(sourceFile, pattern)) {
+        return {
+          memory: fn.memory,
+          maxDuration: fn.maxDuration
+        };
+      }
     }
-    return {};
+  }
+  return {};
 }
-exports.getLambdaOptionsFromFunction = getLambdaOptionsFromFunction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Lambda,
+  createLambda,
+  createZip,
+  getLambdaOptionsFromFunction
+});

package/dist/nodejs-lambda.js

@@ -1,14 +1,42 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodejsLambda = void 0;
-const lambda_1 = require("./lambda");
-class NodejsLambda extends lambda_1.Lambda {
-    constructor({ shouldAddHelpers, shouldAddSourcemapSupport, awsLambdaHandler, ...opts }) {
-        super(opts);
-        this.launcherType = 'Nodejs';
-        this.shouldAddHelpers = shouldAddHelpers;
-        this.shouldAddSourcemapSupport = shouldAddSourcemapSupport;
-        this.awsLambdaHandler = awsLambdaHandler;
-    }
+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 nodejs_lambda_exports = {};
+__export(nodejs_lambda_exports, {
+  NodejsLambda: () => NodejsLambda
+});
+module.exports = __toCommonJS(nodejs_lambda_exports);
+var import_lambda = require("./lambda");
+class NodejsLambda extends import_lambda.Lambda {
+  constructor({
+    shouldAddHelpers,
+    shouldAddSourcemapSupport,
+    awsLambdaHandler,
+    ...opts
+  }) {
+    super(opts);
+    this.launcherType = "Nodejs";
+    this.shouldAddHelpers = shouldAddHelpers;
+    this.shouldAddSourcemapSupport = shouldAddSourcemapSupport;
+    this.awsLambdaHandler = awsLambdaHandler;
+  }
 }
-exports.NodejsLambda = NodejsLambda;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodejsLambda
+});

package/dist/prerender.js

@@ -1,68 +1,113 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Prerender = void 0;
+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 prerender_exports = {};
+__export(prerender_exports, {
+  Prerender: () => Prerender
+});
+module.exports = __toCommonJS(prerender_exports);
 class Prerender {
-    constructor({ expiration, lambda, fallback, group, bypassToken, allowQuery, initialHeaders, initialStatus, passQuery, sourcePath, }) {
-        this.type = 'Prerender';
-        this.expiration = expiration;
-        this.sourcePath = sourcePath;
-        this.lambda = lambda;
-        if (this.lambda) {
-            // "ISR" is the platform default lambda label for prerender functions
-            this.lambda.operationType = this.lambda.operationType || 'ISR';
-        }
-        if (typeof group !== 'undefined' &&
-            (group <= 0 || !Number.isInteger(group))) {
-            throw new Error('The `group` argument for `Prerender` needs to be a natural number.');
-        }
-        this.group = group;
-        if (passQuery === true) {
-            this.passQuery = true;
-        }
-        else if (typeof passQuery !== 'boolean' &&
-            typeof passQuery !== 'undefined') {
-            throw new Error(`The \`passQuery\` argument for \`Prerender\` must be a boolean.`);
-        }
-        if (bypassToken == null) {
-            this.bypassToken = null;
-        }
-        else if (typeof bypassToken === 'string') {
-            if (bypassToken.length < 32) {
-                // Enforce 128 bits of entropy for safety reasons (UUIDv4 size)
-                throw new Error('The `bypassToken` argument for `Prerender` must be 32 characters or more.');
-            }
-            this.bypassToken = bypassToken;
-        }
-        else {
-            throw new Error('The `bypassToken` argument for `Prerender` must be a `string`.');
-        }
-        if (typeof fallback === 'undefined') {
-            throw new Error('The `fallback` argument for `Prerender` needs to be a `FileBlob`, `FileFsRef`, `FileRef`, or null.');
-        }
-        this.fallback = fallback;
-        if (initialHeaders !== undefined) {
-            if (!initialHeaders ||
-                typeof initialHeaders !== 'object' ||
-                Object.entries(initialHeaders).some(([key, value]) => typeof key !== 'string' || typeof value !== 'string')) {
-                throw new Error(`The \`initialHeaders\` argument for \`Prerender\` must be an object with string key/values`);
-            }
-            this.initialHeaders = initialHeaders;
-        }
-        if (initialStatus !== undefined) {
-            if (initialStatus <= 0 || !Number.isInteger(initialStatus)) {
-                throw new Error(`The \`initialStatus\` argument for \`Prerender\` must be a natural number.`);
-            }
-            this.initialStatus = initialStatus;
-        }
-        if (allowQuery !== undefined) {
-            if (!Array.isArray(allowQuery)) {
-                throw new Error('The `allowQuery` argument for `Prerender` must be Array.');
-            }
-            if (!allowQuery.every(q => typeof q === 'string')) {
-                throw new Error('The `allowQuery` argument for `Prerender` must be Array of strings.');
-            }
-            this.allowQuery = allowQuery;
-        }
+  constructor({
+    expiration,
+    lambda,
+    fallback,
+    group,
+    bypassToken,
+    allowQuery,
+    initialHeaders,
+    initialStatus,
+    passQuery,
+    sourcePath
+  }) {
+    this.type = "Prerender";
+    this.expiration = expiration;
+    this.sourcePath = sourcePath;
+    this.lambda = lambda;
+    if (this.lambda) {
+      this.lambda.operationType = this.lambda.operationType || "ISR";
     }
+    if (typeof group !== "undefined" && (group <= 0 || !Number.isInteger(group))) {
+      throw new Error(
+        "The `group` argument for `Prerender` needs to be a natural number."
+      );
+    }
+    this.group = group;
+    if (passQuery === true) {
+      this.passQuery = true;
+    } else if (typeof passQuery !== "boolean" && typeof passQuery !== "undefined") {
+      throw new Error(
+        `The \`passQuery\` argument for \`Prerender\` must be a boolean.`
+      );
+    }
+    if (bypassToken == null) {
+      this.bypassToken = null;
+    } else if (typeof bypassToken === "string") {
+      if (bypassToken.length < 32) {
+        throw new Error(
+          "The `bypassToken` argument for `Prerender` must be 32 characters or more."
+        );
+      }
+      this.bypassToken = bypassToken;
+    } else {
+      throw new Error(
+        "The `bypassToken` argument for `Prerender` must be a `string`."
+      );
+    }
+    if (typeof fallback === "undefined") {
+      throw new Error(
+        "The `fallback` argument for `Prerender` needs to be a `FileBlob`, `FileFsRef`, `FileRef`, or null."
+      );
+    }
+    this.fallback = fallback;
+    if (initialHeaders !== void 0) {
+      if (!initialHeaders || typeof initialHeaders !== "object" || Object.entries(initialHeaders).some(
+        ([key, value]) => typeof key !== "string" || typeof value !== "string"
+      )) {
+        throw new Error(
+          `The \`initialHeaders\` argument for \`Prerender\` must be an object with string key/values`
+        );
+      }
+      this.initialHeaders = initialHeaders;
+    }
+    if (initialStatus !== void 0) {
+      if (initialStatus <= 0 || !Number.isInteger(initialStatus)) {
+        throw new Error(
+          `The \`initialStatus\` argument for \`Prerender\` must be a natural number.`
+        );
+      }
+      this.initialStatus = initialStatus;
+    }
+    if (allowQuery !== void 0) {
+      if (!Array.isArray(allowQuery)) {
+        throw new Error(
+          "The `allowQuery` argument for `Prerender` must be Array."
+        );
+      }
+      if (!allowQuery.every((q) => typeof q === "string")) {
+        throw new Error(
+          "The `allowQuery` argument for `Prerender` must be Array of strings."
+        );
+      }
+      this.allowQuery = allowQuery;
+    }
+  }
 }
-exports.Prerender = Prerender;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Prerender
+});