@teambit/snapping 1.0.107 → 1.0.108

package/tag-model-component.ts

@@ -0,0 +1,641 @@
+import mapSeries from 'p-map-series';
+import fetch from 'node-fetch';
+import R from 'ramda';
+import { isEmpty } from 'lodash';
+import { ReleaseType } from 'semver';
+import { v4 } from 'uuid';
+import { BitError } from '@teambit/bit-error';
+import * as globalConfig from '@teambit/legacy/dist/api/consumer/lib/global-config';
+import { Scope } from '@teambit/legacy/dist/scope';
+import { ComponentID, ComponentIdList } from '@teambit/component-id';
+import {
+  BuildStatus,
+  CFG_USER_EMAIL_KEY,
+  CFG_USER_NAME_KEY,
+  CFG_USER_TOKEN_KEY,
+  getCloudDomain,
+  Extensions,
+} from '@teambit/legacy/dist/constants';
+import { CURRENT_SCHEMA } from '@teambit/legacy/dist/consumer/component/component-schema';
+import { linkToNodeModulesByComponents } from '@teambit/workspace.modules.node-modules-linker';
+import ConsumerComponent from '@teambit/legacy/dist/consumer/component/consumer-component';
+import Consumer from '@teambit/legacy/dist/consumer/consumer';
+import { NewerVersionFound } from '@teambit/legacy/dist/consumer/exceptions';
+import { Component } from '@teambit/component';
+import deleteComponentsFiles from '@teambit/legacy/dist/consumer/component-ops/delete-component-files';
+import logger from '@teambit/legacy/dist/logger/logger';
+import { sha1 } from '@teambit/legacy/dist/utils';
+import { AutoTagResult, getAutoTagInfo } from '@teambit/legacy/dist/scope/component-ops/auto-tag';
+import { getValidVersionOrReleaseType } from '@teambit/legacy/dist/utils/semver-helper';
+import { BuilderMain, OnTagOpts } from '@teambit/builder';
+import { Log } from '@teambit/legacy/dist/scope/models/version';
+import {
+  MessagePerComponent,
+  MessagePerComponentFetcher,
+} from '@teambit/legacy/dist/scope/component-ops/message-per-component';
+import { ModelComponent } from '@teambit/legacy/dist/scope/models';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { ScopeMain, StagedConfig } from '@teambit/scope';
+import { Workspace } from '@teambit/workspace';
+import { SnappingMain, TagDataPerComp } from './snapping.main.runtime';
+
+export type onTagIdTransformer = (id: ComponentID) => ComponentID | null;
+
+export type BasicTagSnapParams = {
+  message: string;
+  skipTests?: boolean;
+  build?: boolean;
+  ignoreBuildErrors?: boolean;
+  rebuildDepsGraph?: boolean;
+};
+
+export type BasicTagParams = BasicTagSnapParams & {
+  ignoreNewestVersion?: boolean;
+  skipAutoTag?: boolean;
+  soft?: boolean;
+  persist: boolean;
+  disableTagAndSnapPipelines?: boolean;
+  preReleaseId?: string;
+  editor?: string;
+  unmodified?: boolean;
+};
+
+function updateDependenciesVersions(
+  componentsToTag: ConsumerComponent[],
+  dependencyResolver: DependencyResolverMain
+): void {
+  const getNewDependencyVersion = (id: ComponentID): ComponentID | null => {
+    const foundDependency = componentsToTag.find((component) => component.id.isEqualWithoutVersion(id));
+    return foundDependency ? id.changeVersion(foundDependency.version) : null;
+  };
+  const changeExtensionsVersion = (component: ConsumerComponent): void => {
+    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: ConsumerComponent[]): void {
+  componentsToTag.forEach((componentToTag) => {
+    componentToTag.setNewVersion(sha1(v4()));
+  });
+}
+
+async function setFutureVersions(
+  componentsToTag: ConsumerComponent[],
+  scope: Scope,
+  releaseType: ReleaseType | undefined,
+  exactVersion: string | null | undefined,
+  persist: boolean,
+  autoTagIds: ComponentIdList,
+  ids: ComponentIdList,
+  incrementBy?: number,
+  preReleaseId?: string,
+  soft?: boolean,
+  tagDataPerComp?: TagDataPerComp[]
+): Promise<void> {
+  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 = (): string => {
+        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 = getValidVersionOrReleaseType(tagData.versionToTag);
+          return modelComponent.getVersionToAdd(
+            exactVersionOrReleaseType.releaseType,
+            exactVersionOrReleaseType.exactVersion,
+            incrementBy,
+            tagData.prereleaseId
+          );
+        }
+        if (nextVersion && persist) {
+          const exactVersionOrReleaseType = 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 as string)
+              : 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 as string)
+          : versionByEnteredId || modelComponent.getVersionToAdd(releaseType, exactVersion, incrementBy, preReleaseId);
+      };
+      const newVersion = getNewVersion();
+      componentToTag.setNewVersion(newVersion);
+    })
+  );
+}
+
+function getVersionByEnteredId(
+  enteredIds: ComponentIdList,
+  component: ConsumerComponent,
+  modelComponent: ModelComponent
+): string | undefined {
+  const enteredId = enteredIds.searchWithoutVersion(component.id);
+  if (enteredId && enteredId.hasVersion()) {
+    const exactVersionOrReleaseType = getValidVersionOrReleaseType(enteredId.version as string);
+    return modelComponent.getVersionToAdd(
+      exactVersionOrReleaseType.releaseType,
+      exactVersionOrReleaseType.exactVersion
+    );
+  }
+  return undefined;
+}
+
+export async function tagModelComponent({
+  workspace,
+  scope,
+  snapping,
+  builder,
+  consumerComponents,
+  ids,
+  tagDataPerComp,
+  populateArtifactsFrom,
+  message,
+  editor,
+  exactVersion,
+  releaseType,
+  preReleaseId,
+  ignoreNewestVersion = false,
+  skipTests = false,
+  skipAutoTag,
+  soft,
+  build,
+  persist,
+  isSnap = false,
+  disableTagAndSnapPipelines,
+  ignoreBuildErrors,
+  rebuildDepsGraph,
+  incrementBy,
+  packageManagerConfigRootDir,
+  dependencyResolver,
+  copyLogFromPreviousSnap = false,
+  exitOnFirstFailedTask = false,
+}: {
+  workspace?: Workspace;
+  scope: ScopeMain;
+  snapping: SnappingMain;
+  builder: BuilderMain;
+  consumerComponents: ConsumerComponent[];
+  ids: ComponentIdList;
+  tagDataPerComp?: TagDataPerComp[];
+  populateArtifactsFrom?: ComponentID[];
+  copyLogFromPreviousSnap?: boolean;
+  exactVersion?: string | null | undefined;
+  releaseType?: ReleaseType;
+  incrementBy?: number;
+  isSnap?: boolean;
+  packageManagerConfigRootDir?: string;
+  dependencyResolver: DependencyResolverMain;
+  exitOnFirstFailedTask?: boolean;
+} & BasicTagParams): Promise<{
+  taggedComponents: ConsumerComponent[];
+  autoTaggedResults: AutoTagResult[];
+  publishedPackages: string[];
+  stagedConfig?: StagedConfig;
+  removedComponents?: ComponentIdList;
+}> {
+  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: ConsumerComponent[] = R.values(consumerComponentsIdsMap); // consumerComponents unique
+  const idsToTag = 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 autoTagData =
+    skipAutoTag || !consumer ? [] : await getAutoTagInfo(consumer, ComponentIdList.fromArray(idsToTriggerAutoTag));
+  const autoTagComponents = autoTagData.map((autoTagItem) => autoTagItem.component);
+  const autoTagComponentsFiltered = autoTagComponents.filter((c) => !idsToTag.has(c.id));
+  const autoTagIds = ComponentIdList.fromArray(autoTagComponentsFiltered.map((autoTag) => autoTag.id));
+  const allComponentsToTag = [...componentsToTag, ...autoTagComponentsFiltered];
+
+  const messagesFromEditorFetcher = new 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
+  if (!ignoreNewestVersion && !isSnap) {
+    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(`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 = newestVersions.filter((newest) => newest);
+    if (!isEmpty(newestVersionsWithoutEmpty)) {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      throw new NewerVersionFound(newestVersionsWithoutEmpty);
+    }
+  }
+
+  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() : [];
+  let stagedConfig;
+  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.throwForDepsFromAnotherLane(allComponentsToTag);
+    if (!build) emptyBuilderData(allComponentsToTag);
+    addBuildStatus(allComponentsToTag, BuildStatus.Pending);
+    await addComponentsToScope(legacyScope, snapping, allComponentsToTag, Boolean(build), consumer, tagDataPerComp);
+
+    if (workspace) {
+      const modelComponents = await Promise.all(
+        allComponentsToTag.map((c) => {
+          return c.modelComponent || legacyScope.getModelComponent(c.id);
+        })
+      );
+      stagedConfig = await updateComponentsVersions(workspace, modelComponents);
+    }
+  }
+
+  const publishedPackages: string[] = [];
+  let harmonyComps: Component[] = [];
+  if (build) {
+    const onTagOpts: OnTagOpts = {
+      disableTagAndSnapPipelines,
+      throwOnError: true,
+      forceDeploy: ignoreBuildErrors,
+      isSnap,
+      populateArtifactsFrom,
+    };
+    const seedersOnly = !workspace; // if tag from scope, build only the given components
+    const isolateOptions = { packageManagerConfigRootDir, seedersOnly };
+    const builderOptions = { exitOnFirstFailedTask, skipTests };
+
+    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);
+      publishedPackages.push(...snapping._getPublishedPackages(componentsToBuild));
+      addBuildStatus(componentsToBuild, BuildStatus.Succeed);
+      await mapSeries(componentsToBuild, (consumerComponent) => snapping._enrichComp(consumerComponent));
+    }
+  }
+
+  let removedComponents: ComponentIdList | undefined;
+  if (!soft) {
+    removedComponents = await removeDeletedComponentsFromBitmap(allComponentsToTag, workspace);
+    await legacyScope.objects.persist();
+    await removeMergeConfigFromComponents(unmergedComps, allComponentsToTag, workspace);
+    if (workspace) {
+      await linkToNodeModulesByComponents(
+        harmonyComps.length ? harmonyComps : await workspace.scope.getManyByLegacy(allComponentsToTag),
+        workspace
+      );
+    }
+  }
+
+  return {
+    taggedComponents: componentsToTag,
+    autoTaggedResults: autoTagData,
+    publishedPackages,
+    stagedConfig,
+    removedComponents,
+  };
+}
+
+async function removeDeletedComponentsFromBitmap(
+  comps: ConsumerComponent[],
+  workspace?: Workspace
+): Promise<ComponentIdList | undefined> {
+  if (!workspace) {
+    return undefined;
+  }
+  const removedComps = comps.filter((comp) => comp.isRemoved());
+  if (!removedComps.length) return undefined;
+  const compBitIdsToRemove = ComponentIdList.fromArray(removedComps.map((c) => c.id));
+  await deleteComponentsFiles(workspace.consumer, compBitIdsToRemove);
+  await workspace.consumer.cleanFromBitMap(compBitIdsToRemove);
+
+  return compBitIdsToRemove;
+}
+
+async function removeMergeConfigFromComponents(
+  unmergedComps: ComponentID[],
+  components: ConsumerComponent[],
+  workspace?: 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();
+  }
+}
+
+async function addComponentsToScope(
+  scope: Scope,
+  snapping: SnappingMain,
+  components: ConsumerComponent[],
+  shouldValidateVersion: boolean,
+  consumer?: Consumer,
+  tagDataPerComp?: TagDataPerComp[]
+) {
+  const lane = await scope.getCurrentLaneObject();
+  if (consumer) {
+    await mapSeries(components, async (component) => {
+      await snapping._addCompToObjects({
+        source: component,
+        consumer,
+        lane,
+        shouldValidateVersion,
+      });
+    });
+  } else {
+    await mapSeries(components, async (component) => {
+      const results = await snapping._addCompFromScopeToObjects(component, lane);
+
+      // in case "tagData.isNew", the version object has "parents" that should not be there.
+      // they got created as a workaround to generate a new component from the scope without having a workspace.
+      const tagData = tagDataPerComp?.find((t) => t.componentId.isEqualWithoutVersion(component.id));
+      if (tagData?.isNew) results.version.removeAllParents();
+    });
+  }
+}
+
+/**
+ * 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: ConsumerComponent[]) {
+  components.forEach((component) => {
+    component.extensions = component.extensions.clone();
+    const existingBuilder = component.extensions.findCoreExtension(Extensions.builder);
+    if (existingBuilder) existingBuilder.data = {};
+  });
+}
+
+async function addLogToComponents(
+  components: ConsumerComponent[],
+  autoTagComps: ConsumerComponent[],
+  persist: boolean,
+  message: string,
+  messagePerComponent: MessagePerComponent[],
+  copyLogFromPreviousSnap = false
+) {
+  // @ts-ignore this happens when running `bit tag -m ""`.
+  if (message === true) {
+    message = '';
+  }
+  const basicLog = await getBasicLog();
+  const getLog = (component: ConsumerComponent): Log => {
+    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;
+    }
+  });
+}
+
+export async function getBasicLog(): Promise<Log> {
+  const username = (await getBitCloudUsername()) || (await globalConfig.get(CFG_USER_NAME_KEY));
+  const email = await globalConfig.get(CFG_USER_EMAIL_KEY);
+  return {
+    username,
+    email,
+    message: '',
+    date: Date.now().toString(),
+  };
+}
+
+export async function getBitCloudUsername(): Promise<string | undefined> {
+  const token = await globalConfig.get(CFG_USER_TOKEN_KEY);
+  if (!token) return '';
+  try {
+    const res = await fetch(`https://api.${getCloudDomain()}/user`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+    });
+    const object = await res.json();
+    const user = object.payload;
+    const username = user.username;
+    return username;
+  } catch (error) {
+    return undefined;
+  }
+}
+
+export type BitCloudUser = {
+  username?: string;
+  name?: string;
+  displayName?: string;
+  profileImage?: string;
+};
+
+export async function getBitCloudUser(): Promise<BitCloudUser | undefined> {
+  const token = await globalConfig.get(CFG_USER_TOKEN_KEY);
+  if (!token) return undefined;
+
+  try {
+    const res = await fetch(`https://api.${getCloudDomain()}/user`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+    });
+    const object = await res.json();
+    const user = object.payload;
+
+    return {
+      ...user,
+    };
+  } catch (error) {
+    return undefined;
+  }
+}
+
+function setCurrentSchema(components: ConsumerComponent[]) {
+  components.forEach((component) => {
+    component.schema = CURRENT_SCHEMA;
+  });
+}
+
+function addBuildStatus(components: ConsumerComponent[], buildStatus: BuildStatus) {
+  components.forEach((component) => {
+    component.buildStatus = buildStatus;
+  });
+}
+
+export async function updateComponentsVersions(
+  workspace: Workspace,
+  components: Array<ModelComponent>,
+  isTag = true
+): Promise<StagedConfig> {
+  const consumer = workspace.consumer;
+  const currentLane = consumer.getCurrentLaneId();
+  const stagedConfig = await workspace.scope.getStagedConfig();
+  const isAvailableOnMain = async (
+    component: ModelComponent | ConsumerComponent,
+    id: ComponentID
+  ): Promise<boolean> => {
+    if (currentLane.isDefault()) {
+      return true;
+    }
+    if (!id.hasVersion()) {
+      // component was unsnapped on the current lane and is back to a new component
+      return true;
+    }
+    const modelComponent =
+      component instanceof ModelComponent ? component : await consumer.scope.getModelComponent(component.id);
+    return modelComponent.hasHead();
+  };
+
+  const updateVersions = async (modelComponent: ModelComponent) => {
+    const id: ComponentID = modelComponent.toBitIdWithLatestVersionAllowNull();
+    consumer.bitMap.updateComponentId(id, undefined, undefined, true);
+    const availableOnMain = await isAvailableOnMain(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 config = componentMap.config;
+      stagedConfig.addComponentConfig(compId, config);
+      consumer.bitMap.removeConfig(id);
+      const hash = modelComponent.getRef(id.version as string);
+      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();
+  };
+  // important! DO NOT use Promise.all here! otherwise, you're gonna enter into a whole world of pain.
+  // imagine tagging comp1 with auto-tagged comp2, comp1 package.json is written while comp2 is
+  // trying to get the dependencies of comp1 using its package.json.
+  await mapSeries(components, updateVersions);
+  await workspace.scope.legacyScope.stagedSnaps.write();
+
+  return stagedConfig;
+}

package/tsconfig.json

@@ -1,38 +1,33 @@
 {
   "compilerOptions": {
     "lib": [
-      "es2019",
-      "DOM",
-      "ES6",
-      "DOM.Iterable",
-      "ScriptHost"
+      "esnext",
+      "dom",
+      "dom.Iterable"
     ],
-    "target": "es2015",
-    "module": "CommonJS",
-    "jsx": "react",
-    "allowJs": true,
-    "composite": true,
+    "target": "es2020",
+    "module": "es2020",
+    "jsx": "react-jsx",
     "declaration": true,
     "sourceMap": true,
-    "skipLibCheck": true,
     "experimentalDecorators": true,
-    "outDir": "dist",
+    "skipLibCheck": true,
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "rootDir": ".",
     "resolveJsonModule": true,
-    "emitDeclarationOnly": true,
-    "emitDecoratorMetadata": true,
-    "allowSyntheticDefaultImports": true,
-    "strictPropertyInitialization": false,
-    "strict": true,
-    "noImplicitAny": false,
-    "preserveConstEnums": true
+    "allowJs": true,
+    "outDir": "dist",
+    "emitDeclarationOnly": true
   },
   "exclude": [
+    "artifacts",
+    "public",
     "dist",
+    "node_modules",
+    "package.json",
     "esm.mjs",
-    "package.json"
+    "**/*.cjs",
+    "./dist"
   ],
   "include": [
     "**/*",