@teambit/dependencies 1.0.1271 → 1.0.1273

package/dependencies-loader/apply-overrides.ts

@@ -23,7 +23,7 @@ import { ComponentOverrides } from '@teambit/legacy.consumer-config';
 import OverridesDependencies from './overrides-dependencies';
 import { DependenciesData } from './dependencies-data';
 import type { DebugDependencies, FileType } from './auto-detect-deps';
-import { getValidComponentVersion } from './auto-detect-deps';
+import { getValidComponentVersion, getVersionInRangeIfOutOfIt } from './auto-detect-deps';
 
 export type AllDependencies = {
   dependencies: Dependency[];
@@ -343,21 +343,14 @@ export class ApplyOverrides {
   }
 
   /**
-   * the scope side of the installed version in updateDependenciesVersions(): a workspace installs a component peer in
-   * the range of the policy, and records the installed version. so when the version is out of the range, it's changed
-   * to the version of the range. (when it's in the range, it's kept, as a workspace that has it installed would do)
+   * the scope side of peerVersionInRange() in updateDependenciesVersions(): when the version of a component peer is
+   * out of the range of the policy, it's changed to the version of the range. (when it's in the range, it's kept)
    */
   private setComponentPeerVersionInRange(dependency: Dependency, range: string) {
     if (!this.workspaceComponentIds || this.workspaceComponentIds.hasWithoutVersion(dependency.id)) return;
     const version = dependency.id.version;
-    if (!version || !semver.validRange(range)) return;
-    // a snap is not in any semver range, a workspace would install a version of the range instead
-    if (semver.valid(version) && semver.satisfies(version, range)) return;
-    const { version: versionInRange } = getValidComponentVersion(range);
-    // e.g. "<2.0.0" is coerced to "2.0.0", which is out of the range. there's no version to take for such a range.
-    if (versionInRange && semver.satisfies(versionInRange, range)) {
-      dependency.id = dependency.id.changeVersion(versionInRange);
-    }
+    const versionInRange = version ? getVersionInRangeIfOutOfIt(version, range) : undefined;
+    if (versionInRange) dependency.id = dependency.id.changeVersion(versionInRange);
   }
 
   private setVersionFromConfig(id: ComponentID) {

package/dependencies-loader/auto-detect-deps.ts

@@ -755,6 +755,18 @@ export class AutoDetectDeps {
   }
 }
 
+/**
+ * a policy (e.g. an env) can set the range of a component peer. a version that satisfies the range is kept, so this
+ * returns undefined. otherwise, it returns the version of the range (a snap is not in any semver range).
+ * it returns undefined also when the range has no such version, e.g. "<2.0.0" is coerced to "2.0.0".
+ */
+export function getVersionInRangeIfOutOfIt(version: string, range: string): string | undefined {
+  if (!semver.validRange(range)) return undefined;
+  if (semver.valid(version) && semver.satisfies(version, range)) return undefined;
+  const { version: versionInRange } = getValidComponentVersion(range);
+  return versionInRange && semver.satisfies(versionInRange, range) ? versionInRange : undefined;
+}
+
 /**
  * this is not necessarily a valid semver version. in case of a snap, it returns the hash only, not a valid semver.
  * this is for the ComponentID.version.

package/dependencies-loader/dependencies-versions-resolver.spec.ts

@@ -0,0 +1,88 @@
+import { expect } from 'chai';
+import { ComponentID, ComponentIdList } from '@teambit/component-id';
+import { Dependencies, Dependency } from '@teambit/legacy.consumer-component';
+import type { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { updateDependenciesVersions } from './dependencies-versions-resolver';
+
+const linkPkg = '@my-scope/navigation.link';
+const linkId = ComponentID.fromString('my-scope/navigation/link');
+
+/**
+ * a component with a component peer that its env sets with a range (the range is set before, by ApplyOverrides).
+ * the last snap of the component has the peer in version 2.0.1.
+ */
+async function resolvePeerVersion({
+  range,
+  inBitmap = false,
+  forced,
+  workspacePolicy,
+  debugDependencies,
+}: {
+  range: string;
+  inBitmap?: boolean;
+  forced?: string;
+  workspacePolicy?: string;
+  debugDependencies?: any[];
+}): Promise<string | undefined> {
+  const peer = new Dependency(linkId.changeVersion('2.0.1'), [], linkPkg, range);
+  const component: any = {
+    id: ComponentID.fromString('my-scope/card@0.0.1'),
+    dependencies: new Dependencies(),
+    devDependencies: new Dependencies(),
+    peerDependencies: new Dependencies([peer]),
+    overrides: { getComponentDependenciesWithVersion: () => ({}) },
+    componentFromModel: { getAllDependenciesIds: () => ComponentIdList.fromArray([linkId.changeVersion('2.0.1')]) },
+  };
+  const workspace: any = {
+    getAutoDetectConfigMerge: () => undefined,
+    getCurrentLaneObject: async () => undefined,
+    consumer: { bitmapIdsFromCurrentLane: ComponentIdList.fromArray(inBitmap ? [linkId.changeVersion('2.0.5')] : []) },
+  };
+  const depsResolver = {
+    calcComponentRangePrefixByConsumerComponent: () => (workspacePolicy ? '^' : undefined),
+    getWorkspacePolicyManifest: () => ({ dependencies: workspacePolicy ? { [linkPkg]: workspacePolicy } : {} }),
+  } as unknown as DependencyResolverMain;
+  const overridesDependencies: any = {
+    envOwnPkgNames: new Set(),
+    getDependenciesToAddManually: () => (forced ? { peerDependencies: { [linkPkg]: forced } } : undefined),
+  };
+  await updateDependenciesVersions(
+    depsResolver,
+    workspace,
+    component,
+    overridesDependencies,
+    undefined,
+    debugDependencies,
+    false
+  );
+  return component.peerDependencies.get()[0].id.version;
+}
+
+describe('updateDependenciesVersions, a component peer with a range from a policy', () => {
+  it('should take the version of the range when the version found is out of the range', async () => {
+    expect(await resolvePeerVersion({ range: '^2.0.3' })).to.equal('2.0.3');
+  });
+  it('should show the version of the range in the dependencies debug', async () => {
+    const debugDependencies = [{ id: linkId.changeVersion('2.0.1') }];
+    await resolvePeerVersion({ range: '^2.0.3', debugDependencies });
+    expect(debugDependencies[0]).to.include({
+      version: '2.0.3',
+      versionResolvedFrom: 'Model (out of the range ^2.0.3)',
+    });
+  });
+  it('should keep the version found when it is in the range', async () => {
+    expect(await resolvePeerVersion({ range: '^2.0.0' })).to.equal('2.0.1');
+  });
+  it('should keep the version of a workspace component', async () => {
+    expect(await resolvePeerVersion({ range: '^2.0.3', inBitmap: true })).to.equal('2.0.5');
+  });
+  it('should keep a forced version', async () => {
+    expect(await resolvePeerVersion({ range: '^2.0.3', forced: '2.0.2' })).to.equal('2.0.2');
+  });
+  it('should check the version against the range of the workspace policy when it replaces the range', async () => {
+    expect(await resolvePeerVersion({ range: '^2.0.3', workspacePolicy: '^2.0.0' })).to.equal('2.0.1');
+  });
+  it('should keep the version found when the range has no version in it', async () => {
+    expect(await resolvePeerVersion({ range: '<2.0.0' })).to.equal('2.0.1');
+  });
+});

package/dependencies-loader/dependencies-versions-resolver.ts

@@ -12,7 +12,7 @@ import { isPlusVersion } from '@teambit/dependency-resolver';
 import { DEPENDENCIES_FIELDS } from '@teambit/legacy.constants';
 import type OverridesDependencies from './overrides-dependencies';
 import type { DebugComponentsDependency } from './auto-detect-deps';
-import { getValidComponentVersion } from './auto-detect-deps';
+import { getValidComponentVersion, getVersionInRangeIfOutOfIt } from './auto-detect-deps';
 
 type DepType = 'dependencies' | 'devDependencies' | 'peerDependencies';
 
@@ -112,10 +112,23 @@ export async function updateDependenciesVersions(
 
   function updateDependency(dependency: Dependency, depType: DepType) {
     const { id, packageName } = dependency;
-    const { version: resolvedVersion, range, fromConfig } = resolveVersion(id, depType, packageName);
+    const resolved = resolveVersion(id, depType, packageName);
+    const { range, fromConfig } = resolved;
+    // the range that is recorded below. a range of a strategy (e.g. the workspace policy) replaces the one of the policy
+    const recordedRange = (supportComponentRange && range) || dependency.versionRange;
+    const resolvedVersion = fromConfig
+      ? resolved.version
+      : peerVersionInRange(dependency, depType, resolved.version, recordedRange);
     if (!resolvedVersion) {
       return;
     }
+    if (resolvedVersion !== resolved.version) {
+      const debugDep = debugDependencies?.find((dep) => dep.id.isEqualWithoutVersion(id));
+      if (debugDep) {
+        debugDep.versionResolvedFrom = `${debugDep.versionResolvedFrom} (out of the range ${recordedRange})`;
+        debugDep.version = resolvedVersion;
+      }
+    }
     if (fromConfig) dependenciesWithVersionFromConfig.push(id.toStringWithoutVersion());
     dependency.id = dependency.id.changeVersion(resolvedVersion);
     if (supportComponentRange) {
@@ -131,6 +144,21 @@ export async function updateDependenciesVersions(
       dependency.versionRange = undefined;
     }
   }
+  /**
+   * a policy (e.g. an env) sets the range of a component peer, and the package.json gets this range. the version found
+   * (e.g. the one of the last snap, or the installed one) can be out of this range, e.g. after the env raised it. then,
+   * take the version of the range, otherwise it's installed and recorded although the range doesn't allow it.
+   * a component of the workspace keeps its version.
+   */
+  function peerVersionInRange(
+    dependency: Dependency,
+    depType: DepType,
+    version?: string,
+    range?: string
+  ): string | undefined {
+    if (depType !== 'peerDependencies' || !version || !range || getIdFromBitMap(dependency.id)) return version;
+    return getVersionInRangeIfOutOfIt(version, range) || version;
+  }
   function updateDependencies(dependencies: Dependencies, depType: DepType) {
     dependencies.get().forEach((dep) => updateDependency(dep, depType));
   }

package/dist/dependencies-loader/apply-overrides.d.ts

@@ -108,9 +108,8 @@ export declare class ApplyOverrides {
      */
     private getComponentIdFromForcedVersion;
     /**
-     * the scope side of the installed version in updateDependenciesVersions(): a workspace installs a component peer in
-     * the range of the policy, and records the installed version. so when the version is out of the range, it's changed
-     * to the version of the range. (when it's in the range, it's kept, as a workspace that has it installed would do)
+     * the scope side of peerVersionInRange() in updateDependenciesVersions(): when the version of a component peer is
+     * out of the range of the policy, it's changed to the version of the range. (when it's in the range, it's kept)
      */
     private setComponentPeerVersionInRange;
     private setVersionFromConfig;

package/dist/dependencies-loader/apply-overrides.js

@@ -382,23 +382,14 @@ class ApplyOverrides {
   }
 
   /**
-   * the scope side of the installed version in updateDependenciesVersions(): a workspace installs a component peer in
-   * the range of the policy, and records the installed version. so when the version is out of the range, it's changed
-   * to the version of the range. (when it's in the range, it's kept, as a workspace that has it installed would do)
+   * the scope side of peerVersionInRange() in updateDependenciesVersions(): when the version of a component peer is
+   * out of the range of the policy, it's changed to the version of the range. (when it's in the range, it's kept)
    */
   setComponentPeerVersionInRange(dependency, range) {
     if (!this.workspaceComponentIds || this.workspaceComponentIds.hasWithoutVersion(dependency.id)) return;
     const version = dependency.id.version;
-    if (!version || !_semver().default.validRange(range)) return;
-    // a snap is not in any semver range, a workspace would install a version of the range instead
-    if (_semver().default.valid(version) && _semver().default.satisfies(version, range)) return;
-    const {
-      version: versionInRange
-    } = (0, _autoDetectDeps().getValidComponentVersion)(range);
-    // e.g. "<2.0.0" is coerced to "2.0.0", which is out of the range. there's no version to take for such a range.
-    if (versionInRange && _semver().default.satisfies(versionInRange, range)) {
-      dependency.id = dependency.id.changeVersion(versionInRange);
-    }
+    const versionInRange = version ? (0, _autoDetectDeps().getVersionInRangeIfOutOfIt)(version, range) : undefined;
+    if (versionInRange) dependency.id = dependency.id.changeVersion(versionInRange);
   }
   setVersionFromConfig(id) {
     const idStr = id.toStringWithoutVersion();