@teambit/importer 0.0.309 → 0.0.311

package/dist/import-components.js

@@ -1,244 +1,170 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 require("core-js/modules/es.array.flat.js");
-
 require("core-js/modules/es.array.flat-map.js");
-
 require("core-js/modules/es.array.iterator.js");
-
 require("core-js/modules/es.array.unscopables.flat.js");
-
 require("core-js/modules/es.array.unscopables.flat-map.js");
-
 require("core-js/modules/es.promise.js");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 function _defineProperty2() {
   const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
   _defineProperty2 = function () {
     return data;
   };
-
   return data;
 }
-
 function _chalk() {
   const data = _interopRequireDefault(require("chalk"));
-
   _chalk = function () {
     return data;
   };
-
   return data;
 }
-
 function _ramda() {
   const data = _interopRequireDefault(require("ramda"));
-
   _ramda = function () {
     return data;
   };
-
   return data;
 }
-
 function _bitError() {
   const data = require("@teambit/bit-error");
-
   _bitError = function () {
     return data;
   };
-
   return data;
 }
-
 function _pMapSeries() {
   const data = _interopRequireDefault(require("p-map-series"));
-
   _pMapSeries = function () {
     return data;
   };
-
   return data;
 }
-
 function _listScope() {
   const data = require("@teambit/legacy/dist/api/consumer/lib/list-scope");
-
   _listScope = function () {
     return data;
   };
-
   return data;
 }
-
 function _bitId() {
   const data = require("@teambit/legacy/dist/bit-id");
-
   _bitId = function () {
     return data;
   };
-
   return data;
 }
-
 function _loader() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/cli/loader"));
-
   _loader = function () {
     return data;
   };
-
   return data;
 }
-
 function _loaderMessages() {
   const data = require("@teambit/legacy/dist/cli/loader/loader-messages");
-
   _loaderMessages = function () {
     return data;
   };
-
   return data;
 }
-
 function _generalError() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/error/general-error"));
-
   _generalError = function () {
     return data;
   };
-
   return data;
 }
-
 function _showDoctorError() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/error/show-doctor-error"));
-
   _showDoctorError = function () {
     return data;
   };
-
   return data;
 }
-
 function _logger() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/logger/logger"));
-
   _logger = function () {
     return data;
   };
-
   return data;
 }
-
 function _scopeRemotes() {
   const data = require("@teambit/legacy/dist/scope/scope-remotes");
-
   _scopeRemotes = function () {
     return data;
   };
-
   return data;
 }
-
 function _utils() {
   const data = require("@teambit/legacy/dist/utils");
-
   _utils = function () {
     return data;
   };
-
   return data;
 }
-
 function _hasWildcard() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/utils/string/has-wildcard"));
-
   _hasWildcard = function () {
     return data;
   };
-
   return data;
 }
-
 function _exceptions() {
   const data = require("@teambit/legacy/dist/consumer/exceptions");
-
   _exceptions = function () {
     return data;
   };
-
   return data;
 }
-
 function _checkoutVersion() {
   const data = require("@teambit/legacy/dist/consumer/versions-ops/checkout-version");
-
   _checkoutVersion = function () {
     return data;
   };
-
   return data;
 }
-
 function _mergeVersion() {
   const data = require("@teambit/legacy/dist/consumer/versions-ops/merge-version");
-
   _mergeVersion = function () {
     return data;
   };
-
   return data;
 }
-
 function _componentsPendingMerge() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/consumer/component-ops/exceptions/components-pending-merge"));
-
   _componentsPendingMerge = function () {
     return data;
   };
-
   return data;
 }
-
 function _manyComponentsWriter() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/consumer/component-ops/many-components-writer"));
-
   _manyComponentsWriter = function () {
     return data;
   };
-
   return data;
 }
-
 function _scopeComponentsImporter() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/scope/component-ops/scope-components-importer"));
-
   _scopeComponentsImporter = function () {
     return data;
   };
-
   return data;
 }
-
 function _versionDependencies() {
   const data = require("@teambit/legacy/dist/scope/version-dependencies");
-
   _versionDependencies = function () {
     return data;
   };
-
   return data;
 }
-
 class ImportComponents {
   constructor(workspace, graph, options) {
     this.workspace = workspace;
@@ -253,32 +179,24 @@ class ImportComponents {
     this.scope = this.consumer.scope;
     this.laneObjects = this.options.lanes ? this.options.lanes.lanes : [];
   }
-
   importComponents() {
     _loader().default.start(_loaderMessages().BEFORE_IMPORT_ACTION);
-
     this.options.saveDependenciesAsComponents = this.consumer.config._saveDependenciesAsComponents;
-
     if (this.options.lanes && !this.options.ids.length) {
       return this.importObjectsOnLane();
     }
-
     if (this.options.ids.length) {
       return this.importSpecificComponents();
     }
-
     return this.importAccordingToBitMap();
   }
-
   async importObjectsOnLane() {
     if (!this.options.objectsOnly) {
       throw new Error(`importObjectsOnLane should have objectsOnly=true`);
     }
-
     if (this.laneObjects.length > 1) {
       throw new Error(`importObjectsOnLane does not support more than one lane`);
     }
-
     const lane = this.laneObjects.length ? this.laneObjects[0] : undefined;
     const bitIds = await this.getBitIds();
     lane ? _logger().default.debug(`importObjectsOnLane, Lane: ${lane.id()}, Ids: ${bitIds.toString()}`) : _logger().default.debug(`importObjectsOnLane, the lane does not exist on the remote. importing only the main components`);
@@ -286,24 +204,24 @@ class ImportComponents {
     const versionDependenciesArr = await this._importComponentsObjects(bitIds, {
       allHistory: this.options.allHistory,
       lane
-    }); // import lane components from their original scope, this way, it's possible to run diff/merge on them.
+    });
+
+    // import lane components from their original scope, this way, it's possible to run diff/merge on them.
     // don't use `scope.getDefaultLaneIdsFromLane()`. we need all components, because it's possible that a component
     // does't have "head" locally although it exits in the origin-scope. it happens when the component was created on
     // the origin-scope after a component with the same-name was created on the lane
-
     if (lane) {
       // @todo: optimize this maybe. currently, it imports twice.
       // try to make the previous `importComponentsObjectsHarmony` import the same component once from the original
       // scope and once from the lane-scope.
       const mainIdsLatest = _bitId().BitIds.fromArray(lane.toBitIds().map(m => m.changeVersion(undefined)));
-
       await this._importComponentsObjects(mainIdsLatest, {
         allHistory: this.options.allHistory,
         ignoreMissingHead: true
       });
-    } // merge the lane objects
-
+    }
 
+    // merge the lane objects
     const mergeAllLanesResults = await (0, _pMapSeries().default)(this.laneObjects, laneObject => this.scope.sources.mergeLane(laneObject, true));
     const mergedLanes = mergeAllLanesResults.map(result => result.mergeLane);
     await Promise.all(mergedLanes.map(mergedLane => this.scope.lanes.saveLane(mergedLane)));
@@ -314,39 +232,30 @@ class ImportComponents {
       importDetails
     };
   }
-
   async importSpecificComponents() {
     var _this$laneObjects;
-
     _logger().default.debug(`importSpecificComponents, Ids: ${this.options.ids.join(', ')}`);
-
     const bitIds = await this.getBitIds();
     const beforeImportVersions = await this._getCurrentVersions(bitIds);
     await this._throwForPotentialIssues(bitIds);
     const versionDependenciesArr = await this._importComponentsObjects(bitIds, {
       lane: (_this$laneObjects = this.laneObjects) === null || _this$laneObjects === void 0 ? void 0 : _this$laneObjects[0]
     });
-
     if (this.laneObjects && this.options.objectsOnly) {
       // merge the lane objects
       const mergeAllLanesResults = await (0, _pMapSeries().default)(this.laneObjects, laneObject => this.scope.sources.mergeLane(laneObject, true));
       const mergedLanes = mergeAllLanesResults.map(result => result.mergeLane);
       await Promise.all(mergedLanes.map(mergedLane => this.scope.lanes.saveLane(mergedLane)));
     }
-
     let writtenComponents = [];
-
     if (!this.options.objectsOnly) {
       const componentsWithDependencies = await (0, _versionDependencies().multipleVersionDependenciesToConsumer)(versionDependenciesArr, this.scope.objects);
       await this._fetchDivergeData(componentsWithDependencies);
-
       this._throwForDivergedHistory();
-
       await this._writeToFileSystem(componentsWithDependencies);
       await this._saveLaneDataIfNeeded(componentsWithDependencies);
       writtenComponents = componentsWithDependencies.map(c => c.component);
     }
-
     const importDetails = await this._getImportDetails(beforeImportVersions, versionDependenciesArr);
     return {
       importedIds: versionDependenciesArr.map(v => v.component.id).flat(),
@@ -355,14 +264,12 @@ class ImportComponents {
       importDetails
     };
   }
-
   async _fetchDivergeData(componentsWithDependencies) {
     if (this.options.objectsOnly) {
       // no need for it when importing objects only. if it's enabled, in case when on a lane and a non-lane
       // component is in bitmap using an older version, it throws "getDivergeData: unable to find Version X of Y"
       return;
     }
-
     await Promise.all(componentsWithDependencies.map(async ({
       component
     }) => {
@@ -371,11 +278,9 @@ class ImportComponents {
       this.divergeData.push(modelComponent);
     }));
   }
-
   _throwForDivergedHistory() {
     if (this.options.merge || this.options.objectsOnly) return;
     const divergedComponents = this.divergeData.filter(modelComponent => modelComponent.getDivergeData().isDiverged());
-
     if (divergedComponents.length) {
       const divergeData = divergedComponents.map(modelComponent => ({
         id: modelComponent.id(),
@@ -385,7 +290,6 @@ class ImportComponents {
       throw new (_componentsPendingMerge().default)(divergeData);
     }
   }
-
   async _importComponentsObjects(ids, {
     fromOriginalScope = false,
     allHistory = false,
@@ -393,11 +297,8 @@ class ImportComponents {
     ignoreMissingHead = false
   }) {
     const scopeComponentsImporter = _scopeComponentsImporter().default.getInstance(this.scope);
-
     await scopeComponentsImporter.importManyDeltaWithoutDeps(ids, allHistory, lane, ignoreMissingHead);
-
     _loader().default.start(`import ${ids.length} components with their dependencies (if missing)`);
-
     const results = fromOriginalScope ? await scopeComponentsImporter.importManyFromOriginalScopes(ids) : await scopeComponentsImporter.importMany({
       ids,
       ignoreMissingHead,
@@ -405,6 +306,7 @@ class ImportComponents {
     });
     return results;
   }
+
   /**
    * consider the following use cases:
    * 1) no ids were provided. it should import all the lanes components objects AND main components objects
@@ -415,140 +317,108 @@ class ImportComponents {
    * 3) ids are provided without wildcards. here, the user knows exactly what's needed and it's ok to get the ids from
    * main if not found on the lane.
    */
-
-
   async getBitIdsForLanes() {
     if (!this.options.lanes) {
       throw new Error(`getBitIdsForLanes: this.options.lanes must be set`);
     }
-
     const bitIdsFromLane = _bitId().BitIds.fromArray(this.laneObjects.flatMap(lane => lane.toBitIds()));
-
     if (!this.options.ids.length) {
       const mainIds = this.consumer.bitMap.getAuthoredAndImportedBitIdsOfDefaultLane();
       const mainIdsToImport = mainIds.filter(id => id.hasScope() && !bitIdsFromLane.hasWithoutVersion(id));
       bitIdsFromLane.push(...mainIdsToImport);
       return bitIdsFromLane;
     }
-
     const idsWithWildcard = this.options.ids.filter(id => (0, _hasWildcard().default)(id));
     const idsWithoutWildcard = this.options.ids.filter(id => !(0, _hasWildcard().default)(id));
     const idsWithoutWildcardPreferFromLane = idsWithoutWildcard.map(idStr => {
       const id = _bitId().BitId.parse(idStr, true);
-
       const fromLane = bitIdsFromLane.searchWithoutVersion(id);
       return fromLane || id;
     });
     const bitIds = [...idsWithoutWildcardPreferFromLane];
-
     if (!idsWithWildcard) {
       return bitIds;
     }
-
     await (0, _pMapSeries().default)(idsWithWildcard, async idStr => {
       const idsFromRemote = await (0, _listScope().getRemoteBitIdsByWildcards)(idStr);
       const existingOnLanes = idsFromRemote.filter(id => bitIdsFromLane.hasWithoutVersion(id));
-
       if (!existingOnLanes.length) {
         throw new (_bitError().BitError)(`the id with the the wildcard "${idStr}" has been parsed to multiple component ids.
 however, none of them existing on the lane "${this.laneObjects.map(l => l.name).join(', ')}"
 in case you intend to import these components from main, please run the following:
 bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
       }
-
       bitIds.push(...existingOnLanes);
     });
     return bitIds;
   }
-
   async getBitIdsForNonLanes() {
     const bitIds = [];
     await Promise.all(this.options.ids.map(async idStr => {
       if ((0, _hasWildcard().default)(idStr)) {
         const ids = await (0, _listScope().getRemoteBitIdsByWildcards)(idStr);
-
         _loader().default.start(_loaderMessages().BEFORE_IMPORT_ACTION); // it stops the previous loader of BEFORE_REMOTE_LIST
-
-
         bitIds.push(...ids);
       } else {
         bitIds.push(_bitId().BitId.parse(idStr, true)); // we don't support importing without a scope name
       }
     }));
+
     return bitIds;
   }
-
   async getBitIds() {
     const bitIds = this.options.lanes ? await this.getBitIdsForLanes() : await this.getBitIdsForNonLanes();
-
     if (this.options.importDependenciesDirectly || this.options.importDependents) {
       const graphs = await this._getComponentsGraphs(bitIds);
-
       if (this.options.importDependenciesDirectly) {
         const dependenciesIds = this._getDependenciesFromGraph(bitIds, graphs);
-
         bitIds.push(...dependenciesIds);
       }
-
       if (this.options.importDependents) {
         const graph = await this.graph.getGraph();
         const targetCompIds = await this.workspace.resolveMultipleComponentIds(bitIds);
         const sourceIds = await this.workspace.listIds();
         const ids = graph.findIdsFromSourcesToTargets(sourceIds, targetCompIds);
-
         _logger().default.debug(`found ${ids.length} component for --dependents flag`, ids.map(id => id.toString()));
-
         bitIds.push(...ids.map(id => id._legacy));
       }
     }
-
     return _bitId().BitIds.uniqFromArray(bitIds);
   }
-
   _getDependenciesFromGraph(bitIds, graphs) {
     const dependencies = bitIds.map(bitId => {
       const componentGraph = graphs.find(graph => graph.scopeName === bitId.scope);
-
       if (!componentGraph) {
         throw new Error(`unable to find a graph for ${bitId.toString()}`);
       }
-
       const dependenciesInfo = componentGraph.getDependenciesInfo(bitId);
       return dependenciesInfo.map(d => d.id);
     });
     return _ramda().default.flatten(dependencies);
   }
-
   _getDependentsFromGraph(bitIds, graphs) {
     const dependents = bitIds.map(bitId => {
       const componentGraph = graphs.find(graph => graph.scopeName === bitId.scope);
-
       if (!componentGraph) {
         throw new Error(`unable to find a graph for ${bitId.toString()}`);
       }
-
       const dependentsInfo = componentGraph.getDependentsInfo(bitId);
       return dependentsInfo.map(d => d.id);
     });
     return _ramda().default.flatten(dependents);
   }
-
   async _getComponentsGraphs(bitIds) {
     const remotes = await (0, _scopeRemotes().getScopeRemotes)(this.consumer.scope);
     return remotes.scopeGraphs(bitIds, this.consumer.scope);
   }
-
   async importAccordingToBitMap() {
     this.options.objectsOnly = !this.options.merge && !this.options.override;
     const componentsIdsToImport = this.getIdsToImportFromBitmap();
-
     if (_ramda().default.isEmpty(componentsIdsToImport)) {
       throw new (_exceptions().NothingToImport)();
     }
-
     await this._throwForModifiedOrNewComponents(componentsIdsToImport);
     const beforeImportVersions = await this._getCurrentVersions(componentsIdsToImport);
-
     if (!componentsIdsToImport.length) {
       return {
         importedIds: [],
@@ -556,23 +426,19 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
         importDetails: []
       };
     }
-
     if (!this.options.objectsOnly) {
       throw new Error(`bit import with no ids and --merge flag was not implemented yet`);
     }
-
     const versionDependenciesArr = await this._importComponentsObjects(componentsIdsToImport, {
       fromOriginalScope: this.options.fromOriginalScope,
       allHistory: this.options.allHistory
     });
     let writtenComponents = [];
-
     if (!this.options.objectsOnly) {
       const componentWithDependencies = await (0, _versionDependencies().multipleVersionDependenciesToConsumer)(versionDependenciesArr, this.scope.objects);
       await this._writeToFileSystem(componentWithDependencies);
       writtenComponents = componentWithDependencies.map(c => c.component);
     }
-
     const importDetails = await this._getImportDetails(beforeImportVersions, versionDependenciesArr);
     return {
       importedIds: versionDependenciesArr.map(v => v.component.id).flat(),
@@ -581,12 +447,10 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
       importDetails
     };
   }
-
   getIdsToImportFromBitmap() {
     const authoredExportedComponents = this.consumer.bitMap.getExportedComponents();
     return _bitId().BitIds.fromArray(authoredExportedComponents);
   }
-
   async _getCurrentVersions(ids) {
     const versionsP = ids.map(async id => {
       const modelComponent = await this.consumer.scope.getModelComponentIfExist(id.changeVersion(undefined));
@@ -597,33 +461,27 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
     const versions = await Promise.all(versionsP);
     return _ramda().default.fromPairs(versions);
   }
+
   /**
    * get import details, includes the diff between the versions array before import and after import
    */
-
-
   async _getImportDetails(currentVersions, components) {
     const detailsP = components.map(async component => {
       const id = component.component.id;
       const idStr = id.toStringWithoutVersion();
       const beforeImportVersions = currentVersions[idStr];
-
       if (!beforeImportVersions) {
         throw new Error(`_getImportDetails failed finding ${idStr} in currentVersions, which has ${Object.keys(currentVersions).join(', ')}`);
       }
-
       const modelComponent = await this.consumer.scope.getModelComponentIfExist(id);
       if (!modelComponent) throw new (_showDoctorError().default)(`imported component ${idStr} was not found in the model`);
       const afterImportVersions = modelComponent.listVersions();
-
       const versionDifference = _ramda().default.difference(afterImportVersions, beforeImportVersions);
-
       const getStatus = () => {
         if (!versionDifference.length) return 'up to date';
         if (!beforeImportVersions.length) return 'added';
         return 'updated';
       };
-
       const filesStatus = this.mergeStatus && this.mergeStatus[idStr] ? this.mergeStatus[idStr] : null;
       const deprecated = await modelComponent.isDeprecated(this.scope.objects);
       const removed = await component.component.component.isRemoved(this.scope.objects);
@@ -641,13 +499,10 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
     });
     return Promise.all(detailsP);
   }
-
   async _throwForPotentialIssues(ids) {
     await this._throwForModifiedOrNewComponents(ids);
-
     this._throwForDifferentComponentWithSameName(ids);
   }
-
   async _throwForModifiedOrNewComponents(ids) {
     // the typical objectsOnly option is when a user cloned a project with components tagged to the source code, but
     // doesn't have the model objects. in that case, calling getComponentStatusById() may return an error as it relies
@@ -657,22 +512,19 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
     const modifiedComponents = componentsStatuses.filter(({
       status
     }) => status.modified || status.newlyCreated).map(c => c.id);
-
     if (modifiedComponents.length) {
       throw new (_generalError().default)(_chalk().default.yellow(`unable to import the following components due to local changes, use --merge flag to merge your local changes or --override to override them\n${modifiedComponents.join('\n')} `));
     }
   }
+
   /**
    * Model Component id() calculation uses id.toString() for the hash.
    * If an imported component has scopereadonly name equals to a local name, both will have the exact same
    * hash and they'll override each other.
    */
-
-
   _throwForDifferentComponentWithSameName(ids) {
     ids.forEach(id => {
       const existingId = this.consumer.getParsedIdIfExist(id.toStringWithoutVersion());
-
       if (existingId && !existingId.hasScope()) {
         throw new (_generalError().default)(`unable to import ${id.toString()}. the component name conflicted with your local component with the same name.
         it's fine to have components with the same name as long as their scope names are different.
@@ -680,7 +532,6 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
       }
     });
   }
-
   async _getMergeStatus(componentWithDependencies) {
     const component = componentWithDependencies.component;
     const componentStatus = await this.consumer.getComponentStatusById(component.id);
@@ -694,10 +545,11 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
       ignoreVersion: true
     });
     const fsComponent = await this.consumer.loadComponent(existingBitMapBitId);
-    const currentlyUsedVersion = existingBitMapBitId.version; // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-
+    const currentlyUsedVersion = existingBitMapBitId.version;
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
     const baseComponent = await componentModel.loadVersion(currentlyUsedVersion, this.consumer.scope.objects);
-    const otherComponent = await componentModel.loadVersion( // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    const otherComponent = await componentModel.loadVersion(
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
     component.id.version, this.consumer.scope.objects);
     const mergeResults = await (0, _mergeVersion().threeWayMerge)({
       consumer: this.consumer,
@@ -710,6 +562,7 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
     mergeStatus.mergeResults = mergeResults;
     return mergeStatus;
   }
+
   /**
    * 1) when there are conflicts and the strategy is "ours", don't write the imported component to
    * the filesystem, only update bitmap.
@@ -720,17 +573,14 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
    * 3) when there is no conflict or there are conflicts and the strategy is manual, write the files
    * according to the merge result. (done by applyModifiedVersion())
    */
-
-
   _updateComponentFilesPerMergeStrategy(componentMergeStatus) {
     const mergeResults = componentMergeStatus.mergeResults;
     if (!mergeResults) return null;
     const component = componentMergeStatus.componentWithDependencies.component;
     const files = component.files;
-
     if (mergeResults.hasConflicts && this.options.mergeStrategy === _mergeVersion().MergeOptions.ours) {
-      const filesStatus = {}; // don't write the files to the filesystem, only bump the bitmap version.
-
+      const filesStatus = {};
+      // don't write the files to the filesystem, only bump the bitmap version.
       files.forEach(file => {
         // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
         filesStatus[(0, _utils().pathNormalizeToLinux)(file.relative)] = _mergeVersion().FileStatus.unchanged;
@@ -739,17 +589,15 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
       this.consumer.bitMap.hasChanged = true;
       return filesStatus;
     }
-
     if (mergeResults.hasConflicts && this.options.mergeStrategy === _mergeVersion().MergeOptions.theirs) {
-      const filesStatus = {}; // the local changes will be overridden (as if the user entered --override flag for this component)
-
+      const filesStatus = {};
+      // the local changes will be overridden (as if the user entered --override flag for this component)
       files.forEach(file => {
         // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
         filesStatus[(0, _utils().pathNormalizeToLinux)(file.relative)] = _mergeVersion().FileStatus.updated;
       });
       return filesStatus;
     }
-
     const {
       filesStatus,
       modifiedFiles
@@ -757,12 +605,11 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
     component.files = modifiedFiles;
     return filesStatus;
   }
+
   /**
    * update the component files if they are modified and there is a merge strategy.
    * returns only the components that need to be written to the filesystem
    */
-
-
   async updateAllComponentsAccordingToMergeStrategy(componentsWithDependencies) {
     if (!this.options.merge) return componentsWithDependencies;
     const componentsStatusP = componentsWithDependencies.map(componentWithDependencies => {
@@ -770,63 +617,48 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
     });
     const componentsStatus = await Promise.all(componentsStatusP);
     const componentWithConflict = componentsStatus.find(component => component.mergeResults && component.mergeResults.hasConflicts);
-
     if (componentWithConflict && !this.options.mergeStrategy) {
       this.options.mergeStrategy = await (0, _mergeVersion().getMergeStrategyInteractive)();
     }
-
     this.mergeStatus = {};
     const componentsToWrite = componentsStatus.map(componentStatus => {
       const filesStatus = this._updateComponentFilesPerMergeStrategy(componentStatus);
-
       const componentWithDependencies = componentStatus.componentWithDependencies;
       if (!filesStatus) return componentWithDependencies;
       this.mergeStatus[componentWithDependencies.component.id.toStringWithoutVersion()] = filesStatus;
       const unchangedFiles = Object.keys(filesStatus).filter(file => filesStatus[file] === _mergeVersion().FileStatus.unchanged);
-
       if (unchangedFiles.length === Object.keys(filesStatus).length) {
         // all files are unchanged
         return null;
       }
-
       return componentWithDependencies;
     });
-
     const removeNulls = _ramda().default.reject(_ramda().default.isNil);
-
     return removeNulls(componentsToWrite);
   }
-
   _shouldSaveLaneData() {
     if (this.options.objectsOnly) {
       return false;
     }
-
     return this.consumer.isOnLane();
   }
-
   async _saveLaneDataIfNeeded(componentsWithDependencies) {
     if (!this._shouldSaveLaneData()) {
       return;
     }
-
     const currentLane = await this.consumer.getCurrentLaneObject();
-
     if (!currentLane) {
       return; // user on main
     }
 
     const idsFromRemoteLanes = _bitId().BitIds.fromArray(this.laneObjects.flatMap(lane => lane.toBitIds()));
-
     const components = componentsWithDependencies.map(c => c.component);
     await Promise.all(components.map(async comp => {
       const existOnRemoteLane = idsFromRemoteLanes.has(comp.id);
-
       if (!existOnRemoteLane && !this.options.saveInLane) {
         this.consumer.bitMap.setComponentProp(comp.id, 'onLanesOnly', false);
         return;
       }
-
       const modelComponent = await this.scope.getModelComponent(comp.id);
       const ref = modelComponent.getRef(comp.id.version);
       if (!ref) throw new Error(`_saveLaneDataIfNeeded unable to get ref for ${comp.id.toString()}`);
@@ -837,12 +669,10 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
     }));
     await this.scope.lanes.saveLane(currentLane);
   }
-
   async _writeToFileSystem(componentsWithDependencies) {
     if (this.options.objectsOnly) {
       return;
     }
-
     const componentsToWrite = await this.updateAllComponentsAccordingToMergeStrategy(componentsWithDependencies);
     const manyComponentsWriter = new (_manyComponentsWriter().default)({
       consumer: this.consumer,
@@ -855,9 +685,7 @@ bit import ${idsFromRemote.map(id => id.toStringWithoutVersion()).join(' ')}`);
     });
     await manyComponentsWriter.writeAll();
   }
-
 }
-
 exports.default = ImportComponents;
 
 //# sourceMappingURL=import-components.js.map