@teambit/snapping 1.0.1254 → 1.0.1256

package/dist/version-maker.js

@@ -173,6 +173,13 @@ function _dependencyResolver() {
   };
   return data;
 }
+function _workspace() {
+  const data = require("@teambit/workspace");
+  _workspace = function () {
+    return data;
+  };
+  return data;
+}
 function _workspaceRoot() {
   const data = require("@teambit/workspace-root");
   _workspaceRoot = function () {
@@ -230,7 +237,9 @@ class VersionMaker {
     const componentsToTag = this.getUniqCompsToTag();
     const idsToTag = _componentId().ComponentIdList.fromArray(componentsToTag.map(c => c.id));
     // a component that is tagged explicitly is not auto-tagged too (the scope flow may find it as both)
-    const autoTagData = (await this.getAutoTagData(idsToTag)).filter(autoTagItem => !idsToTag.has(autoTagItem.component.id));
+    // like updateDependenciesVersions, a removed component is not a new version of its dependents' dependency
+    const removedIds = _componentId().ComponentIdList.fromArray(componentsToTag.filter(c => c.isRemoved()).map(c => c.id));
+    const autoTagData = (await this.getAutoTagData(idsToTag, removedIds)).filter(autoTagItem => !idsToTag.has(autoTagItem.component.id));
     const autoTagComponents = autoTagData.map(autoTagItem => autoTagItem.component);
     const autoTagIds = _componentId().ComponentIdList.fromArray(autoTagComponents.map(autoTag => autoTag.id));
 
@@ -547,13 +556,13 @@ class VersionMaker {
     });
     return Object.values(consumerComponentsIdsMap); // consumerComponents unique
   }
-  async getAutoTagData(idsToTag) {
+  async getAutoTagData(idsToTag, removedIds) {
     if (this.params.skipAutoTag) return [];
     // hidden lane.updateDependents are scope-only — they're not in the workspace
     // bitmap, so the workspace autotag candidate pool can't see them. Always run the scope-side
     // autotag pass alongside the workspace one when on a lane, so cascading a hidden updateDependent
     // off a workspace snap (scenario 1) works.
-    const fromScope = await this.getLaneAutoTagIdsFromScope(idsToTag, /* hiddenOnly */Boolean(this.workspace));
+    const fromScope = await this.getLaneAutoTagIdsFromScope(idsToTag, removedIds, /* hiddenOnly */Boolean(this.workspace));
     if (!this.workspace) return fromScope;
     // ids without versions are new. it's impossible that tagged (and not-modified) components has
     // them as dependencies. Also filter out hidden lane entries — getAutoTagInfo loads
@@ -574,43 +583,27 @@ class VersionMaker {
     const fromScopeFiltered = fromScope.filter(a => !workspaceIds.has(a.component.id.toStringWithoutVersion()));
     return [...fromWorkspace, ...fromScopeFiltered];
   }
-  async getLaneAutoTagIdsFromScope(idsToTag, hiddenOnly = false) {
+  async getLaneAutoTagIdsFromScope(idsToTag, removedIds, hiddenOnly = false) {
+    const triggerIds = _componentId().ComponentIdList.fromArray(idsToTag.filter(id => !removedIds.has(id)));
+    if (!triggerIds.length) return [];
     const lane = await this.legacyScope.getCurrentLaneObject();
     if (!lane) return [];
     // for the workspace+lane path we only care about hidden entries — workspace autotag handles
     // visible ones. for the bare-scope path (no workspace), include all lane entries.
-    const hiddenLaneIds = lane.updateDependents || [];
-    const candidateLaneIds = hiddenOnly ? hiddenLaneIds : [...lane.toComponentIds(), ...hiddenLaneIds];
+    const laneIds = hiddenOnly ? lane.updateDependents || [] : lane.toComponentIdsIncludeUpdateDependents();
+    const candidateLaneIds = laneIds.filter(id => !idsToTag.hasWithoutVersion(id));
     if (!candidateLaneIds.length) return [];
-    const laneCompIds = _componentId().ComponentIdList.fromArray(candidateLaneIds);
-    // include `idsToTag` in the graph too. For the bare-scope reverse cascade
-    // (`snapFromScope({ updateDependents: true })`), the targeted hidden entry is being NEWLY
-    // introduced to the lane and isn't in candidateLaneEntries yet — without seeding it into
-    // the graph, predecessors lookup wouldn't surface lane.components that depend on it, and
-    // the reverse cascade (re-snap visible dependents) wouldn't fire.
-    const graphSeedIds = _componentId().ComponentIdList.uniqFromArray([...laneCompIds, ...idsToTag]);
-    const graphIds = await this.scope.getGraphIds(graphSeedIds);
-    const dependentsMap = idsToTag.reduce((acc, id) => {
-      const dependents = graphIds.predecessors(id.toString());
-      const dependentsCompIds = dependents.map(d => d.attr);
-      const dependentsCompIdsFromTheLane = dependentsCompIds.filter(s => laneCompIds.has(s));
-      if (!dependentsCompIdsFromTheLane.length) return acc;
-      acc[id.toString()] = _componentId().ComponentIdList.fromArray(dependentsCompIdsFromTheLane);
-      return acc;
-    }, {});
-    if (Object.keys(dependentsMap).length === 0) return [];
-    const allDependentsIds = _componentId().ComponentIdList.uniqFromArray(Object.values(dependentsMap).flat());
-    const allDependents = await this.legacyScope.getManyConsumerComponents(allDependentsIds);
-    // a component that was removed from the lane is not snapped again, same as in a workspace, where it's not loaded
-    const notRemovedDependents = allDependents.filter(dependent => !dependent.isRemoved());
-    return notRemovedDependents.map(dependent => {
-      const triggeredByIds = Object.keys(dependentsMap).filter(id => dependentsMap[id].has(dependent.id));
-      const triggeredBy = _componentId().ComponentIdList.fromStringArray(triggeredByIds);
-      return {
-        component: dependent,
-        triggeredBy
-      };
+    // a bare scope (e.g. a Ripple cascade) has only the components it snaps. fetch the lane entries that are missing.
+    await this.scope.import(candidateLaneIds, {
+      lane,
+      includeUpdateDependents: true,
+      reFetchUnBuiltVersion: false,
+      reason: 'to find the lane components to snap along'
     });
+    const candidates = await this.legacyScope.getManyConsumerComponents(_componentId().ComponentIdList.fromArray(candidateLaneIds));
+    // a component that was removed from the lane is not snapped again, same as in a workspace, where it's not loaded
+    const notRemovedCandidates = candidates.filter(candidate => !candidate.isRemoved());
+    return (0, _workspace().getAutoTagInfoFromComponents)(notRemovedCandidates, triggerIds);
   }
   async setFutureVersions(autoTagIds) {
     const {