isolate-package 1.10.1 → 1.12.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 // src/isolate.ts
 import fs15 from "fs-extra";
 import assert6 from "node:assert";
-import path16 from "node:path";
+import path17 from "node:path";
 
 // src/lib/config.ts
 import fs5 from "fs-extra";
@@ -82,12 +82,12 @@ function toErrorWithMessage(maybeError) {
 }
 
 // src/lib/utils/get-relative-path.ts
-function getRootRelativePath(path17, rootPath) {
-  const strippedPath = path17.replace(rootPath, "");
+function getRootRelativePath(path18, rootPath) {
+  const strippedPath = path18.replace(rootPath, "");
   return strippedPath.startsWith("/") ? `(root)${strippedPath}` : `(root)/${strippedPath}`;
 }
-function getIsolateRelativePath(path17, isolatePath) {
-  const strippedPath = path17.replace(isolatePath, "");
+function getIsolateRelativePath(path18, isolatePath) {
+  const strippedPath = path18.replace(isolatePath, "");
   return strippedPath.startsWith("/") ? `(isolate)${strippedPath}` : `(isolate)/${strippedPath}`;
 }
 
@@ -103,7 +103,9 @@ import stripJsonComments from "strip-json-comments";
 function readTypedJsonSync(filePath) {
   try {
     const rawContent = fs.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(stripJsonComments(rawContent));
+    const data = JSON.parse(
+      stripJsonComments(rawContent, { trailingCommas: true })
+    );
     return data;
   } catch (err) {
     throw new Error(
@@ -114,7 +116,9 @@ function readTypedJsonSync(filePath) {
 async function readTypedJson(filePath) {
   try {
     const rawContent = await fs.readFile(filePath, "utf-8");
-    const data = JSON.parse(rawContent);
+    const data = JSON.parse(
+      stripJsonComments(rawContent, { trailingCommas: true })
+    );
     return data;
   } catch (err) {
     throw new Error(
@@ -257,9 +261,6 @@ function resolveConfig() {
   return config;
 }
 
-// src/lib/lockfile/process-lockfile.ts
-import { mapValues } from "remeda";
-
 // src/lib/package-manager/helpers/infer-from-files.ts
 import fs6 from "fs-extra";
 import { execSync } from "node:child_process";
@@ -388,15 +389,38 @@ import {
   readWantedLockfile,
   writeWantedLockfile
 } from "@pnpm/lockfile-file";
+import { pruneLockfile } from "@pnpm/prune-lockfile";
 import assert3 from "node:assert";
 import path6 from "node:path";
 import { pick } from "remeda";
+
+// src/lib/lockfile/helpers/pnpm-map-importer.ts
+import { mapValues } from "remeda";
+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 mapValues(
+    def,
+    (value, key) => value.startsWith("link:") ? `link:./${directoryByPackageName[key]}` : value
+  );
+}
+
+// src/lib/lockfile/helpers/generate-pnpm-lockfile.ts
 async function generatePnpmLockfile({
   workspaceRootDir,
   targetPackageDir,
   isolateDir,
   internalDepPackageNames,
-  packagesRegistry
+  packagesRegistry,
+  targetPackageManifest
 }) {
   const { includeDevDependencies, includePatchedDependencies } = useConfig();
   const log = useLogger();
@@ -452,8 +476,14 @@ async function generatePnpmLockfile({
         }
       )
     );
+    log.debug("Pruning the lockfile");
+    const prunedLockfile = await pruneLockfile(
+      lockfile,
+      targetPackageManifest,
+      "."
+    );
     await writeWantedLockfile(isolateDir, {
-      ...lockfile,
+      ...prunedLockfile,
       /**
        * Don't know how to map the patched dependencies yet, so we just include
        * them but I don't think it would work like this. The important thing for
@@ -495,28 +525,13 @@ async function generateYarnLockfile({
 }
 
 // src/lib/lockfile/process-lockfile.ts
-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 mapValues(
-    def,
-    (value, key) => value.startsWith("link:") ? `link:./${directoryByPackageName[key]}` : value
-  );
-}
 async function processLockfile({
   workspaceRootDir,
   packagesRegistry,
   isolateDir,
   internalDepPackageNames,
-  targetPackageDir
+  targetPackageDir,
+  targetPackageManifest
 }) {
   const log = useLogger();
   const { forceNpm } = useConfig();
@@ -563,7 +578,8 @@ async function processLockfile({
         targetPackageDir,
         isolateDir,
         internalDepPackageNames,
-        packagesRegistry
+        packagesRegistry,
+        targetPackageManifest
       });
       break;
     }
@@ -647,17 +663,17 @@ async function adaptInternalPackageManifests(internalPackageNames, packagesRegis
   await Promise.all(
     internalPackageNames.map(async (packageName) => {
       const { manifest, rootRelativeDir } = packagesRegistry[packageName];
-      const inputManifest = omit(manifest, ["scripts", "devDependencies"]);
+      const strippedManifest = omit(manifest, ["scripts", "devDependencies"]);
       const outputManifest = packageManager2.name === "pnpm" && !forceNpm ? (
         /**
          * For PNPM the output itself is a workspace so we can preserve the specifiers
          * with "workspace:*" in the output manifest.
          */
-        inputManifest
+        strippedManifest
       ) : (
         /** For other package managers we replace the links to internal dependencies */
         adaptManifestInternalDeps({
-          manifest: inputManifest,
+          manifest: strippedManifest,
           packagesRegistry,
           parentRootRelativeDir: rootRelativeDir
         })
@@ -670,17 +686,40 @@ async function adaptInternalPackageManifests(internalPackageNames, packagesRegis
   );
 }
 
+// src/lib/manifest/helpers/adopt-pnpm-fields-from-root.ts
+import path11 from "path";
+async function adoptPnpmFieldsFromRoot(targetPackageManifest, workspaceRootDir) {
+  const rootPackageManifest = await readTypedJson(
+    path11.join(workspaceRootDir, "package.json")
+  );
+  const overrides = rootPackageManifest.pnpm?.overrides;
+  if (!overrides) {
+    return targetPackageManifest;
+  }
+  return {
+    ...targetPackageManifest,
+    pnpm: {
+      overrides
+    }
+  };
+}
+
 // src/lib/manifest/adapt-target-package-manifest.ts
-async function adaptTargetPackageManifest(manifest, packagesRegistry, isolateDir) {
+async function adaptTargetPackageManifest({
+  manifest,
+  packagesRegistry,
+  workspaceRootDir
+}) {
   const packageManager2 = usePackageManager();
   const { includeDevDependencies, forceNpm, pickFromScripts, omitFromScripts } = useConfig();
   const inputManifest = includeDevDependencies ? manifest : omit2(manifest, ["devDependencies"]);
   const adaptedManifest = packageManager2.name === "pnpm" && !forceNpm ? (
     /**
      * For PNPM the output itself is a workspace so we can preserve the specifiers
-     * with "workspace:*" in the output manifest.
+     * with "workspace:*" in the output manifest, but we do want to adopt the
+     * pnpm.overrides field from the root package.json.
      */
-    inputManifest
+    await adoptPnpmFieldsFromRoot(inputManifest, workspaceRootDir)
   ) : (
     /** For other package managers we replace the links to internal dependencies */
     adaptManifestInternalDeps({
@@ -688,7 +727,7 @@ async function adaptTargetPackageManifest(manifest, packagesRegistry, isolateDir
       packagesRegistry
     })
   );
-  const outputManifest = {
+  return {
     ...adaptedManifest,
     /**
      * Scripts are removed by default if not explicitly picked or omitted via
@@ -696,27 +735,26 @@ async function adaptTargetPackageManifest(manifest, packagesRegistry, isolateDir
      */
     scripts: pickFromScripts ? pick2(manifest.scripts ?? {}, pickFromScripts) : omitFromScripts ? omit2(manifest.scripts ?? {}, omitFromScripts) : void 0
   };
-  await writeManifest(isolateDir, outputManifest);
 }
 
 // src/lib/output/get-build-output-dir.ts
 import fs11 from "fs-extra";
-import path11 from "node:path";
+import path12 from "node:path";
 import outdent from "outdent";
 async function getBuildOutputDir(targetPackageDir) {
   const config = useConfig();
   const log = useLogger();
   if (config.buildDirName) {
     log.debug("Using buildDirName from config:", config.buildDirName);
-    return path11.join(targetPackageDir, config.buildDirName);
+    return path12.join(targetPackageDir, config.buildDirName);
   }
-  const tsconfigPath = path11.join(targetPackageDir, config.tsconfigPath);
+  const tsconfigPath = path12.join(targetPackageDir, config.tsconfigPath);
   if (fs11.existsSync(tsconfigPath)) {
     log.debug("Found tsconfig at:", config.tsconfigPath);
     const tsconfig = await readTypedJson(tsconfigPath);
     const outDir = tsconfig.compilerOptions?.outDir;
     if (outDir) {
-      return path11.join(targetPackageDir, outDir);
+      return path12.join(targetPackageDir, outDir);
     } else {
       throw new Error(outdent`
         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.
@@ -772,7 +810,7 @@ async function packDependencies({
 
 // src/lib/output/process-build-output-files.ts
 import fs12 from "fs-extra";
-import path12 from "node:path";
+import path13 from "node:path";
 var TIMEOUT_MS = 5e3;
 async function processBuildOutputFiles({
   targetPackageDir,
@@ -781,7 +819,7 @@ async function processBuildOutputFiles({
 }) {
   const log = useLogger();
   const packedFilePath = await pack(targetPackageDir, tmpDir);
-  const unpackDir = path12.join(tmpDir, "target");
+  const unpackDir = path13.join(tmpDir, "target");
   const now = Date.now();
   let isWaitingYet = false;
   while (!fs12.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
@@ -792,19 +830,19 @@ async function processBuildOutputFiles({
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   await unpack(packedFilePath, unpackDir);
-  await fs12.copy(path12.join(unpackDir, "package"), isolateDir);
+  await fs12.copy(path13.join(unpackDir, "package"), isolateDir);
 }
 
 // src/lib/output/unpack-dependencies.ts
 import fs13 from "fs-extra";
-import path13, { join } from "node:path";
+import path14, { join } from "node:path";
 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 = join(tmpDir, dir);
-      log.debug("Unpacking", `(temp)/${path13.basename(filePath)}`);
+      log.debug("Unpacking", `(temp)/${path14.basename(filePath)}`);
       await unpack(filePath, unpackDir);
       const destinationDir = join(isolateDir, dir);
       await fs13.ensureDir(destinationDir);
@@ -824,25 +862,25 @@ async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, i
 // src/lib/registry/create-packages-registry.ts
 import fs14 from "fs-extra";
 import { globSync } from "glob";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // src/lib/registry/helpers/find-packages-globs.ts
 import assert5 from "node:assert";
-import path14 from "node:path";
+import path15 from "node:path";
 function findPackagesGlobs(workspaceRootDir) {
   const log = useLogger();
   const packageManager2 = usePackageManager();
   switch (packageManager2.name) {
     case "pnpm": {
       const { packages: globs } = readTypedYamlSync(
-        path14.join(workspaceRootDir, "pnpm-workspace.yaml")
+        path15.join(workspaceRootDir, "pnpm-workspace.yaml")
       );
       log.debug("Detected pnpm packages globs:", inspectValue(globs));
       return globs;
     }
     case "yarn":
     case "npm": {
-      const workspaceRootManifestPath = path14.join(
+      const workspaceRootManifestPath = path15.join(
         workspaceRootDir,
         "package.json"
       );
@@ -882,7 +920,7 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
   const allPackages = packagesGlobs.flatMap((glob) => globSync(glob)).filter((dir) => fs14.lstatSync(dir).isDirectory());
   const registry = (await Promise.all(
     allPackages.map(async (rootRelativeDir) => {
-      const manifestPath = path15.join(rootRelativeDir, "package.json");
+      const manifestPath = path16.join(rootRelativeDir, "package.json");
       if (!fs14.existsSync(manifestPath)) {
         log.warn(
           `Ignoring directory ./${rootRelativeDir} because it does not contain a package.json file`
@@ -891,12 +929,12 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
       } else {
         log.debug(`Registering package ./${rootRelativeDir}`);
         const manifest = await readTypedJson(
-          path15.join(rootRelativeDir, "package.json")
+          path16.join(rootRelativeDir, "package.json")
         );
         return {
           manifest,
           rootRelativeDir,
-          absoluteDir: path15.join(workspaceRootDir, rootRelativeDir)
+          absoluteDir: path16.join(workspaceRootDir, rootRelativeDir)
         };
       }
     })
@@ -941,11 +979,11 @@ async function isolate(options = {}) {
   setLogLevel(config.logLevel);
   const log = useLogger();
   const thisPackageManifest = await readTypedJson(
-    path16.join(path16.join(__dirname, "..", "package.json"))
+    path17.join(path17.join(__dirname, "..", "package.json"))
   );
   log.debug("Using isolate-package version", thisPackageManifest.version);
-  const targetPackageDir = config.targetPackagePath ? path16.join(process.cwd(), config.targetPackagePath) : process.cwd();
-  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path16.join(targetPackageDir, config.workspaceRoot);
+  const targetPackageDir = config.targetPackagePath ? path17.join(process.cwd(), config.targetPackagePath) : process.cwd();
+  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path17.join(targetPackageDir, config.workspaceRoot);
   const buildOutputDir = await getBuildOutputDir(targetPackageDir);
   assert6(
     fs15.existsSync(buildOutputDir),
@@ -956,7 +994,7 @@ async function isolate(options = {}) {
     "Isolate target package",
     getRootRelativePath(targetPackageDir, workspaceRootDir)
   );
-  const isolateDir = path16.join(targetPackageDir, config.isolateDirName);
+  const isolateDir = path17.join(targetPackageDir, config.isolateDirName);
   log.debug(
     "Isolate output directory",
     getRootRelativePath(isolateDir, workspaceRootDir)
@@ -966,10 +1004,10 @@ async function isolate(options = {}) {
     log.debug("Cleaned the existing isolate output directory");
   }
   await fs15.ensureDir(isolateDir);
-  const tmpDir = path16.join(isolateDir, "__tmp");
+  const tmpDir = path17.join(isolateDir, "__tmp");
   await fs15.ensureDir(tmpDir);
   const targetPackageManifest = await readTypedJson(
-    path16.join(targetPackageDir, "package.json")
+    path17.join(targetPackageDir, "package.json")
   );
   const packageManager2 = detectPackageManager(workspaceRootDir);
   log.debug(
@@ -1009,18 +1047,20 @@ async function isolate(options = {}) {
     tmpDir,
     isolateDir
   });
-  await adaptTargetPackageManifest(
-    targetPackageManifest,
+  const outputManifest = await adaptTargetPackageManifest({
+    manifest: targetPackageManifest,
     packagesRegistry,
-    isolateDir
-  );
+    workspaceRootDir
+  });
+  await writeManifest(isolateDir, outputManifest);
   const usedFallbackToNpm = await processLockfile({
     workspaceRootDir,
     isolateDir,
     packagesRegistry,
     internalDepPackageNames: internalPackageNames,
     targetPackageDir,
-    targetPackageName: targetPackageManifest.name
+    targetPackageName: targetPackageManifest.name,
+    targetPackageManifest: outputManifest
   });
   if (usedFallbackToNpm) {
     const manifest = await readManifest(isolateDir);
@@ -1030,13 +1070,13 @@ async function isolate(options = {}) {
   }
   if (packageManager2.name === "pnpm" && !config.forceNpm) {
     fs15.copyFileSync(
-      path16.join(workspaceRootDir, "pnpm-workspace.yaml"),
-      path16.join(isolateDir, "pnpm-workspace.yaml")
+      path17.join(workspaceRootDir, "pnpm-workspace.yaml"),
+      path17.join(isolateDir, "pnpm-workspace.yaml")
     );
   }
-  const npmrcPath = path16.join(workspaceRootDir, ".npmrc");
+  const npmrcPath = path17.join(workspaceRootDir, ".npmrc");
   if (fs15.existsSync(npmrcPath)) {
-    fs15.copyFileSync(npmrcPath, path16.join(isolateDir, ".npmrc"));
+    fs15.copyFileSync(npmrcPath, path17.join(isolateDir, ".npmrc"));
     log.debug("Copied .npmrc file to the isolate output");
   }
   log.debug(