@teambit/dependency-resolver 1.0.912 → 1.0.913

package/manifest/workspace-manifest-factory.ts

@@ -4,13 +4,16 @@ import { IssuesClasses } from '@teambit/component-issues';
 import type { Component } from '@teambit/component';
 import { componentIdToPackageName } from '@teambit/pkg.modules.component-package-name';
 import { fromPairs, pickBy, mapValues, uniq, difference } from 'lodash';
-import { SemVer } from 'semver';
+import semver, { SemVer } from 'semver';
 import pMapSeries from 'p-map-series';
 import { snapToSemver } from '@teambit/component-package-version';
+import type { Logger } from '@teambit/logger';
 import type { DependencyList, PackageName } from '../dependencies';
 import { ComponentDependency } from '../dependencies';
 import type { WorkspacePolicy, EnvPolicy } from '../policy';
 import { VariantPolicy } from '../policy';
+import type { VariantPolicyEntry } from '../policy/variant-policy';
+import { createVariantPolicyEntry } from '../policy/variant-policy';
 import type { DependencyResolverMain } from '../dependency-resolver.main.runtime';
 import type { ComponentsManifestsMap } from '../types';
 import { ComponentManifest } from './component-manifest';
@@ -49,7 +52,10 @@ const DEFAULT_CREATE_OPTIONS: CreateFromComponentsOptions = {
 export class WorkspaceManifestFactory {
   constructor(
     private dependencyResolver: DependencyResolverMain,
-    private aspectLoader: AspectLoaderMain
+    private aspectLoader: AspectLoaderMain,
+    private logger?: Logger,
+    private resolveEnvPeersFromRoot: boolean = true,
+    private forceEnvPeersToRoot: boolean = false
   ) {}
 
   async createFromComponents(
@@ -97,14 +103,29 @@ export class WorkspaceManifestFactory {
       components,
       optsWithDefaults.createManifestForComponentsWithoutDependencies
     );
-    const envSelfPeers = this.getEnvsSelfPeersPolicy(componentsManifestsMap);
+    let envSelfPeers: VariantPolicy;
+    let peerOverrides: Record<string, string> = {};
+    if (this.resolveEnvPeersFromRoot) {
+      const workspacePackageNames = new Set(
+        components.map((component) => this.dependencyResolver.getPackageName(component))
+      );
+      const result = this.mergeEnvPeersToRoot(componentsManifestsMap, workspacePackageNames);
+      envSelfPeers = result.rootPolicy;
+      peerOverrides = result.peerOverrides;
+      if (result.componentPeerOverrides.size > 0) {
+        this.injectConflictingPeersToComponents(componentsManifestsMap, result.componentPeerOverrides);
+      }
+    } else {
+      envSelfPeers = this.getEnvsSelfPeersPolicy(componentsManifestsMap);
+    }
     const workspaceManifest = new WorkspaceManifest(
       name,
       version,
       dedupedDependencies.rootDependencies,
       envSelfPeers,
       rootDir,
-      componentsManifestsMap
+      componentsManifestsMap,
+      peerOverrides
     );
     return workspaceManifest;
   }
@@ -116,6 +137,230 @@ export class WorkspaceManifestFactory {
     return rootPolicy.filter((dep) => !coreAspectPkgNames.has(dep.dependencyId));
   }
 
+  /**
+   * Merge env peer dependencies to the workspace root.
+   * - Non-conflicting peers: always merge to root
+   * - Conflicting peers with workspaceSingleton: merge majority to root, warn about unsatisfied envs
+   * - Conflicting peers without workspaceSingleton: skip root, return as componentPeerOverrides for per-component injection
+   */
+  private mergeEnvPeersToRoot(
+    componentsManifestsMap: ComponentsManifestsMap,
+    workspacePackageNames: Set<string>
+  ): {
+    rootPolicy: VariantPolicy;
+    componentPeerOverrides: Map<string, Record<string, string>>;
+    peerOverrides: Record<string, string>;
+  } {
+    // Collect all env selfPolicies grouped by package name
+    // Map<packageName, Map<version, Set<envId>>>
+    const peerVersionsMap = new Map<string, Map<string, Set<string>>>();
+    // Track workspaceSingleton flag per package (true if ANY env marks it)
+    const singletonFlags = new Map<string, boolean>();
+    // Track overrides flag per package (true if ANY env marks it)
+    const overridesFlags = new Map<string, boolean>();
+
+    for (const manifest of componentsManifestsMap.values()) {
+      const envId = manifest.envPolicy.envId || 'unknown';
+      const selfPolicy = manifest.envPolicy.selfPolicy;
+      for (const entry of selfPolicy.entries) {
+        // Skip peers that are workspace components — they're linked, not installed
+        if (workspacePackageNames.has(entry.dependencyId)) continue;
+        const pkgName = entry.dependencyId;
+        const version = entry.value.version;
+        if (!peerVersionsMap.has(pkgName)) {
+          peerVersionsMap.set(pkgName, new Map());
+        }
+        const versionsMap = peerVersionsMap.get(pkgName)!;
+        if (!versionsMap.has(version)) {
+          versionsMap.set(version, new Set());
+        }
+        versionsMap.get(version)!.add(envId);
+        if (entry.value.workspaceSingleton) {
+          singletonFlags.set(pkgName, true);
+        }
+        if (entry.value.override) {
+          overridesFlags.set(pkgName, true);
+        }
+      }
+    }
+
+    // Resolve each peer dependency
+    const resolvedEntries: VariantPolicyEntry[] = [];
+    // Map<envId, Record<pkgName, version>> for per-component injection
+    const componentPeerOverrides = new Map<string, Record<string, string>>();
+    // Collect pnpm overrides from entries with overrides: true
+    const peerOverrides: Record<string, string> = {};
+    // Track packages with conflicts for the hint message
+    const conflictingPackages: string[] = [];
+
+    for (const [pkgName, versionsMap] of peerVersionsMap.entries()) {
+      const versions = Array.from(versionsMap.keys());
+
+      if (versions.length === 1) {
+        // No conflict — merge to root
+        const entry = this.createResolvedEntry(componentsManifestsMap, pkgName, versions[0]);
+        resolvedEntries.push(entry);
+        if (overridesFlags.get(pkgName) && versions[0] !== '+') {
+          peerOverrides[pkgName] = versions[0];
+        }
+        continue;
+      }
+
+      // overrides:true implies singleton — an override forces a single version across the workspace
+      const isSingleton =
+        this.forceEnvPeersToRoot || (singletonFlags.get(pkgName) ?? false) || (overridesFlags.get(pkgName) ?? false);
+
+      if (isSingleton) {
+        // Conflict + workspaceSingleton: merge majority to root, warn about unsatisfied
+        const chosenVersion = this.resolveConflictingPeerVersions(pkgName, versionsMap);
+        resolvedEntries.push(this.createResolvedEntry(componentsManifestsMap, pkgName, chosenVersion));
+        conflictingPackages.push(pkgName);
+        if (overridesFlags.get(pkgName) && chosenVersion !== '+') {
+          peerOverrides[pkgName] = chosenVersion;
+        }
+      } else {
+        // Conflict + no workspaceSingleton: per-component injection
+        // Each env gets its own version injected into its components
+        for (const [version, envIds] of versionsMap.entries()) {
+          // Skip "+" placeholder — it's resolved at the workspace root level
+          if (version === '+') continue;
+          for (const envId of envIds) {
+            if (!componentPeerOverrides.has(envId)) {
+              componentPeerOverrides.set(envId, {});
+            }
+            componentPeerOverrides.get(envId)![pkgName] = version;
+          }
+        }
+      }
+    }
+
+    if (conflictingPackages.length > 0) {
+      this.logger?.console?.(
+        `\n💡 To resolve workspace peer version conflicts, pin a version in workspace.jsonc under "teambit.dependencies/dependency-resolver" > "overrides", ` +
+          `e.g. "overrides": { "${conflictingPackages[0]}": "<version>" }\n`
+      );
+    }
+
+    return {
+      rootPolicy: VariantPolicy.fromArray(resolvedEntries),
+      componentPeerOverrides,
+      peerOverrides,
+    };
+  }
+
+  private createResolvedEntry(
+    componentsManifestsMap: ComponentsManifestsMap,
+    pkgName: string,
+    version: string
+  ): VariantPolicyEntry {
+    const existingEntry = this.findEntryWithVersion(componentsManifestsMap, pkgName, version);
+    if (existingEntry) return existingEntry;
+    return createVariantPolicyEntry(pkgName, version, 'runtime', {
+      source: 'env-own',
+      force: true,
+    });
+  }
+
+  /**
+   * Inject conflicting non-singleton peer deps into component manifests.
+   * Each component gets the version specified by its env.
+   */
+  private injectConflictingPeersToComponents(
+    componentsManifestsMap: ComponentsManifestsMap,
+    componentPeerOverrides: Map<string, Record<string, string>>
+  ): void {
+    for (const manifest of componentsManifestsMap.values()) {
+      const envId = manifest.envPolicy.envId || 'unknown';
+      const overrides = componentPeerOverrides.get(envId);
+      if (!overrides) continue;
+      manifest.dependencies.dependencies = {
+        ...overrides,
+        ...manifest.dependencies.dependencies,
+      };
+    }
+  }
+
+  private resolveConflictingPeerVersions(pkgName: string, versionsMap: Map<string, Set<string>>): string {
+    const versions = Array.from(versionsMap.keys());
+    const envsByVersion = Array.from(versionsMap.entries());
+
+    // Filter out non-semver versions (like '+') for comparison
+    const semverVersions = versions.filter((v) => v !== '+' && semver.coerce(v) !== null);
+
+    if (semverVersions.length === 0) {
+      // All versions are non-semver (e.g., '+'), just pick the first
+      return versions[0];
+    }
+
+    // For each version, count how many envs it could satisfy
+    let bestVersion = semverVersions[0];
+    let bestCount = 0;
+
+    for (const candidateVersion of semverVersions) {
+      const coercedCandidate = semver.coerce(candidateVersion);
+      if (!coercedCandidate) continue;
+      let satisfiedCount = 0;
+      for (const [version, envIds] of envsByVersion) {
+        if (version === candidateVersion || version === '+') {
+          satisfiedCount += envIds.size;
+        } else if (semver.validRange(version)) {
+          // Check if the candidate could satisfy the range
+          if (semver.satisfies(coercedCandidate.version, version)) {
+            satisfiedCount += envIds.size;
+          }
+        }
+      }
+      const coercedBest = semver.coerce(bestVersion);
+      if (
+        satisfiedCount > bestCount ||
+        (satisfiedCount === bestCount && coercedBest && semver.gt(coercedCandidate.version, coercedBest.version))
+      ) {
+        bestVersion = candidateVersion;
+        bestCount = satisfiedCount;
+      }
+    }
+
+    // Only warn about envs whose version is NOT satisfied by the chosen version
+    const coercedBestForCheck = semver.coerce(bestVersion);
+    const unsatisfiedEnvs = envsByVersion.filter(([version]) => {
+      if (version === bestVersion || version === '+') return false;
+      if (coercedBestForCheck && semver.validRange(version) && semver.satisfies(coercedBestForCheck.version, version))
+        return false;
+      return true;
+    });
+
+    if (unsatisfiedEnvs.length > 0) {
+      const allDetails = envsByVersion
+        .map(([version, envIds]) => `  ${version} (from envs: ${Array.from(envIds).join(', ')})`)
+        .join('\n');
+      this.logger?.warn(
+        `Conflicting env peer dependency versions for "${pkgName}":\n${allDetails}\n  → Resolved to: ${bestVersion}`
+      );
+      const unsatisfiedDetails = unsatisfiedEnvs
+        .map(([version, envIds]) => `${version} (${Array.from(envIds).join(', ')})`)
+        .join(', ');
+      this.logger?.consoleWarning?.(
+        `Conflicting env peer versions for "${pkgName}": using ${bestVersion}, but not compatible with: ${unsatisfiedDetails}`
+      );
+    }
+
+    return bestVersion;
+  }
+
+  private findEntryWithVersion(
+    componentsManifestsMap: ComponentsManifestsMap,
+    pkgName: string,
+    version: string
+  ): VariantPolicyEntry | undefined {
+    for (const manifest of componentsManifestsMap.values()) {
+      const entry = manifest.envPolicy.selfPolicy.entries.find(
+        (e) => e.dependencyId === pkgName && e.value.version === version
+      );
+      if (entry) return entry;
+    }
+    return undefined;
+  }
+
   private getEnvsSelfPeersPolicy(componentsManifestsMap: ComponentsManifestsMap) {
     const foundEnvs: EnvPolicy[] = [];
     for (const component of componentsManifestsMap.values()) {
@@ -215,36 +460,34 @@ export class WorkspaceManifestFactory {
         );
       });
 
-      const envPeerDependencies = await this._getEnvPeerDependencies(component, packageNames);
-      // When includeAllEnvPeers is true, use ALL env peer deps to ensure consistent
-      // peer dependency contexts across all components. Otherwise, pnpm creates separate
-      // "injected" copies in .pnpm/ for components with different peer sets, causing
-      // TypeScript to see duplicate types from different physical paths.
-      // When false, only include peer deps that the component actually uses, to avoid
-      // writing unnecessary deps to the generated install manifest.
-      let peerDepsForManifest: Record<string, string>;
-      if (includeAllEnvPeers ?? true) {
-        peerDepsForManifest = envPeerDependencies;
-      } else {
-        peerDepsForManifest = pickBy(envPeerDependencies, (_val, pkgName) => {
-          return (
-            depManifestBeforeFiltering.dependencies[pkgName] ||
-            depManifestBeforeFiltering.devDependencies[pkgName] ||
-            depManifestBeforeFiltering.peerDependencies[pkgName]
-          );
-        });
-        // In case the env has peer dependencies on both react and react-dom, we want to make sure to keep the versions
-        // in sync with each other, otherwise it may cause issues in the workspace
-        // This is a special case for react and react-dom, as most component do import from react, making it a peer dependency,
-        // but not necessarily import from react-dom, which from env.jsonc peers in that case not added to the peers of the component.
-        // and if the versions are not in sync, it may cause issues in the workspace
-        // an example:
-        // my-comp depend on react, and using @testing-library/react which depend on react-dom (as peer),
-        // the component don't have react-dom as peer dependency, but when we install the dependencies in the workspace,
-        // it will install the latest version of react-dom which may not be compatible with the version of react that my-comp
-        // is using, and it may cause issues in the workspace.
-        if (peerDepsForManifest.react && envPeerDependencies['react-dom']) {
-          peerDepsForManifest['react-dom'] = envPeerDependencies['react-dom'];
+      let peerDepsForManifest: Record<string, string> = {};
+      if (!this.resolveEnvPeersFromRoot) {
+        // Legacy behavior: inject env peer deps into each component's manifest
+        const envPeerDependencies = await this._getEnvPeerDependencies(component, packageNames);
+        if (includeAllEnvPeers ?? true) {
+          peerDepsForManifest = envPeerDependencies;
+        } else {
+          peerDepsForManifest = pickBy(envPeerDependencies, (_val, pkgName) => {
+            return (
+              depManifestBeforeFiltering.dependencies[pkgName] ||
+              depManifestBeforeFiltering.devDependencies[pkgName] ||
+              depManifestBeforeFiltering.peerDependencies[pkgName]
+            );
+          });
+
+          // In case the env has peer dependencies on both react and react-dom, we want to make sure to keep the versions
+          // in sync with each other, otherwise it may cause issues in the workspace
+          // This is a special case for react and react-dom, as most component do import from react, making it a peer dependency,
+          // but not necessarily import from react-dom, which from env.jsonc peers in that case not added to the peers of the component.
+          // and if the versions are not in sync, it may cause issues in the workspace
+          // an example:
+          // my-comp depend on react, and using @testing-library/react which depend on react-dom (as peer),
+          // the component don't have react-dom as peer dependency, but when we install the dependencies in the workspace,
+          // it will install the latest version of react-dom which may not be compatible with the version of react that my-comp
+          // is using, and it may cause issues in the workspace.
+          if (peerDepsForManifest.react && envPeerDependencies['react-dom']) {
+            peerDepsForManifest['react-dom'] = envPeerDependencies['react-dom'];
+          }
         }
       }
 

package/manifest/workspace-manifest.ts

@@ -7,6 +7,7 @@ import { Manifest } from './manifest';
 
 export interface WorkspaceManifestToJsonOptions extends ManifestToJsonOptions {
   installPeersFromEnvs?: boolean;
+  resolveEnvPeersFromRoot?: boolean;
 }
 
 export class WorkspaceManifest extends Manifest {
@@ -17,7 +18,8 @@ export class WorkspaceManifest extends Manifest {
     public dependencies: ManifestDependenciesObject,
     private envSelfPeersPolicy: VariantPolicy | undefined,
     private rootDir: string,
-    public componentsManifestsMap: ComponentsManifestsMap
+    public componentsManifestsMap: ComponentsManifestsMap,
+    public peerOverrides: Record<string, string> = {}
   ) {
     super(name, version, dependencies);
   }
@@ -30,12 +32,21 @@ export class WorkspaceManifest extends Manifest {
 
   toJson(options: WorkspaceManifestToJsonOptions = {}): Record<string, any> {
     const manifest = super.toJson(options);
-    if (options.installPeersFromEnvs) {
+    if (options.installPeersFromEnvs || options.resolveEnvPeersFromRoot) {
       const peersManifest = this.envSelfPeersPolicy?.toVersionManifest();
       // Resolve "+" version placeholders from peersManifest
       const resolvedPeersManifest = this._resolvePlusVersions(peersManifest || {});
       manifest.dependencies = manifest.dependencies || {};
-      Object.assign(manifest.dependencies, resolvedPeersManifest);
+      // Env peers are added as defaults — workspace.jsonc policy takes priority across all dep sections
+      for (const [pkgName, version] of Object.entries(resolvedPeersManifest)) {
+        const alreadyDefined = manifest.dependencies?.[pkgName] ||
+          manifest.devDependencies?.[pkgName] ||
+          manifest.peerDependencies?.[pkgName] ||
+          manifest.optionalDependencies?.[pkgName];
+        if (!alreadyDefined) {
+          manifest.dependencies[pkgName] = version;
+        }
+      }
     }
     return manifest;
   }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/dependency-resolver",
-  "version": "1.0.912",
+  "version": "1.0.913",
   "homepage": "https://bit.cloud/teambit/dependencies/dependency-resolver",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.dependencies",
     "name": "dependency-resolver",
-    "version": "1.0.912"
+    "version": "1.0.913"
   },
   "dependencies": {
     "chalk": "4.1.2",
@@ -52,14 +52,14 @@
     "@teambit/component-issues": "0.0.170",
     "@teambit/component-package-version": "0.0.449",
     "@teambit/legacy-bit-id": "1.1.3",
-    "@teambit/toolbox.object.sorter": "0.0.2",
     "@teambit/legacy.consumer-config": "0.0.101",
     "@teambit/toolbox.crypto.sha1": "0.0.15",
-    "@teambit/component": "1.0.912",
-    "@teambit/envs": "1.0.912",
-    "@teambit/aspect-loader": "1.0.912",
-    "@teambit/objects": "0.0.419",
-    "@teambit/graphql": "1.0.912"
+    "@teambit/toolbox.object.sorter": "0.0.2",
+    "@teambit/component": "1.0.913",
+    "@teambit/envs": "1.0.913",
+    "@teambit/aspect-loader": "1.0.913",
+    "@teambit/objects": "0.0.420",
+    "@teambit/graphql": "1.0.913"
   },
   "devDependencies": {
     "@types/fs-extra": "9.0.7",

package/policy/env-policy/env-policy.ts

@@ -23,6 +23,19 @@ export type EnvJsoncPolicyEntry = {
 
 export type EnvJsoncPolicyPeerEntry = EnvJsoncPolicyEntry & {
   supportedRange: string;
+  /**
+   * When true, this peer dependency will be resolved as a single version at the workspace root,
+   * even if different envs specify different versions. Useful for @types packages and workspace-level
+   * tools (eslint, prettier) that must resolve from the workspace root.
+   * When false (default), conflicts are resolved per-component via env roots.
+   */
+  workspaceSingleton?: boolean;
+  /**
+   * When true, generates a pnpm override for this peer using its version,
+   * forcing all transitive dependencies to use the same version.
+   * Useful to prevent old versions from being pulled by published packages.
+   */
+  override?: boolean;
 };
 
 export type VersionKeyName = 'version' | 'supportedRange';
@@ -45,14 +58,16 @@ export type EnvPolicyConfigObject = EnvPolicyEnvJsoncConfigObject | EnvPolicyLeg
 export class EnvPolicy extends VariantPolicy {
   constructor(
     _policiesEntries: VariantPolicyEntry[],
-    readonly selfPolicy: VariantPolicy
+    readonly selfPolicy: VariantPolicy,
+    readonly envId?: string
   ) {
     super(_policiesEntries);
   }
 
   static fromConfigObject(
     configObject: EnvPolicyConfigObject,
-    { includeLegacyPeersInSelfPolicy }: VariantPolicyFromConfigObjectOptions = {}
+    { includeLegacyPeersInSelfPolicy }: VariantPolicyFromConfigObjectOptions = {},
+    envId?: string
   ): EnvPolicy {
     validateEnvPolicyConfigObject(configObject);
 
@@ -95,7 +110,7 @@ export class EnvPolicy extends VariantPolicy {
     );
     const newPolicy = VariantPolicy.fromArray(componentPeersEntries.concat(otherEntries));
     const finalComponentPolicy = VariantPolicy.mergePolices([legacyPolicy, newPolicy]);
-    return new EnvPolicy(finalComponentPolicy.entries, selfPolicy);
+    return new EnvPolicy(finalComponentPolicy.entries, selfPolicy, envId);
   }
 
   static getEmpty(): EnvPolicy {
@@ -134,7 +149,12 @@ function entriesFromKey(
         `env.jsonc: "policy.${keyName}" entry must be a property with a "${versionKey}" field. got "${entry}"`
       );
     }
-    return createVariantPolicyEntry(entry.name, entry[versionKey], lifecycleType, {
+    const peerEntry = entry as EnvJsoncPolicyPeerEntry;
+    const hasPeerProps = 'workspaceSingleton' in entry || 'override' in entry;
+    const value = hasPeerProps
+      ? { version: entry[versionKey], workspaceSingleton: peerEntry.workspaceSingleton, override: peerEntry.override }
+      : entry[versionKey];
+    return createVariantPolicyEntry(entry.name, value, lifecycleType, {
       ...options,
       source: options.source ?? 'env',
       hidden: entry.hidden,

package/policy/variant-policy/variant-policy.ts

@@ -40,6 +40,8 @@ export type VariantPolicyEntryValue = {
   version: VariantPolicyEntryVersion;
   resolveFromEnv?: boolean;
   optional?: boolean;
+  workspaceSingleton?: boolean;
+  override?: boolean;
 };
 
 export type DependencySource = 'auto' | 'env' | 'env-own' | 'slots' | 'config';
@@ -343,10 +345,14 @@ export function createVariantPolicyEntry(
   const version = typeof value === 'string' ? value : value.version;
   const resolveFromEnv = typeof value === 'string' ? false : value.resolveFromEnv;
   const optional = typeof value === 'string' ? undefined : value.optional;
+  const workspaceSingleton = typeof value === 'string' ? undefined : value.workspaceSingleton;
+  const override = typeof value === 'string' ? undefined : value.override;
 
   const entryValue: VariantPolicyEntryValue = {
     version,
     resolveFromEnv,
+    workspaceSingleton,
+    override,
   };
   const entry: VariantPolicyEntry = {
     ...opts,