@walkeros/cli 3.3.0-next-1776098542393 → 3.3.0

package/dist/index.js

@@ -966,6 +966,15 @@ async function withTimeout(promise, ms, errorMessage) {
 function getPackageDirectory(baseDir, packageName) {
   return path8.join(baseDir, "node_modules", packageName);
 }
+function getNestedPackageDirectory(baseDir, consumerName, nestedPackageName) {
+  return path8.join(
+    baseDir,
+    "node_modules",
+    consumerName,
+    "node_modules",
+    nestedPackageName
+  );
+}
 async function collectAllSpecs(packages, logger, configDir, overrides = {}) {
   const allSpecs = /* @__PURE__ */ new Map();
   const visited = /* @__PURE__ */ new Set();
@@ -1094,11 +1103,12 @@ async function collectAllSpecs(packages, logger, configDir, overrides = {}) {
   return allSpecs;
 }
 function resolveVersionConflicts(allSpecs, logger) {
-  const resolved = /* @__PURE__ */ new Map();
+  const topLevel = /* @__PURE__ */ new Map();
+  const nested = [];
   for (const [name, specs] of allSpecs) {
     const localSpec = specs.find((s) => s.localPath);
     if (localSpec) {
-      resolved.set(name, {
+      topLevel.set(name, {
         name,
         version: "local",
         localPath: localSpec.localPath
@@ -1124,6 +1134,7 @@ function resolveVersionConflicts(allSpecs, logger) {
     const directSpecs = activeSpecs.filter((s) => s.source === "direct");
     const directExact = directSpecs.find((s) => semver2.valid(s.spec) !== null);
     let chosenVersion;
+    const alreadyNested = /* @__PURE__ */ new Set();
     if (directExact) {
       chosenVersion = directExact.spec;
     } else if (directSpecs.length > 0) {
@@ -1132,9 +1143,14 @@ function resolveVersionConflicts(allSpecs, logger) {
       const exactVersions = activeSpecs.filter((s) => semver2.valid(s.spec) !== null).map((s) => s.spec);
       const uniqueExact = [...new Set(exactVersions)];
       if (uniqueExact.length > 1) {
-        throw new Error(
-          `Version conflict for ${name}: ${uniqueExact.join(" vs ")} (from ${activeSpecs.map((s) => `${s.spec} via ${s.from}`).join(", ")})`
-        );
+        const sorted = [...uniqueExact].sort(semver2.rcompare);
+        chosenVersion = sorted[0];
+        for (let i2 = 1; i2 < sorted.length; i2++) {
+          const loserVersion = sorted[i2];
+          const consumers = activeSpecs.filter((s) => s.spec === loserVersion).map((s) => s.from);
+          nested.push({ name, version: loserVersion, consumers });
+          alreadyNested.add(loserVersion);
+        }
       } else if (uniqueExact.length === 1) {
         chosenVersion = uniqueExact[0];
       } else {
@@ -1150,6 +1166,9 @@ function resolveVersionConflicts(allSpecs, logger) {
               logger.warn(
                 `${name}@${chosenVersion} differs from peer constraint ${spec.spec} (from ${spec.from})`
               );
+            } else if (!alreadyNested.has(spec.spec)) {
+              nested.push({ name, version: spec.spec, consumers: [spec.from] });
+              alreadyNested.add(spec.spec);
             }
           }
         } else {
@@ -1161,17 +1180,27 @@ function resolveVersionConflicts(allSpecs, logger) {
                 `${name}@${chosenVersion} may not satisfy peer constraint ${spec.spec} (from ${spec.from})`
               );
             } else {
-              throw new Error(
-                `Version conflict: ${name}@${chosenVersion} does not satisfy ${spec.spec} required by ${spec.from}`
-              );
+              nested.push({ name, version: spec.spec, consumers: [spec.from] });
             }
           }
         }
       }
     }
-    resolved.set(name, { name, version: chosenVersion });
+    topLevel.set(name, { name, version: chosenVersion });
   }
-  return resolved;
+  const consolidatedMap = /* @__PURE__ */ new Map();
+  for (const entry of nested) {
+    const key = `${entry.name}@${entry.version}`;
+    const existing = consolidatedMap.get(key);
+    if (existing) {
+      for (const c2 of entry.consumers) {
+        if (!existing.consumers.includes(c2)) existing.consumers.push(c2);
+      }
+    } else {
+      consolidatedMap.set(key, { ...entry, consumers: [...entry.consumers] });
+    }
+  }
+  return { topLevel, nested: [...consolidatedMap.values()] };
 }
 async function downloadPackages(packages, targetDir, logger, useCache = true, configDir, tmpDir, overrides = {}) {
   const packagePaths = /* @__PURE__ */ new Map();
@@ -1184,13 +1213,13 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
     configDir,
     overrides
   );
-  const resolved = resolveVersionConflicts(allSpecs, logger);
+  const { topLevel, nested } = resolveVersionConflicts(allSpecs, logger);
   await fs7.ensureDir(targetDir);
   const localPackageMap = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
     if (pkg.path) localPackageMap.set(pkg.name, pkg.path);
   }
-  for (const [name, pkg] of resolved) {
+  for (const [name, pkg] of topLevel) {
     if (pkg.localPath || localPackageMap.has(name)) {
       const localPath = pkg.localPath || localPackageMap.get(name);
       const localPkg = await resolveLocalPackage(
@@ -1248,6 +1277,48 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
       throw new Error(`Failed to download ${packageSpec}: ${error}`);
     }
   }
+  for (const nestedPkg of nested) {
+    let resolvedSpec = `${nestedPkg.name}@${nestedPkg.version}`;
+    if (!semver2.valid(nestedPkg.version)) {
+      try {
+        const manifest = await withTimeout(
+          pacote.manifest(resolvedSpec, PACOTE_OPTS),
+          PACKAGE_DOWNLOAD_TIMEOUT_MS,
+          `Manifest fetch timed out: ${resolvedSpec}`
+        );
+        const resolved = manifest.version;
+        resolvedSpec = `${nestedPkg.name}@${resolved}`;
+      } catch (error) {
+        throw new Error(
+          `Failed to resolve nested dependency ${resolvedSpec}: ${error}`
+        );
+      }
+    }
+    for (const consumer of nestedPkg.consumers) {
+      const nestedDir = getNestedPackageDirectory(
+        targetDir,
+        consumer,
+        nestedPkg.name
+      );
+      try {
+        await fs7.ensureDir(path8.dirname(nestedDir));
+        const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(tmpDir, "cache", "npm");
+        await withTimeout(
+          pacote.extract(resolvedSpec, nestedDir, {
+            ...PACOTE_OPTS,
+            cache: cacheDir
+          }),
+          PACKAGE_DOWNLOAD_TIMEOUT_MS,
+          `Nested package download timed out: ${resolvedSpec}`
+        );
+        logger.debug(`Nested: ${resolvedSpec} under ${consumer}`);
+      } catch (error) {
+        throw new Error(
+          `Failed to install nested ${resolvedSpec} for ${consumer}: ${error}`
+        );
+      }
+    }
+  }
   return packagePaths;
 }
 async function getCachedPackagePath(pkg, tmpDir) {
@@ -1932,7 +2003,7 @@ function detectExplicitCodeImports(flowSettings) {
   }
   return explicitCodeImports;
 }
-async function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, storePackages, explicitCodeImports, packagePaths) {
+async function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, storePackages, explicitCodeImports, packagePaths, withDev) {
   const importStatements = [];
   const usedPackages = /* @__PURE__ */ new Set([
     ...destinationPackages,
@@ -1978,21 +2049,23 @@ async function generateImportStatements(packages, destinationPackages, sourcePac
     }
   }
   const devExportEntries = [];
-  for (const packageName of usedPackages) {
-    const localPath = packagePaths.get(packageName);
-    if (!localPath) continue;
-    try {
-      const pkgJsonPath = path10.join(localPath, "package.json");
-      const pkgJson = await fs9.readJSON(pkgJsonPath);
-      const exports = pkgJson.exports;
-      if (exports && typeof exports === "object" && "./dev" in exports) {
-        const varName = `__dev_${packageNameToVariable(packageName)}`;
-        importStatements.push(
-          `import * as ${varName} from '${packageName}/dev';`
-        );
-        devExportEntries.push(`'${packageName}': ${varName}`);
+  if (withDev) {
+    for (const packageName of usedPackages) {
+      const localPath = packagePaths.get(packageName);
+      if (!localPath) continue;
+      try {
+        const pkgJsonPath = path10.join(localPath, "package.json");
+        const pkgJson = await fs9.readJSON(pkgJsonPath);
+        const exports = pkgJson.exports;
+        if (exports && typeof exports === "object" && "./dev" in exports) {
+          const varName = `__dev_${packageNameToVariable(packageName)}`;
+          importStatements.push(
+            `import * as ${varName} from '${packageName}/dev';`
+          );
+          devExportEntries.push(`'${packageName}': ${varName}`);
+        }
+      } catch {
       }
-    } catch {
     }
   }
   return { importStatements, devExportEntries };
@@ -2065,7 +2138,8 @@ async function createEntryPoint(flowSettings, buildOptions, packagePaths) {
     transformerPackages,
     storePackages,
     explicitCodeImports,
-    packagePaths
+    packagePaths,
+    buildOptions.skipWrapper === true
   );
   const importsCode = importStatements.join("\n");
   const hasFlow = Object.values(flowSettings.sources || {}).some(