@vercel/build-utils 13.14.2 → 13.16.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @vercel/build-utils
 
+## 13.16.0
+
+### Minor Changes
+
+- Add shared deserialization and build-result collection utilities. ([#15961](https://github.com/vercel/vercel/pull/15961))
+
+- Add root to experimentalServices to set a service's working directory. ([#15929](https://github.com/vercel/vercel/pull/15929))
+
+- Add a new flag to vercel deploy to let users deploy to hive ([#15892](https://github.com/vercel/vercel/pull/15892))
+
+## 13.15.0
+
+### Minor Changes
+
+- [services] allow multiple v2beta triggers for a single Lambda when config is coming from services ([#15890](https://github.com/vercel/vercel/pull/15890))
+
+### Patch Changes
+
+- Add deserialization utilities ([#15927](https://github.com/vercel/vercel/pull/15927))
+
 ## 13.14.2
 
 ### Patch Changes

package/dist/collect-build-result/file-to-build-output-file.d.ts

@@ -0,0 +1,26 @@
+import type { FileDigest } from '../fs/stream-to-digest-async';
+import type FileFsRef from '../file-fs-ref';
+import type FileRef from '../file-ref';
+import type FileBlob from '../file-blob';
+export interface BuildOutputFile {
+    contentType?: string;
+    digest: string;
+    lambda: null;
+    mode: number;
+    path: string;
+    paths?: string[];
+    size?: number;
+    type?: 'file';
+    prerenderPath?: string;
+}
+export declare function fileToBuildOutputFile(params: {
+    buildResult: FileBlob | FileFsRef | FileRef;
+    extendedBody?: {
+        prefix: string;
+        suffix: string;
+    };
+    outputPath: string;
+}): Promise<{
+    output: BuildOutputFile;
+    digest: FileDigest;
+}>;

package/dist/collect-build-result/file-to-build-output-file.js

@@ -0,0 +1,54 @@
+"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 file_to_build_output_file_exports = {};
+__export(file_to_build_output_file_exports, {
+  fileToBuildOutputFile: () => fileToBuildOutputFile
+});
+module.exports = __toCommonJS(file_to_build_output_file_exports);
+var import_stream_to_digest_async = require("../fs/stream-to-digest-async");
+var import_stream_with_extended_payload = require("./stream-with-extended-payload");
+var import_validate_regular_file = require("./validate-regular-file");
+var import_get_content_type = require("./get-content-type");
+async function fileToBuildOutputFile(params) {
+  await (0, import_validate_regular_file.validateRegularFile)(params.buildResult);
+  const digest = await (0, import_stream_to_digest_async.streamToDigestAsync)(
+    (0, import_stream_with_extended_payload.streamWithExtendedPayload)(
+      params.buildResult.toStreamAsync ? await params.buildResult.toStreamAsync() : params.buildResult.toStream(),
+      params.extendedBody
+    )
+  );
+  const contentType = params.buildResult.contentType ? params.buildResult.contentType : "fsPath" in params.buildResult ? (0, import_get_content_type.getContentType)(params.buildResult.fsPath) : void 0;
+  return {
+    digest,
+    output: {
+      type: "file",
+      path: params.outputPath,
+      prerenderPath: params.buildResult.prerenderPath,
+      digest: digest.sha256,
+      mode: params.buildResult.mode,
+      contentType,
+      size: digest.size,
+      lambda: null
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileToBuildOutputFile
+});

package/dist/collect-build-result/get-content-type.d.ts

@@ -0,0 +1 @@
+export declare function getContentType(path: string): string;

package/dist/collect-build-result/get-content-type.js

@@ -0,0 +1,45 @@
+"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 get_content_type_exports = {};
+__export(get_content_type_exports, {
+  getContentType: () => getContentType
+});
+module.exports = __toCommonJS(get_content_type_exports);
+var import_path = require("path");
+var import_mime_types = __toESM(require("mime-types"));
+function getContentType(path) {
+  if (path.endsWith(".html")) {
+    return "text/html; charset=utf-8";
+  }
+  return import_mime_types.default.contentType((0, import_path.extname)(path)) || "application/octet-stream";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getContentType
+});

package/dist/collect-build-result/prerender-to-build-output-file.d.ts

@@ -0,0 +1,23 @@
+import type { FileDigest } from '../fs/stream-to-digest-async';
+import type { Prerender } from '../prerender';
+import type { File } from '../types';
+import { type BuildOutputFile } from './file-to-build-output-file';
+interface PrerenderToBuildOutputFileResult {
+    digest: FileDigest;
+    extended: ExtendedPayload;
+    file: File;
+    output: BuildOutputFile;
+}
+export declare function prerenderToBuildOutputFile(params: {
+    buildResult: Prerender;
+    outputPath: string;
+}): Promise<PrerenderToBuildOutputFileResult | null>;
+export interface ExtendedPayload {
+    extendedBody: {
+        prefix: string;
+        suffix: string;
+    } | undefined;
+    fallback?: File | null;
+    initialHeaders: Record<string, string> | undefined;
+}
+export {};

package/dist/collect-build-result/prerender-to-build-output-file.js

@@ -0,0 +1,85 @@
+"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 prerender_to_build_output_file_exports = {};
+__export(prerender_to_build_output_file_exports, {
+  prerenderToBuildOutputFile: () => prerenderToBuildOutputFile
+});
+module.exports = __toCommonJS(prerender_to_build_output_file_exports);
+var import_file_blob = __toESM(require("../file-blob"));
+var import_crypto = require("crypto");
+var import_file_to_build_output_file = require("./file-to-build-output-file");
+async function prerenderToBuildOutputFile(params) {
+  const extended = getExtendedPayload(params.buildResult);
+  if (!extended.fallback) {
+    return null;
+  }
+  const filePath = params.outputPath + ".fallback";
+  const { output, digest } = await (0, import_file_to_build_output_file.fileToBuildOutputFile)({
+    outputPath: filePath,
+    buildResult: extended.fallback,
+    extendedBody: extended.extendedBody
+  });
+  return {
+    file: extended.fallback,
+    output,
+    digest,
+    extended
+  };
+}
+const CRLF = "\r\n";
+const MULTIPART_HEADER = "multipart/x-nextjs-extended-payload";
+function getExtendedPayload({
+  initialHeaders,
+  fallback
+}) {
+  if (!initialHeaders || !Object.entries(initialHeaders).length) {
+    return { initialHeaders: void 0, fallback, extendedBody: void 0 };
+  }
+  const boundary = (0, import_crypto.randomBytes)(8).toString("hex");
+  return {
+    initialHeaders: {
+      ...fallback ? {} : { "x-vercel-empty-fallback": "true" },
+      "content-type": `${MULTIPART_HEADER}; boundary=${boundary}`
+    },
+    fallback: fallback ?? new import_file_blob.default({ data: "" }),
+    extendedBody: {
+      suffix: `${CRLF}${CRLF}--${boundary}--${CRLF}`,
+      prefix: [
+        `--${boundary}`,
+        ...Object.entries(initialHeaders).map(
+          ([key, value]) => `${key}: ${value}`
+        )
+      ].join(CRLF) + CRLF + CRLF
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prerenderToBuildOutputFile
+});

package/dist/collect-build-result/validate-prerender.d.ts

@@ -0,0 +1,8 @@
+import type { Lambda } from '../lambda';
+interface PrerenderLike {
+    lambda?: Lambda;
+}
+export declare function validatePrerender(prerender: PrerenderLike): asserts prerender is {
+    lambda: Lambda;
+};
+export {};

package/dist/collect-build-result/validate-prerender.js

@@ -0,0 +1,32 @@
+"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 validate_prerender_exports = {};
+__export(validate_prerender_exports, {
+  validatePrerender: () => validatePrerender
+});
+module.exports = __toCommonJS(validate_prerender_exports);
+function validatePrerender(prerender) {
+  if (typeof prerender.lambda === "undefined") {
+    throw new Error(`Prerender "buildResult" is missing "lambda" property`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validatePrerender
+});

package/dist/collect-build-result/validate-regular-file.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type FileFsRef from '../file-fs-ref';
+import { type Stats } from 'fs-extra';
+interface FileLike {
+    fsPath?: string;
+}
+export declare function validateRegularFile(file: FileFsRef): Promise<Stats>;
+export declare function validateRegularFile<T extends object>(file: FileLike | T): Promise<Stats | null>;
+export {};

package/dist/collect-build-result/validate-regular-file.js

@@ -0,0 +1,42 @@
+"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 validate_regular_file_exports = {};
+__export(validate_regular_file_exports, {
+  validateRegularFile: () => validateRegularFile
+});
+module.exports = __toCommonJS(validate_regular_file_exports);
+var import_errors = require("../errors");
+var import_fs_extra = require("fs-extra");
+async function validateRegularFile(file) {
+  if ("fsPath" in file && typeof file.fsPath === "string") {
+    const stat = await (0, import_fs_extra.lstat)(file.fsPath);
+    if (!stat.isFile() && !stat.isDirectory() && !stat.isSymbolicLink()) {
+      throw new import_errors.NowBuildError({
+        message: `Output file path is actually not a (regular) file: \`${file.fsPath}\``,
+        code: "OUTPUT_FILE_IS_NOT_REGULAR_FILE"
+      });
+    }
+    return stat;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateRegularFile
+});

package/dist/deserialize/create-functions-iterator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates an async iterator that scans a directory for sub-directories
+ * that end with the suffix `.func`.
+ *
+ * @param dir Absolute path to scan for `.func` directories
+ * @param root The root directory from where the scanning started
+ */
+export declare function createFunctionsIterator(dir: string, root?: string): AsyncIterable<string>;

package/dist/deserialize/create-functions-iterator.js

@@ -0,0 +1,52 @@
+"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 create_functions_iterator_exports = {};
+__export(create_functions_iterator_exports, {
+  createFunctionsIterator: () => createFunctionsIterator
+});
+module.exports = __toCommonJS(create_functions_iterator_exports);
+var import_path = require("path");
+var import_fs_extra = require("fs-extra");
+const SUFFIX = ".func";
+async function* createFunctionsIterator(dir, root = dir) {
+  let paths;
+  try {
+    paths = await (0, import_fs_extra.readdir)(dir);
+  } catch (err) {
+    if (err.code !== "ENOENT" && err.code !== "ENOTDIR") {
+      throw err;
+    }
+    paths = [];
+  }
+  for (const path of paths) {
+    const abs = (0, import_path.join)(dir, path);
+    const s = await (0, import_fs_extra.stat)(abs);
+    if (s.isDirectory()) {
+      if (path.endsWith(SUFFIX)) {
+        yield (0, import_path.relative)(root, abs.substring(0, abs.length - SUFFIX.length));
+      } else {
+        yield* createFunctionsIterator(abs, root);
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFunctionsIterator
+});

package/dist/deserialize/deserialize-edge-function.d.ts

@@ -0,0 +1,5 @@
+import type { Files } from '../types';
+import { EdgeFunction } from '../edge-function';
+import type FileFsRef from '../file-fs-ref';
+import type { SerializedEdgeFunction } from './serialized-types';
+export declare function deserializeEdgeFunction(files: Files, config: SerializedEdgeFunction, repoRootPath: string, fileFsRefsCache: Map<string, FileFsRef>): Promise<EdgeFunction>;

package/dist/deserialize/deserialize-edge-function.js

@@ -0,0 +1,47 @@
+"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 deserialize_edge_function_exports = {};
+__export(deserialize_edge_function_exports, {
+  deserializeEdgeFunction: () => deserializeEdgeFunction
+});
+module.exports = __toCommonJS(deserialize_edge_function_exports);
+var import_edge_function = require("../edge-function");
+var import_hydrate_files_map = require("./hydrate-files-map");
+async function deserializeEdgeFunction(files, config, repoRootPath, fileFsRefsCache) {
+  if (config.filePathMap) {
+    await (0, import_hydrate_files_map.hydrateFilesMap)(
+      files,
+      config.filePathMap,
+      repoRootPath,
+      fileFsRefsCache
+    );
+  }
+  const edgeFunction = new import_edge_function.EdgeFunction({
+    // "v8-worker" is currently the only supported target, so specify
+    // it implicitly here so that `.vc-config.json` does not need to.
+    deploymentTarget: "v8-worker",
+    ...config,
+    files
+  });
+  return edgeFunction;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deserializeEdgeFunction
+});

package/dist/deserialize/deserialize-lambda.d.ts

@@ -0,0 +1,22 @@
+import type { Files } from '../types';
+import { Lambda } from '../lambda';
+import { NodejsLambda } from '../nodejs-lambda';
+import type FileFsRef from '../file-fs-ref';
+import type { SerializedLambda, SerializedNodejsLambda } from './serialized-types';
+export interface DeserializeLambdaOptions {
+    useOnlyStreamingLambda?: boolean;
+    forceNodejsStreaming?: boolean;
+    /**
+     * Custom Lambda class constructor. Defaults to the base Lambda class.
+     * Pass an extended class (e.g. with BYOC `external` property) to
+     * preserve extra properties through deserialization.
+     */
+    LambdaClass?: typeof Lambda;
+    /**
+     * Custom NodejsLambda class constructor. Defaults to the base NodejsLambda class.
+     * Pass an extended class (e.g. with BYOC `external` property) to
+     * preserve extra properties through deserialization.
+     */
+    NodejsLambdaClass?: typeof NodejsLambda;
+}
+export declare function deserializeLambda(files: Files, config: SerializedLambda | SerializedNodejsLambda, repoRootPath: string, fileFsRefsCache: Map<string, FileFsRef>, options?: DeserializeLambdaOptions): Promise<Lambda>;

package/dist/deserialize/deserialize-lambda.js

@@ -0,0 +1,56 @@
+"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 deserialize_lambda_exports = {};
+__export(deserialize_lambda_exports, {
+  deserializeLambda: () => deserializeLambda
+});
+module.exports = __toCommonJS(deserialize_lambda_exports);
+var import_lambda = require("../lambda");
+var import_nodejs_lambda = require("../nodejs-lambda");
+var import_hydrate_files_map = require("./hydrate-files-map");
+async function deserializeLambda(files, config, repoRootPath, fileFsRefsCache, options) {
+  const LambdaCtor = options?.LambdaClass ?? import_lambda.Lambda;
+  const NodejsLambdaCtor = options?.NodejsLambdaClass ?? import_nodejs_lambda.NodejsLambda;
+  if (config.filePathMap) {
+    await (0, import_hydrate_files_map.hydrateFilesMap)(
+      files,
+      config.filePathMap,
+      repoRootPath,
+      fileFsRefsCache
+    );
+  }
+  const supportsResponseStreaming = config.supportsResponseStreaming ?? config.experimentalResponseStreaming;
+  if ("launcherType" in config && config.launcherType === "Nodejs") {
+    const overrideResponseStreaming = (options?.useOnlyStreamingLambda || options?.forceNodejsStreaming) && (config.awsLambdaHandler === void 0 || config.awsLambdaHandler === "");
+    return new NodejsLambdaCtor({
+      ...config,
+      supportsResponseStreaming: overrideResponseStreaming || supportsResponseStreaming,
+      files
+    });
+  }
+  return new LambdaCtor({
+    ...config,
+    supportsResponseStreaming,
+    files
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deserializeLambda
+});

package/dist/deserialize/hydrate-files-map.d.ts

@@ -0,0 +1,3 @@
+import type { Files } from '../types';
+import FileFsRef from '../file-fs-ref';
+export declare function hydrateFilesMap(files: Files, filesMap: Record<string, string>, repoRootPath: string, fileFsRefsCache: Map<string, FileFsRef>): Promise<void>;

package/dist/deserialize/hydrate-files-map.js

@@ -0,0 +1,55 @@
+"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 hydrate_files_map_exports = {};
+__export(hydrate_files_map_exports, {
+  hydrateFilesMap: () => hydrateFilesMap
+});
+module.exports = __toCommonJS(hydrate_files_map_exports);
+var import_file_fs_ref = __toESM(require("../file-fs-ref"));
+var import_path = require("path");
+async function hydrateFilesMap(files, filesMap, repoRootPath, fileFsRefsCache) {
+  for (const [funcPath, projectPath] of Object.entries(filesMap)) {
+    files[funcPath] = await fileFsRefCached(
+      (0, import_path.join)(repoRootPath, projectPath),
+      fileFsRefsCache
+    );
+  }
+}
+async function fileFsRefCached(fsPath, cache) {
+  let file = cache.get(fsPath);
+  if (!file) {
+    file = await import_file_fs_ref.default.fromFsPath({ fsPath });
+    cache.set(fsPath, file);
+  }
+  return file;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hydrateFilesMap
+});

package/dist/deserialize/maybe-read-json.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reads the JSON file at `path`.
+ * Returns `undefined` if the file does not exist.
+ */
+export declare function maybeReadJSON<T = any>(path: string): Promise<T | undefined>;

package/dist/deserialize/maybe-read-json.js

@@ -0,0 +1,37 @@
+"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 maybe_read_json_exports = {};
+__export(maybe_read_json_exports, {
+  maybeReadJSON: () => maybeReadJSON
+});
+module.exports = __toCommonJS(maybe_read_json_exports);
+var import_fs_extra = require("fs-extra");
+async function maybeReadJSON(path) {
+  try {
+    return await (0, import_fs_extra.readJSON)(path);
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  maybeReadJSON
+});