@teambit/snapping 1.0.516 → 1.0.518

package/dist/tag-model-component.js

@@ -4,637 +4,29 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.tagModelComponent = tagModelComponent;
-exports.updateVersions = updateVersions;
-function _pMapSeries() {
-  const data = _interopRequireDefault(require("p-map-series"));
-  _pMapSeries = function () {
+function _versionMaker() {
+  const data = require("./version-maker");
+  _versionMaker = function () {
     return data;
   };
   return data;
 }
-function _lodash() {
-  const data = require("lodash");
-  _lodash = function () {
-    return data;
-  };
-  return data;
-}
-function _uuid() {
-  const data = require("uuid");
-  _uuid = function () {
-    return data;
-  };
-  return data;
-}
-function _bitError() {
-  const data = require("@teambit/bit-error");
-  _bitError = function () {
-    return data;
-  };
-  return data;
-}
-function _componentId() {
-  const data = require("@teambit/component-id");
-  _componentId = function () {
-    return data;
-  };
-  return data;
-}
-function _legacy() {
-  const data = require("@teambit/legacy.constants");
-  _legacy = function () {
-    return data;
-  };
-  return data;
-}
-function _legacy2() {
-  const data = require("@teambit/legacy.consumer-component");
-  _legacy2 = function () {
-    return data;
-  };
-  return data;
-}
-function _workspaceModules() {
-  const data = require("@teambit/workspace.modules.node-modules-linker");
-  _workspaceModules = function () {
-    return data;
-  };
-  return data;
-}
-function _legacy3() {
-  const data = require("@teambit/legacy.consumer");
-  _legacy3 = function () {
-    return data;
-  };
-  return data;
-}
-function _remove() {
-  const data = require("@teambit/remove");
-  _remove = function () {
-    return data;
-  };
-  return data;
-}
-function _legacy4() {
-  const data = require("@teambit/legacy.logger");
-  _legacy4 = function () {
-    return data;
-  };
-  return data;
-}
-function _pkgModules() {
-  const data = require("@teambit/pkg.modules.semver-helper");
-  _pkgModules = function () {
-    return data;
-  };
-  return data;
-}
-function _harmonyModules() {
-  const data = require("@teambit/harmony.modules.get-basic-log");
-  _harmonyModules = function () {
-    return data;
-  };
-  return data;
-}
-function _toolboxCrypto() {
-  const data = require("@teambit/toolbox.crypto.sha1");
-  _toolboxCrypto = function () {
-    return data;
-  };
-  return data;
-}
-function _objects() {
-  const data = require("@teambit/objects");
-  _objects = function () {
-    return data;
-  };
-  return data;
-}
-function _messagePerComponent() {
-  const data = require("./message-per-component");
-  _messagePerComponent = function () {
-    return data;
-  };
-  return data;
-}
-function _toolboxPromise() {
-  const data = require("@teambit/toolbox.promise.map-pool");
-  _toolboxPromise = function () {
-    return data;
-  };
-  return data;
-}
-function _harmonyModules2() {
-  const data = require("@teambit/harmony.modules.feature-toggle");
-  _harmonyModules2 = function () {
-    return data;
-  };
-  return data;
-}
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function updateDependenciesVersions(allComponentsToTag, dependencyResolver) {
-  // filter out removed components.
-  // if a component has a deleted-component as a dependency, it was probably running "bit install <dep>" with a version
-  // from main. we want to keep it as the user requested. Otherwise, this changes the dependency version to the newly
-  // snapped one unintentionally.
-  const componentsToTag = allComponentsToTag.filter(c => !c.isRemoved());
-  const getNewDependencyVersion = id => {
-    const foundDependency = componentsToTag.find(component => component.id.isEqualWithoutVersion(id));
-    return foundDependency ? id.changeVersion(foundDependency.version) : null;
-  };
-  const changeExtensionsVersion = component => {
-    component.extensions.forEach(ext => {
-      if (ext.extensionId) {
-        const newDepId = getNewDependencyVersion(ext.extensionId);
-        if (newDepId) ext.extensionId = newDepId;
-      }
-    });
-  };
-  componentsToTag.forEach(oneComponentToTag => {
-    oneComponentToTag.getAllDependencies().forEach(dependency => {
-      const newDepId = getNewDependencyVersion(dependency.id);
-      if (newDepId) dependency.id = newDepId;
-    });
-    changeExtensionsVersion(oneComponentToTag);
-    // @ts-ignore
-    oneComponentToTag = dependencyResolver.updateDepsOnLegacyTag(oneComponentToTag, getNewDependencyVersion.bind(this));
-  });
-}
-function setHashes(componentsToTag) {
-  componentsToTag.forEach(componentToTag => {
-    componentToTag.setNewVersion((0, _toolboxCrypto().sha1)((0, _uuid().v4)()));
-  });
-}
-async function setFutureVersions(componentsToTag, scope, releaseType, exactVersion, persist, autoTagIds, ids, incrementBy, preReleaseId, soft, tagDataPerComp) {
-  const isPreReleaseLike = releaseType ? ['prerelease', 'premajor', 'preminor', 'prepatch'].includes(releaseType) : false;
-  await Promise.all(componentsToTag.map(async componentToTag => {
-    const isAutoTag = autoTagIds.hasWithoutVersion(componentToTag.id);
-    const modelComponent = await scope.sources.findOrAddComponent(componentToTag);
-    const nextVersion = componentToTag.componentMap?.nextVersion?.version;
-    const getNewVersion = () => {
-      if (tagDataPerComp) {
-        const tagData = tagDataPerComp.find(t => t.componentId.isEqualWithoutVersion(componentToTag.id));
-        if (!tagData) throw new Error(`tag-data is missing for ${componentToTag.id.toStringWithoutVersion()}`);
-        if (!tagData.versionToTag) throw new Error(`tag-data.TagResults is missing for ${componentToTag.id.toStringWithoutVersion()}`);
-        const exactVersionOrReleaseType = (0, _pkgModules().getValidVersionOrReleaseType)(tagData.versionToTag);
-        return modelComponent.getVersionToAdd(exactVersionOrReleaseType.releaseType, exactVersionOrReleaseType.exactVersion, incrementBy, tagData.prereleaseId);
-      }
-      if (nextVersion && persist) {
-        const exactVersionOrReleaseType = (0, _pkgModules().getValidVersionOrReleaseType)(nextVersion);
-        return modelComponent.getVersionToAdd(exactVersionOrReleaseType.releaseType, exactVersionOrReleaseType.exactVersion, undefined, componentToTag.componentMap?.nextVersion?.preRelease);
-      }
-      if (isAutoTag) {
-        // auto-tag always bumped as patch unless it's pre-release
-        if (isPreReleaseLike) {
-          return soft ? releaseType : modelComponent.getVersionToAdd(releaseType, exactVersion, incrementBy, preReleaseId);
-        }
-        return soft ? 'patch' : modelComponent.getVersionToAdd('patch', undefined, incrementBy, preReleaseId);
-      }
-      const versionByEnteredId = getVersionByEnteredId(ids, componentToTag, modelComponent);
-      return soft ? versionByEnteredId || exactVersion || releaseType : versionByEnteredId || modelComponent.getVersionToAdd(releaseType, exactVersion, incrementBy, preReleaseId);
-    };
-    const newVersion = getNewVersion();
-    componentToTag.setNewVersion(newVersion);
-  }));
-}
-function getVersionByEnteredId(enteredIds, component, modelComponent) {
-  const enteredId = enteredIds.searchWithoutVersion(component.id);
-  if (enteredId && enteredId.hasVersion()) {
-    const exactVersionOrReleaseType = (0, _pkgModules().getValidVersionOrReleaseType)(enteredId.version);
-    return modelComponent.getVersionToAdd(exactVersionOrReleaseType.releaseType, exactVersionOrReleaseType.exactVersion);
-  }
-  return undefined;
-}
-
-// eslint-disable-next-line complexity
-async function tagModelComponent({
-  snapping,
-  consumerComponents,
-  components,
-  ids,
-  tagDataPerComp,
-  populateArtifactsFrom,
-  populateArtifactsIgnorePkgJson,
-  message,
-  editor,
-  exactVersion,
-  releaseType,
-  preReleaseId,
-  ignoreNewestVersion = false,
-  skipTests = false,
-  skipTasks,
-  skipAutoTag,
-  soft,
-  build,
-  persist,
-  isSnap = false,
-  disableTagAndSnapPipelines,
-  ignoreBuildErrors,
-  rebuildDepsGraph,
-  incrementBy,
-  packageManagerConfigRootDir,
-  copyLogFromPreviousSnap = false,
-  exitOnFirstFailedTask = false,
-  updateDependentsOnLane = false,
-  // on lane, adds it into updateDependents prop
-  setHeadAsParent,
-  // kind of rebase. in case component is checked out to older version, ignore that version, use head
-  detachHead,
-  overrideHead
-}) {
-  const workspace = snapping.workspace;
-  const scope = snapping.scope;
-  const builder = snapping.builder;
-  const dependencyResolver = snapping.dependencyResolver;
-  const consumer = workspace?.consumer;
-  const legacyScope = scope.legacyScope;
-  const consumerComponentsIdsMap = {};
-  // Concat and unique all the dependencies from all the components so we will not import
-  // the same dependency more then once, it's mainly for performance purpose
-  consumerComponents.forEach(consumerComponent => {
-    const componentIdString = consumerComponent.id.toString();
-    // Store it in a map so we can take it easily from the sorted array which contain only the id
-    consumerComponentsIdsMap[componentIdString] = consumerComponent;
-  });
-  const componentsToTag = Object.values(consumerComponentsIdsMap); // consumerComponents unique
-  const idsToTag = _componentId().ComponentIdList.fromArray(componentsToTag.map(c => c.id));
-  // ids without versions are new. it's impossible that tagged (and not-modified) components has
-  // them as dependencies.
-  const idsToTriggerAutoTag = idsToTag.filter(id => id.hasVersion());
-  const autoTagDataWithLocalOnly = skipAutoTag || !consumer ? [] : await workspace.getAutoTagInfo(_componentId().ComponentIdList.fromArray(idsToTriggerAutoTag));
-  const localOnly = workspace?.listLocalOnly();
-  const autoTagData = localOnly ? autoTagDataWithLocalOnly.filter(autoTagItem => !localOnly.hasWithoutVersion(autoTagItem.component.id)) : autoTagDataWithLocalOnly;
-  const autoTagComponents = autoTagData.map(autoTagItem => autoTagItem.component);
-  const autoTagComponentsFiltered = autoTagComponents.filter(c => !idsToTag.has(c.id));
-  const autoTagIds = _componentId().ComponentIdList.fromArray(autoTagComponentsFiltered.map(autoTag => autoTag.id));
-  const allComponentsToTag = [...componentsToTag, ...autoTagComponentsFiltered];
-  const messagesFromEditorFetcher = new (_messagePerComponent().MessagePerComponentFetcher)(idsToTag, autoTagIds);
-  const getMessagePerId = async () => {
-    if (editor) return messagesFromEditorFetcher.getMessagesFromEditor(legacyScope.tmp, editor);
-    if (tagDataPerComp) return tagDataPerComp.map(t => ({
-      id: t.componentId,
-      msg: t.message || message
-    }));
-    return [];
-  };
-  const messagePerId = await getMessagePerId();
-
-  // check for each one of the components whether it is using an old version
-  // TODO: once --detach-head is supported by the remote, deprecate --ignore-newest-version. and change this
-  // throwForNewestVersion to suggest using --detach-head instead. also, it the error should not be limited
-  // to tags and can be thrown for snaps as well.
-  // once --ignore-newest-version is removed, no need for this condition. it's ok to not provide the override-head option.
-  if (detachHead && !(0, _harmonyModules2().isFeatureEnabled)(_harmonyModules2().DETACH_HEAD)) {
-    throw new Error('unable to detach head, the feature is not enabled');
-  }
-  if (ignoreNewestVersion && !detachHead) overrideHead = true;
-  if (!ignoreNewestVersion && !isSnap) {
-    await throwForNewestVersion(allComponentsToTag, legacyScope);
-  }
-  _legacy4().logger.debugAndAddBreadCrumb('tag-model-components', 'sequentially persist all components');
-  setCurrentSchema(allComponentsToTag);
-
-  // go through all components and find the future versions for them
-  isSnap ? setHashes(allComponentsToTag) : await setFutureVersions(allComponentsToTag, legacyScope, releaseType, exactVersion, persist, autoTagIds, ids, incrementBy, preReleaseId, soft, tagDataPerComp);
-  // go through all dependencies and update their versions
-  updateDependenciesVersions(allComponentsToTag, dependencyResolver);
-  await addLogToComponents(componentsToTag, autoTagComponents, persist, message, messagePerId, copyLogFromPreviousSnap);
-  // don't move it down. otherwise, it'll be empty and we don't know which components were during merge.
-  // (it's being deleted in snapping.main.runtime - `_addCompToObjects` method)
-  const unmergedComps = workspace ? await workspace.listComponentsDuringMerge() : [];
-  const lane = await legacyScope.getCurrentLaneObject();
-  const stagedConfig = workspace ? await workspace.scope.getStagedConfig() : undefined;
-  if (soft) {
-    if (!consumer) throw new Error(`unable to soft-tag without consumer`);
-    consumer.updateNextVersionOnBitmap(allComponentsToTag, preReleaseId);
-  } else {
-    await snapping._addFlattenedDependenciesToComponents(allComponentsToTag, rebuildDepsGraph);
-    await snapping._addDependenciesGraphToComponents(components);
-    await snapping.throwForDepsFromAnotherLane(allComponentsToTag);
-    if (!build) emptyBuilderData(allComponentsToTag);
-    addBuildStatus(allComponentsToTag, _legacy().BuildStatus.Pending);
-    const currentLane = consumer ? consumer.getCurrentLaneId() : undefined;
-    await (0, _pMapSeries().default)(allComponentsToTag, async component => {
-      const results = await snapping._addCompToObjects({
-        source: component,
-        lane,
-        shouldValidateVersion: Boolean(build),
-        addVersionOpts: {
-          addToUpdateDependentsInLane: updateDependentsOnLane,
-          setHeadAsParent,
-          detachHead,
-          overrideHead: overrideHead
-        }
-      });
-      if (workspace) {
-        const modelComponent = component.modelComponent || (await legacyScope.getModelComponent(component.id));
-        await updateVersions(workspace, stagedConfig, currentLane, modelComponent, results.addedVersionStr, true);
-      } else {
-        const tagData = tagDataPerComp?.find(t => t.componentId.isEqualWithoutVersion(component.id));
-        if (tagData?.isNew) results.version.removeAllParents();
-      }
-    });
-    if (workspace) {
-      await workspace.scope.legacyScope.stagedSnaps.write();
-    }
-  }
-  const publishedPackages = [];
-  let harmonyComps = [];
-  if (build) {
-    const onTagOpts = {
-      disableTagAndSnapPipelines,
-      throwOnError: true,
-      forceDeploy: ignoreBuildErrors,
-      isSnap,
-      populateArtifactsFrom
-    };
-    const skipTasksParsed = skipTasks ? skipTasks.split(',').map(t => t.trim()) : undefined;
-    const seedersOnly = !workspace; // if tag from scope, build only the given components
-    const isolateOptions = {
-      packageManagerConfigRootDir,
-      seedersOnly,
-      populateArtifactsIgnorePkgJson
-    };
-    const builderOptions = {
-      exitOnFirstFailedTask,
-      skipTests,
-      skipTasks: skipTasksParsed
-    };
-    const componentsToBuild = allComponentsToTag.filter(c => !c.isRemoved());
-    if (componentsToBuild.length) {
-      await scope.reloadAspectsWithNewVersion(componentsToBuild);
-      harmonyComps = await (workspace || scope).getManyByLegacy(componentsToBuild);
-      const {
-        builderDataMap
-      } = await builder.tagListener(harmonyComps, onTagOpts, isolateOptions, builderOptions);
-      const buildResult = scope.builderDataMapToLegacyOnTagResults(builderDataMap);
-      snapping._updateComponentsByTagResult(componentsToBuild, buildResult);
-      const packageIntegritiesByPublishedPackages = snapping._getPublishedPackages(componentsToBuild);
-      publishedPackages.push(...Array.from(packageIntegritiesByPublishedPackages.keys()));
-      addIntegritiesToConsumerComponentsGraphs(packageIntegritiesByPublishedPackages, allComponentsToTag);
-      addBuildStatus(componentsToBuild, _legacy().BuildStatus.Succeed);
-      await (0, _pMapSeries().default)(harmonyComps, comp => snapping.enrichComp(comp));
-      if (populateArtifactsFrom) await updateHiddenProp(scope, populateArtifactsFrom);
-    }
-  }
-  let removedComponents;
-  if (!soft) {
-    removedComponents = await removeDeletedComponentsFromBitmap(allComponentsToTag, workspace);
-    if (lane) {
-      const msgStr = message ? ` (${message})` : '';
-      const laneHistory = await legacyScope.lanes.updateLaneHistory(lane, `snap${msgStr}`);
-      legacyScope.objects.add(laneHistory);
-    }
-    await legacyScope.objects.persist();
-    await removeMergeConfigFromComponents(unmergedComps, allComponentsToTag, workspace);
-    if (workspace) {
-      await (0, _workspaceModules().linkToNodeModulesByComponents)(harmonyComps.length ? harmonyComps : await workspace.scope.getManyByLegacy(allComponentsToTag), workspace);
-    }
-  }
-
-  // clear all objects. otherwise, ModelComponent has the wrong divergeData
-  legacyScope.objects.clearObjectsFromCache();
-  return {
-    taggedComponents: componentsToTag,
-    autoTaggedResults: autoTagData,
-    publishedPackages,
-    stagedConfig,
-    removedComponents
-  };
-}
-async function throwForNewestVersion(allComponentsToTag, legacyScope) {
-  const newestVersionsP = allComponentsToTag.map(async component => {
-    if (component.componentFromModel) {
-      // otherwise it's a new component, so this check is irrelevant
-      const modelComponent = await legacyScope.getModelComponentIfExist(component.id);
-      if (!modelComponent) throw new (_bitError().BitError)(`component ${component.id} was not found in the model`);
-      if (!modelComponent.listVersions().length) return null; // no versions yet, no issues.
-      const latest = modelComponent.getHeadRegardlessOfLaneAsTagOrHash();
-      if (latest !== component.version) {
-        return {
-          componentId: component.id.toStringWithoutVersion(),
-          currentVersion: component.version,
-          latestVersion: latest
-        };
-      }
-    }
-    return null;
-  });
-  const newestVersions = await Promise.all(newestVersionsP);
-  const newestVersionsWithoutEmpty = (0, _lodash().compact)(newestVersions);
-  if (newestVersionsWithoutEmpty.length) {
-    throw new (_legacy3().NewerVersionFound)(newestVersionsWithoutEmpty);
-  }
-}
-function addIntegritiesToConsumerComponentsGraphs(packageIntegritiesByPublishedPackages, consumerComponents) {
-  const _addIntegritiesToDependenciesGraph = addIntegritiesToDependenciesGraph.bind(null, packageIntegritiesByPublishedPackages);
-  for (const consumerComponent of consumerComponents) {
-    if (consumerComponent.dependenciesGraph) {
-      consumerComponent.dependenciesGraph = _addIntegritiesToDependenciesGraph(consumerComponent.dependenciesGraph);
-    }
-  }
-}
-
-/**
- * Updates the dependencies graph by replacing all "pending" version numbers of component dependencies
- * with the actual version numbers of the recently published packages. It also attaches the integrity
- * checksums of these components to ensure data integrity for each resolved dependency.
- *
- * @param packageIntegritiesByPublishedPackages - A map of package names and versions to their integrity checksums.
- * @param dependenciesGraph - The current dependencies graph, containing nodes with potentially "pending" versions.
- * @returns A new DependenciesGraph with updated versions and integrity checksums for all previously pending dependencies.
- */
-function addIntegritiesToDependenciesGraph(packageIntegritiesByPublishedPackages, dependenciesGraph) {
-  const resolvedVersions = [];
-  for (const [selector, integrity] of packageIntegritiesByPublishedPackages.entries()) {
-    if (integrity == null) continue;
-    const index = selector.indexOf('@', 1);
-    const name = selector.substring(0, index);
-    const version = selector.substring(index + 1);
-    const pendingPkg = dependenciesGraph.packages.get(`${name}@pending:`);
-    if (pendingPkg) {
-      pendingPkg.resolution = {
-        integrity
-      };
-      resolvedVersions.push({
-        name,
-        version
-      });
-    }
-  }
-  return replacePendingVersions(dependenciesGraph, resolvedVersions);
-}
-async function removeDeletedComponentsFromBitmap(comps, workspace) {
-  if (!workspace) {
-    return undefined;
-  }
-  const removedComps = comps.filter(comp => comp.isRemoved());
-  if (!removedComps.length) return undefined;
-  const compBitIdsToRemove = _componentId().ComponentIdList.fromArray(removedComps.map(c => c.id));
-  await (0, _remove().deleteComponentsFiles)(workspace.consumer, compBitIdsToRemove);
-  await workspace.consumer.cleanFromBitMap(compBitIdsToRemove);
-  return compBitIdsToRemove;
-}
-async function removeMergeConfigFromComponents(unmergedComps, components, workspace) {
-  if (!workspace || !unmergedComps.length) {
-    return;
-  }
-  const configMergeFile = workspace.getConflictMergeFile();
-  unmergedComps.forEach(compId => {
-    const isNowSnapped = components.find(c => c.id.isEqualWithoutVersion(compId));
-    if (isNowSnapped) {
-      configMergeFile.removeConflict(compId.toStringWithoutVersion());
-    }
-  });
-  const currentlyUnmerged = workspace ? await workspace.listComponentsDuringMerge() : [];
-  if (configMergeFile.hasConflict() && currentlyUnmerged.length) {
-    // it's possible that "workspace" section is still there. but if all "unmerged" are now merged,
-    // then, it's safe to delete the file.
-    await configMergeFile.write();
-  } else {
-    await configMergeFile.delete();
-  }
-}
-
-/**
- * otherwise, tagging without build will have the old build data of the previous snap/tag.
- * in case we currently build, it's ok to leave the data as is, because it'll be overridden anyway.
- */
-function emptyBuilderData(components) {
-  components.forEach(component => {
-    component.extensions = component.extensions.clone();
-    const existingBuilder = component.extensions.findCoreExtension(_legacy().Extensions.builder);
-    if (existingBuilder) existingBuilder.data = {};
-  });
-}
-async function addLogToComponents(components, autoTagComps, persist, message, messagePerComponent, copyLogFromPreviousSnap = false) {
-  // @ts-ignore this happens when running `bit tag -m ""`.
-  if (message === true) {
-    message = '';
-  }
-  const basicLog = await (0, _harmonyModules().getBasicLog)();
-  const getLog = component => {
-    const nextVersion = persist ? component.componentMap?.nextVersion : null;
-    const msgFromEditor = messagePerComponent.find(item => item.id.isEqualWithoutVersion(component.id))?.msg;
-    if (copyLogFromPreviousSnap) {
-      const currentLog = component.log;
-      if (!currentLog) {
-        throw new Error(`addLogToComponents is set  copyLogFromPreviousSnap: true, but it is unable to find log in the previous snap`);
-      }
-      currentLog.message = msgFromEditor || message || currentLog.message;
-      currentLog.date = basicLog.date;
-      return currentLog;
-    }
-    return {
-      username: nextVersion?.username || basicLog.username,
-      email: nextVersion?.email || basicLog.email,
-      message: nextVersion?.message || msgFromEditor || message,
-      date: basicLog.date
-    };
-  };
-  components.forEach(component => {
-    component.log = getLog(component);
-  });
-  autoTagComps.forEach(autoTagComp => {
-    autoTagComp.log = getLog(autoTagComp);
-    const defaultMsg = 'bump dependencies versions';
-    if (message) {
-      autoTagComp.log.message += ` (${defaultMsg})`;
-    } else if (!autoTagComp.log.message) {
-      autoTagComp.log.message = defaultMsg;
-    }
-  });
-}
-function setCurrentSchema(components) {
-  components.forEach(component => {
-    component.schema = _legacy2().CURRENT_SCHEMA;
-  });
-}
-function addBuildStatus(components, buildStatus) {
-  components.forEach(component => {
-    component.buildStatus = component.isRemoved() ? _legacy().BuildStatus.Skipped : buildStatus;
-  });
-}
-function isAvailableOnMain(currentLane, modelComponent, id) {
-  if (currentLane.isDefault()) {
-    return true;
-  }
-  if (!id.hasVersion()) {
-    // component was unsnapped on the current lane and is back to a new component
-    return true;
-  }
-  return modelComponent.hasHead();
-}
-async function updateVersions(workspace, stagedConfig, currentLane, modelComponent, versionToSetInBitmap,
-// helpful for detached head
-isTag = true) {
-  const consumer = workspace.consumer;
-  const idLatest = modelComponent.toBitIdWithLatestVersionAllowNull();
-  const id = versionToSetInBitmap ? idLatest.changeVersion(versionToSetInBitmap) : idLatest;
-  const isOnBitmap = consumer.bitMap.getComponentIfExist(id, {
-    ignoreVersion: true
-  });
-  if (!isOnBitmap && !isTag) {
-    // handle the case when a component was deleted, snapped/tagged and is now reset.
-    const stagedData = stagedConfig.getPerId(id);
-    if (stagedData?.config && stagedData.config[_remove().RemoveAspect.id]) {
-      consumer.bitMap.addFromComponentJson(stagedData.id, stagedData.componentMapObject);
-    }
-  }
-  consumer.bitMap.updateComponentId(id, undefined, undefined, true);
-  const availableOnMain = isAvailableOnMain(currentLane, modelComponent, id);
-  if (!availableOnMain) {
-    consumer.bitMap.setOnLanesOnly(id, true);
-  }
-  const componentMap = consumer.bitMap.getComponent(id);
-  const compId = await workspace.resolveComponentId(id);
-  // it can be either a tag/snap or reset.
-  if (isTag) {
-    const compMapObj = componentMap.toPlainObject();
-    const config = componentMap.config;
-    stagedConfig.addComponentConfig(compId, config, compMapObj);
-    consumer.bitMap.removeConfig(id);
-    const hash = modelComponent.getRef(id.version);
-    if (!hash) throw new Error(`updateComponentsVersions: unable to find a hash for ${id.toString()}`);
-    workspace.scope.legacyScope.stagedSnaps.addSnap(hash?.toString());
-  } else if (!componentMap.config) {
-    componentMap.config = stagedConfig.getConfigPerId(compId);
-  }
-  componentMap.clearNextVersion();
-}
-function replacePendingVersions(graph, resolvedVersions) {
-  let s = graph.serialize();
-  for (const {
-    name,
-    version
-  } of resolvedVersions) {
-    s = s.replaceAll(`${name}@pending:`, `${name}@${version}`);
-  }
-  const updatedDependenciesGraph = _objects().DependenciesGraph.deserialize(s);
-  // This should never happen as we know at this point that the schema version is supported
-  if (updatedDependenciesGraph == null) {
-    throw new (_bitError().BitError)('Failed to deserialize dependencies graph in replacePendingVersions()');
-  }
-  return updatedDependenciesGraph;
-}
-
+const _excluded = ["snapping", "consumerComponents", "components", "ids"];
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var s = Object.getOwnPropertySymbols(e); for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.includes(n)) continue; t[n] = r[n]; } return t; }
 /**
- * relevant for "_tag" (tag-from-scope) command.
- * the new tag uses the same files/config/build-artifacts as the previous snap.
- * we want to mark the previous snap as hidden. so then "bit log" and "bit blame" won't show it.
+ * @deprecated use VersionMaker class instead
  */
-async function updateHiddenProp(scope, ids) {
-  const log = await (0, _harmonyModules().getBasicLog)();
-  log.message = 'marked as hidden';
-  await (0, _toolboxPromise().pMapPool)(ids, async id => {
-    const versionObj = await scope.getBitObjectVersionById(id);
-    if (!versionObj) return;
-    versionObj.hidden = true;
-    versionObj.addModifiedLog(log);
-    scope.legacyScope.objects.add(versionObj);
-  }, {
-    concurrency: 50
-  });
+async function tagModelComponent(_ref) {
+  let {
+      snapping,
+      consumerComponents,
+      components,
+      ids
+    } = _ref,
+    params = _objectWithoutProperties(_ref, _excluded);
+  const versionMaker = new (_versionMaker().VersionMaker)(snapping, components, consumerComponents, ids, params);
+  return versionMaker.makeVersion();
 }
 
 //# sourceMappingURL=tag-model-component.js.map