isolate-package 1.20.0 → 1.22.0

package/dist/index.mjs

@@ -1,12 +1,12 @@
 // src/isolate.ts
-import fs16 from "fs-extra";
-import assert6 from "node:assert";
+import fs15 from "fs-extra";
+import assert7 from "node:assert";
 import path20 from "node:path";
 import { unique as unique2 } from "remeda";
 
 // src/lib/config.ts
 import fs8 from "fs-extra";
-import assert2 from "node:assert";
+import assert3 from "node:assert";
 import path6 from "node:path";
 import { isEmpty } from "remeda";
 
@@ -136,6 +136,7 @@ async function readTypedJson(filePath) {
 }
 
 // src/lib/utils/pack.ts
+import assert2 from "node:assert";
 import { exec } from "node:child_process";
 import fs5 from "node:fs";
 import path5 from "node:path";
@@ -287,7 +288,10 @@ async function pack(srcDir, dstDir) {
       }
     );
   });
-  const fileName = path5.basename(stdout.trim());
+  const lastLine = stdout.trim().split("\n").at(-1);
+  assert2(lastLine, `Failed to parse last line from stdout: ${stdout.trim()}`);
+  const fileName = path5.basename(lastLine);
+  assert2(fileName, `Failed to parse file name from: ${lastLine}`);
   const filePath = path5.join(dstDir, fileName);
   if (!fs5.existsSync(filePath)) {
     log.error(
@@ -438,7 +442,7 @@ async function generateNpmLockfile({
 }
 
 // src/lib/lockfile/helpers/generate-pnpm-lockfile.ts
-import assert3 from "node:assert";
+import assert4 from "node:assert";
 import path9 from "node:path";
 import {
   getLockfileImporterId as getLockfileImporterId_v8,
@@ -480,10 +484,7 @@ function pnpmMapDependenciesLinks(importerPath, def, directoryByPackageName) {
     if (!value.startsWith("link:")) {
       return value;
     }
-    const relativePath = path8.relative(
-      importerPath,
-      directoryByPackageName[key]
-    );
+    const relativePath = path8.relative(importerPath, directoryByPackageName[key]).replace(path8.sep, path8.posix.sep);
     return relativePath.startsWith(".") ? `link:${relativePath}` : `link:./${relativePath}`;
   });
 }
@@ -515,12 +516,12 @@ async function generatePnpmLockfile({
         ignoreIncompatible: false
       }
     );
-    assert3(lockfile, `No input lockfile found at ${workspaceRootDir}`);
+    assert4(lockfile, `No input lockfile found at ${workspaceRootDir}`);
     const targetImporterId = useVersion9 ? getLockfileImporterId_v9(workspaceRootDir, targetPackageDir) : getLockfileImporterId_v8(workspaceRootDir, targetPackageDir);
     const directoryByPackageName = Object.fromEntries(
       internalDepPackageNames.map((name) => {
         const pkg = packagesRegistry[name];
-        assert3(pkg, `Package ${name} not found in packages registry`);
+        assert4(pkg, `Package ${name} not found in packages registry`);
         return [name, pkg.rootRelativeDir];
       })
     );
@@ -531,7 +532,17 @@ async function generatePnpmLockfile({
        * importer ids in the context of a lockfile.
        */
       ...Object.values(directoryByPackageName)
-    ];
+      /**
+       * Split the path by the OS separator and join it back with the POSIX
+       * separator.
+       *
+       * The importerIds are built from directory names, so Windows Git Bash
+       * environments will have double backslashes in their ids:
+       * "packages\common" vs. "packages/common". Without this split & join, any
+       * packages not on the top-level will have ill-formatted importerIds and
+       * their entries will be missing from the lockfile.importers list.
+       */
+    ].map((x) => x.split(path9.sep).join(path9.posix.sep));
     log.debug("Relevant importer ids:", relevantImporterIds);
     const relevantImporterIdsWithPrefix = relevantImporterIds.map(
       (x) => isRush ? `../../${x}` : x
@@ -850,7 +861,7 @@ async function adaptTargetPackageManifest({
 }
 
 // src/lib/output/get-build-output-dir.ts
-import fs12 from "fs-extra";
+import { getTsconfig } from "get-tsconfig";
 import path15 from "node:path";
 import outdent from "outdent";
 async function getBuildOutputDir(targetPackageDir) {
@@ -861,10 +872,10 @@ async function getBuildOutputDir(targetPackageDir) {
     return path15.join(targetPackageDir, config.buildDirName);
   }
   const tsconfigPath = path15.join(targetPackageDir, config.tsconfigPath);
-  if (fs12.existsSync(tsconfigPath)) {
-    log.debug("Found tsconfig at:", config.tsconfigPath);
-    const tsconfig = await readTypedJson(tsconfigPath);
-    const outDir = tsconfig.compilerOptions?.outDir;
+  const tsconfig = getTsconfig(tsconfigPath);
+  if (tsconfig) {
+    log.debug("Found tsconfig at:", tsconfig.path);
+    const outDir = tsconfig.config.compilerOptions?.outDir;
     if (outDir) {
       return path15.join(targetPackageDir, outDir);
     } else {
@@ -881,7 +892,7 @@ async function getBuildOutputDir(targetPackageDir) {
 }
 
 // src/lib/output/pack-dependencies.ts
-import assert4 from "node:assert";
+import assert5 from "node:assert";
 async function packDependencies({
   /** All packages found in the monorepo by workspaces declaration */
   packagesRegistry,
@@ -899,7 +910,7 @@ async function packDependencies({
   const packedFileByName = {};
   for (const dependency of internalPackageNames) {
     const def = packagesRegistry[dependency];
-    assert4(dependency, `Failed to find package definition for ${dependency}`);
+    assert5(dependency, `Failed to find package definition for ${dependency}`);
     const { name } = def.manifest;
     if (packedFileByName[name]) {
       log.debug(`Skipping ${name} because it has already been packed`);
@@ -911,7 +922,7 @@ async function packDependencies({
 }
 
 // src/lib/output/process-build-output-files.ts
-import fs13 from "fs-extra";
+import fs12 from "fs-extra";
 import path16 from "node:path";
 var TIMEOUT_MS = 5e3;
 async function processBuildOutputFiles({
@@ -924,7 +935,7 @@ async function processBuildOutputFiles({
   const unpackDir = path16.join(tmpDir, "target");
   const now = Date.now();
   let isWaitingYet = false;
-  while (!fs13.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
+  while (!fs12.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
     if (!isWaitingYet) {
       log.debug(`Waiting for ${packedFilePath} to become available...`);
     }
@@ -932,11 +943,11 @@ async function processBuildOutputFiles({
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   await unpack(packedFilePath, unpackDir);
-  await fs13.copy(path16.join(unpackDir, "package"), isolateDir);
+  await fs12.copy(path16.join(unpackDir, "package"), isolateDir);
 }
 
 // src/lib/output/unpack-dependencies.ts
-import fs14 from "fs-extra";
+import fs13 from "fs-extra";
 import path17, { join as join2 } from "node:path";
 async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, isolateDir) {
   const log = useLogger();
@@ -947,8 +958,8 @@ async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, i
       log.debug("Unpacking", `(temp)/${path17.basename(filePath)}`);
       await unpack(filePath, unpackDir);
       const destinationDir = join2(isolateDir, dir);
-      await fs14.ensureDir(destinationDir);
-      await fs14.move(join2(unpackDir, "package"), destinationDir, {
+      await fs13.ensureDir(destinationDir);
+      await fs13.move(join2(unpackDir, "package"), destinationDir, {
         overwrite: true
       });
       log.debug(
@@ -962,12 +973,12 @@ async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, i
 }
 
 // src/lib/registry/create-packages-registry.ts
-import fs15 from "fs-extra";
+import fs14 from "fs-extra";
 import { globSync } from "glob";
 import path19 from "node:path";
 
 // src/lib/registry/helpers/find-packages-globs.ts
-import assert5 from "node:assert";
+import assert6 from "node:assert";
 import path18 from "node:path";
 function findPackagesGlobs(workspaceRootDir) {
   const log = useLogger();
@@ -999,7 +1010,7 @@ function findPackagesGlobs(workspaceRootDir) {
         return workspaces;
       } else {
         const workspacesObject = workspaces;
-        assert5(
+        assert6(
           workspacesObject.packages,
           "workspaces.packages must be an array"
         );
@@ -1025,7 +1036,7 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
     allPackages.map(async (rootRelativeDir) => {
       const absoluteDir = path19.join(workspaceRootDir, rootRelativeDir);
       const manifestPath = path19.join(absoluteDir, "package.json");
-      if (!fs15.existsSync(manifestPath)) {
+      if (!fs14.existsSync(manifestPath)) {
         log.warn(
           `Ignoring directory ${rootRelativeDir} because it does not contain a package.json file`
         );
@@ -1060,7 +1071,7 @@ function listWorkspacePackages(workspacePackagesOverride, workspaceRootDir) {
     const currentDir = process.cwd();
     process.chdir(workspaceRootDir);
     const packagesGlobs = workspacePackagesOverride ?? findPackagesGlobs(workspaceRootDir);
-    const allPackages = packagesGlobs.flatMap((glob) => globSync(glob)).filter((dir) => fs15.lstatSync(dir).isDirectory());
+    const allPackages = packagesGlobs.flatMap((glob) => globSync(glob)).filter((dir) => fs14.lstatSync(dir).isDirectory());
     process.chdir(currentDir);
     return allPackages;
   }
@@ -1103,8 +1114,8 @@ async function isolate(options = {}) {
   const targetPackageDir = config.targetPackagePath ? path20.join(process.cwd(), config.targetPackagePath) : process.cwd();
   const workspaceRootDir = config.targetPackagePath ? process.cwd() : path20.join(targetPackageDir, config.workspaceRoot);
   const buildOutputDir = await getBuildOutputDir(targetPackageDir);
-  assert6(
-    fs16.existsSync(buildOutputDir),
+  assert7(
+    fs15.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);
@@ -1117,13 +1128,13 @@ async function isolate(options = {}) {
     "Isolate output directory",
     getRootRelativePath(isolateDir, workspaceRootDir)
   );
-  if (fs16.existsSync(isolateDir)) {
-    await fs16.remove(isolateDir);
+  if (fs15.existsSync(isolateDir)) {
+    await fs15.remove(isolateDir);
     log.debug("Cleaned the existing isolate output directory");
   }
-  await fs16.ensureDir(isolateDir);
+  await fs15.ensureDir(isolateDir);
   const tmpDir = path20.join(isolateDir, "__tmp");
-  await fs16.ensureDir(tmpDir);
+  await fs15.ensureDir(tmpDir);
   const targetPackageManifest = await readTypedJson(
     path20.join(targetPackageDir, "package.json")
   );
@@ -1203,22 +1214,22 @@ async function isolate(options = {}) {
         packages
       });
     } else {
-      fs16.copyFileSync(
+      fs15.copyFileSync(
         path20.join(workspaceRootDir, "pnpm-workspace.yaml"),
         path20.join(isolateDir, "pnpm-workspace.yaml")
       );
     }
   }
   const npmrcPath = path20.join(workspaceRootDir, ".npmrc");
-  if (fs16.existsSync(npmrcPath)) {
-    fs16.copyFileSync(npmrcPath, path20.join(isolateDir, ".npmrc"));
+  if (fs15.existsSync(npmrcPath)) {
+    fs15.copyFileSync(npmrcPath, path20.join(isolateDir, ".npmrc"));
     log.debug("Copied .npmrc file to the isolate output");
   }
   log.debug(
     "Deleting temp directory",
     getRootRelativePath(tmpDir, workspaceRootDir)
   );
-  await fs16.remove(tmpDir);
+  await fs15.remove(tmpDir);
   log.info("Isolate completed at", isolateDir);
   return isolateDir;
 }