@teambit/dependencies 1.0.82 → 1.0.83

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

@@ -0,0 +1,100 @@
+import { ComponentID } from '@teambit/component-id';
+import { IssuesList } from '@teambit/component-issues';
+import Component from '@teambit/legacy/dist/consumer/component/consumer-component';
+import { Workspace } from '@teambit/workspace';
+import { Dependency } from '@teambit/legacy/dist/consumer/component/dependencies';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import Consumer from '@teambit/legacy/dist/consumer/consumer';
+import OverridesDependencies from './overrides-dependencies';
+import { DependenciesData } from './dependencies-data';
+import { DebugDependencies } from './auto-detect-deps';
+export declare type AllDependencies = {
+    dependencies: Dependency[];
+    devDependencies: Dependency[];
+};
+export declare type AllPackagesDependencies = {
+    packageDependencies: Record<string, string>;
+    devPackageDependencies: Record<string, string>;
+    peerPackageDependencies: Record<string, string>;
+};
+export declare class ApplyOverrides {
+    private component;
+    private depsResolver;
+    private workspace?;
+    componentId: ComponentID;
+    componentFromModel: Component;
+    allDependencies: AllDependencies;
+    allPackagesDependencies: AllPackagesDependencies;
+    /**
+     * This will store a copy of the package deps before removal
+     * in order to apply auto detected rules that are running after the removal
+     */
+    originAllPackagesDependencies: AllPackagesDependencies;
+    issues: IssuesList;
+    coreAspects: string[];
+    processedFiles: string[];
+    overridesDependencies: OverridesDependencies;
+    debugDependenciesData: DebugDependencies;
+    autoDetectOverrides: Record<string, any> | undefined;
+    constructor(component: Component, depsResolver: DependencyResolverMain, workspace?: Workspace | undefined);
+    get consumer(): Consumer | undefined;
+    getDependenciesData(): Promise<{
+        dependenciesData: DependenciesData;
+        overridesDependencies: OverridesDependencies;
+        autoDetectOverrides?: Record<string, any>;
+    }>;
+    /**
+     * Given the tree of file dependencies from the driver, find the components of these files.
+     * Each dependency file has a path, use bit.map to search for the component name by that path.
+     * If the component is found, add it to "this.allDependencies.dependencies". Otherwise, add it to "this.issues.untrackedDependencies".
+     *
+     * For the found components, add their sourceRelativePath and destinationRelativePath, they are being used for
+     * generating links upon import:
+     * sourceRelativePath - location of the link file.
+     * destinationRelativePath - destination written inside the link file.
+     *
+     * When a dependency is found in a regular (implementation) file, it goes to `dependencies`. If
+     * it found on a test file, it goes to `devDependencies`.
+     * Similarly, when a package is found in a regular file, it goes to `packageDependencies`. When
+     * if found in a test file, it goes to `devPackageDependencies`.
+     * An exception for the above is when a package is required in a regular or test file but is also
+     * mentioned in the `package.json` file as a peerDependency, in that case, the package is added
+     * to `peerPackageDependencies` and removed from other places. Unless this package is overridden
+     * and marked as ignored in the consumer or component config file.
+     */
+    private populateDependencies;
+    private removeIgnoredComponentsByOverrides;
+    private loadAutoDetectOverrides;
+    private cloneAllPackagesDependencies;
+    private removeIgnoredPackagesByOverrides;
+    private _resolvePackageData;
+    private _getComponentIdToAdd;
+    getDependenciesToAddManually(packageJson: Record<string, any> | null | undefined, existingDependencies: AllDependencies): {
+        components: Record<string, any>;
+        packages: Record<string, any>;
+    } | undefined;
+    private manuallyAddDependencies;
+    /**
+     * Remove the dependencies which appear both in dev and regular deps from the dev
+     * Because if a dependency is both dev dependency and regular dependency it should be treated as regular one
+     * Apply for both packages and components dependencies
+     */
+    private removeDevAndEnvDepsIfTheyAlsoRegulars;
+    private applyPeersFromComponentModel;
+    private applyPackageJson;
+    private applyWorkspacePolicy;
+    /**
+     * It removes the @teambit/legacy dependency from the dependencies/devDeps and adds it as a peer dependency with ^.
+     */
+    private makeLegacyAsPeer;
+    private applyAutoDetectOverridesOnComponent;
+    private applyAutoDetectedPeersFromEnvOnEnvItSelf;
+    /**
+     * returns `package.json` of the component when it's imported, or `package.json` of the workspace
+     * when it's authored.
+     */
+    private _getPackageJson;
+    private _getPackageJsonFromComponentModel;
+    private setLegacyInsideHarmonyIssue;
+    private _pkgFieldMapping;
+}

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

@@ -0,0 +1,541 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ApplyOverrides = void 0;
+function _ramda() {
+  const data = _interopRequireDefault(require("ramda"));
+  _ramda = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _componentIssues() {
+  const data = require("@teambit/component-issues");
+  _componentIssues = function () {
+    return data;
+  };
+  return data;
+}
+function _constants() {
+  const data = require("@teambit/legacy/dist/constants");
+  _constants = function () {
+    return data;
+  };
+  return data;
+}
+function _packageJsonFile() {
+  const data = _interopRequireDefault(require("@teambit/legacy/dist/consumer/component/package-json-file"));
+  _packageJsonFile = function () {
+    return data;
+  };
+  return data;
+}
+function _packages() {
+  const data = require("@teambit/legacy/dist/utils/packages");
+  _packages = function () {
+    return data;
+  };
+  return data;
+}
+function _dependencies() {
+  const data = require("@teambit/legacy/dist/consumer/component/dependencies");
+  _dependencies = function () {
+    return data;
+  };
+  return data;
+}
+function _overridesDependencies() {
+  const data = _interopRequireDefault(require("./overrides-dependencies"));
+  _overridesDependencies = function () {
+    return data;
+  };
+  return data;
+}
+function _dependenciesData() {
+  const data = require("./dependencies-data");
+  _dependenciesData = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const DepsKeysToAllPackagesDepsKeys = {
+  dependencies: 'packageDependencies',
+  devDependencies: 'devPackageDependencies',
+  peerDependencies: 'peerPackageDependencies'
+};
+class ApplyOverrides {
+  constructor(component, depsResolver, workspace) {
+    this.component = component;
+    this.depsResolver = depsResolver;
+    this.workspace = workspace;
+    _defineProperty(this, "componentId", void 0);
+    _defineProperty(this, "componentFromModel", void 0);
+    _defineProperty(this, "allDependencies", void 0);
+    _defineProperty(this, "allPackagesDependencies", void 0);
+    /**
+     * This will store a copy of the package deps before removal
+     * in order to apply auto detected rules that are running after the removal
+     */
+    _defineProperty(this, "originAllPackagesDependencies", void 0);
+    _defineProperty(this, "issues", void 0);
+    _defineProperty(this, "coreAspects", []);
+    _defineProperty(this, "processedFiles", void 0);
+    _defineProperty(this, "overridesDependencies", void 0);
+    _defineProperty(this, "debugDependenciesData", void 0);
+    _defineProperty(this, "autoDetectOverrides", void 0);
+    this.componentId = component.componentId;
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    this.componentFromModel = this.component.componentFromModel;
+    this.allDependencies = {
+      dependencies: [],
+      devDependencies: []
+    };
+    this.allPackagesDependencies = {
+      packageDependencies: {},
+      devPackageDependencies: {},
+      peerPackageDependencies: {}
+    };
+    this.processedFiles = [];
+    this.issues = component.issues;
+    this.setLegacyInsideHarmonyIssue();
+    this.overridesDependencies = new (_overridesDependencies().default)(component);
+    this.debugDependenciesData = {
+      components: []
+    };
+  }
+  get consumer() {
+    var _this$workspace;
+    return (_this$workspace = this.workspace) === null || _this$workspace === void 0 ? void 0 : _this$workspace.consumer;
+  }
+  async getDependenciesData() {
+    await this.populateDependencies();
+    const dependenciesData = new (_dependenciesData().DependenciesData)(this.allDependencies, this.allPackagesDependencies, this.issues, this.coreAspects);
+    return {
+      dependenciesData,
+      overridesDependencies: this.overridesDependencies,
+      autoDetectOverrides: this.autoDetectOverrides
+    };
+  }
+
+  /**
+   * Given the tree of file dependencies from the driver, find the components of these files.
+   * Each dependency file has a path, use bit.map to search for the component name by that path.
+   * If the component is found, add it to "this.allDependencies.dependencies". Otherwise, add it to "this.issues.untrackedDependencies".
+   *
+   * For the found components, add their sourceRelativePath and destinationRelativePath, they are being used for
+   * generating links upon import:
+   * sourceRelativePath - location of the link file.
+   * destinationRelativePath - destination written inside the link file.
+   *
+   * When a dependency is found in a regular (implementation) file, it goes to `dependencies`. If
+   * it found on a test file, it goes to `devDependencies`.
+   * Similarly, when a package is found in a regular file, it goes to `packageDependencies`. When
+   * if found in a test file, it goes to `devPackageDependencies`.
+   * An exception for the above is when a package is required in a regular or test file but is also
+   * mentioned in the `package.json` file as a peerDependency, in that case, the package is added
+   * to `peerPackageDependencies` and removed from other places. Unless this package is overridden
+   * and marked as ignored in the consumer or component config file.
+   */
+  async populateDependencies() {
+    await this.loadAutoDetectOverrides();
+    this.removeIgnoredComponentsByOverrides();
+    this.cloneAllPackagesDependencies();
+    this.removeIgnoredPackagesByOverrides();
+    this.removeDevAndEnvDepsIfTheyAlsoRegulars();
+    this.applyPeersFromComponentModel();
+    this.applyPackageJson();
+    this.applyWorkspacePolicy();
+    this.makeLegacyAsPeer();
+    await this.applyAutoDetectOverridesOnComponent();
+    this.manuallyAddDependencies();
+    // Doing this here (after manuallyAddDependencies) because usually the env of the env is adding dependencies as peer of the env
+    // which will make this not work if it come before
+    // example:
+    // custom react has peers with react 16.4.0.
+    // the custom react uses the "teambit.envs/env" env, which will add react ^17.0.0 to every component that uses it
+    // we want to make sure that the custom react is using 16.4.0 not 17.
+    await this.applyAutoDetectedPeersFromEnvOnEnvItSelf();
+    this.coreAspects = _ramda().default.uniq(this.coreAspects);
+  }
+  removeIgnoredComponentsByOverrides() {
+    const shouldBeIncluded = (dep, fileType) => !this.overridesDependencies.shouldIgnorePackage(dep.packageName, fileType);
+    this.allDependencies.dependencies = this.allDependencies.dependencies.filter(dep => shouldBeIncluded(dep, {
+      isTestFile: false
+    }));
+    this.allDependencies.devDependencies = this.allDependencies.devDependencies.filter(dep => shouldBeIncluded(dep, {
+      isTestFile: true
+    }));
+    const missingIssue = this.issues.getIssueByName('MissingPackagesDependenciesOnFs');
+    if (!missingIssue) return;
+    const missingData = missingIssue.data;
+    missingData.forEach(m => {
+      m.missingPackages = m.missingPackages.filter(pkg => !this.overridesDependencies.shouldIgnorePackage(pkg, {
+        isTestFile: m.isDevFile
+      }));
+    });
+    missingIssue.data = missingData.filter(m => m.missingPackages.length);
+    if (!missingIssue.data.length) this.issues.delete(_componentIssues().IssuesClasses.MissingPackagesDependenciesOnFs);
+  }
+  async loadAutoDetectOverrides() {
+    var _this$workspace2;
+    this.autoDetectOverrides = await ((_this$workspace2 = this.workspace) === null || _this$workspace2 === void 0 ? void 0 : _this$workspace2.getAutoDetectOverrides(this.component.extensions, this.component.id, this.component.files));
+  }
+  cloneAllPackagesDependencies() {
+    this.originAllPackagesDependencies = (0, _lodash().cloneDeep)(this.allPackagesDependencies);
+  }
+  removeIgnoredPackagesByOverrides() {
+    const shouldBeIncluded = (pkgVersion, pkgName) => !this.overridesDependencies.shouldIgnorePackageByType(pkgName, 'dependencies');
+    const shouldBeIncludedDev = (pkgVersion, pkgName) => !this.overridesDependencies.shouldIgnorePackageByType(pkgName, 'devDependencies');
+    this.allPackagesDependencies.packageDependencies = _ramda().default.pickBy(shouldBeIncluded, this.allPackagesDependencies.packageDependencies);
+    this.allPackagesDependencies.devPackageDependencies = _ramda().default.pickBy(shouldBeIncludedDev, this.allPackagesDependencies.devPackageDependencies);
+  }
+
+  // TODO: maybe cache those results??
+  _resolvePackageData(packageName) {
+    const consumer = this.consumer;
+    if (!consumer) return undefined;
+    // if consumer is defined, then it has componentMap prop.
+    const componentMap = this.component.componentMap;
+    const rootDir = componentMap.rootDir;
+    const consumerPath = consumer.getPath();
+    const basePath = rootDir ? _path().default.join(consumerPath, rootDir) : consumerPath;
+    const modulePath = (0, _packages().resolvePackagePath)(packageName, basePath, consumerPath);
+    if (!modulePath) return undefined; // e.g. it's author and wasn't exported yet, so there's no node_modules of that component
+    const packageObject = (0, _packages().resolvePackageData)(basePath, modulePath);
+    return packageObject;
+  }
+  _getComponentIdToAdd(field, dependency) {
+    if (field === 'peerDependencies') return undefined;
+    const packageData = this._resolvePackageData(dependency);
+    return {
+      componentId: packageData === null || packageData === void 0 ? void 0 : packageData.componentId,
+      packageName: packageData === null || packageData === void 0 ? void 0 : packageData.name
+    };
+  }
+  getDependenciesToAddManually(packageJson, existingDependencies) {
+    const overrides = this.overridesDependencies.getDependenciesToAddManually();
+    if (!overrides) return undefined;
+    const components = {};
+    const packages = {};
+    _constants().DEPENDENCIES_FIELDS.forEach(depField => {
+      if (!overrides[depField]) return;
+      Object.keys(overrides[depField]).forEach(dependency => {
+        const dependencyValue = overrides[depField][dependency];
+        const componentData = this._getComponentIdToAdd(depField, dependency);
+        if (componentData !== null && componentData !== void 0 && componentData.componentId) {
+          const dependencyExist = existingDependencies[depField].find(d => d.id.isEqualWithoutVersion(componentData.componentId));
+          if (!dependencyExist) {
+            this.overridesDependencies._addManuallyAddedDep(depField, componentData.componentId.toString());
+            components[depField] ? components[depField].push(componentData) : components[depField] = [componentData];
+          }
+          return;
+        }
+        const addedPkg = this.overridesDependencies._manuallyAddPackage(depField, dependency, dependencyValue, packageJson);
+        if (addedPkg) {
+          packages[depField] = Object.assign(packages[depField] || {}, addedPkg);
+          if (componentData && !componentData.packageName) {
+            this.overridesDependencies.missingPackageDependencies.push(dependency);
+          }
+        }
+      });
+    });
+    return {
+      components,
+      packages
+    };
+  }
+  manuallyAddDependencies() {
+    const packageJson = this._getPackageJson();
+    const dependencies = this.getDependenciesToAddManually(packageJson, this.allDependencies);
+    if (!dependencies) return;
+    const {
+      components,
+      packages
+    } = dependencies;
+    _constants().DEPENDENCIES_FIELDS.forEach(depField => {
+      if (components[depField] && components[depField].length) {
+        components[depField].forEach(depData => this.allDependencies[depField].push(new (_dependencies().Dependency)(depData.componentId, [], depData.packageName)));
+      }
+      if (packages[depField] && !_ramda().default.isEmpty(packages[depField])) {
+        Object.assign(this.allPackagesDependencies[this._pkgFieldMapping(depField)], packages[depField]);
+      }
+    });
+    // The automatic dependency detector considers all found dependencies to be runtime dependencies.
+    // But this breaks proper installation of injected subdependencies that are resolved from workspace components.
+    if (this.allPackagesDependencies.packageDependencies && packages.peerDependencies) {
+      for (const peerName of Object.keys(packages.peerDependencies)) {
+        delete this.allPackagesDependencies.packageDependencies[peerName];
+      }
+    }
+    if (this.allPackagesDependencies.packageDependencies && packages.peerPackageDependencies) {
+      for (const peerName of Object.keys(packages.peerPackageDependencies)) {
+        delete this.allPackagesDependencies.packageDependencies[peerName];
+      }
+    }
+  }
+
+  /**
+   * Remove the dependencies which appear both in dev and regular deps from the dev
+   * Because if a dependency is both dev dependency and regular dependency it should be treated as regular one
+   * Apply for both packages and components dependencies
+   */
+  removeDevAndEnvDepsIfTheyAlsoRegulars() {
+    // remove dev and env packages that are also regular packages
+    const getNotRegularPackages = packages => _ramda().default.difference(_ramda().default.keys(packages), _ramda().default.keys(this.allPackagesDependencies.packageDependencies));
+    this.allPackagesDependencies.devPackageDependencies = _ramda().default.pick(getNotRegularPackages(this.allPackagesDependencies.devPackageDependencies), this.allPackagesDependencies.devPackageDependencies);
+    // remove dev dependencies that are also regular dependencies
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    const componentDepsIds = new (_componentId().ComponentIdList)(...this.allDependencies.dependencies.map(c => c.id));
+    this.allDependencies.devDependencies = this.allDependencies.devDependencies.filter(d => !componentDepsIds.has(d.id));
+  }
+  applyPeersFromComponentModel() {
+    const getPeerDependencies = () => {
+      const packageJson = this._getPackageJsonFromComponentModel();
+      if (packageJson && packageJson.peerDependencies) return packageJson.peerDependencies;
+      return {};
+    };
+    const projectPeerDependencies = getPeerDependencies();
+    const peerPackages = {};
+    if (_ramda().default.isEmpty(projectPeerDependencies)) return;
+
+    // check whether the peer-dependencies was actually require in the code. if so, remove it from
+    // the packages/dev-packages and add it as a peer-package.
+    // if it was not required in the code, don't add it to the peerPackages
+    Object.keys(projectPeerDependencies).forEach(pkg => {
+      if (this.overridesDependencies.shouldIgnorePeerPackage(pkg)) return;
+      ['packageDependencies', 'devPackageDependencies'].forEach(field => {
+        if (Object.keys(this.allPackagesDependencies[field]).includes(pkg)) {
+          delete this.allPackagesDependencies[field][pkg];
+          peerPackages[pkg] = projectPeerDependencies[pkg];
+        }
+      });
+    });
+    this.allPackagesDependencies.peerPackageDependencies = peerPackages;
+  }
+  applyPackageJson() {
+    const packageJson = this._getPackageJson();
+    if (!packageJson) return;
+    const pkgJsonPeer = packageJson.peerDependencies || {};
+    const pkgJsonRegularDeps = packageJson.dependencies || {};
+    const peerDeps = this.allPackagesDependencies.peerPackageDependencies || {};
+    ['packageDependencies', 'devPackageDependencies', 'peerPackageDependencies'].forEach(field => {
+      _ramda().default.forEachObjIndexed((_pkgVal, pkgName) => {
+        const peerVersionFromPkgJson = pkgJsonPeer[pkgName];
+        const regularVersionFromPkgJson = pkgJsonRegularDeps[pkgName];
+        if (peerVersionFromPkgJson) {
+          delete this.allPackagesDependencies[field][pkgName];
+          peerDeps[pkgName] = peerVersionFromPkgJson;
+        } else if (regularVersionFromPkgJson) {
+          var _this$allPackagesDepe;
+          (_this$allPackagesDepe = this.allPackagesDependencies.peerPackageDependencies) === null || _this$allPackagesDepe === void 0 || delete _this$allPackagesDepe[pkgName];
+          this.allPackagesDependencies[field][pkgName] = regularVersionFromPkgJson;
+        }
+      }, this.allPackagesDependencies[field]);
+    });
+    this.allPackagesDependencies.peerPackageDependencies = peerDeps;
+  }
+  applyWorkspacePolicy() {
+    const wsPolicy = this.depsResolver.getWorkspacePolicyManifest();
+    if (!wsPolicy) return;
+    const wsPeer = wsPolicy.peerDependencies || {};
+    const wsRegular = wsPolicy.dependencies || {};
+    const peerDeps = this.allPackagesDependencies.peerPackageDependencies || {};
+    // we are not iterate component deps since they are resolved from what actually installed
+    // the policy used for installation only in that case
+    ['packageDependencies', 'devPackageDependencies', 'peerPackageDependencies'].forEach(field => {
+      _ramda().default.forEachObjIndexed((_pkgVal, pkgName) => {
+        const peerVersionFromWsPolicy = wsPeer[pkgName];
+        const regularVersionFromWsPolicy = wsRegular[pkgName];
+        if (peerVersionFromWsPolicy) {
+          delete this.allPackagesDependencies[field][pkgName];
+          peerDeps[pkgName] = peerVersionFromWsPolicy;
+        } else if (regularVersionFromWsPolicy) {
+          var _this$allPackagesDepe2;
+          (_this$allPackagesDepe2 = this.allPackagesDependencies.peerPackageDependencies) === null || _this$allPackagesDepe2 === void 0 || delete _this$allPackagesDepe2[pkgName];
+          this.allPackagesDependencies[field][pkgName] = regularVersionFromWsPolicy;
+        }
+      }, this.allPackagesDependencies[field]);
+    });
+    this.allPackagesDependencies.peerPackageDependencies = peerDeps;
+  }
+
+  /**
+   * It removes the @teambit/legacy dependency from the dependencies/devDeps and adds it as a peer dependency with ^.
+   */
+  makeLegacyAsPeer() {
+    let version;
+    if (this.allPackagesDependencies.packageDependencies['@teambit/legacy']) {
+      version = this.allPackagesDependencies.packageDependencies['@teambit/legacy'];
+      delete this.allPackagesDependencies.packageDependencies['@teambit/legacy'];
+    }
+    if (this.allPackagesDependencies.devPackageDependencies['@teambit/legacy']) {
+      if (!version) version = this.allPackagesDependencies.devPackageDependencies['@teambit/legacy'];
+      delete this.allPackagesDependencies.devPackageDependencies['@teambit/legacy'];
+    }
+    if (version) {
+      if (!Number.isNaN(version[0])) version = `^${version}`;
+      this.allPackagesDependencies.peerPackageDependencies['@teambit/legacy'] = version;
+    }
+  }
+  async applyAutoDetectOverridesOnComponent() {
+    var _this$issues$getIssue;
+    const autoDetectOverrides = this.autoDetectOverrides;
+    if (!autoDetectOverrides || !Object.keys(autoDetectOverrides).length) {
+      return;
+    }
+    const originallyExists = [];
+    let missingPackages = [];
+    // We want to also add missing packages to the peer list as we know to resolve the version from the env anyway
+    const missingData = (_this$issues$getIssue = this.issues.getIssueByName('MissingPackagesDependenciesOnFs')) === null || _this$issues$getIssue === void 0 ? void 0 : _this$issues$getIssue.data;
+    if (missingData) {
+      missingPackages = (0, _lodash().uniq)(missingData.map(d => d.missingPackages).flat());
+    }
+    ['dependencies', 'devDependencies', 'peerDependencies'].forEach(field => {
+      _ramda().default.forEachObjIndexed((pkgVal, pkgName) => {
+        if (this.overridesDependencies.shouldIgnorePeerPackage(pkgName)) return;
+        // Validate it was auto detected, we only affect stuff that were detected
+        const existsInCompsDeps = this.allDependencies.dependencies.find(dep => {
+          return dep.packageName === pkgName;
+        });
+        const existsInCompsDevDeps = this.allDependencies.devDependencies.find(dep => {
+          return dep.packageName === pkgName;
+        });
+        if (
+        // We are checking originAllPackagesDependencies instead of allPackagesDependencies
+        // as it might be already removed from allPackagesDependencies at this point if it was set with
+        // "-" in runtime/dev
+        // in such case we still want to apply it here
+        !this.originAllPackagesDependencies.packageDependencies[pkgName] && !this.originAllPackagesDependencies.devPackageDependencies[pkgName] && !this.originAllPackagesDependencies.peerPackageDependencies[pkgName] && !existsInCompsDeps && !existsInCompsDevDeps &&
+        // Check if it was orignally exists in the component
+        // as we might have a policy which looks like this:
+        // "components": {
+        //   "dependencies": {
+        //       "my-dep": "-"
+        //    },
+        //   "devDependencies": {
+        //       "my-dep": "1.0.0"
+        //    },
+        // }
+        // in that case we might remove it before getting to the devDeps then we will think that it wasn't required in the component
+        // which is incorrect
+        !originallyExists.includes(pkgName) && !missingPackages.includes(pkgName)) {
+          return;
+        }
+        originallyExists.push(pkgName);
+        const key = DepsKeysToAllPackagesDepsKeys[field];
+        delete this.allPackagesDependencies[key][pkgName];
+        // When changing peer dependency we want it to be stronger than the other types
+        if (field === 'peerDependencies') {
+          delete this.allPackagesDependencies.devPackageDependencies[pkgName];
+          delete this.allPackagesDependencies.packageDependencies[pkgName];
+          if (existsInCompsDeps) {
+            this.allDependencies.dependencies = this.allDependencies.dependencies.filter(dep => dep.packageName !== pkgName);
+          }
+          if (existsInCompsDevDeps) {
+            this.allDependencies.devDependencies = this.allDependencies.devDependencies.filter(dep => dep.packageName !== pkgName);
+          }
+        }
+        // delete this.allPackagesDependencies.packageDependencies[pkgName];
+        // delete this.allPackagesDependencies.devPackageDependencies[pkgName];
+        // delete this.allPackagesDependencies.peerPackageDependencies[pkgName];
+
+        // If it exists in comps deps / comp dev deps, we don't want to add it to the allPackagesDependencies
+        // as it will make the same dep both a dev and runtime dep
+        // since we are here only for auto detected deps, it means we already resolved the version correctly
+        // so we don't need to really modify the version
+        // also the version here might have a range (^ or ~ for example) so we can't
+        // just put it as is, as it is not valid for component deps to have range
+        if (pkgVal !== _constants().MANUALLY_REMOVE_DEPENDENCY && (!existsInCompsDeps && !existsInCompsDevDeps || field === 'peerDependencies')) {
+          this.allPackagesDependencies[key][pkgName] = pkgVal;
+        }
+      }, autoDetectOverrides[field]);
+    });
+  }
+  async applyAutoDetectedPeersFromEnvOnEnvItSelf() {
+    const envPolicy = await this.depsResolver.getEnvPolicyFromEnvLegacyId(this.component.id, this.component.files);
+    if (!envPolicy) return;
+    const envPolicyManifest = envPolicy.selfPolicy.toVersionManifest();
+    if (!envPolicyManifest || !Object.keys(envPolicyManifest).length) {
+      return;
+    }
+    const deps = this.allPackagesDependencies.packageDependencies || {};
+    // we are not iterate component deps since they are resolved from what actually installed
+    // the policy used for installation only in that case
+    ['packageDependencies', 'devPackageDependencies', 'peerPackageDependencies'].forEach(field => {
+      _ramda().default.forEachObjIndexed((_pkgVal, pkgName) => {
+        const peerVersionFromEnvPolicy = envPolicyManifest[pkgName];
+        if (peerVersionFromEnvPolicy) {
+          delete this.allPackagesDependencies[field][pkgName];
+        }
+      }, this.allPackagesDependencies[field]);
+    });
+    Object.assign(deps, envPolicyManifest);
+    // TODO: handle component deps once we support peers between components
+    this.allPackagesDependencies.packageDependencies = deps;
+  }
+
+  /**
+   * returns `package.json` of the component when it's imported, or `package.json` of the workspace
+   * when it's authored.
+   */
+  _getPackageJson() {
+    var _this$consumer;
+    return (_this$consumer = this.consumer) === null || _this$consumer === void 0 ? void 0 : _this$consumer.packageJson.packageJsonObject;
+  }
+  _getPackageJsonFromComponentModel() {
+    if (this.componentFromModel && this.component.componentMap) {
+      // a component is imported but the package.json file is missing or never written
+      // read the values from the model
+      const packageJson = _packageJsonFile().default.createFromComponent(this.component.componentMap.rootDir, this.componentFromModel);
+      return packageJson.packageJsonObject;
+    }
+    return undefined;
+  }
+  setLegacyInsideHarmonyIssue() {
+    if (this.componentFromModel && this.componentFromModel.isLegacy) {
+      this.issues.getOrCreate(_componentIssues().IssuesClasses.LegacyInsideHarmony).data = true;
+    }
+  }
+  _pkgFieldMapping(field) {
+    switch (field) {
+      case 'dependencies':
+        return 'packageDependencies';
+      case 'devDependencies':
+        return 'devPackageDependencies';
+      case 'peerDependencies':
+        return 'peerPackageDependencies';
+      default:
+        throw new Error(`${field} is not recognized`);
+    }
+  }
+}
+exports.ApplyOverrides = ApplyOverrides;
+
+//# sourceMappingURL=apply-overrides.js.map