isolate-package 1.4.0 → 1.4.1-0

package/dist/isolate-bin.cjs

@@ -0,0 +1,1003 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// node_modules/.pnpm/tsup@6.7.0_typescript@5.3.2/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL("file:" + __filename).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/isolate-bin.ts
+var import_node_console = __toESM(require("console"), 1);
+var import_source_map_support = __toESM(require("source-map-support"), 1);
+
+// src/isolate.ts
+var import_fs_extra14 = __toESM(require("fs-extra"), 1);
+var import_node_assert6 = __toESM(require("assert"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
+
+// src/utils/filter-object-undefined.ts
+function filterObjectUndefined(object) {
+  return Object.fromEntries(
+    Object.entries(object).filter(([_, value]) => value !== void 0)
+  );
+}
+
+// src/utils/get-dirname.ts
+var import_url = require("url");
+function getDirname(importMetaUrl2) {
+  return (0, import_url.fileURLToPath)(new URL(".", importMetaUrl2));
+}
+
+// src/utils/get-error-message.ts
+function getErrorMessage(error) {
+  return toErrorWithMessage(error).message;
+}
+function isErrorWithMessage(error) {
+  return typeof error === "object" && error !== null && "message" in error;
+}
+function toErrorWithMessage(maybeError) {
+  if (isErrorWithMessage(maybeError))
+    return maybeError;
+  try {
+    return new Error(JSON.stringify(maybeError));
+  } catch {
+    return new Error(String(maybeError));
+  }
+}
+
+// src/utils/get-relative-path.ts
+function getRootRelativePath(path16, rootPath) {
+  const strippedPath = path16.replace(rootPath, "");
+  return strippedPath.startsWith("/") ? `(root)${strippedPath}` : `(root)/${strippedPath}`;
+}
+function getIsolateRelativePath(path16, isolatePath) {
+  const strippedPath = path16.replace(isolatePath, "");
+  return strippedPath.startsWith("/") ? `(isolate)${strippedPath}` : `(isolate)/${strippedPath}`;
+}
+
+// src/utils/inspect-value.ts
+var import_node_util = require("util");
+function inspectValue(value) {
+  return (0, import_node_util.inspect)(value, false, 4, true);
+}
+
+// src/utils/is-present.ts
+function isDefined(t) {
+  return t !== void 0;
+}
+
+// src/utils/json.ts
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_strip_json_comments = __toESM(require("strip-json-comments"), 1);
+function readTypedJsonSync(filePath) {
+  try {
+    const rawContent = import_fs_extra.default.readFileSync(filePath, "utf-8");
+    const data = JSON.parse((0, import_strip_json_comments.default)(rawContent));
+    return data;
+  } catch (err) {
+    throw new Error(
+      `Failed to read JSON from ${filePath}: ${getErrorMessage(err)}`
+    );
+  }
+}
+async function readTypedJson(filePath) {
+  try {
+    const rawContent = await import_fs_extra.default.readFile(filePath, "utf-8");
+    const data = JSON.parse(rawContent);
+    return data;
+  } catch (err) {
+    throw new Error(
+      `Failed to read JSON from ${filePath}: ${getErrorMessage(err)}`
+    );
+  }
+}
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var _loggerHandlers = {
+  debug(...args) {
+    console.log(import_chalk.default.blue("debug"), ...args);
+  },
+  info(...args) {
+    console.log(import_chalk.default.green("info"), ...args);
+  },
+  warn(...args) {
+    console.log(import_chalk.default.yellow("warning"), ...args);
+  },
+  error(...args) {
+    console.log(import_chalk.default.red("error"), ...args);
+  }
+};
+var _logger = {
+  debug(...args) {
+    if (_logLevel === "debug") {
+      _loggerHandlers.debug(...args);
+    }
+  },
+  info(...args) {
+    if (_logLevel === "debug" || _logLevel === "info") {
+      _loggerHandlers.info(...args);
+    }
+  },
+  warn(...args) {
+    if (_logLevel === "debug" || _logLevel === "info" || _logLevel === "warn") {
+      _loggerHandlers.warn(...args);
+    }
+  },
+  error(...args) {
+    _loggerHandlers.error(...args);
+  }
+};
+var _logLevel = "info";
+function setLogger(logger) {
+  _loggerHandlers = logger;
+  return _logger;
+}
+function setLogLevel(logLevel) {
+  _logLevel = logLevel;
+  return _logger;
+}
+function useLogger() {
+  return _logger;
+}
+
+// src/utils/pack.ts
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_node_child_process = require("child_process");
+var import_node_path = __toESM(require("path"), 1);
+async function pack(srcDir, dstDir, usePnpmPack = false) {
+  const execOptions = {
+    maxBuffer: 10 * 1024 * 1024
+  };
+  const log = useLogger();
+  const previousCwd = process.cwd();
+  process.chdir(srcDir);
+  const stdout = usePnpmPack ? await new Promise((resolve, reject) => {
+    (0, import_node_child_process.exec)(
+      `pnpm pack --pack-destination ${dstDir}`,
+      execOptions,
+      (err, stdout2, stderr) => {
+        if (err) {
+          log.error(stderr);
+          return reject(err);
+        }
+        resolve(stdout2);
+      }
+    );
+  }) : await new Promise((resolve, reject) => {
+    (0, import_node_child_process.exec)(
+      `npm pack --pack-destination ${dstDir}`,
+      execOptions,
+      (err, stdout2) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(stdout2);
+      }
+    );
+  });
+  const fileName = import_node_path.default.basename(stdout.trim());
+  const filePath = import_node_path.default.join(dstDir, fileName);
+  if (!import_fs_extra2.default.existsSync(filePath)) {
+    log.error(
+      `The response from pack could not be resolved to an existing file: ${filePath}`
+    );
+  } else {
+    log.debug(`Packed (temp)/${fileName}`);
+  }
+  process.chdir(previousCwd);
+  return filePath;
+}
+
+// src/utils/unpack.ts
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_tar_fs = __toESM(require("tar-fs"), 1);
+var import_zlib = require("zlib");
+async function unpack(filePath, unpackDir) {
+  await new Promise((resolve, reject) => {
+    import_fs_extra3.default.createReadStream(filePath).pipe((0, import_zlib.createGunzip)()).pipe(import_tar_fs.default.extract(unpackDir)).on("finish", () => resolve()).on("error", (err) => reject(err));
+  });
+}
+
+// src/utils/yaml.ts
+var import_fs_extra4 = __toESM(require("fs-extra"), 1);
+var import_yaml = __toESM(require("yaml"), 1);
+function readTypedYamlSync(filePath) {
+  try {
+    const rawContent = import_fs_extra4.default.readFileSync(filePath, "utf-8");
+    const data = import_yaml.default.parse(rawContent);
+    return data;
+  } catch (err) {
+    throw new Error(
+      `Failed to read YAML from ${filePath}: ${getErrorMessage(err)}`
+    );
+  }
+}
+
+// src/helpers/adapt-internal-package-manifests.ts
+var import_fs_extra8 = __toESM(require("fs-extra"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+var import_ramda5 = require("ramda");
+
+// src/helpers/adapt-manifest-internal-deps.ts
+var import_ramda = require("ramda");
+
+// src/helpers/patch-internal-entries.ts
+var import_node_path2 = __toESM(require("path"), 1);
+function patchInternalEntries(dependencies, packagesRegistry, parentRootRelativeDir) {
+  const log = useLogger();
+  const allWorkspacePackageNames = Object.keys(packagesRegistry);
+  return Object.fromEntries(
+    Object.entries(dependencies).map(([key, value]) => {
+      if (allWorkspacePackageNames.includes(key)) {
+        const def = packagesRegistry[key];
+        const relativePath = parentRootRelativeDir ? import_node_path2.default.relative(parentRootRelativeDir, `./${def.rootRelativeDir}`) : `./${def.rootRelativeDir}`;
+        const linkPath = `file:${relativePath}`;
+        log.debug(`Linking dependency ${key} to ${linkPath}`);
+        return [key, linkPath];
+      } else {
+        return [key, value];
+      }
+    })
+  );
+}
+
+// src/helpers/adapt-manifest-internal-deps.ts
+function adaptManifestInternalDeps({
+  manifest,
+  packagesRegistry,
+  parentRootRelativeDir
+}, opts = {}) {
+  return Object.assign(
+    (0, import_ramda.omit)(["devDependencies"], manifest),
+    filterObjectUndefined({
+      dependencies: manifest.dependencies ? patchInternalEntries(
+        manifest.dependencies,
+        packagesRegistry,
+        parentRootRelativeDir
+      ) : void 0,
+      devDependencies: opts.includeDevDependencies && manifest.devDependencies ? patchInternalEntries(
+        manifest.devDependencies,
+        packagesRegistry,
+        parentRootRelativeDir
+      ) : void 0
+    })
+  );
+}
+
+// src/helpers/config.ts
+var import_fs_extra5 = __toESM(require("fs-extra"), 1);
+var import_node_assert = __toESM(require("assert"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_ramda2 = require("ramda");
+var configDefaults = {
+  buildDirName: void 0,
+  includeDevDependencies: false,
+  isolateDirName: "isolate",
+  logLevel: "info",
+  targetPackagePath: void 0,
+  tsconfigPath: "./tsconfig.json",
+  workspacePackages: void 0,
+  workspaceRoot: "../..",
+  excludeLockfile: false,
+  avoidPnpmPack: false
+};
+var _resolvedConfig;
+var _user_defined_config;
+var validConfigKeys = Object.keys(configDefaults);
+var CONFIG_FILE_NAME = "isolate.config.json";
+function setUserConfig(config) {
+  _user_defined_config = config;
+  if (config.logLevel) {
+    setLogLevel(config.logLevel);
+  }
+}
+function useConfig() {
+  if (_resolvedConfig) {
+    return _resolvedConfig;
+  } else {
+    throw new Error("Called useConfig before config was made available");
+  }
+}
+function resolveConfig() {
+  if (_resolvedConfig) {
+    return _resolvedConfig;
+  }
+  setLogLevel(process.env.DEBUG_ISOLATE_CONFIG ? "debug" : "info");
+  const log = useLogger();
+  const configFilePath = import_node_path3.default.join(process.cwd(), CONFIG_FILE_NAME);
+  if (_user_defined_config) {
+    log.debug(`Using user defined config:`, inspectValue(_user_defined_config));
+  } else {
+    log.debug(`Attempting to load config from ${configFilePath}`);
+    _user_defined_config = import_fs_extra5.default.existsSync(configFilePath) ? readTypedJsonSync(configFilePath) : {};
+  }
+  const foreignKeys = Object.keys(_user_defined_config).filter(
+    (key) => !validConfigKeys.includes(key)
+  );
+  if (!(0, import_ramda2.isEmpty)(foreignKeys)) {
+    log.warn(`Found invalid config settings:`, foreignKeys.join(", "));
+  }
+  const config = Object.assign(
+    {},
+    configDefaults,
+    _user_defined_config
+  );
+  log.debug("Using configuration:", inspectValue(config));
+  _resolvedConfig = config;
+  return config;
+}
+function getUserDefinedConfig() {
+  (0, import_node_assert.default)(
+    _user_defined_config,
+    "Called getUserDefinedConfig before user config was made available"
+  );
+  return _user_defined_config;
+}
+
+// src/helpers/detect-package-manager.ts
+var import_fs_extra7 = __toESM(require("fs-extra"), 1);
+var import_node_assert3 = __toESM(require("assert"), 1);
+var import_node_child_process2 = require("child_process");
+var import_node_path7 = __toESM(require("path"), 1);
+
+// src/helpers/process-lockfile.ts
+var import_fs_extra6 = __toESM(require("fs-extra"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_ramda4 = require("ramda");
+
+// src/helpers/generate-npm-lockfile.ts
+var import_arborist = __toESM(require("@npmcli/arborist"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+
+// src/helpers/generate-pnpm-lockfile.ts
+var import_lockfile_file = require("@pnpm/lockfile-file");
+var import_node_assert2 = __toESM(require("assert"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_ramda3 = require("ramda");
+async function generatePnpmLockfile({
+  workspaceRootDir,
+  targetPackageDir,
+  isolateDir,
+  internalDepPackageNames,
+  packagesRegistry
+}) {
+  const { includeDevDependencies } = useConfig();
+  const log = useLogger();
+  log.debug("Generating PNPM lockfile");
+  const lockfile = await (0, import_lockfile_file.readWantedLockfile)(workspaceRootDir, {
+    ignoreIncompatible: false
+  });
+  (0, import_node_assert2.default)(lockfile, "No lockfile found");
+  const targetImporterId = (0, import_lockfile_file.getLockfileImporterId)(
+    workspaceRootDir,
+    targetPackageDir
+  );
+  const directoryByPackageName = Object.fromEntries(
+    internalDepPackageNames.map((name) => {
+      const pkg = packagesRegistry[name];
+      (0, import_node_assert2.default)(pkg, `Package ${name} not found in packages registry`);
+      return [name, pkg.rootRelativeDir];
+    })
+  );
+  const relevantImporterIds = [
+    targetImporterId,
+    /**
+     * The directory paths happen to correspond with what PNPM calls the
+     * importer ids in the context of a lockfile.
+     */
+    ...Object.values(directoryByPackageName)
+  ];
+  log.debug("Relevant importer ids:", relevantImporterIds);
+  lockfile.importers = Object.fromEntries(
+    Object.entries((0, import_ramda3.pick)(relevantImporterIds, lockfile.importers)).map(
+      ([importerId, importer]) => {
+        if (importerId === targetImporterId) {
+          log.debug("Setting target package importer on root");
+          return [
+            ".",
+            pnpmMapImporter(importer, {
+              includeDevDependencies,
+              directoryByPackageName
+            })
+          ];
+        }
+        log.debug("Setting internal package importer:", importerId);
+        return [
+          importerId,
+          pnpmMapImporter(importer, {
+            includeDevDependencies,
+            directoryByPackageName
+          })
+        ];
+      }
+    )
+  );
+  await (0, import_lockfile_file.writeWantedLockfile)(isolateDir, lockfile);
+  log.debug("Created lockfile at", import_node_path5.default.join(isolateDir, "pnpm-lock.yaml"));
+}
+
+// src/helpers/process-lockfile.ts
+function getLockfileFileName(name) {
+  switch (name) {
+    case "pnpm":
+      return "pnpm-lock.yaml";
+    case "yarn":
+      return "yarn.lock";
+    case "npm":
+      return "package-lock.json";
+  }
+}
+function pnpmMapImporter({ dependencies, devDependencies, ...rest }, {
+  includeDevDependencies,
+  directoryByPackageName
+}) {
+  return {
+    dependencies: dependencies ? pnpmMapDependenciesLinks(dependencies, directoryByPackageName) : void 0,
+    devDependencies: includeDevDependencies && devDependencies ? pnpmMapDependenciesLinks(devDependencies, directoryByPackageName) : void 0,
+    ...rest
+  };
+}
+function pnpmMapDependenciesLinks(def, directoryByPackageName) {
+  return (0, import_ramda4.mapObjIndexed)(
+    (version, name) => version.startsWith("link:") ? `link:./${directoryByPackageName[name]}` : version,
+    def
+  );
+}
+async function processLockfile({
+  workspaceRootDir,
+  packagesRegistry,
+  isolateDir,
+  internalDepPackageNames,
+  targetPackageDir,
+  targetPackageName
+}) {
+  const log = useLogger();
+  const { name } = usePackageManager();
+  const fileName = getLockfileFileName(name);
+  const lockfileSrcPath = import_node_path6.default.join(workspaceRootDir, fileName);
+  const lockfileDstPath = import_node_path6.default.join(isolateDir, fileName);
+  switch (name) {
+    case "npm": {
+      const shrinkwrapSrcPath = import_node_path6.default.join(
+        workspaceRootDir,
+        "npm-shrinkwrap.json"
+      );
+      const shrinkwrapDstPath = import_node_path6.default.join(isolateDir, "npm-shrinkwrap.json");
+      if (import_fs_extra6.default.existsSync(shrinkwrapSrcPath)) {
+        import_fs_extra6.default.copyFileSync(shrinkwrapSrcPath, shrinkwrapDstPath);
+        log.debug("Copied shrinkwrap to", shrinkwrapDstPath);
+      } else {
+        import_fs_extra6.default.copyFileSync(lockfileSrcPath, lockfileDstPath);
+        log.debug("Copied lockfile to", lockfileDstPath);
+      }
+      if (false) {
+        await generateNpmLockfile({
+          workspaceRootDir,
+          targetPackageName,
+          isolateDir,
+          packagesRegistry
+        });
+      }
+      break;
+    }
+    case "yarn": {
+      import_fs_extra6.default.copyFileSync(lockfileSrcPath, lockfileDstPath);
+      log.debug("Copied lockfile to", lockfileDstPath);
+      break;
+    }
+    case "pnpm": {
+      await generatePnpmLockfile({
+        workspaceRootDir,
+        targetPackageDir,
+        isolateDir,
+        internalDepPackageNames,
+        packagesRegistry
+      });
+      break;
+    }
+    default:
+      log.warn(`Unexpected package manager ${name}`);
+  }
+}
+
+// src/helpers/detect-package-manager.ts
+var supportedPackageManagerNames = ["pnpm", "yarn", "npm"];
+var packageManager;
+function detectPackageManager(workspaceRoot) {
+  packageManager = inferFromManifest(workspaceRoot) ?? inferFromFiles(workspaceRoot);
+  return packageManager;
+}
+function inferFromManifest(workspaceRoot) {
+  const log = useLogger();
+  const rootManifest = readTypedJsonSync(
+    import_node_path7.default.join(workspaceRoot, "package.json")
+  );
+  if (!rootManifest.packageManager) {
+    log.debug("No packageManager field found in root manifest");
+    return;
+  }
+  const [name, version = "*"] = rootManifest.packageManager.split("@");
+  (0, import_node_assert3.default)(
+    supportedPackageManagerNames.includes(name),
+    `Package manager "${name}" is not currently supported`
+  );
+  const lockfileName = getLockfileFileName(name);
+  (0, import_node_assert3.default)(
+    import_fs_extra7.default.existsSync(import_node_path7.default.join(workspaceRoot, lockfileName)),
+    `Manifest declares ${name} to be the packageManager, but failed to find ${lockfileName} in workspace root`
+  );
+  return { name, version };
+}
+function inferFromFiles(workspaceRoot) {
+  for (const name of supportedPackageManagerNames) {
+    const lockfileName = getLockfileFileName(name);
+    if (import_fs_extra7.default.existsSync(import_node_path7.default.join(workspaceRoot, lockfileName))) {
+      return { name, version: getVersion(name) };
+    }
+  }
+  if (import_fs_extra7.default.existsSync(import_node_path7.default.join(workspaceRoot, "npm-shrinkwrap.json"))) {
+    return { name: "npm", version: getVersion("npm") };
+  }
+  throw new Error(`Failed to detect package manager`);
+}
+function getVersion(packageManagerName) {
+  const buffer = (0, import_node_child_process2.execSync)(`${packageManagerName} --version`);
+  return buffer.toString().trim();
+}
+function usePackageManager() {
+  if (!packageManager) {
+    throw Error(
+      "No package manager detected. Make sure to call detectPackageManager() before usePackageManager()"
+    );
+  }
+  return packageManager;
+}
+
+// src/helpers/adapt-internal-package-manifests.ts
+async function adaptInternalPackageManifests(internalPackageNames, packagesRegistry, isolateDir) {
+  const packageManager2 = usePackageManager();
+  const { includeDevDependencies } = useConfig();
+  await Promise.all(
+    internalPackageNames.map(async (packageName) => {
+      const { manifest, rootRelativeDir } = packagesRegistry[packageName];
+      const outputManifest = packageManager2.name === "pnpm" ? Object.assign(
+        /**
+         * For internal dependencies we want to omit the peerDependencies,
+         * because installing these is the responsibility of the consuming
+         * app / service, and otherwise the frozen lockfile install will
+         * error since the package file contains something that is not
+         * referenced in the lockfile.
+         */
+        (0, import_ramda5.omit)(["devDependencies", "peerDependencies"], manifest),
+        {
+          dependencies: manifest.dependencies,
+          devDependencies: includeDevDependencies ? manifest.devDependencies : void 0
+        }
+      ) : adaptManifestInternalDeps(
+        {
+          manifest,
+          packagesRegistry,
+          parentRootRelativeDir: rootRelativeDir
+        },
+        { includeDevDependencies }
+      );
+      await import_fs_extra8.default.writeFile(
+        import_node_path8.default.join(isolateDir, rootRelativeDir, "package.json"),
+        JSON.stringify(outputManifest, null, 2)
+      );
+    })
+  );
+}
+
+// src/helpers/adapt-target-package-manifest.ts
+var import_fs_extra9 = __toESM(require("fs-extra"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+var import_ramda6 = require("ramda");
+async function adaptTargetPackageManifest(manifest, packagesRegistry, isolateDir) {
+  const packageManager2 = usePackageManager();
+  const { includeDevDependencies } = useConfig();
+  const outputManifest = packageManager2.name === "pnpm" ? Object.assign((0, import_ramda6.omit)(["devDependencies", "scripts"], manifest), {
+    devDependencies: includeDevDependencies ? manifest.devDependencies : void 0
+  }) : adaptManifestInternalDeps(
+    {
+      manifest,
+      packagesRegistry
+    },
+    { includeDevDependencies }
+  );
+  await import_fs_extra9.default.writeFile(
+    import_node_path9.default.join(isolateDir, "package.json"),
+    JSON.stringify(outputManifest, null, 2)
+  );
+}
+
+// src/helpers/create-packages-registry.ts
+var import_fs_extra10 = __toESM(require("fs-extra"), 1);
+var import_glob = require("glob");
+var import_node_path11 = __toESM(require("path"), 1);
+
+// src/helpers/find-packages-globs.ts
+var import_node_assert4 = __toESM(require("assert"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
+function findPackagesGlobs(workspaceRootDir) {
+  const log = useLogger();
+  const packageManager2 = usePackageManager();
+  switch (packageManager2.name) {
+    case "pnpm": {
+      const { packages: globs } = readTypedYamlSync(
+        import_node_path10.default.join(workspaceRootDir, "pnpm-workspace.yaml")
+      );
+      log.debug("Detected pnpm packages globs:", inspectValue(globs));
+      return globs;
+    }
+    case "yarn":
+    case "npm": {
+      const workspaceRootManifestPath = import_node_path10.default.join(
+        workspaceRootDir,
+        "package.json"
+      );
+      const { workspaces } = readTypedJsonSync(
+        workspaceRootManifestPath
+      );
+      if (!workspaces) {
+        throw new Error(
+          `No workspaces field found in ${workspaceRootManifestPath}`
+        );
+      }
+      if (Array.isArray(workspaces)) {
+        return workspaces;
+      } else {
+        const workspacesObject = workspaces;
+        (0, import_node_assert4.default)(
+          workspacesObject.packages,
+          "workspaces.packages must be an array"
+        );
+        return workspacesObject.packages;
+      }
+    }
+  }
+}
+
+// src/helpers/create-packages-registry.ts
+async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverride) {
+  const log = useLogger();
+  if (workspacePackagesOverride) {
+    log.debug(
+      `Override workspace packages via config: ${workspacePackagesOverride}`
+    );
+  }
+  const packagesGlobs = workspacePackagesOverride ?? findPackagesGlobs(workspaceRootDir);
+  const cwd = process.cwd();
+  process.chdir(workspaceRootDir);
+  const allPackages = packagesGlobs.flatMap((glob) => (0, import_glob.globSync)(glob)).filter((dir) => import_fs_extra10.default.lstatSync(dir).isDirectory());
+  const registry = (await Promise.all(
+    allPackages.map(async (rootRelativeDir) => {
+      const manifestPath = import_node_path11.default.join(rootRelativeDir, "package.json");
+      if (!import_fs_extra10.default.existsSync(manifestPath)) {
+        log.warn(
+          `Ignoring directory ./${rootRelativeDir} because it does not contain a package.json file`
+        );
+        return;
+      } else {
+        log.debug(`Registering package ./${rootRelativeDir}`);
+        const manifest = await readTypedJson(
+          import_node_path11.default.join(rootRelativeDir, "package.json")
+        );
+        return {
+          manifest,
+          rootRelativeDir,
+          absoluteDir: import_node_path11.default.join(workspaceRootDir, rootRelativeDir)
+        };
+      }
+    })
+  )).reduce((acc, info) => {
+    if (info) {
+      acc[info.manifest.name] = info;
+    }
+    return acc;
+  }, {});
+  process.chdir(cwd);
+  return registry;
+}
+
+// src/helpers/get-build-output-dir.ts
+var import_fs_extra11 = __toESM(require("fs-extra"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
+var import_outdent = __toESM(require("outdent"), 1);
+async function getBuildOutputDir(targetPackageDir) {
+  const config = useConfig();
+  const log = useLogger();
+  if (config.buildDirName) {
+    log.debug("Using buildDirName from config:", config.buildDirName);
+    return import_node_path12.default.join(targetPackageDir, config.buildDirName);
+  }
+  const tsconfigPath = import_node_path12.default.join(targetPackageDir, config.tsconfigPath);
+  if (import_fs_extra11.default.existsSync(tsconfigPath)) {
+    log.debug("Found tsconfig at:", config.tsconfigPath);
+    const tsconfig = await readTypedJson(tsconfigPath);
+    const outDir = tsconfig.compilerOptions?.outDir;
+    if (outDir) {
+      return import_node_path12.default.join(targetPackageDir, outDir);
+    } else {
+      throw new Error(import_outdent.default`
+        Failed to find outDir in tsconfig. If you are executing isolate from the root of a monorepo you should specify the buildDirName in isolate.config.json.
+      `);
+    }
+  } else {
+    log.warn("Failed to find tsconfig at:", tsconfigPath);
+    throw new Error(import_outdent.default`
+      Failed to infer the build output directory from either the isolate config buildDirName or a Typescript config file. See the documentation on how to configure one of these options.
+    `);
+  }
+}
+
+// src/helpers/list-internal-packages.ts
+var import_ramda7 = require("ramda");
+function listInternalPackages(manifest, packagesRegistry, { includeDevDependencies = false } = {}) {
+  const allWorkspacePackageNames = Object.keys(packagesRegistry);
+  const internalPackageNames = (includeDevDependencies ? [
+    ...Object.keys(manifest.dependencies ?? {}),
+    ...Object.keys(manifest.devDependencies ?? {})
+  ] : Object.keys(manifest.dependencies ?? {})).filter((name) => allWorkspacePackageNames.includes(name));
+  const nestedInternalPackageNames = internalPackageNames.flatMap(
+    (packageName) => listInternalPackages(
+      packagesRegistry[packageName].manifest,
+      packagesRegistry,
+      { includeDevDependencies }
+    )
+  );
+  return (0, import_ramda7.uniq)(internalPackageNames.concat(nestedInternalPackageNames));
+}
+
+// src/helpers/pack-dependencies.ts
+var import_node_assert5 = __toESM(require("assert"), 1);
+async function packDependencies({
+  /** All packages found in the monorepo by workspaces declaration */
+  packagesRegistry,
+  /** The dependencies that appear to be internal packages */
+  internalPackageNames,
+  /**
+   * The directory where the isolated package and all its dependencies will end
+   * up. This is also the directory from where the package will be deployed. By
+   * default it is a subfolder in targetPackageDir called "isolate" but you can
+   * configure it.
+   */
+  packDestinationDir
+}) {
+  const config = useConfig();
+  const log = useLogger();
+  const packedFileByName = {};
+  const { name, version } = usePackageManager();
+  const versionMajor = parseInt(version.split(".")[0], 10);
+  const usePnpmPack = !config.avoidPnpmPack && name === "pnpm" && versionMajor >= 8;
+  if (usePnpmPack) {
+    log.debug("Using PNPM pack instead of NPM pack");
+  }
+  for (const dependency of internalPackageNames) {
+    const def = packagesRegistry[dependency];
+    (0, import_node_assert5.default)(dependency, `Failed to find package definition for ${dependency}`);
+    const { name: name2 } = def.manifest;
+    if (packedFileByName[name2]) {
+      log.debug(`Skipping ${name2} because it has already been packed`);
+      continue;
+    }
+    packedFileByName[name2] = await pack(
+      def.absoluteDir,
+      packDestinationDir,
+      usePnpmPack
+    );
+  }
+  return packedFileByName;
+}
+
+// src/helpers/process-build-output-files.ts
+var import_fs_extra12 = __toESM(require("fs-extra"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
+var TIMEOUT_MS = 5e3;
+async function processBuildOutputFiles({
+  targetPackageDir,
+  tmpDir,
+  isolateDir
+}) {
+  const log = useLogger();
+  const packedFilePath = await pack(targetPackageDir, tmpDir);
+  const unpackDir = import_node_path13.default.join(tmpDir, "target");
+  const now = Date.now();
+  let isWaitingYet = false;
+  while (!import_fs_extra12.default.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
+    if (!isWaitingYet) {
+      log.debug(`Waiting for ${packedFilePath} to become available...`);
+    }
+    isWaitingYet = true;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  await unpack(packedFilePath, unpackDir);
+  await import_fs_extra12.default.copy(import_node_path13.default.join(unpackDir, "package"), isolateDir);
+}
+
+// src/helpers/unpack-dependencies.ts
+var import_fs_extra13 = __toESM(require("fs-extra"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
+async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, isolateDir) {
+  const log = useLogger();
+  await Promise.all(
+    Object.entries(packedFilesByName).map(async ([packageName, filePath]) => {
+      const dir = packagesRegistry[packageName].rootRelativeDir;
+      const unpackDir = (0, import_node_path14.join)(tmpDir, dir);
+      log.debug("Unpacking", `(temp)/${import_node_path14.default.basename(filePath)}`);
+      await unpack(filePath, unpackDir);
+      const destinationDir = (0, import_node_path14.join)(isolateDir, dir);
+      await import_fs_extra13.default.ensureDir(destinationDir);
+      await import_fs_extra13.default.move((0, import_node_path14.join)(unpackDir, "package"), destinationDir, {
+        overwrite: true
+      });
+      log.debug(
+        `Moved package files to ${getIsolateRelativePath(
+          destinationDir,
+          isolateDir
+        )}`
+      );
+    })
+  );
+}
+
+// src/isolate.ts
+var __dirname = getDirname(importMetaUrl);
+async function isolate(options = {}) {
+  if (options.logger) {
+    setLogger(options.logger);
+  }
+  if (options.config) {
+    setUserConfig(options.config);
+  }
+  const config = resolveConfig();
+  setLogLevel(config.logLevel);
+  const log = useLogger();
+  const thisPackageManifest = await readTypedJson(
+    import_node_path15.default.join(import_node_path15.default.join(__dirname, "..", "package.json"))
+  );
+  log.debug("Using isolate-package version", thisPackageManifest.version);
+  const targetPackageDir = config.targetPackagePath ? import_node_path15.default.join(process.cwd(), config.targetPackagePath) : process.cwd();
+  const workspaceRootDir = config.targetPackagePath ? process.cwd() : import_node_path15.default.join(targetPackageDir, config.workspaceRoot);
+  const buildOutputDir = await getBuildOutputDir(targetPackageDir);
+  (0, import_node_assert6.default)(
+    import_fs_extra14.default.existsSync(buildOutputDir),
+    `Failed to find build output path at ${buildOutputDir}. Please make sure you build the source before isolating it.`
+  );
+  log.debug("Workspace root resolved to", workspaceRootDir);
+  log.debug(
+    "Isolate target package",
+    getRootRelativePath(targetPackageDir, workspaceRootDir)
+  );
+  const isolateDir = import_node_path15.default.join(targetPackageDir, config.isolateDirName);
+  log.debug(
+    "Isolate output directory",
+    getRootRelativePath(isolateDir, workspaceRootDir)
+  );
+  if (import_fs_extra14.default.existsSync(isolateDir)) {
+    await import_fs_extra14.default.remove(isolateDir);
+    log.debug("Cleaned the existing isolate output directory");
+  }
+  await import_fs_extra14.default.ensureDir(isolateDir);
+  const tmpDir = import_node_path15.default.join(isolateDir, "__tmp");
+  await import_fs_extra14.default.ensureDir(tmpDir);
+  const targetPackageManifest = await readTypedJson(
+    import_node_path15.default.join(targetPackageDir, "package.json")
+  );
+  const packageManager2 = detectPackageManager(workspaceRootDir);
+  log.debug(
+    "Detected package manager",
+    packageManager2.name,
+    packageManager2.version
+  );
+  const packagesRegistry = await createPackagesRegistry(
+    workspaceRootDir,
+    config.workspacePackages
+  );
+  const internalPackageNames = listInternalPackages(
+    targetPackageManifest,
+    packagesRegistry,
+    {
+      includeDevDependencies: config.includeDevDependencies
+    }
+  );
+  const packedFilesByName = await packDependencies({
+    internalPackageNames,
+    packagesRegistry,
+    packDestinationDir: tmpDir
+  });
+  await unpackDependencies(
+    packedFilesByName,
+    packagesRegistry,
+    tmpDir,
+    isolateDir
+  );
+  await adaptInternalPackageManifests(
+    internalPackageNames,
+    packagesRegistry,
+    isolateDir
+  );
+  await processBuildOutputFiles({
+    targetPackageDir,
+    tmpDir,
+    isolateDir
+  });
+  await adaptTargetPackageManifest(
+    targetPackageManifest,
+    packagesRegistry,
+    isolateDir
+  );
+  const userDefinedConfig = getUserDefinedConfig();
+  if (!isDefined(userDefinedConfig.excludeLockfile)) {
+    if (packageManager2.name === "npm" || packageManager2.name === "yarn") {
+      config.excludeLockfile = true;
+    }
+  }
+  if (config.excludeLockfile) {
+    log.warn("Excluding the lockfile from the isolate output");
+  } else {
+    await processLockfile({
+      workspaceRootDir,
+      isolateDir,
+      packagesRegistry,
+      internalDepPackageNames: internalPackageNames,
+      targetPackageDir,
+      targetPackageName: targetPackageManifest.name
+    });
+  }
+  if (packageManager2.name === "pnpm") {
+    import_fs_extra14.default.copyFileSync(
+      import_node_path15.default.join(workspaceRootDir, "pnpm-workspace.yaml"),
+      import_node_path15.default.join(isolateDir, "pnpm-workspace.yaml")
+    );
+  }
+  const npmrcPath = import_node_path15.default.join(workspaceRootDir, ".npmrc");
+  if (import_fs_extra14.default.existsSync(npmrcPath)) {
+    import_fs_extra14.default.copyFileSync(npmrcPath, import_node_path15.default.join(isolateDir, ".npmrc"));
+    log.debug("Copied .npmrc file to the isolate output");
+  }
+  log.debug(
+    "Deleting temp directory",
+    getRootRelativePath(tmpDir, workspaceRootDir)
+  );
+  await import_fs_extra14.default.remove(tmpDir);
+  log.info("Isolate completed at", isolateDir);
+}
+
+// src/isolate-bin.ts
+import_source_map_support.default.install();
+async function run() {
+  await isolate();
+}
+run().catch((err) => {
+  if (err instanceof Error) {
+    import_node_console.default.error(err.stack);
+    process.exit(1);
+  } else {
+    import_node_console.default.error(err);
+  }
+});
+//# sourceMappingURL=isolate-bin.cjs.map