@teambit/merging 1.0.1242 → 1.0.1244

package/dist/merge-dependencies.d.ts

@@ -1,5 +1,6 @@
 import type { MergeStrategy } from '@teambit/component.modules.merge-helper';
 import type { ComponentIdList } from '@teambit/component-id';
+import type { ImportedPackages } from '@teambit/dependencies';
 import type { ExtensionDataList } from '@teambit/legacy.extension-data';
 import { Dependencies } from '@teambit/legacy.consumer-component';
 declare const COMPONENT_DEPS_FIELDS: readonly ['dependencies', 'devDependencies', 'peerDependencies'];
@@ -23,6 +24,14 @@ export type DependenciesSnapshot = {
 export declare function getDependenciesOfVersion(version: DependenciesSnapshot & {
     extensions: ExtensionDataList;
 }): DependenciesSnapshot;
+/**
+ * the packages imported by the files of a merge, see detectImportedPackages().
+ */
+export type ImportsOfMerge = {
+    merged: ImportedPackages;
+    sides: Set<string>;
+    isOfPolicy?: (name: string) => boolean;
+};
 /**
  * 3-way merge of the resolved dependencies of a component: base (the common snap), current (the target lane) and
  * other (the merged lane/main).
@@ -30,9 +39,15 @@ export declare function getDependenciesOfVersion(version: DependenciesSnapshot &
  * a workspace merge gets the dependencies of the merged component by re-detecting them from the merged files. a bare
  * scope has no node_modules to resolve imports against, so it merges the dependencies that each side resolved when it
  * was snapped instead: a dependency added or removed on one side, or whose version or type (runtime/dev/peer) changed
- * on one side, is taken from that side. it's close to what the detection finds, not identical. e.g. when one side
- * removed an import of a dependency from one file and the other side added an import of it to another file, the
- * dependency is removed, although the merged files still import it.
+ * on one side, is taken from that side.
+ *
+ * when `imports` is given, the dependencies that come from imports follow the merged files, same as the detection: a
+ * dependency that no merged file imports is removed, one that a merged file imports is kept (taken from the side that
+ * has it when the 3-way merge removed it), and it's a runtime or dev dependency according to the files that import it.
+ * the version is still the one of the 3-way merge. a dependency that no side imports (e.g. one added by a policy) keeps
+ * the 3-way result. without `imports`, it's close to the detection, not identical. e.g. when one side removed an
+ * import of a dependency from one file and the other side added an import of it to another file, the dependency is
+ * removed, although the merged files still import it.
  *
  * each dependency is keyed by its name, and its field (runtime/dev/peer) is part of what is compared, so a dependency
  * that moved between fields on one side is taken from that side, and it's never added to two fields.
@@ -44,5 +59,28 @@ export declare function getDependenciesOfVersion(version: DependenciesSnapshot &
  * anyway (see MergingMain.setLaneVersionsOfDeps), so its version is not compared. otherwise, the lane snap of it would
  * look like a change on the lane, and a removal of it on the other side would be lost.
  */
-export declare function mergeDependencies(base: DependenciesSnapshot, current: DependenciesSnapshot, other: DependenciesSnapshot, mergeStrategy?: MergeStrategy, laneComponentIds?: ComponentIdList): DependenciesSnapshot;
+export declare function mergeDependencies(base: DependenciesSnapshot, current: DependenciesSnapshot, other: DependenciesSnapshot, mergeStrategy?: MergeStrategy, laneComponentIds?: ComponentIdList, imports?: ImportsOfMerge): DependenciesSnapshot;
+/**
+ * the dependencies of one side of a merge, and the packages that its dependencies policy ignores ("-") or forces (adds
+ * even when no file imports them, e.g. the own peers of an env).
+ */
+export type SideOfMerge = {
+    dependencies: DependenciesSnapshot;
+    ignoredPackages: Set<string>;
+    forcedPackages: Set<string>;
+};
+/**
+ * packages that the merged files import, that the merged policy doesn't ignore, and that no side has as a dependency,
+ * because the sides that import them ignored them. (e.g. one side imports a package while it's ignored, and the other
+ * side removes the "-"). a workspace adds such a package with the version installed in node_modules, a bare scope has
+ * no version for it. a types package of it (e.g. @types/foo) is not a version of it.
+ */
+export declare function getImportedPackagesWithoutVersion(base: SideOfMerge, current: SideOfMerge, other: SideOfMerge, importedByMergedFiles: Iterable<string>): string[];
+/**
+ * the imports of a merge, with the packages that the merged policy ignores ("-") or forces. these keep the 3-way
+ * result, which follows the policy of each side, the imports don't change them. e.g. when one side adds a "-" for a
+ * package that the files import, the 3-way merge removes it, and the imports don't restore it. and an env keeps its
+ * own peers when no file imports them anymore.
+ */
+export declare function withPolicyOfMerge(imports: ImportsOfMerge, base: SideOfMerge, current: SideOfMerge, other: SideOfMerge): ImportsOfMerge;
 export {};

package/dist/merge-dependencies.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getDependenciesOfVersion = getDependenciesOfVersion;
+exports.getImportedPackagesWithoutVersion = getImportedPackagesWithoutVersion;
 exports.mergeDependencies = mergeDependencies;
+exports.withPolicyOfMerge = withPolicyOfMerge;
 function _lodash() {
   const data = require("lodash");
   _lodash = function () {
@@ -56,6 +58,10 @@ function getDependenciesOfVersion(version) {
   };
 }
 
+/**
+ * the packages imported by the files of a merge, see detectImportedPackages().
+ */
+
 /**
  * 3-way merge of the resolved dependencies of a component: base (the common snap), current (the target lane) and
  * other (the merged lane/main).
@@ -63,9 +69,15 @@ function getDependenciesOfVersion(version) {
  * a workspace merge gets the dependencies of the merged component by re-detecting them from the merged files. a bare
  * scope has no node_modules to resolve imports against, so it merges the dependencies that each side resolved when it
  * was snapped instead: a dependency added or removed on one side, or whose version or type (runtime/dev/peer) changed
- * on one side, is taken from that side. it's close to what the detection finds, not identical. e.g. when one side
- * removed an import of a dependency from one file and the other side added an import of it to another file, the
- * dependency is removed, although the merged files still import it.
+ * on one side, is taken from that side.
+ *
+ * when `imports` is given, the dependencies that come from imports follow the merged files, same as the detection: a
+ * dependency that no merged file imports is removed, one that a merged file imports is kept (taken from the side that
+ * has it when the 3-way merge removed it), and it's a runtime or dev dependency according to the files that import it.
+ * the version is still the one of the 3-way merge. a dependency that no side imports (e.g. one added by a policy) keeps
+ * the 3-way result. without `imports`, it's close to the detection, not identical. e.g. when one side removed an
+ * import of a dependency from one file and the other side added an import of it to another file, the dependency is
+ * removed, although the merged files still import it.
  *
  * each dependency is keyed by its name, and its field (runtime/dev/peer) is part of what is compared, so a dependency
  * that moved between fields on one side is taken from that side, and it's never added to two fields.
@@ -77,20 +89,31 @@ function getDependenciesOfVersion(version) {
  * anyway (see MergingMain.setLaneVersionsOfDeps), so its version is not compared. otherwise, the lane snap of it would
  * look like a change on the lane, and a removal of it on the other side would be lost.
  */
-function mergeDependencies(base, current, other, mergeStrategy, laneComponentIds) {
+function mergeDependencies(base, current, other, mergeStrategy, laneComponentIds, imports) {
   const componentDeps = snapshot => new Map(COMPONENT_DEPS_FIELDS.flatMap(field => snapshot[field].get().map(dep => [dep.id.toStringWithoutVersion(), {
     field,
     value: dep
   }])));
+  const applyImportsIfNeeded = (entries, sides, nameOf, fields) => imports ? applyImports(entries, sides, nameOf, fields, imports) : entries;
   // all the persisted data is compared (e.g. the import paths and the version range), not only the id, so a change of
   // any of them on one side is not lost. (no methods are called, a loaded component has the dependencies as plain objects)
   const isSameDep = (a, b) => (laneComponentIds?.hasWithoutVersion(a.id) ? a.id.isEqualWithoutVersion(b.id) : a.id.isEqual(b.id)) && a.packageName === b.packageName && a.versionRange === b.versionRange && (0, _lodash().isEqual)(a.relativePaths, b.relativePaths);
-  const mergedCompDeps = mergeEntries(componentDeps(base), componentDeps(current), componentDeps(other), mergeStrategy, isSameDep);
+  const [baseCompDeps, currentCompDeps, otherCompDeps] = [base, current, other].map(componentDeps);
+  const mergedCompDeps = applyImportsIfNeeded(mergeEntries(baseCompDeps, currentCompDeps, otherCompDeps, mergeStrategy, isSameDep), [otherCompDeps, currentCompDeps, baseCompDeps], (_key, dep) => dep.packageName, {
+    runtime: 'dependencies',
+    dev: 'devDependencies',
+    peer: 'peerDependencies'
+  });
   const packageDeps = snapshot => new Map(PACKAGE_DEPS_FIELDS.flatMap(field => Object.entries(snapshot[field] || {}).map(([name, version]) => [name, {
     field,
     value: version
   }])));
-  const mergedPkgDeps = mergeEntries(packageDeps(base), packageDeps(current), packageDeps(other), mergeStrategy, (a, b) => a === b);
+  const [basePkgDeps, currentPkgDeps, otherPkgDeps] = [base, current, other].map(packageDeps);
+  const mergedPkgDeps = applyImportsIfNeeded(mergeEntries(basePkgDeps, currentPkgDeps, otherPkgDeps, mergeStrategy, (a, b) => a === b), [otherPkgDeps, currentPkgDeps, basePkgDeps], key => key, {
+    runtime: 'packageDependencies',
+    dev: 'devPackageDependencies',
+    peer: 'peerPackageDependencies'
+  });
   const compDepsOf = field => new (_legacy().Dependencies)(mergedCompDeps.filter(entry => entry.field === field).map(({
     value
   }) => cloneDependency(value)));
@@ -107,6 +130,109 @@ function mergeDependencies(base, current, other, mergeStrategy, laneComponentIds
     peerPackageDependencies: pkgDepsOf('peerPackageDependencies')
   };
 }
+
+/**
+ * the dependencies of one side of a merge, and the packages that its dependencies policy ignores ("-") or forces (adds
+ * even when no file imports them, e.g. the own peers of an env).
+ */
+
+/**
+ * packages that the merged files import, that the merged policy doesn't ignore, and that no side has as a dependency,
+ * because the sides that import them ignored them. (e.g. one side imports a package while it's ignored, and the other
+ * side removes the "-"). a workspace adds such a package with the version installed in node_modules, a bare scope has
+ * no version for it. a types package of it (e.g. @types/foo) is not a version of it.
+ */
+function getImportedPackagesWithoutVersion(base, current, other, importedByMergedFiles) {
+  const sides = [base, current, other];
+  const dependencyNames = new Set(sides.flatMap(({
+    dependencies
+  }) => namesOfDependencies(dependencies)));
+  return [...importedByMergedFiles].filter(name => !dependencyNames.has(name) && sides.some(side => side.ignoredPackages.has(name)) && !isSetOnMerge(base, current, other, side => side.ignoredPackages.has(name)));
+}
+
+/**
+ * the imports of a merge, with the packages that the merged policy ignores ("-") or forces. these keep the 3-way
+ * result, which follows the policy of each side, the imports don't change them. e.g. when one side adds a "-" for a
+ * package that the files import, the 3-way merge removes it, and the imports don't restore it. and an env keeps its
+ * own peers when no file imports them anymore.
+ */
+function withPolicyOfMerge(imports, base, current, other) {
+  const isOfPolicy = name => isSetOnMerge(base, current, other, side => side.ignoredPackages.has(name)) || isSetOnMerge(base, current, other, side => side.forcedPackages.has(name));
+  return _objectSpread(_objectSpread({}, imports), {}, {
+    isOfPolicy
+  });
+}
+
+/**
+ * whether the merged policy sets something for a package (e.g. ignores it), by a 3-way merge of whether the policy of
+ * each side sets it.
+ */
+function isSetOnMerge(base, current, other, isSet) {
+  const [onBase, onCurrent, onOther] = [base, current, other].map(isSet);
+  return Boolean(mergeValue(onBase, onCurrent, onOther, undefined, (a, b) => a === b));
+}
+function namesOfDependencies(dependencies) {
+  const componentDeps = COMPONENT_DEPS_FIELDS.flatMap(field => dependencies[field].get());
+  const packageNames = PACKAGE_DEPS_FIELDS.flatMap(field => Object.keys(dependencies[field] || {}));
+  return [...(0, _lodash().compact)(componentDeps.map(dep => dep.packageName)), ...packageNames];
+}
+/**
+ * make the dependencies that come from imports follow the merged files, see mergeDependencies().
+ * `sides` are the entries of other, current and base, in this order of preference, to take a dependency from when the
+ * 3-way merge removed it.
+ */
+function applyImports(entries, sides, nameOf, fields, imports) {
+  // a types package (e.g. @types/foo) follows the package it types, see AutoDetectDeps._addTypesPackagesForTypeScript
+  const importedName = name => typedPackageName(name) || name;
+  const isFromImports = name => imports.merged.has(importedName(name)) || imports.sides.has(importedName(name));
+  const isOfPolicy = name => Boolean(imports.isOfPolicy?.(name));
+  const withFieldOfImports = (entry, name) => {
+    const importedAs = imports.merged.get(name);
+    // a peer is set by a policy or by the dependency itself, not by the files that import it
+    if (!importedAs || entry.field === fields.peer) return entry;
+    return _objectSpread(_objectSpread({}, entry), {}, {
+      field: fields[importedAs]
+    });
+  };
+  const result = [];
+  const names = new Set();
+  entries.forEach(entry => {
+    const name = nameOf(entry.key, entry.value);
+    if (!name || isOfPolicy(name)) {
+      result.push(entry);
+      return;
+    }
+    if (isFromImports(name) && !imports.merged.has(importedName(name))) return; // no merged file imports it
+    names.add(name);
+    result.push(withFieldOfImports(entry, name));
+  });
+  const sidesByName = sides.map(side => new Map([...side].map(([key, entry]) => [nameOf(key, entry.value), _objectSpread({
+    key
+  }, entry)])));
+  const importedNames = [...imports.merged.keys()].flatMap(name => [name, toTypesPackageName(name)]);
+  importedNames.forEach(name => {
+    if (names.has(name) || isOfPolicy(name)) return;
+    // when no side has it, it's e.g. a core aspect, or a package that a policy ignores
+    const fromSide = sidesByName.map(side => side.get(name)).find(Boolean);
+    if (!fromSide) return;
+    names.add(name);
+    result.push(withFieldOfImports(fromSide, name));
+  });
+  return result;
+}
+
+/**
+ * e.g. "@types/foo" => "foo", "@types/scope__foo" => "@scope/foo". undefined when it's not a types package.
+ */
+function typedPackageName(name) {
+  if (!name.startsWith('@types/')) return undefined;
+  const typed = name.slice('@types/'.length);
+  return typed.includes('__') ? `@${typed.replace('__', '/')}` : typed;
+}
+function toTypesPackageName(name) {
+  return `@types/${name.replace(/^@([^/]+)\//, '$1__')}`;
+}
+
 /**
  * 3-way merge of the entries of each key. an entry is unchanged between two sides when it's in the same field with an
  * equal value. returns the merged entries that exist (not removed).

package/dist/merge-dependencies.js.map

@@ -1 +1 @@
-{"version":3,"names":["_lodash","data","require","_legacy","_objects","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","COMPONENT_DEPS_FIELDS","PACKAGE_DEPS_FIELDS","getDependenciesOfVersion","version","withPackageNames","deps","Dependencies","ModelComponent","addDepsInfoFromDepsResolver","extensions","dependencies","devDependencies","peerDependencies","packageDependencies","devPackageDependencies","peerPackageDependencies","mergeDependencies","base","current","other","mergeStrategy","laneComponentIds","componentDeps","snapshot","Map","flatMap","field","get","map","dep","id","toStringWithoutVersion","isSameDep","a","b","hasWithoutVersion","isEqualWithoutVersion","isEqual","packageName","versionRange","relativePaths","mergedCompDeps","mergeEntries","packageDeps","entries","name","mergedPkgDeps","compDepsOf","entry","cloneDependency","pkgDepsOf","fromEntries","key","isEqualValue","union","merged","mergeValue","equal","undefined","clone","Dependency","getClone"],"sources":["merge-dependencies.ts"],"sourcesContent":["import type { MergeStrategy } from '@teambit/component.modules.merge-helper';\nimport { isEqual, union } from 'lodash';\nimport type { ComponentIdList } from '@teambit/component-id';\nimport type { ExtensionDataList } from '@teambit/legacy.extension-data';\nimport { Dependencies, Dependency } from '@teambit/legacy.consumer-component';\nimport { ModelComponent } from '@teambit/objects';\n\nconst COMPONENT_DEPS_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies'] as const;\nconst PACKAGE_DEPS_FIELDS = ['packageDependencies', 'devPackageDependencies', 'peerPackageDependencies'] as const;\n\ntype ComponentDepsField = (typeof COMPONENT_DEPS_FIELDS)[number];\ntype PackageDepsField = (typeof PACKAGE_DEPS_FIELDS)[number];\n\n/**\n * the dependency fields shared by a Version object and a ConsumerComponent.\n */\nexport type DependenciesSnapshot = { [field in ComponentDepsField]: Dependencies } & {\n  [field in PackageDepsField]: Record<string, string>;\n};\n\n/**\n * the dependencies of a Version, with the package names of the component dependencies, same as a component loaded from\n * the scope has them (see ModelComponent.toConsumerComponent). without them, a dependency of a Version and the same\n * dependency of a loaded component are not equal.\n * returns copies, so they can be changed (e.g. set to a component that is snapped) without changing the Version.\n */\nexport function getDependenciesOfVersion(\n  version: DependenciesSnapshot & { extensions: ExtensionDataList }\n): DependenciesSnapshot {\n  const withPackageNames = (deps: Dependencies) =>\n    new Dependencies(ModelComponent.addDepsInfoFromDepsResolver(deps, version.extensions));\n  return {\n    dependencies: withPackageNames(version.dependencies),\n    devDependencies: withPackageNames(version.devDependencies),\n    peerDependencies: withPackageNames(version.peerDependencies),\n    packageDependencies: { ...version.packageDependencies },\n    devPackageDependencies: { ...version.devPackageDependencies },\n    peerPackageDependencies: { ...version.peerPackageDependencies },\n  };\n}\n\n/**\n * 3-way merge of the resolved dependencies of a component: base (the common snap), current (the target lane) and\n * other (the merged lane/main).\n *\n * a workspace merge gets the dependencies of the merged component by re-detecting them from the merged files. a bare\n * scope has no node_modules to resolve imports against, so it merges the dependencies that each side resolved when it\n * was snapped instead: a dependency added or removed on one side, or whose version or type (runtime/dev/peer) changed\n * on one side, is taken from that side. it's close to what the detection finds, not identical. e.g. when one side\n * removed an import of a dependency from one file and the other side added an import of it to another file, the\n * dependency is removed, although the merged files still import it.\n *\n * each dependency is keyed by its name, and its field (runtime/dev/peer) is part of what is compared, so a dependency\n * that moved between fields on one side is taken from that side, and it's never added to two fields.\n * when both sides changed the same dependency differently, \"theirs\" takes other, any other strategy keeps current\n * (in \"manual\", such a version conflict is reported by the config-merger, which stops the merge before the snap).\n * the returned component dependencies are copies, so they can be changed without changing the inputs.\n *\n * `laneComponentIds` are the components of the current lane. a dependency on one of them gets the lane's version\n * anyway (see MergingMain.setLaneVersionsOfDeps), so its version is not compared. otherwise, the lane snap of it would\n * look like a change on the lane, and a removal of it on the other side would be lost.\n */\nexport function mergeDependencies(\n  base: DependenciesSnapshot,\n  current: DependenciesSnapshot,\n  other: DependenciesSnapshot,\n  mergeStrategy?: MergeStrategy,\n  laneComponentIds?: ComponentIdList\n): DependenciesSnapshot {\n  const componentDeps = (snapshot: DependenciesSnapshot) =>\n    new Map(\n      COMPONENT_DEPS_FIELDS.flatMap((field) =>\n        snapshot[field].get().map((dep) => [dep.id.toStringWithoutVersion(), { field, value: dep }] as const)\n      )\n    );\n  // all the persisted data is compared (e.g. the import paths and the version range), not only the id, so a change of\n  // any of them on one side is not lost. (no methods are called, a loaded component has the dependencies as plain objects)\n  const isSameDep = (a: Dependency, b: Dependency) =>\n    (laneComponentIds?.hasWithoutVersion(a.id) ? a.id.isEqualWithoutVersion(b.id) : a.id.isEqual(b.id)) &&\n    a.packageName === b.packageName &&\n    a.versionRange === b.versionRange &&\n    isEqual(a.relativePaths, b.relativePaths);\n  const mergedCompDeps = mergeEntries(\n    componentDeps(base),\n    componentDeps(current),\n    componentDeps(other),\n    mergeStrategy,\n    isSameDep\n  );\n  const packageDeps = (snapshot: DependenciesSnapshot) =>\n    new Map(\n      PACKAGE_DEPS_FIELDS.flatMap((field) =>\n        Object.entries(snapshot[field] || {}).map(([name, version]) => [name, { field, value: version }] as const)\n      )\n    );\n  const mergedPkgDeps = mergeEntries(\n    packageDeps(base),\n    packageDeps(current),\n    packageDeps(other),\n    mergeStrategy,\n    (a, b) => a === b\n  );\n  const compDepsOf = (field: ComponentDepsField) =>\n    new Dependencies(\n      mergedCompDeps.filter((entry) => entry.field === field).map(({ value }) => cloneDependency(value))\n    );\n  const pkgDepsOf = (field: PackageDepsField) =>\n    Object.fromEntries(mergedPkgDeps.filter((entry) => entry.field === field).map(({ key, value }) => [key, value]));\n  return {\n    dependencies: compDepsOf('dependencies'),\n    devDependencies: compDepsOf('devDependencies'),\n    peerDependencies: compDepsOf('peerDependencies'),\n    packageDependencies: pkgDepsOf('packageDependencies'),\n    devPackageDependencies: pkgDepsOf('devPackageDependencies'),\n    peerPackageDependencies: pkgDepsOf('peerPackageDependencies'),\n  };\n}\n\ntype FieldEntry<Field, Value> = { field: Field; value: Value };\n\n/**\n * 3-way merge of the entries of each key. an entry is unchanged between two sides when it's in the same field with an\n * equal value. returns the merged entries that exist (not removed).\n */\nfunction mergeEntries<Field, Value>(\n  base: Map<string, FieldEntry<Field, Value>>,\n  current: Map<string, FieldEntry<Field, Value>>,\n  other: Map<string, FieldEntry<Field, Value>>,\n  mergeStrategy: MergeStrategy | undefined,\n  isEqualValue: (a: Value, b: Value) => boolean\n): Array<FieldEntry<Field, Value> & { key: string }> {\n  return union([...current.keys()], [...other.keys()]).flatMap((key) => {\n    const merged = mergeValue(\n      base.get(key),\n      current.get(key),\n      other.get(key),\n      mergeStrategy,\n      (a, b) => a.field === b.field && isEqualValue(a.value, b.value)\n    );\n    return merged ? [{ key, ...merged }] : [];\n  });\n}\n\n/**\n * returns undefined when the merged result is \"absent\" (removed or never existed).\n */\nfunction mergeValue<T>(\n  base: T | undefined,\n  current: T | undefined,\n  other: T | undefined,\n  mergeStrategy: MergeStrategy | undefined,\n  isEqualValue: (a: T, b: T) => boolean\n): T | undefined {\n  const equal = (a?: T, b?: T) => (a === undefined || b === undefined ? a === b : isEqualValue(a, b));\n  if (equal(current, other)) return current;\n  if (equal(base, current)) return other; // changed (or removed) on other only\n  if (equal(base, other)) return current; // changed (or removed) on current only\n  return mergeStrategy === 'theirs' ? other : current;\n}\n\nfunction cloneDependency(dep: Dependency): Dependency {\n  const clone = Dependency.getClone(dep);\n  return new Dependency(clone.id, clone.relativePaths, clone.packageName, clone.versionRange);\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_lodash","data","require","_legacy","_objects","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","COMPONENT_DEPS_FIELDS","PACKAGE_DEPS_FIELDS","getDependenciesOfVersion","version","withPackageNames","deps","Dependencies","ModelComponent","addDepsInfoFromDepsResolver","extensions","dependencies","devDependencies","peerDependencies","packageDependencies","devPackageDependencies","peerPackageDependencies","mergeDependencies","base","current","other","mergeStrategy","laneComponentIds","imports","componentDeps","snapshot","Map","flatMap","field","get","map","dep","id","toStringWithoutVersion","applyImportsIfNeeded","entries","sides","nameOf","fields","applyImports","isSameDep","a","b","hasWithoutVersion","isEqualWithoutVersion","isEqual","packageName","versionRange","relativePaths","baseCompDeps","currentCompDeps","otherCompDeps","mergedCompDeps","mergeEntries","_key","runtime","dev","peer","packageDeps","name","basePkgDeps","currentPkgDeps","otherPkgDeps","mergedPkgDeps","key","compDepsOf","entry","cloneDependency","pkgDepsOf","fromEntries","getImportedPackagesWithoutVersion","importedByMergedFiles","dependencyNames","Set","namesOfDependencies","has","some","side","ignoredPackages","isSetOnMerge","withPolicyOfMerge","isOfPolicy","forcedPackages","isSet","onBase","onCurrent","onOther","Boolean","mergeValue","undefined","packageNames","compact","importedName","typedPackageName","isFromImports","merged","withFieldOfImports","importedAs","result","names","add","sidesByName","importedNames","toTypesPackageName","fromSide","find","startsWith","typed","slice","includes","replace","isEqualValue","union","equal","clone","Dependency","getClone"],"sources":["merge-dependencies.ts"],"sourcesContent":["import type { MergeStrategy } from '@teambit/component.modules.merge-helper';\nimport { compact, isEqual, union } from 'lodash';\nimport type { ComponentIdList } from '@teambit/component-id';\nimport type { ImportedPackages } from '@teambit/dependencies';\nimport type { ExtensionDataList } from '@teambit/legacy.extension-data';\nimport { Dependencies, Dependency } from '@teambit/legacy.consumer-component';\nimport { ModelComponent } from '@teambit/objects';\n\nconst COMPONENT_DEPS_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies'] as const;\nconst PACKAGE_DEPS_FIELDS = ['packageDependencies', 'devPackageDependencies', 'peerPackageDependencies'] as const;\n\ntype ComponentDepsField = (typeof COMPONENT_DEPS_FIELDS)[number];\ntype PackageDepsField = (typeof PACKAGE_DEPS_FIELDS)[number];\n\n/**\n * the dependency fields shared by a Version object and a ConsumerComponent.\n */\nexport type DependenciesSnapshot = { [field in ComponentDepsField]: Dependencies } & {\n  [field in PackageDepsField]: Record<string, string>;\n};\n\n/**\n * the dependencies of a Version, with the package names of the component dependencies, same as a component loaded from\n * the scope has them (see ModelComponent.toConsumerComponent). without them, a dependency of a Version and the same\n * dependency of a loaded component are not equal.\n * returns copies, so they can be changed (e.g. set to a component that is snapped) without changing the Version.\n */\nexport function getDependenciesOfVersion(\n  version: DependenciesSnapshot & { extensions: ExtensionDataList }\n): DependenciesSnapshot {\n  const withPackageNames = (deps: Dependencies) =>\n    new Dependencies(ModelComponent.addDepsInfoFromDepsResolver(deps, version.extensions));\n  return {\n    dependencies: withPackageNames(version.dependencies),\n    devDependencies: withPackageNames(version.devDependencies),\n    peerDependencies: withPackageNames(version.peerDependencies),\n    packageDependencies: { ...version.packageDependencies },\n    devPackageDependencies: { ...version.devPackageDependencies },\n    peerPackageDependencies: { ...version.peerPackageDependencies },\n  };\n}\n\n/**\n * the packages imported by the files of a merge, see detectImportedPackages().\n */\nexport type ImportsOfMerge = {\n  merged: ImportedPackages; // imported by the merged files\n  sides: Set<string>; // imported by the files of base, current or other\n  isOfPolicy?: (name: string) => boolean; // whether the merged policy decides on the package, see withPolicyOfMerge()\n};\n\n/**\n * 3-way merge of the resolved dependencies of a component: base (the common snap), current (the target lane) and\n * other (the merged lane/main).\n *\n * a workspace merge gets the dependencies of the merged component by re-detecting them from the merged files. a bare\n * scope has no node_modules to resolve imports against, so it merges the dependencies that each side resolved when it\n * was snapped instead: a dependency added or removed on one side, or whose version or type (runtime/dev/peer) changed\n * on one side, is taken from that side.\n *\n * when `imports` is given, the dependencies that come from imports follow the merged files, same as the detection: a\n * dependency that no merged file imports is removed, one that a merged file imports is kept (taken from the side that\n * has it when the 3-way merge removed it), and it's a runtime or dev dependency according to the files that import it.\n * the version is still the one of the 3-way merge. a dependency that no side imports (e.g. one added by a policy) keeps\n * the 3-way result. without `imports`, it's close to the detection, not identical. e.g. when one side removed an\n * import of a dependency from one file and the other side added an import of it to another file, the dependency is\n * removed, although the merged files still import it.\n *\n * each dependency is keyed by its name, and its field (runtime/dev/peer) is part of what is compared, so a dependency\n * that moved between fields on one side is taken from that side, and it's never added to two fields.\n * when both sides changed the same dependency differently, \"theirs\" takes other, any other strategy keeps current\n * (in \"manual\", such a version conflict is reported by the config-merger, which stops the merge before the snap).\n * the returned component dependencies are copies, so they can be changed without changing the inputs.\n *\n * `laneComponentIds` are the components of the current lane. a dependency on one of them gets the lane's version\n * anyway (see MergingMain.setLaneVersionsOfDeps), so its version is not compared. otherwise, the lane snap of it would\n * look like a change on the lane, and a removal of it on the other side would be lost.\n */\nexport function mergeDependencies(\n  base: DependenciesSnapshot,\n  current: DependenciesSnapshot,\n  other: DependenciesSnapshot,\n  mergeStrategy?: MergeStrategy,\n  laneComponentIds?: ComponentIdList,\n  imports?: ImportsOfMerge\n): DependenciesSnapshot {\n  const componentDeps = (snapshot: DependenciesSnapshot) =>\n    new Map(\n      COMPONENT_DEPS_FIELDS.flatMap((field) =>\n        snapshot[field].get().map((dep) => [dep.id.toStringWithoutVersion(), { field, value: dep }] as const)\n      )\n    );\n  const applyImportsIfNeeded = <Field extends string, Value>(\n    entries: Array<MergedEntry<Field, Value>>,\n    sides: Array<Map<string, FieldEntry<Field, Value>>>,\n    nameOf: (key: string, value: Value) => string | undefined,\n    fields: DepTypeFields<Field>\n  ) => (imports ? applyImports(entries, sides, nameOf, fields, imports) : entries);\n  // all the persisted data is compared (e.g. the import paths and the version range), not only the id, so a change of\n  // any of them on one side is not lost. (no methods are called, a loaded component has the dependencies as plain objects)\n  const isSameDep = (a: Dependency, b: Dependency) =>\n    (laneComponentIds?.hasWithoutVersion(a.id) ? a.id.isEqualWithoutVersion(b.id) : a.id.isEqual(b.id)) &&\n    a.packageName === b.packageName &&\n    a.versionRange === b.versionRange &&\n    isEqual(a.relativePaths, b.relativePaths);\n  const [baseCompDeps, currentCompDeps, otherCompDeps] = [base, current, other].map(componentDeps);\n  const mergedCompDeps = applyImportsIfNeeded(\n    mergeEntries(baseCompDeps, currentCompDeps, otherCompDeps, mergeStrategy, isSameDep),\n    [otherCompDeps, currentCompDeps, baseCompDeps],\n    (_key, dep) => dep.packageName,\n    { runtime: 'dependencies', dev: 'devDependencies', peer: 'peerDependencies' }\n  );\n  const packageDeps = (snapshot: DependenciesSnapshot) =>\n    new Map(\n      PACKAGE_DEPS_FIELDS.flatMap((field) =>\n        Object.entries(snapshot[field] || {}).map(([name, version]) => [name, { field, value: version }] as const)\n      )\n    );\n  const [basePkgDeps, currentPkgDeps, otherPkgDeps] = [base, current, other].map(packageDeps);\n  const mergedPkgDeps = applyImportsIfNeeded(\n    mergeEntries(basePkgDeps, currentPkgDeps, otherPkgDeps, mergeStrategy, (a, b) => a === b),\n    [otherPkgDeps, currentPkgDeps, basePkgDeps],\n    (key) => key,\n    { runtime: 'packageDependencies', dev: 'devPackageDependencies', peer: 'peerPackageDependencies' }\n  );\n  const compDepsOf = (field: ComponentDepsField) =>\n    new Dependencies(\n      mergedCompDeps.filter((entry) => entry.field === field).map(({ value }) => cloneDependency(value))\n    );\n  const pkgDepsOf = (field: PackageDepsField) =>\n    Object.fromEntries(mergedPkgDeps.filter((entry) => entry.field === field).map(({ key, value }) => [key, value]));\n  return {\n    dependencies: compDepsOf('dependencies'),\n    devDependencies: compDepsOf('devDependencies'),\n    peerDependencies: compDepsOf('peerDependencies'),\n    packageDependencies: pkgDepsOf('packageDependencies'),\n    devPackageDependencies: pkgDepsOf('devPackageDependencies'),\n    peerPackageDependencies: pkgDepsOf('peerPackageDependencies'),\n  };\n}\n\n/**\n * the dependencies of one side of a merge, and the packages that its dependencies policy ignores (\"-\") or forces (adds\n * even when no file imports them, e.g. the own peers of an env).\n */\nexport type SideOfMerge = {\n  dependencies: DependenciesSnapshot;\n  ignoredPackages: Set<string>;\n  forcedPackages: Set<string>;\n};\n\n/**\n * packages that the merged files import, that the merged policy doesn't ignore, and that no side has as a dependency,\n * because the sides that import them ignored them. (e.g. one side imports a package while it's ignored, and the other\n * side removes the \"-\"). a workspace adds such a package with the version installed in node_modules, a bare scope has\n * no version for it. a types package of it (e.g. @types/foo) is not a version of it.\n */\nexport function getImportedPackagesWithoutVersion(\n  base: SideOfMerge,\n  current: SideOfMerge,\n  other: SideOfMerge,\n  importedByMergedFiles: Iterable<string>\n): string[] {\n  const sides = [base, current, other];\n  const dependencyNames = new Set(sides.flatMap(({ dependencies }) => namesOfDependencies(dependencies)));\n  return [...importedByMergedFiles].filter(\n    (name) =>\n      !dependencyNames.has(name) &&\n      sides.some((side) => side.ignoredPackages.has(name)) &&\n      !isSetOnMerge(base, current, other, (side) => side.ignoredPackages.has(name))\n  );\n}\n\n/**\n * the imports of a merge, with the packages that the merged policy ignores (\"-\") or forces. these keep the 3-way\n * result, which follows the policy of each side, the imports don't change them. e.g. when one side adds a \"-\" for a\n * package that the files import, the 3-way merge removes it, and the imports don't restore it. and an env keeps its\n * own peers when no file imports them anymore.\n */\nexport function withPolicyOfMerge(\n  imports: ImportsOfMerge,\n  base: SideOfMerge,\n  current: SideOfMerge,\n  other: SideOfMerge\n): ImportsOfMerge {\n  const isOfPolicy = (name: string) =>\n    isSetOnMerge(base, current, other, (side) => side.ignoredPackages.has(name)) ||\n    isSetOnMerge(base, current, other, (side) => side.forcedPackages.has(name));\n  return { ...imports, isOfPolicy };\n}\n\n/**\n * whether the merged policy sets something for a package (e.g. ignores it), by a 3-way merge of whether the policy of\n * each side sets it.\n */\nfunction isSetOnMerge(\n  base: SideOfMerge,\n  current: SideOfMerge,\n  other: SideOfMerge,\n  isSet: (side: SideOfMerge) => boolean\n): boolean {\n  const [onBase, onCurrent, onOther] = [base, current, other].map(isSet);\n  return Boolean(mergeValue(onBase, onCurrent, onOther, undefined, (a, b) => a === b));\n}\n\nfunction namesOfDependencies(dependencies: DependenciesSnapshot): string[] {\n  const componentDeps = COMPONENT_DEPS_FIELDS.flatMap((field) => dependencies[field].get());\n  const packageNames = PACKAGE_DEPS_FIELDS.flatMap((field) => Object.keys(dependencies[field] || {}));\n  return [...compact(componentDeps.map((dep) => dep.packageName)), ...packageNames];\n}\n\ntype FieldEntry<Field, Value> = { field: Field; value: Value };\ntype MergedEntry<Field, Value> = FieldEntry<Field, Value> & { key: string };\ntype DepTypeFields<Field> = { runtime: Field; dev: Field; peer: Field };\n\n/**\n * make the dependencies that come from imports follow the merged files, see mergeDependencies().\n * `sides` are the entries of other, current and base, in this order of preference, to take a dependency from when the\n * 3-way merge removed it.\n */\nfunction applyImports<Field extends string, Value>(\n  entries: Array<MergedEntry<Field, Value>>,\n  sides: Array<Map<string, FieldEntry<Field, Value>>>,\n  nameOf: (key: string, value: Value) => string | undefined,\n  fields: DepTypeFields<Field>,\n  imports: ImportsOfMerge\n): Array<MergedEntry<Field, Value>> {\n  // a types package (e.g. @types/foo) follows the package it types, see AutoDetectDeps._addTypesPackagesForTypeScript\n  const importedName = (name: string) => typedPackageName(name) || name;\n  const isFromImports = (name: string) =>\n    imports.merged.has(importedName(name)) || imports.sides.has(importedName(name));\n  const isOfPolicy = (name: string) => Boolean(imports.isOfPolicy?.(name));\n  const withFieldOfImports = (entry: MergedEntry<Field, Value>, name: string): MergedEntry<Field, Value> => {\n    const importedAs = imports.merged.get(name);\n    // a peer is set by a policy or by the dependency itself, not by the files that import it\n    if (!importedAs || entry.field === fields.peer) return entry;\n    return { ...entry, field: fields[importedAs] };\n  };\n  const result: Array<MergedEntry<Field, Value>> = [];\n  const names = new Set<string>();\n  entries.forEach((entry) => {\n    const name = nameOf(entry.key, entry.value);\n    if (!name || isOfPolicy(name)) {\n      result.push(entry);\n      return;\n    }\n    if (isFromImports(name) && !imports.merged.has(importedName(name))) return; // no merged file imports it\n    names.add(name);\n    result.push(withFieldOfImports(entry, name));\n  });\n  const sidesByName = sides.map(\n    (side) => new Map([...side].map(([key, entry]) => [nameOf(key, entry.value), { key, ...entry }]))\n  );\n  const importedNames = [...imports.merged.keys()].flatMap((name) => [name, toTypesPackageName(name)]);\n  importedNames.forEach((name) => {\n    if (names.has(name) || isOfPolicy(name)) return;\n    // when no side has it, it's e.g. a core aspect, or a package that a policy ignores\n    const fromSide = sidesByName.map((side) => side.get(name)).find(Boolean);\n    if (!fromSide) return;\n    names.add(name);\n    result.push(withFieldOfImports(fromSide, name));\n  });\n  return result;\n}\n\n/**\n * e.g. \"@types/foo\" => \"foo\", \"@types/scope__foo\" => \"@scope/foo\". undefined when it's not a types package.\n */\nfunction typedPackageName(name: string): string | undefined {\n  if (!name.startsWith('@types/')) return undefined;\n  const typed = name.slice('@types/'.length);\n  return typed.includes('__') ? `@${typed.replace('__', '/')}` : typed;\n}\n\nfunction toTypesPackageName(name: string): string {\n  return `@types/${name.replace(/^@([^/]+)\\//, '$1__')}`;\n}\n\n/**\n * 3-way merge of the entries of each key. an entry is unchanged between two sides when it's in the same field with an\n * equal value. returns the merged entries that exist (not removed).\n */\nfunction mergeEntries<Field, Value>(\n  base: Map<string, FieldEntry<Field, Value>>,\n  current: Map<string, FieldEntry<Field, Value>>,\n  other: Map<string, FieldEntry<Field, Value>>,\n  mergeStrategy: MergeStrategy | undefined,\n  isEqualValue: (a: Value, b: Value) => boolean\n): Array<MergedEntry<Field, Value>> {\n  return union([...current.keys()], [...other.keys()]).flatMap((key) => {\n    const merged = mergeValue(\n      base.get(key),\n      current.get(key),\n      other.get(key),\n      mergeStrategy,\n      (a, b) => a.field === b.field && isEqualValue(a.value, b.value)\n    );\n    return merged ? [{ key, ...merged }] : [];\n  });\n}\n\n/**\n * returns undefined when the merged result is \"absent\" (removed or never existed).\n */\nfunction mergeValue<T>(\n  base: T | undefined,\n  current: T | undefined,\n  other: T | undefined,\n  mergeStrategy: MergeStrategy | undefined,\n  isEqualValue: (a: T, b: T) => boolean\n): T | undefined {\n  const equal = (a?: T, b?: T) => (a === undefined || b === undefined ? a === b : isEqualValue(a, b));\n  if (equal(current, other)) return current;\n  if (equal(base, current)) return other; // changed (or removed) on other only\n  if (equal(base, other)) return current; // changed (or removed) on current only\n  return mergeStrategy === 'theirs' ? other : current;\n}\n\nfunction cloneDependency(dep: Dependency): Dependency {\n  const clone = Dependency.getClone(dep);\n  return new Dependency(clone.id, clone.relativePaths, clone.packageName, clone.versionRange);\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/merge-dependencies.spec.js

@@ -49,19 +49,30 @@ const toDeps = (ids = []) => asLoaded(ids.map(id => {
 function snapshot({
   comps,
   devComps,
+  peerComps,
   pkgs,
-  devPkgs
+  devPkgs,
+  peerPkgs
 }) {
   return {
     dependencies: toDeps(comps),
     devDependencies: toDeps(devComps),
-    peerDependencies: toDeps(),
+    peerDependencies: toDeps(peerComps),
     packageDependencies: pkgs || {},
     devPackageDependencies: devPkgs || {},
-    peerPackageDependencies: {}
+    peerPackageDependencies: peerPkgs || {}
   };
 }
+const importsOf = (merged, sides) => ({
+  merged: new Map(Object.entries(merged)),
+  sides: new Set(sides)
+});
 const idsOf = deps => deps.get().map(dep => dep.id.toString());
+const side = (input, ignoredPackages = [], forcedPackages = []) => ({
+  dependencies: snapshot(input),
+  ignoredPackages: new Set(ignoredPackages),
+  forcedPackages: new Set(forcedPackages)
+});
 describe('mergeDependencies', () => {
   describe('packages', () => {
     const base = snapshot({
@@ -294,6 +305,206 @@ describe('mergeDependencies', () => {
       (0, _chai().expect)(idsOf((0, _mergeDependencies().mergeDependencies)(base, current, other, 'manual').dependencies)).to.deep.equal([]);
     });
   });
+  describe('with the imports of the merged files', () => {
+    describe('a package that one side stopped importing and the other side imports from another file', () => {
+      // the lane removed the only import of lodash, main kept it and imports it from another file as well
+      const base = snapshot({
+        pkgs: {
+          lodash: '4.17.20'
+        }
+      });
+      const current = snapshot({});
+      const other = snapshot({
+        pkgs: {
+          lodash: '4.17.21'
+        }
+      });
+      const imports = importsOf({
+        lodash: 'runtime'
+      }, ['lodash']);
+      it('should be removed without the imports, as it was removed on current only', () => {
+        (0, _chai().expect)((0, _mergeDependencies().mergeDependencies)(base, current, other, 'manual').packageDependencies).to.deep.equal({});
+      });
+      it('should be kept, taken from other, when the merged files import it', () => {
+        const merged = (0, _mergeDependencies().mergeDependencies)(base, current, other, 'manual', undefined, imports);
+        (0, _chai().expect)(merged.packageDependencies).to.deep.equal({
+          lodash: '4.17.21'
+        });
+      });
+    });
+    describe('a package that each side stopped importing from a different file', () => {
+      // both sides still import it, but not the merged files
+      const base = snapshot({
+        pkgs: {
+          lodash: '4.17.20'
+        }
+      });
+      const merged = (0, _mergeDependencies().mergeDependencies)(base, base, base, 'manual', undefined, importsOf({}, ['lodash']));
+      it('should be removed', () => {
+        (0, _chai().expect)(merged.packageDependencies).to.deep.equal({});
+      });
+    });
+    describe('a component dependency that the merged files import from dev files only', () => {
+      const base = snapshot({
+        comps: ['my-scope/b@0.0.1']
+      });
+      const merged = (0, _mergeDependencies().mergeDependencies)(base, base, base, 'manual', undefined, importsOf({
+        '@my-scope/b': 'dev'
+      }, []));
+      it('should be a dev dependency', () => {
+        (0, _chai().expect)(idsOf(merged.dependencies)).to.deep.equal([]);
+        (0, _chai().expect)(idsOf(merged.devDependencies)).to.deep.equal(['my-scope/b@0.0.1']);
+      });
+    });
+    describe('a component dependency that the merged files import, and only base has', () => {
+      const base = snapshot({
+        comps: ['my-scope/b@0.0.1']
+      });
+      const current = snapshot({});
+      const merged = (0, _mergeDependencies().mergeDependencies)(base, current, current, 'manual', undefined, importsOf({
+        '@my-scope/b': 'runtime'
+      }, []));
+      it('should be taken from base', () => {
+        (0, _chai().expect)(idsOf(merged.dependencies)).to.deep.equal(['my-scope/b@0.0.1']);
+      });
+    });
+    describe('a peer package that the merged files import', () => {
+      const base = snapshot({
+        peerPkgs: {
+          react: '^18.0.0'
+        }
+      });
+      const merged = (0, _mergeDependencies().mergeDependencies)(base, base, base, 'manual', undefined, importsOf({
+        react: 'runtime'
+      }, ['react']));
+      it('should stay a peer', () => {
+        (0, _chai().expect)(merged.peerPackageDependencies).to.deep.equal({
+          react: '^18.0.0'
+        });
+        (0, _chai().expect)(merged.packageDependencies).to.deep.equal({});
+      });
+    });
+    describe('a package that no side imports', () => {
+      // e.g. added by a policy
+      const base = snapshot({
+        pkgs: {
+          'core-js': '3.0.0'
+        }
+      });
+      const merged = (0, _mergeDependencies().mergeDependencies)(base, base, base, 'manual', undefined, importsOf({}, []));
+      it('should keep the 3-way result', () => {
+        (0, _chai().expect)(merged.packageDependencies).to.deep.equal({
+          'core-js': '3.0.0'
+        });
+      });
+    });
+    describe('a types package', () => {
+      const base = snapshot({
+        pkgs: {
+          '@scope/foo': '1.0.0'
+        },
+        devPkgs: {
+          '@types/scope__foo': '1.0.0'
+        }
+      });
+      const current = snapshot({});
+      it('should be removed with the package it types', () => {
+        const merged = (0, _mergeDependencies().mergeDependencies)(base, base, base, 'manual', undefined, importsOf({}, ['@scope/foo']));
+        (0, _chai().expect)(merged.devPackageDependencies).to.deep.equal({});
+      });
+      it('should be kept with the package it types', () => {
+        const imports = importsOf({
+          '@scope/foo': 'runtime'
+        }, ['@scope/foo']);
+        const merged = (0, _mergeDependencies().mergeDependencies)(base, current, base, 'manual', undefined, imports);
+        (0, _chai().expect)(merged.packageDependencies).to.deep.equal({
+          '@scope/foo': '1.0.0'
+        });
+        (0, _chai().expect)(merged.devPackageDependencies).to.deep.equal({
+          '@types/scope__foo': '1.0.0'
+        });
+      });
+    });
+  });
+});
+describe('getImportedPackagesWithoutVersion', () => {
+  it('should return a package that a side ignored and the merge does not, when no side has it', () => {
+    // the lane imports lodash while it's ignored, main removes the "-"
+    const result = (0, _mergeDependencies().getImportedPackagesWithoutVersion)(side({}, ['lodash']), side({}, ['lodash']), side({}), ['lodash']);
+    (0, _chai().expect)(result).to.deep.equal(['lodash']);
+  });
+  it('should not return a package that the merge still ignores', () => {
+    const ignoring = side({}, ['lodash']);
+    (0, _chai().expect)((0, _mergeDependencies().getImportedPackagesWithoutVersion)(ignoring, ignoring, ignoring, ['lodash'])).to.deep.equal([]);
+  });
+  it('should not return a package that a side has as a dependency', () => {
+    const result = (0, _mergeDependencies().getImportedPackagesWithoutVersion)(side({}, ['lodash']), side({}, ['lodash']), side({
+      pkgs: {
+        lodash: '4.17.21'
+      }
+    }), ['lodash']);
+    (0, _chai().expect)(result).to.deep.equal([]);
+  });
+  it('should return a package that a side ignored and the merge does not, when a side has its types package only', () => {
+    const result = (0, _mergeDependencies().getImportedPackagesWithoutVersion)(side({}, ['lodash']), side({
+      devPkgs: {
+        '@types/lodash': '4.17.0'
+      }
+    }, ['lodash']), side({}), ['lodash']);
+    (0, _chai().expect)(result).to.deep.equal(['lodash']);
+  });
+  it('should not return a package that no side ignored', () => {
+    // e.g. a core aspect, which is never a dependency
+    (0, _chai().expect)((0, _mergeDependencies().getImportedPackagesWithoutVersion)(side({}), side({}), side({}), ['@scope/core'])).to.deep.equal([]);
+  });
+});
+describe('withPolicyOfMerge', () => {
+  const mergeWithImports = (base, current, other, imports) => (0, _mergeDependencies().mergeDependencies)(base.dependencies, current.dependencies, other.dependencies, 'manual', undefined, (0, _mergeDependencies().withPolicyOfMerge)(imports, base, current, other));
+  it('should let the 3-way merge remove a package that other started to ignore, although the files import it', () => {
+    const base = side({
+      pkgs: {
+        lodash: '4.17.21'
+      }
+    });
+    const merged = mergeWithImports(base, base, side({}, ['lodash']), importsOf({
+      lodash: 'runtime'
+    }, ['lodash']));
+    (0, _chai().expect)(merged.packageDependencies).to.deep.equal({});
+  });
+  it('should keep a package that the policy forces, when the merged files stop importing it', () => {
+    // e.g. an own peer of an env, which is a runtime dependency of the env
+    const env = side({
+      pkgs: {
+        react: '^18.0.0'
+      }
+    }, [], ['react']);
+    const merged = mergeWithImports(env, env, env, importsOf({}, ['react']));
+    (0, _chai().expect)(merged.packageDependencies).to.deep.equal({
+      react: '^18.0.0'
+    });
+  });
+  it('should let the 3-way merge remove a types package that other started to ignore, although the files import it', () => {
+    const base = side({
+      pkgs: {
+        react: '18.0.0'
+      },
+      devPkgs: {
+        '@types/react': '18.0.0'
+      }
+    });
+    const other = side({
+      pkgs: {
+        react: '18.0.0'
+      }
+    }, ['@types/react']);
+    const merged = mergeWithImports(base, base, other, importsOf({
+      react: 'runtime'
+    }, ['react']));
+    (0, _chai().expect)(merged.devPackageDependencies).to.deep.equal({});
+    (0, _chai().expect)(merged.packageDependencies).to.deep.equal({
+      react: '18.0.0'
+    });
+  });
 });
 
 //# sourceMappingURL=merge-dependencies.spec.js.map