isolate-package 1.18.0 → 1.19.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 // src/isolate.ts
 import fs16 from "fs-extra";
 import assert6 from "node:assert";
-import path19 from "node:path";
+import path20 from "node:path";
 import { unique } from "remeda";
 
 // src/lib/config.ts
@@ -84,12 +84,12 @@ function toErrorWithMessage(maybeError) {
 
 // src/lib/utils/get-relative-path.ts
 import { join } from "node:path";
-function getRootRelativePath(path20, rootPath) {
-  const strippedPath = path20.replace(rootPath, "");
+function getRootRelativePath(path21, rootPath) {
+  const strippedPath = path21.replace(rootPath, "");
   return join("(root)", strippedPath);
 }
-function getIsolateRelativePath(path20, isolatePath) {
-  const strippedPath = path20.replace(isolatePath, "");
+function getIsolateRelativePath(path21, isolatePath) {
+  const strippedPath = path21.replace(isolatePath, "");
   return join("(isolate)", strippedPath);
 }
 
@@ -406,13 +406,14 @@ async function generateNpmLockfile({
     await fs9.writeFile(lockfilePath, String(meta));
     log.debug("Created lockfile at", lockfilePath);
   } catch (err) {
-    throw new Error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
+    log.error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
+    throw err;
   }
 }
 
 // src/lib/lockfile/helpers/generate-pnpm-lockfile.ts
 import assert3 from "node:assert";
-import path8 from "node:path";
+import path9 from "node:path";
 import {
   getLockfileImporterId as getLockfileImporterId_v8,
   readWantedLockfile as readWantedLockfile_v8,
@@ -428,22 +429,37 @@ import { pruneLockfile as pruneLockfile_v9 } from "pnpm_prune_lockfile_v9";
 import { pick } from "remeda";
 
 // src/lib/lockfile/helpers/pnpm-map-importer.ts
+import path8 from "node:path";
 import { mapValues } from "remeda";
-function pnpmMapImporter({ dependencies, devDependencies, ...rest }, {
+function pnpmMapImporter(importerPath, { dependencies, devDependencies, ...rest }, {
   includeDevDependencies,
   directoryByPackageName
 }) {
   return {
-    dependencies: dependencies ? pnpmMapDependenciesLinks(dependencies, directoryByPackageName) : void 0,
-    devDependencies: includeDevDependencies && devDependencies ? pnpmMapDependenciesLinks(devDependencies, directoryByPackageName) : void 0,
+    dependencies: dependencies ? pnpmMapDependenciesLinks(
+      importerPath,
+      dependencies,
+      directoryByPackageName
+    ) : void 0,
+    devDependencies: includeDevDependencies && devDependencies ? pnpmMapDependenciesLinks(
+      importerPath,
+      devDependencies,
+      directoryByPackageName
+    ) : void 0,
     ...rest
   };
 }
-function pnpmMapDependenciesLinks(def, directoryByPackageName) {
-  return mapValues(
-    def,
-    (value, key) => value.startsWith("link:") ? `link:./${directoryByPackageName[key]}` : value
-  );
+function pnpmMapDependenciesLinks(importerPath, def, directoryByPackageName) {
+  return mapValues(def, (value, key) => {
+    if (!value.startsWith("link:")) {
+      return value;
+    }
+    const relativePath = path8.relative(
+      importerPath,
+      directoryByPackageName[key]
+    );
+    return relativePath.startsWith(".") ? `link:${relativePath}` : `link:./${relativePath}`;
+  });
 }
 
 // src/lib/lockfile/helpers/generate-pnpm-lockfile.ts
@@ -463,12 +479,12 @@ async function generatePnpmLockfile({
   try {
     const isRush = isRushWorkspace(workspaceRootDir);
     const lockfile = useVersion9 ? await readWantedLockfile_v9(
-      isRush ? path8.join(workspaceRootDir, "common/config/rush") : workspaceRootDir,
+      isRush ? path9.join(workspaceRootDir, "common/config/rush") : workspaceRootDir,
       {
         ignoreIncompatible: false
       }
     ) : await readWantedLockfile_v8(
-      isRush ? path8.join(workspaceRootDir, "common/config/rush") : workspaceRootDir,
+      isRush ? path9.join(workspaceRootDir, "common/config/rush") : workspaceRootDir,
       {
         ignoreIncompatible: false
       }
@@ -503,7 +519,7 @@ async function generatePnpmLockfile({
           log.debug("Setting target package importer on root");
           return [
             ".",
-            pnpmMapImporter(importer, {
+            pnpmMapImporter(".", importer, {
               includeDevDependencies,
               includePatchedDependencies,
               directoryByPackageName
@@ -513,7 +529,7 @@ async function generatePnpmLockfile({
         log.debug("Setting internal package importer:", importerId);
         return [
           importerId,
-          pnpmMapImporter(importer, {
+          pnpmMapImporter(importerId, importer, {
             includeDevDependencies,
             includePatchedDependencies,
             directoryByPackageName
@@ -534,24 +550,25 @@ async function generatePnpmLockfile({
       ...prunedLockfile,
       patchedDependencies
     });
-    log.debug("Created lockfile at", path8.join(isolateDir, "pnpm-lock.yaml"));
+    log.debug("Created lockfile at", path9.join(isolateDir, "pnpm-lock.yaml"));
   } catch (err) {
-    throw new Error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
+    log.error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
+    throw err;
   }
 }
 
 // src/lib/lockfile/helpers/generate-yarn-lockfile.ts
 import fs10 from "fs-extra";
 import { execSync as execSync2 } from "node:child_process";
-import path9 from "node:path";
+import path10 from "node:path";
 async function generateYarnLockfile({
   workspaceRootDir,
   isolateDir
 }) {
   const log = useLogger();
   log.debug("Generating Yarn lockfile...");
-  const origLockfilePath = isRushWorkspace(workspaceRootDir) ? path9.join(workspaceRootDir, "common/config/rush", "yarn.lock") : path9.join(workspaceRootDir, "yarn.lock");
-  const newLockfilePath = path9.join(isolateDir, "yarn.lock");
+  const origLockfilePath = isRushWorkspace(workspaceRootDir) ? path10.join(workspaceRootDir, "common/config/rush", "yarn.lock") : path10.join(workspaceRootDir, "yarn.lock");
+  const newLockfilePath = path10.join(isolateDir, "yarn.lock");
   if (!fs10.existsSync(origLockfilePath)) {
     throw new Error(`Failed to find lockfile at ${origLockfilePath}`);
   }
@@ -562,7 +579,8 @@ async function generateYarnLockfile({
     execSync2(`yarn install --cwd ${isolateDir}`);
     log.debug("Generated lockfile at", newLockfilePath);
   } catch (err) {
-    throw new Error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
+    log.error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
+    throw err;
   }
 }
 
@@ -631,24 +649,24 @@ async function processLockfile({
 import { omit as omit2, pick as pick2 } from "remeda";
 
 // src/lib/manifest/helpers/adapt-internal-package-manifests.ts
-import path12 from "node:path";
+import path13 from "node:path";
 import { omit } from "remeda";
 
 // src/lib/manifest/io.ts
 import fs11 from "fs-extra";
-import path10 from "node:path";
+import path11 from "node:path";
 async function readManifest(packageDir) {
-  return readTypedJson(path10.join(packageDir, "package.json"));
+  return readTypedJson(path11.join(packageDir, "package.json"));
 }
 async function writeManifest(outputDir, manifest) {
   await fs11.writeFile(
-    path10.join(outputDir, "package.json"),
+    path11.join(outputDir, "package.json"),
     JSON.stringify(manifest, null, 2)
   );
 }
 
 // src/lib/manifest/helpers/patch-internal-entries.ts
-import path11 from "node:path";
+import path12 from "node:path";
 function patchInternalEntries(dependencies, packagesRegistry, parentRootRelativeDir) {
   const log = useLogger();
   const allWorkspacePackageNames = Object.keys(packagesRegistry);
@@ -656,7 +674,7 @@ function patchInternalEntries(dependencies, packagesRegistry, parentRootRelative
     Object.entries(dependencies).map(([key, value]) => {
       if (allWorkspacePackageNames.includes(key)) {
         const def = packagesRegistry[key];
-        const relativePath = parentRootRelativeDir ? path11.relative(parentRootRelativeDir, `./${def.rootRelativeDir}`) : `./${def.rootRelativeDir}`;
+        const relativePath = parentRootRelativeDir ? path12.relative(parentRootRelativeDir, `./${def.rootRelativeDir}`) : `./${def.rootRelativeDir}`;
         const linkPath = `file:${relativePath}`;
         log.debug(`Linking dependency ${key} to ${linkPath}`);
         return [key, linkPath];
@@ -711,7 +729,7 @@ async function adaptInternalPackageManifests(internalPackageNames, packagesRegis
         })
       );
       await writeManifest(
-        path12.join(isolateDir, rootRelativeDir),
+        path13.join(isolateDir, rootRelativeDir),
         outputManifest
       );
     })
@@ -719,13 +737,13 @@ async function adaptInternalPackageManifests(internalPackageNames, packagesRegis
 }
 
 // src/lib/manifest/helpers/adopt-pnpm-fields-from-root.ts
-import path13 from "path";
+import path14 from "path";
 async function adoptPnpmFieldsFromRoot(targetPackageManifest, workspaceRootDir) {
   if (isRushWorkspace(workspaceRootDir)) {
     return targetPackageManifest;
   }
   const rootPackageManifest = await readTypedJson(
-    path13.join(workspaceRootDir, "package.json")
+    path14.join(workspaceRootDir, "package.json")
   );
   const overrides = rootPackageManifest.pnpm?.overrides;
   if (!overrides) {
@@ -785,22 +803,22 @@ async function adaptTargetPackageManifest({
 
 // src/lib/output/get-build-output-dir.ts
 import fs12 from "fs-extra";
-import path14 from "node:path";
+import path15 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 path14.join(targetPackageDir, config.buildDirName);
+    return path15.join(targetPackageDir, config.buildDirName);
   }
-  const tsconfigPath = path14.join(targetPackageDir, config.tsconfigPath);
+  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;
     if (outDir) {
-      return path14.join(targetPackageDir, outDir);
+      return path15.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.
@@ -846,7 +864,7 @@ async function packDependencies({
 
 // src/lib/output/process-build-output-files.ts
 import fs13 from "fs-extra";
-import path15 from "node:path";
+import path16 from "node:path";
 var TIMEOUT_MS = 5e3;
 async function processBuildOutputFiles({
   targetPackageDir,
@@ -855,7 +873,7 @@ async function processBuildOutputFiles({
 }) {
   const log = useLogger();
   const packedFilePath = await pack(targetPackageDir, tmpDir);
-  const unpackDir = path15.join(tmpDir, "target");
+  const unpackDir = path16.join(tmpDir, "target");
   const now = Date.now();
   let isWaitingYet = false;
   while (!fs13.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
@@ -866,19 +884,19 @@ async function processBuildOutputFiles({
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   await unpack(packedFilePath, unpackDir);
-  await fs13.copy(path15.join(unpackDir, "package"), isolateDir);
+  await fs13.copy(path16.join(unpackDir, "package"), isolateDir);
 }
 
 // src/lib/output/unpack-dependencies.ts
 import fs14 from "fs-extra";
-import path16, { join as join2 } from "node:path";
+import path17, { join as join2 } 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 = join2(tmpDir, dir);
-      log.debug("Unpacking", `(temp)/${path16.basename(filePath)}`);
+      log.debug("Unpacking", `(temp)/${path17.basename(filePath)}`);
       await unpack(filePath, unpackDir);
       const destinationDir = join2(isolateDir, dir);
       await fs14.ensureDir(destinationDir);
@@ -898,25 +916,25 @@ async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, i
 // src/lib/registry/create-packages-registry.ts
 import fs15 from "fs-extra";
 import { globSync } from "glob";
-import path18 from "node:path";
+import path19 from "node:path";
 
 // src/lib/registry/helpers/find-packages-globs.ts
 import assert5 from "node:assert";
-import path17 from "node:path";
+import path18 from "node:path";
 function findPackagesGlobs(workspaceRootDir) {
   const log = useLogger();
   const packageManager2 = usePackageManager();
   switch (packageManager2.name) {
     case "pnpm": {
       const { packages: globs } = readTypedYamlSync(
-        path17.join(workspaceRootDir, "pnpm-workspace.yaml")
+        path18.join(workspaceRootDir, "pnpm-workspace.yaml")
       );
       log.debug("Detected pnpm packages globs:", inspectValue(globs));
       return globs;
     }
     case "yarn":
     case "npm": {
-      const workspaceRootManifestPath = path17.join(
+      const workspaceRootManifestPath = path18.join(
         workspaceRootDir,
         "package.json"
       );
@@ -956,8 +974,8 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
   );
   const registry = (await Promise.all(
     allPackages.map(async (rootRelativeDir) => {
-      const absoluteDir = path18.join(workspaceRootDir, rootRelativeDir);
-      const manifestPath = path18.join(absoluteDir, "package.json");
+      const absoluteDir = path19.join(workspaceRootDir, rootRelativeDir);
+      const manifestPath = path19.join(absoluteDir, "package.json");
       if (!fs15.existsSync(manifestPath)) {
         log.warn(
           `Ignoring directory ${rootRelativeDir} because it does not contain a package.json file`
@@ -966,7 +984,7 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
       } else {
         log.debug(`Registering package ${rootRelativeDir}`);
         const manifest = await readTypedJson(
-          path18.join(absoluteDir, "package.json")
+          path19.join(absoluteDir, "package.json")
         );
         return {
           manifest,
@@ -986,7 +1004,7 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
 function listWorkspacePackages(workspacePackagesOverride, workspaceRootDir) {
   if (isRushWorkspace(workspaceRootDir)) {
     const rushConfig = readTypedJsonSync(
-      path18.join(workspaceRootDir, "rush.json")
+      path19.join(workspaceRootDir, "rush.json")
     );
     return rushConfig.projects.map(({ projectFolder }) => projectFolder);
   } else {
@@ -1030,11 +1048,11 @@ async function isolate(options = {}) {
   setLogLevel(config.logLevel);
   const log = useLogger();
   const { version: libraryVersion } = await readTypedJson(
-    path19.join(path19.join(__dirname, "..", "package.json"))
+    path20.join(path20.join(__dirname, "..", "package.json"))
   );
   log.info("Using isolate-package version", libraryVersion);
-  const targetPackageDir = config.targetPackagePath ? path19.join(process.cwd(), config.targetPackagePath) : process.cwd();
-  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path19.join(targetPackageDir, config.workspaceRoot);
+  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),
@@ -1045,7 +1063,7 @@ async function isolate(options = {}) {
     "Isolate target package",
     getRootRelativePath(targetPackageDir, workspaceRootDir)
   );
-  const isolateDir = path19.join(targetPackageDir, config.isolateDirName);
+  const isolateDir = path20.join(targetPackageDir, config.isolateDirName);
   log.debug(
     "Isolate output directory",
     getRootRelativePath(isolateDir, workspaceRootDir)
@@ -1055,10 +1073,10 @@ async function isolate(options = {}) {
     log.debug("Cleaned the existing isolate output directory");
   }
   await fs16.ensureDir(isolateDir);
-  const tmpDir = path19.join(isolateDir, "__tmp");
+  const tmpDir = path20.join(isolateDir, "__tmp");
   await fs16.ensureDir(tmpDir);
   const targetPackageManifest = await readTypedJson(
-    path19.join(targetPackageDir, "package.json")
+    path20.join(targetPackageDir, "package.json")
   );
   const packageManager2 = detectPackageManager(workspaceRootDir);
   log.debug(
@@ -1126,25 +1144,25 @@ async function isolate(options = {}) {
     if (isRushWorkspace(workspaceRootDir)) {
       const packagesFolderNames = unique(
         internalPackageNames.map(
-          (name) => path19.parse(packagesRegistry[name].rootRelativeDir).dir
+          (name) => path20.parse(packagesRegistry[name].rootRelativeDir).dir
         )
       );
       log.debug("Generating pnpm-workspace.yaml for Rush workspace");
       log.debug("Packages folder names:", packagesFolderNames);
-      const packages = packagesFolderNames.map((x) => path19.join(x, "/*"));
-      await writeTypedYamlSync(path19.join(isolateDir, "pnpm-workspace.yaml"), {
+      const packages = packagesFolderNames.map((x) => path20.join(x, "/*"));
+      await writeTypedYamlSync(path20.join(isolateDir, "pnpm-workspace.yaml"), {
         packages
       });
     } else {
       fs16.copyFileSync(
-        path19.join(workspaceRootDir, "pnpm-workspace.yaml"),
-        path19.join(isolateDir, "pnpm-workspace.yaml")
+        path20.join(workspaceRootDir, "pnpm-workspace.yaml"),
+        path20.join(isolateDir, "pnpm-workspace.yaml")
       );
     }
   }
-  const npmrcPath = path19.join(workspaceRootDir, ".npmrc");
+  const npmrcPath = path20.join(workspaceRootDir, ".npmrc");
   if (fs16.existsSync(npmrcPath)) {
-    fs16.copyFileSync(npmrcPath, path19.join(isolateDir, ".npmrc"));
+    fs16.copyFileSync(npmrcPath, path20.join(isolateDir, ".npmrc"));
     log.debug("Copied .npmrc file to the isolate output");
   }
   log.debug(