isolate-package 1.10.0 → 1.11.0

package/dist/isolate-bin.mjs

@@ -7,7 +7,7 @@ import sourceMaps from "source-map-support";
 // 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";
@@ -88,12 +88,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}`;
 }
 
@@ -109,7 +109,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(
@@ -120,7 +122,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(
@@ -458,7 +462,16 @@ async function generatePnpmLockfile({
         }
       )
     );
-    await writeWantedLockfile(isolateDir, lockfile);
+    await writeWantedLockfile(isolateDir, {
+      ...lockfile,
+      /**
+       * 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
+       * now is that they are omitted by default, because that is the most
+       * common use case.
+       */
+      patchedDependencies: includePatchedDependencies ? lockfile.patchedDependencies : void 0
+    });
     log.debug("Created lockfile at", path6.join(isolateDir, "pnpm-lock.yaml"));
   } catch (err) {
     throw new Error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
@@ -492,26 +505,13 @@ async function generateYarnLockfile({
 }
 
 // src/lib/lockfile/process-lockfile.ts
-function pnpmMapImporter({
-  dependencies,
-  devDependencies,
-  patchedDependencies,
-  ...rest
-}, {
+function pnpmMapImporter({ dependencies, devDependencies, ...rest }, {
   includeDevDependencies,
-  includePatchedDependencies,
   directoryByPackageName
 }) {
   return {
     dependencies: dependencies ? pnpmMapDependenciesLinks(dependencies, directoryByPackageName) : void 0,
     devDependencies: includeDevDependencies && devDependencies ? pnpmMapDependenciesLinks(devDependencies, directoryByPackageName) : void 0,
-    /**
-     * 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
-     * now is that they are omitted by default, because that is the most common
-     * use case.
-     */
-    patchedDependencies: includePatchedDependencies ? patchedDependencies : void 0,
     ...rest
   };
 }
@@ -653,22 +653,25 @@ function adaptManifestInternalDeps({
 // src/lib/manifest/helpers/adapt-internal-package-manifests.ts
 async function adaptInternalPackageManifests(internalPackageNames, packagesRegistry, isolateDir) {
   const packageManager2 = usePackageManager();
-  const { includeDevDependencies, forceNpm } = useConfig();
+  const { forceNpm } = useConfig();
   await Promise.all(
     internalPackageNames.map(async (packageName) => {
       const { manifest, rootRelativeDir } = packagesRegistry[packageName];
-      const inputManifest = includeDevDependencies ? omit(manifest, ["peerDependencies"]) : omit(manifest, ["devDependencies", "peerDependencies"]);
+      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
-      ) : adaptManifestInternalDeps({
-        manifest,
-        packagesRegistry,
-        parentRootRelativeDir: rootRelativeDir
-      });
+        strippedManifest
+      ) : (
+        /** For other package managers we replace the links to internal dependencies */
+        adaptManifestInternalDeps({
+          manifest: strippedManifest,
+          packagesRegistry,
+          parentRootRelativeDir: rootRelativeDir
+        })
+      );
       await writeManifest(
         path10.join(isolateDir, rootRelativeDir),
         outputManifest
@@ -677,17 +680,41 @@ 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,
+  isolateDir,
+  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({
@@ -708,22 +735,22 @@ async function adaptTargetPackageManifest(manifest, packagesRegistry, isolateDir
 
 // 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.
@@ -779,7 +806,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,
@@ -788,7 +815,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) {
@@ -799,19 +826,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);
@@ -831,25 +858,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"
       );
@@ -889,7 +916,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`
@@ -898,12 +925,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)
         };
       }
     })
@@ -948,11 +975,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),
@@ -963,7 +990,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)
@@ -973,10 +1000,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(
@@ -1016,11 +1043,12 @@ async function isolate(options = {}) {
     tmpDir,
     isolateDir
   });
-  await adaptTargetPackageManifest(
-    targetPackageManifest,
+  await adaptTargetPackageManifest({
+    manifest: targetPackageManifest,
     packagesRegistry,
-    isolateDir
-  );
+    isolateDir,
+    workspaceRootDir
+  });
   const usedFallbackToNpm = await processLockfile({
     workspaceRootDir,
     isolateDir,
@@ -1037,13 +1065,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(