@teambit/workspace 1.0.106 → 1.0.108

package/aspects-merger.ts

@@ -0,0 +1,319 @@
+import { Harmony } from '@teambit/harmony';
+import { Component } from '@teambit/component';
+import { UnmergedComponent } from '@teambit/legacy/dist/scope/lanes/unmerged-components';
+import { ComponentID } from '@teambit/component-id';
+import { EnvsAspect } from '@teambit/envs';
+import { DependencyResolverAspect } from '@teambit/dependency-resolver';
+import { ExtensionDataList, getCompareExtPredicate } from '@teambit/legacy/dist/consumer/config/extension-data';
+import { partition, mergeWith, merge, uniq, uniqWith } from 'lodash';
+import { MergeConfigConflict } from './exceptions/merge-config-conflict';
+import { AspectSpecificField, ExtensionsOrigin, Workspace } from './workspace';
+import { MergeConflictFile } from './merge-conflict-file';
+
+export class AspectsMerger {
+  readonly mergeConflictFile: MergeConflictFile;
+  private mergeConfigDepsResolverDataCache: { [compIdStr: string]: Record<string, any> } = {};
+  constructor(private workspace: Workspace, private harmony: Harmony) {
+    this.mergeConflictFile = new MergeConflictFile(workspace.path);
+  }
+
+  getDepsDataOfMergeConfig(id: ComponentID) {
+    return this.mergeConfigDepsResolverDataCache[id.toString()];
+  }
+
+  /**
+   * Calculate the component config based on:
+   * the config property in the .bitmap file
+   * the component.json file in the component folder
+   * matching pattern in the variants config
+   * defaults extensions from workspace config
+   * extensions from the model.
+   */
+  // eslint-disable-next-line complexity
+  async merge(
+    componentId: ComponentID,
+    componentFromScope?: Component,
+    excludeOrigins: ExtensionsOrigin[] = []
+  ): Promise<{
+    extensions: ExtensionDataList;
+    beforeMerge: Array<{ extensions: ExtensionDataList; origin: ExtensionsOrigin; extraData: any }>; // useful for debugging
+    errors?: Error[];
+  }> {
+    // TODO: consider caching this result
+    let configFileExtensions: ExtensionDataList | undefined;
+    let variantsExtensions: ExtensionDataList | undefined;
+    const mergeFromScope = true;
+    const errors: Error[] = [];
+
+    const bitMapEntry = this.workspace.consumer.bitMap.getComponentIfExist(componentId);
+    const bitMapExtensions = bitMapEntry?.config;
+
+    let configMerge: Record<string, any> | undefined;
+    try {
+      configMerge = this.mergeConflictFile.getConflictParsed(componentId.toStringWithoutVersion());
+    } catch (err) {
+      if (!(err instanceof MergeConfigConflict)) {
+        throw err;
+      }
+      this.workspace.logger.error(`unable to parse the config file for ${componentId.toString()} due to conflicts`);
+      errors.push(err);
+    }
+
+    const adjustEnvsOnConfigMerge = (conf: Record<string, any>) => {
+      const env = conf[EnvsAspect.id]?.env;
+      if (!env) return;
+      const [id] = env.split('@');
+      conf[EnvsAspect.id] = { env: id };
+      conf[env] = {};
+    };
+
+    const unmergedData = this.getUnmergedData(componentId);
+    const unmergedDataMergeConf = unmergedData?.mergedConfig;
+    const getMergeConfigCombined = () => {
+      if (!configMerge && !unmergedDataMergeConf) return undefined;
+      if (!configMerge) return unmergedDataMergeConf;
+      if (!unmergedDataMergeConf) return configMerge;
+
+      return mergeWith(configMerge, unmergedDataMergeConf, (objValue, srcValue) => {
+        if (Array.isArray(objValue)) {
+          // critical for dependencyResolver.policy.*dependencies. otherwise, it will override the array
+          return objValue.concat(srcValue);
+        }
+        return undefined;
+      });
+    };
+    const mergeConfigCombined = getMergeConfigCombined();
+    adjustEnvsOnConfigMerge(mergeConfigCombined || {});
+
+    const configMergeExtensions = mergeConfigCombined
+      ? ExtensionDataList.fromConfigObject(mergeConfigCombined)
+      : undefined;
+
+    this.removeAutoDepsFromConfig(componentId, configMergeExtensions);
+    const scopeExtensions = this.getComponentFromScopeWithoutDuplications(componentFromScope);
+    // backward compatibility. previously, it was saved as an array into the model (when there was merge-config)
+    this.removeAutoDepsFromConfig(componentId, scopeExtensions, true);
+    const [specific, nonSpecific] = partition(scopeExtensions, (entry) => entry.config[AspectSpecificField] === true);
+    const scopeExtensionsNonSpecific = new ExtensionDataList(...nonSpecific);
+    const scopeExtensionsSpecific = new ExtensionDataList(...specific);
+
+    const componentConfigFile = await this.workspace.componentConfigFile(componentId);
+    if (componentConfigFile) {
+      configFileExtensions = componentConfigFile.aspects.toLegacy();
+    }
+    const relativeComponentDir = this.workspace.componentDir(componentId, { ignoreVersion: true }, { relative: true });
+    const variantConfig = this.workspace.variants.byRootDirAndName(relativeComponentDir, componentId.fullName);
+    if (variantConfig) {
+      variantsExtensions = variantConfig.extensions.clone();
+      // Do not merge from scope when there is specific variant (which is not *) that match the component
+      // if (variantConfig.maxSpecificity > 0) {
+      //   mergeFromScope = false;
+      // }
+    }
+    // We don't stop on each step because we want to merge the default scope even if propagate=false but the default scope is not defined
+    // in the case the same extension pushed twice, the former takes precedence (opposite of Object.assign)
+    const extensionsToMerge: Array<{ origin: ExtensionsOrigin; extensions: ExtensionDataList; extraData: any }> = [];
+    let envWasFoundPreviously = false;
+    const removedExtensionIds: string[] = [];
+
+    const addExtensionsToMerge = async (extensions: ExtensionDataList, origin: ExtensionsOrigin, extraData?: any) => {
+      if (!extensions.length) {
+        return;
+      }
+      removedExtensionIds.push(...extensions.filter((extData) => extData.isRemoved).map((extData) => extData.stringId));
+      const extsWithoutRemoved = extensions.filterRemovedExtensions();
+      const selfInMergedExtensions = extsWithoutRemoved.findExtension(componentId.toStringWithoutVersion(), true);
+      const extsWithoutSelf = selfInMergedExtensions?.extensionId
+        ? extsWithoutRemoved.remove(selfInMergedExtensions.extensionId)
+        : extsWithoutRemoved;
+      const preferWorkspaceVersion = origin !== 'BitmapFile' && origin !== 'ComponentJsonFile';
+      // it's important to do this resolution before the merge, otherwise we have issues with extensions
+      // coming from scope with local scope name, as opposed to the same extension comes from the workspace with default scope name
+      // also, it's important to do it before filtering the env, because when the env was not exported, it's saved with scope-name
+      // inside the "env" prop of teambit.envs/env, but without scope-name in the root.
+      const extsWithUpdatedIds = await this.resolveExtensionListIds(extsWithoutSelf, preferWorkspaceVersion);
+      const { extensionDataListFiltered, envIsCurrentlySet } = await this.filterEnvsFromExtensionsIfNeeded(
+        extsWithUpdatedIds,
+        envWasFoundPreviously,
+        origin
+      );
+      if (envIsCurrentlySet) {
+        envWasFoundPreviously = true;
+      }
+
+      extensionsToMerge.push({ origin, extensions: extensionDataListFiltered, extraData });
+    };
+    const setDataListAsSpecific = (extensions: ExtensionDataList) => {
+      extensions.forEach((dataEntry) => (dataEntry.config[AspectSpecificField] = true));
+    };
+    if (bitMapExtensions && !excludeOrigins.includes('BitmapFile')) {
+      const extensionDataList = ExtensionDataList.fromConfigObject(bitMapExtensions);
+      setDataListAsSpecific(extensionDataList);
+      await addExtensionsToMerge(extensionDataList, 'BitmapFile');
+    }
+    // config-merge is after the .bitmap. because normally if you have config set in .bitmap, you won't
+    // be able to lane-merge. (unless you specify --ignore-config-changes).
+    // so, if there is config in .bitmap, it probably happened after lane-merge.
+    if (configMergeExtensions && !excludeOrigins.includes('ConfigMerge')) {
+      await addExtensionsToMerge(ExtensionDataList.fromArray(configMergeExtensions), 'ConfigMerge');
+    }
+    if (configFileExtensions && !excludeOrigins.includes('ComponentJsonFile')) {
+      setDataListAsSpecific(configFileExtensions);
+      await addExtensionsToMerge(configFileExtensions, 'ComponentJsonFile');
+    }
+    if (!excludeOrigins.includes('ModelSpecific')) {
+      await addExtensionsToMerge(ExtensionDataList.fromArray(scopeExtensionsSpecific), 'ModelSpecific');
+    }
+    let continuePropagating = componentConfigFile?.propagate ?? true;
+    if (variantsExtensions && continuePropagating && !excludeOrigins.includes('WorkspaceVariants')) {
+      const appliedRules = variantConfig?.sortedMatches.map(({ pattern, specificity }) => ({ pattern, specificity }));
+      await addExtensionsToMerge(variantsExtensions, 'WorkspaceVariants', { appliedRules });
+    }
+    continuePropagating = continuePropagating && (variantConfig?.propagate ?? true);
+    if (mergeFromScope && continuePropagating && !excludeOrigins.includes('ModelNonSpecific')) {
+      await addExtensionsToMerge(scopeExtensionsNonSpecific, 'ModelNonSpecific');
+    }
+
+    const afterMerge = ExtensionDataList.mergeConfigs(extensionsToMerge.map((ext) => ext.extensions));
+    const withoutRemoved = afterMerge.filter((extData) => !removedExtensionIds.includes(extData.stringId));
+    const extensions = ExtensionDataList.fromArray(withoutRemoved);
+    return {
+      extensions,
+      beforeMerge: extensionsToMerge,
+      errors,
+    };
+  }
+
+  /**
+   * before version 0.0.882 it was possible to save Version object with the same extension twice.
+   */
+  private getComponentFromScopeWithoutDuplications(componentFromScope?: Component) {
+    if (!componentFromScope) return new ExtensionDataList();
+    const scopeExtensions = componentFromScope.config.extensions;
+    const scopeExtIds = scopeExtensions.ids;
+    const scopeExtHasDuplications = scopeExtIds.length !== uniq(scopeExtIds).length;
+    if (!scopeExtHasDuplications) {
+      return scopeExtensions;
+    }
+    // let's remove this duplicated extension blindly without trying to merge. (no need to merge coz it's old data from scope
+    // which will be overridden anyway by the workspace or other config strategies).
+    const arr = uniqWith(scopeExtensions, getCompareExtPredicate(true));
+    return ExtensionDataList.fromArray(arr);
+  }
+
+  /**
+   * from the merge-config we get the dep-resolver policy as an array, because it needs to support "force" prop.
+   * however, when we save the config, we want to save it as an object, so we need split the data into two:
+   * 1. force: true, which gets saved into the config.
+   * 2. force: false, which gets saved into the data.dependencies later on. see the workspace.getAutoDetectOverrides()
+   */
+  private removeAutoDepsFromConfig(componentId: ComponentID, conf?: ExtensionDataList, fromScope = false) {
+    if (!conf) return;
+    const policy = conf.findCoreExtension(DependencyResolverAspect.id)?.config.policy;
+    if (!policy) return;
+
+    const mergeConfigObj = {};
+    ['dependencies', 'devDependencies', 'peerDependencies'].forEach((key) => {
+      if (!policy[key]) return;
+      // this is only relevant when it is saved as an array. otherwise, it's always force: true.
+      if (!Array.isArray(policy[key])) return;
+
+      mergeConfigObj[key] = policy[key].filter((dep) => !dep.force);
+      policy[key] = policy[key].filter((dep) => dep.force);
+
+      if (!policy[key].length) {
+        delete policy[key];
+        return;
+      }
+      // convert to object
+      policy[key] = policy[key].reduce((acc, current) => {
+        acc[current.name] = current.version;
+        return acc;
+      }, {});
+    });
+
+    if (!fromScope) {
+      if (!this.mergeConfigDepsResolverDataCache[componentId.toString()]) {
+        this.mergeConfigDepsResolverDataCache[componentId.toString()] = {};
+      }
+      this.mergeConfigDepsResolverDataCache[componentId.toString()] = merge(
+        this.mergeConfigDepsResolverDataCache[componentId.toString()],
+        mergeConfigObj
+      );
+    }
+  }
+
+  private getUnmergedData(componentId: ComponentID): UnmergedComponent | undefined {
+    return this.workspace.scope.legacyScope.objects.unmergedComponents.getEntry(componentId.fullName);
+  }
+
+  private async filterEnvsFromExtensionsIfNeeded(
+    extensionDataList: ExtensionDataList,
+    envWasFoundPreviously: boolean,
+    origin: ExtensionsOrigin
+  ) {
+    const envAspect = extensionDataList.findExtension(EnvsAspect.id);
+    const envFromEnvsAspect: string | undefined = envAspect?.config.env || envAspect?.data.id;
+    const aspectsRegisteredAsEnvs = extensionDataList
+      .filter((aspect) =>
+        this.workspace.envs.getEnvDefinitionByStringId(aspect.newExtensionId?.toString() || aspect.stringId)
+      )
+      .map((aspect) => aspect.stringId);
+    if (envWasFoundPreviously && (envAspect || aspectsRegisteredAsEnvs.length)) {
+      const nonEnvs = extensionDataList.filter((e) => {
+        // normally the env-id inside the envs aspect doesn't have a version, but the aspect itself has a version.
+        // also, the env-id inside the envs aspect includes the default-scope, but the aspect itself doesn't.
+        if (
+          (envFromEnvsAspect && e.stringId === envFromEnvsAspect) ||
+          (envFromEnvsAspect && e.extensionId?.toStringWithoutVersion() === envFromEnvsAspect) ||
+          aspectsRegisteredAsEnvs.includes(e.stringId)
+        ) {
+          return false;
+        }
+        return true;
+      });
+      // still, aspect env may have other data other then config.env.
+      if (envAspect) delete envAspect.config.env;
+      return { extensionDataListFiltered: new ExtensionDataList(...nonEnvs), envIsCurrentlySet: true };
+    }
+    if (envFromEnvsAspect && (origin === 'ModelNonSpecific' || origin === 'ModelSpecific')) {
+      // if env was found, search for this env in the workspace and if found, replace the env-id with the one from the workspace
+      const envAspectExt = extensionDataList.find((e) => e.extensionId?.toStringWithoutVersion() === envFromEnvsAspect);
+      const ids = await this.workspace.listIds();
+      const envAspectId = envAspectExt?.extensionId;
+      const found = envAspectId && ids.find((id) => id.isEqualWithoutVersion(envAspectId));
+      if (found) {
+        envAspectExt.extensionId = found;
+      }
+    }
+    return { extensionDataListFiltered: extensionDataList, envIsCurrentlySet: Boolean(envFromEnvsAspect) };
+  }
+
+  /**
+   * This will mutate the entries with extensionId prop to have resolved legacy id
+   * This should be worked on the extension data list not the new aspect list
+   * @param extensionList
+   */
+  private async resolveExtensionListIds(
+    extensionList: ExtensionDataList,
+    preferWorkspaceVersion = false
+  ): Promise<ExtensionDataList> {
+    const promises = extensionList.map(async (entry) => {
+      if (entry.extensionId) {
+        // don't pass `entry.extensionId` (as ComponentID) to `resolveComponentId` because then it'll use the optimization
+        // of parsing it to ComponentID without checking the workspace. Normally, this optimization is good, but here
+        // in case the extension wasn't exported, the ComponentID is wrong, it has the scope-name due to incorrect ComponentID.fromString
+        // in configEntryToDataEntry() function. It'd be ideal to fix it from there but it's not easy.
+        const componentId = await this.workspace.resolveComponentId(entry.extensionId.toString());
+        const idFromWorkspace = preferWorkspaceVersion ? this.workspace.getIdIfExist(componentId) : undefined;
+        const id = idFromWorkspace || componentId;
+        entry.extensionId = id;
+        entry.newExtensionId = id;
+      }
+
+      return entry;
+    });
+    await Promise.all(promises);
+    return extensionList;
+  }
+}

package/bit-map.ts

@@ -0,0 +1,277 @@
+import { isEqual, merge } from 'lodash';
+import { ComponentID } from '@teambit/component-id';
+import LegacyBitMap from '@teambit/legacy/dist/consumer/bit-map';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import { GetBitMapComponentOptions } from '@teambit/legacy/dist/consumer/bit-map/bit-map';
+import ComponentMap from '@teambit/legacy/dist/consumer/bit-map/component-map';
+import { REMOVE_EXTENSION_SPECIAL_SIGN } from '@teambit/legacy/dist/consumer/config';
+import { BitError } from '@teambit/bit-error';
+import { LaneId } from '@teambit/lane-id';
+import EnvsAspect from '@teambit/envs';
+import { getPathStatIfExist } from '@teambit/legacy/dist/utils/fs/last-modified';
+import { PathOsBasedAbsolute } from '@teambit/legacy/dist/utils/path';
+
+export type MergeOptions = {
+  mergeStrategy?: 'theirs' | 'ours' | 'manual';
+};
+/**
+ * consider extracting to a new component.
+ * (pro: making Workspace aspect smaller. con: it's an implementation details of the workspace)
+ */
+export class BitMap {
+  constructor(private legacyBitMap: LegacyBitMap, private consumer: Consumer) {}
+
+  mergeBitmaps(bitmapContent: string, otherBitmapContent: string, opts: MergeOptions = {}): string {
+    return LegacyBitMap.mergeContent(bitmapContent, otherBitmapContent, opts);
+  }
+
+  getPath(): PathOsBasedAbsolute {
+    return this.legacyBitMap.mapPath;
+  }
+
+  /**
+   * adds component config to the .bitmap file.
+   * later, upon `bit tag`, the data is saved in the scope.
+   * returns a boolean indicating whether a change has been made.
+   */
+  addComponentConfig(
+    id: ComponentID,
+    aspectId: string,
+    config: Record<string, any> = {},
+    shouldMergeConfig = false
+  ): boolean {
+    if (!aspectId || typeof aspectId !== 'string') throw new Error(`expect aspectId to be string, got ${aspectId}`);
+    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
+    const currentConfig = (bitMapEntry.config ||= {})[aspectId];
+    if (isEqual(currentConfig, config)) {
+      return false; // no changes
+    }
+    const getNewConfig = () => {
+      if (!config) return null;
+      if (!shouldMergeConfig) return config;
+      // should merge
+      if (!currentConfig) return config;
+      if (currentConfig === '-') return config;
+      // lodash merge performs a deep merge. (the native concatenation don't)
+      return merge(currentConfig, config);
+    };
+    const newConfig = getNewConfig();
+    if (newConfig) {
+      bitMapEntry.config[aspectId] = newConfig;
+    } else {
+      delete bitMapEntry.config[aspectId];
+    }
+    this.legacyBitMap.markAsChanged();
+
+    return true; // changes have been made
+  }
+
+  updateDefaultScope(oldScope: string, newScope: string) {
+    const changedId: ComponentID[] = [];
+    this.legacyBitMap.components.forEach((componentMap) => {
+      // only new components (not snapped/tagged) can be changed
+      if (componentMap.defaultScope === oldScope && !componentMap.id.hasVersion()) {
+        componentMap.defaultScope = newScope;
+        changedId.push(componentMap.id);
+      }
+    });
+    if (changedId.length) {
+      this.legacyBitMap.markAsChanged();
+    }
+    return changedId;
+  }
+
+  markAsChanged() {
+    this.legacyBitMap.markAsChanged();
+  }
+
+  removeComponentConfig(id: ComponentID, aspectId: string, markWithMinusIfNotExist: boolean): boolean {
+    if (!aspectId || typeof aspectId !== 'string') throw new Error(`expect aspectId to be string, got ${aspectId}`);
+    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
+    const currentConfig = (bitMapEntry.config ||= {})[aspectId];
+    if (currentConfig) {
+      delete bitMapEntry.config[aspectId];
+    } else {
+      if (!markWithMinusIfNotExist) {
+        return false; // no changes
+      }
+      bitMapEntry.config[aspectId] = REMOVE_EXTENSION_SPECIAL_SIGN;
+    }
+
+    this.legacyBitMap.markAsChanged();
+
+    return true; // changes have been made
+  }
+
+  removeEntireConfig(id: ComponentID): boolean {
+    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
+    if (!bitMapEntry.config) return false;
+    delete bitMapEntry.config;
+    this.legacyBitMap.markAsChanged();
+    return true;
+  }
+
+  setEntireConfig(id: ComponentID, config: Record<string, any>) {
+    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
+    bitMapEntry.config = config;
+    this.legacyBitMap.markAsChanged();
+  }
+
+  removeDefaultScope(id: ComponentID) {
+    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
+    if (bitMapEntry.defaultScope) {
+      delete bitMapEntry.defaultScope;
+      this.legacyBitMap.markAsChanged();
+    }
+  }
+
+  setDefaultScope(id: ComponentID, defaultScope: string) {
+    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
+    bitMapEntry.defaultScope = defaultScope;
+    bitMapEntry.id = bitMapEntry.id.changeDefaultScope(defaultScope);
+    this.legacyBitMap.markAsChanged();
+  }
+
+  /**
+   * write .bitmap object to the filesystem
+   * optionally pass a reason for the change to be saved in the local scope `bitmap-history-metadata.txt` file.
+   */
+  async write(reasonForChange?: string) {
+    await this.consumer.writeBitMap(reasonForChange);
+  }
+
+  /**
+   * get the data saved in the .bitmap file for this component-id.
+   * throws if not found
+   * @see this.getBitmapEntryIfExist
+   */
+  getBitmapEntry(id: ComponentID, { ignoreVersion }: GetBitMapComponentOptions = {}): ComponentMap {
+    return this.legacyBitMap.getComponent(id, { ignoreVersion });
+  }
+
+  getBitmapEntryIfExist(id: ComponentID, { ignoreVersion }: GetBitMapComponentOptions = {}): ComponentMap | undefined {
+    return this.legacyBitMap.getComponentIfExist(id, { ignoreVersion });
+  }
+
+  getAspectIdFromConfig(
+    componentId: ComponentID,
+    aspectId: ComponentID,
+    ignoreAspectVersion = false
+  ): string | undefined {
+    const bitMapEntry = this.getBitmapEntry(componentId);
+    const config = bitMapEntry.config;
+    if (!config) {
+      return undefined;
+    }
+    if (config[aspectId.toString()]) {
+      return aspectId.toString();
+    }
+    if (!ignoreAspectVersion) {
+      return undefined;
+    }
+    const allVersions = Object.keys(config).filter((id) => id.startsWith(`${aspectId.toStringWithoutVersion()}@`));
+    if (allVersions.length > 1) {
+      throw new BitError(
+        `error: the same aspect ${
+          aspectId.toStringWithoutVersion
+        } configured multiple times for "${componentId.toString()}"\n${allVersions.join('\n')}`
+      );
+    }
+    return allVersions.length === 1 ? allVersions[0] : undefined;
+  }
+
+  /**
+   * components that were not tagged yet are safe to rename them from the .bitmap file.
+   */
+  renameNewComponent(sourceId: ComponentID, targetId: ComponentID) {
+    const bitMapEntry = this.getBitmapEntry(sourceId);
+    if (bitMapEntry.id.hasVersion()) {
+      throw new Error(`unable to rename tagged or exported component: ${bitMapEntry.id.toString()}`);
+    }
+    if (sourceId.isEqual(targetId)) {
+      throw new Error(`source-id and target-id are equal: "${sourceId.toString()}"`);
+    }
+    if (sourceId.fullName !== targetId.fullName) {
+      this.legacyBitMap.removeComponent(bitMapEntry.id);
+      bitMapEntry.id = targetId;
+      this.legacyBitMap.setComponent(bitMapEntry.id, bitMapEntry);
+    }
+    if (sourceId.scope !== targetId.scope) {
+      this.setDefaultScope(sourceId, targetId.scope);
+    }
+  }
+
+  /**
+   * helpful when reaming an aspect and this aspect is used in the config of other components.
+   */
+  renameAspectInConfig(sourceId: ComponentID, targetId: ComponentID) {
+    this.legacyBitMap.components.forEach((componentMap) => {
+      const config = componentMap.config;
+      if (!config) return;
+      Object.keys(config).forEach((aspectId) => {
+        if (aspectId === sourceId.toString()) {
+          config[targetId.toString()] = config[aspectId];
+          delete config[aspectId];
+          this.markAsChanged();
+        }
+        if (aspectId === EnvsAspect.id) {
+          const envConfig = config[aspectId];
+          if (envConfig !== REMOVE_EXTENSION_SPECIAL_SIGN && envConfig.env === sourceId.toString()) {
+            envConfig.env = targetId.toString();
+            this.markAsChanged();
+          }
+        }
+      });
+      componentMap.config = config;
+    });
+  }
+
+  removeComponent(id: ComponentID) {
+    this.legacyBitMap.removeComponent(id);
+  }
+
+  /**
+   * this is the lane-id of the recently exported lane. in case of a new lane, which was not exported yet, this will be
+   * empty.
+   */
+  getExportedLaneId(): LaneId | undefined {
+    return this.legacyBitMap.isLaneExported ? this.legacyBitMap.laneId : undefined;
+  }
+
+  makeComponentsAvailableOnMain(ids: ComponentID[]) {
+    ids.forEach((id) => {
+      const componentMap = this.getBitmapEntry(id);
+      componentMap.isAvailableOnCurrentLane = true;
+      delete componentMap.onLanesOnly;
+    });
+    this.legacyBitMap.markAsChanged();
+  }
+
+  /**
+   * whether .bitmap file has changed in-memory
+   */
+  hasChanged(): boolean {
+    return this.legacyBitMap.hasChanged;
+  }
+
+  takeSnapshot(): ComponentMap[] {
+    return this.legacyBitMap.components.map((comp) => comp.clone());
+  }
+
+  restoreFromSnapshot(componentMaps: ComponentMap[]) {
+    this.legacyBitMap.components = componentMaps;
+    this.legacyBitMap._invalidateCache();
+  }
+
+  /**
+   * .bitmap file could be changed by other sources (e.g. manually or by "git pull") not only by bit.
+   * this method returns the timestamp when the .bitmap has changed through bit. (e.g. as part of snap/tag/export/merge
+   * process)
+   */
+  async getLastModifiedBitmapThroughBit(): Promise<number | undefined> {
+    const bitmapHistoryDir = this.consumer.getBitmapHistoryDir();
+    const stat = await getPathStatIfExist(bitmapHistoryDir);
+    if (!stat) return undefined;
+    return stat.mtimeMs;
+  }
+}