@teambit/snapping 1.0.443 → 1.0.445

package/dist/snapping.main.runtime.d.ts

@@ -115,6 +115,12 @@ export declare class SnappingMain {
         rebuildArtifacts?: boolean;
         ignoreLastPkgJson?: boolean;
     } & Partial<BasicTagParams>): Promise<TagResults | null>;
+    forkAndSnap(snapDataPerCompRaw: SnapDataPerCompRaw[], params: {
+        push?: boolean;
+        ignoreIssues?: string;
+        lane?: string;
+        updateDependents?: boolean;
+    } & Partial<BasicTagParams>): Promise<SnapFromScopeResults>;
     snapFromScope(snapDataPerCompRaw: SnapDataPerCompRaw[], params: {
         push?: boolean;
         ignoreIssues?: string;

package/dist/snapping.main.runtime.js

@@ -578,10 +578,10 @@ if you're willing to lose the history from the head to the specified version, us
       newComponents: new (_componentId().ComponentIdList)()
     };
   }
-  async snapFromScope(snapDataPerCompRaw, params) {
-    const hasForkedFrom = snapDataPerCompRaw.some(s => s.forkFrom);
-    if (this.workspace && !hasForkedFrom) {
-      throw new (_bitError().BitError)(`unable to run this command from a workspace, please create a new bare-scope and run it from there`);
+  async forkAndSnap(snapDataPerCompRaw, params) {
+    const allAreForkedFrom = snapDataPerCompRaw.every(s => s.forkFrom);
+    if (!allAreForkedFrom) {
+      throw new (_bitError().BitError)(`when forkedFrom prop is used, all components must have the forkedFrom prop`);
     }
     let lane;
     const laneIdStr = params.lane;
@@ -592,18 +592,9 @@ if you're willing to lose the history from the head to the specified version, us
       } catch (err) {
         if (err.constructor.name !== _legacy2().LaneNotFound.name) throw err;
         // if the lane is not found, it's probably because it's new. create a new lane.
-        lane = await (0, _lanesModules().createLaneInScope)(laneId.name, this.scope, laneId.scope);
-        // it's important to set the lane as new in scope.json. otherwise, later, when importing and the lane is loaded
-        // from the filesystem, it looses the "isNew: true", and then it tries to fetch the lane from the remote scope.
-        // which fails with the importer.
-        this.scope.legacyScope.scopeJson.setLaneAsNew(laneId.name);
+        lane = await (0, _lanesModules().createLane)(this.workspace, laneId.name, laneId.scope);
       }
-      // this is critical. otherwise, later on, when loading aspects and isolating capsules, we'll try to fetch dists
-      // from the original scope instead of the lane-scope.
-      this.scope.legacyScope.setCurrentLaneId(laneId);
-      this.scope.legacyScope.scopeImporter.shouldOnlyFetchFromCurrentLane = true;
     }
-    const laneCompIds = lane?.toComponentIdsIncludeUpdateDependents();
     const snapDataPerComp = snapDataPerCompRaw.map(snapData => {
       return {
         componentId: _componentId().ComponentID.fromString(snapData.componentId),
@@ -620,26 +611,22 @@ if you're willing to lose the history from the head to the specified version, us
           type: dep.type ?? 'runtime'
         })),
         removeDependencies: snapData.removeDependencies,
-        forkFrom: snapData.forkFrom ? _componentId().ComponentID.fromString(snapData.forkFrom) : undefined
+        forkFrom: _componentId().ComponentID.fromString(snapData.forkFrom)
       };
     });
 
     // console.log('snapDataPerComp', JSON.stringify(snapDataPerComp, undefined, 2));
 
-    const componentIds = (0, _lodash().compact)(snapDataPerComp.map(t => t.isNew || t.forkFrom ? null : t.componentId));
     const allCompIds = snapDataPerComp.map(s => s.componentId);
-    const componentIdsLatest = componentIds.map(id => id.changeVersion(_constants().LATEST));
-    const newCompsData = (0, _lodash().compact)(snapDataPerComp.map(t => t.isNew && !t.forkFrom ? t : null));
     const forkedFromData = (0, _lodash().compact)(snapDataPerComp.map(t => t.forkFrom ? t : null));
-    const newComponents = await Promise.all(newCompsData.map(newComp => (0, _generateCompFromScope().generateCompFromScope)(this.scope, newComp, this)));
     const forkMultipleData = forkedFromData.map(f => ({
       sourceId: f.forkFrom.toString(),
       targetId: f.componentId.fullName,
       targetScope: f.componentId.scope
     }));
-    const forkResults = forkMultipleData.length ? await this.forking.forkMultipleFromRemote(forkMultipleData, {
+    const forkResults = await this.forking.forkMultipleFromRemote(forkMultipleData, {
       refactor: true
-    }) : [];
+    });
     const newEnvData = {};
     forkedFromData.forEach(f => {
       const bitmapElem = this.workspace.bitMap.getBitmapEntry(f.componentId);
@@ -655,7 +642,157 @@ if you're willing to lose the history from the head to the specified version, us
     await (0, _pMapSeries().default)(Object.entries(newEnvData), async ([env, compIds]) => {
       await this.workspace.setEnvToComponents(_componentId().ComponentID.fromString(env), compIds, false);
     });
-    const newForkedComponents = forkResults.length ? await this.workspace.getMany(forkResults.map(f => f.targetCompId)) : [];
+    const getSnapData = id => {
+      const snapData = snapDataPerComp.find(t => {
+        return t.componentId.isEqual(id, {
+          ignoreVersion: true
+        });
+      });
+      if (!snapData) throw new Error(`unable to find ${id.toString()} in snapDataPerComp`);
+      return snapData;
+    };
+    const newForkedComponents = await this.workspace.getMany(forkResults.map(f => f.targetCompId));
+    await Promise.all(newForkedComponents.map(async comp => {
+      const snapData = getSnapData(comp.id);
+      if (snapData.files?.length) {
+        await this.updateSourceFiles(comp, snapData.files);
+        await this.workspace.write(comp);
+      }
+      if (snapData.aspects) {
+        const bitmapElem = this.workspace.bitMap.getBitmapEntry(comp.id);
+        if (!bitmapElem) throw new Error(`unable to find ${comp.id.toString()} in the bitmap`);
+        const currentConfig = bitmapElem.config;
+        if (!currentConfig) {
+          this.workspace.bitMap.setEntireConfig(comp.id, snapData.aspects);
+          return;
+        }
+        const currentEnvSettings = currentConfig['teambit.envs/envs'];
+        const currentEnv = currentEnvSettings !== '-' && currentEnvSettings.env;
+        const newEnv = snapData.aspects['teambit.envs/envs']?.env;
+        if (!currentEnv || !newEnv) {
+          this.workspace.bitMap.setEntireConfig(comp.id, _objectSpread(_objectSpread({}, currentConfig), snapData.aspects));
+          return;
+        }
+        const currentEnvWithPotentialVer = Object.keys(currentConfig).find(c => c === currentEnv || c.startsWith(`${currentEnv}@`));
+        if (currentEnvWithPotentialVer) delete currentConfig[currentEnvWithPotentialVer];
+        delete currentConfig['teambit.envs/envs'];
+        this.workspace.bitMap.setEntireConfig(comp.id, _objectSpread(_objectSpread({}, currentConfig), snapData.aspects));
+      }
+    }));
+    await this.workspace.bitMap.write();
+    // if you don't clear the cache here, the installation assumes all components have the old env.
+    await this.workspace.clearCache();
+    await this.install.install(undefined, {
+      dedupe: true,
+      import: false,
+      copyPeerToRuntimeOnRoot: true,
+      copyPeerToRuntimeOnComponents: false,
+      updateExisting: false
+    });
+    // if we don't clear the cache here, the "build" process during tag doesn't install the necessary packages
+    // on the capsules.
+    await this.workspace.clearCache();
+    const components = await this.workspace.getMany(forkedFromData.map(f => f.componentId));
+    const consumerComponents = components.map(c => c.state._consumer);
+    const ids = _componentId().ComponentIdList.fromArray(allCompIds);
+    const results = await (0, _tagModelComponent().tagModelComponent)(_objectSpread(_objectSpread({}, params), {}, {
+      scope: this.scope,
+      consumerComponents,
+      tagDataPerComp: snapDataPerComp.map(s => ({
+        componentId: s.componentId,
+        message: s.message,
+        dependencies: []
+      })),
+      snapping: this,
+      builder: this.builder,
+      dependencyResolver: this.dependencyResolver,
+      skipAutoTag: true,
+      persist: true,
+      isSnap: true,
+      ids,
+      message: params.message,
+      updateDependentsOnLane: params.updateDependents
+    }));
+    const {
+      taggedComponents
+    } = results;
+    let exportedIds;
+    if (params.push) {
+      const updatedLane = lane ? await this.scope.legacyScope.loadLane(lane.toLaneId()) : undefined;
+      const {
+        exported
+      } = await this.exporter.exportMany({
+        scope: this.scope.legacyScope,
+        ids,
+        idsWithFutureScope: ids,
+        allVersions: false,
+        laneObject: updatedLane,
+        // no need other snaps. only the latest one. without this option, when snapping on lane from another-scope, it
+        // may throw an error saying the previous snaps don't exist on the filesystem.
+        // (see the e2e - "snap on a lane when the component is new to the lane and the scope")
+        exportHeadsOnly: true
+      });
+      exportedIds = exported;
+    }
+    return {
+      snappedComponents: taggedComponents,
+      snappedIds: taggedComponents.map(comp => comp.id),
+      exportedIds
+    };
+  }
+  async snapFromScope(snapDataPerCompRaw, params) {
+    const hasForkedFrom = snapDataPerCompRaw.some(s => s.forkFrom);
+    if (hasForkedFrom) return this.forkAndSnap(snapDataPerCompRaw, params);
+    if (this.workspace) {
+      throw new (_bitError().BitError)(`unable to run this command from a workspace, please create a new bare-scope and run it from there`);
+    }
+    let lane;
+    const laneIdStr = params.lane;
+    if (laneIdStr) {
+      const laneId = _laneId().LaneId.parse(laneIdStr);
+      try {
+        lane = await this.importer.importLaneObject(laneId);
+      } catch (err) {
+        if (err.constructor.name !== _legacy2().LaneNotFound.name) throw err;
+        // if the lane is not found, it's probably because it's new. create a new lane.
+        lane = await (0, _lanesModules().createLaneInScope)(laneId.name, this.scope, laneId.scope);
+        // it's important to set the lane as new in scope.json. otherwise, later, when importing and the lane is loaded
+        // from the filesystem, it looses the "isNew: true", and then it tries to fetch the lane from the remote scope.
+        // which fails with the importer.
+        this.scope.legacyScope.scopeJson.setLaneAsNew(laneId.name);
+      }
+      // this is critical. otherwise, later on, when loading aspects and isolating capsules, we'll try to fetch dists
+      // from the original scope instead of the lane-scope.
+      this.scope.legacyScope.setCurrentLaneId(laneId);
+      this.scope.legacyScope.scopeImporter.shouldOnlyFetchFromCurrentLane = true;
+    }
+    const laneCompIds = lane?.toComponentIdsIncludeUpdateDependents();
+    const snapDataPerComp = snapDataPerCompRaw.map(snapData => {
+      return {
+        componentId: _componentId().ComponentID.fromString(snapData.componentId),
+        dependencies: snapData.dependencies || [],
+        aspects: snapData.aspects,
+        message: snapData.message,
+        files: snapData.files,
+        isNew: snapData.isNew,
+        mainFile: snapData.mainFile,
+        newDependencies: (snapData.newDependencies || []).map(dep => ({
+          id: dep.id,
+          version: dep.version,
+          isComponent: dep.isComponent ?? true,
+          type: dep.type ?? 'runtime'
+        })),
+        removeDependencies: snapData.removeDependencies
+      };
+    });
+
+    // console.log('snapDataPerComp', JSON.stringify(snapDataPerComp, undefined, 2));
+
+    const componentIds = (0, _lodash().compact)(snapDataPerComp.map(t => t.isNew ? null : t.componentId));
+    const allCompIds = snapDataPerComp.map(s => s.componentId);
+    const componentIdsLatest = componentIds.map(id => id.changeVersion(_constants().LATEST));
+    const newCompsData = (0, _lodash().compact)(snapDataPerComp.map(t => t.isNew ? t : null));
+    const newComponents = await Promise.all(newCompsData.map(newComp => (0, _generateCompFromScope().generateCompFromScope)(this.scope, newComp, this)));
     await this.scope.import(componentIdsLatest, {
       preferDependencyGraph: false,
       lane,
@@ -685,7 +822,7 @@ if you're willing to lose the history from the head to the specified version, us
         });
       });
     }
-    const components = [...existingComponents, ...newComponents, ...newForkedComponents];
+    const components = [...existingComponents, ...newComponents];
 
     // this must be done before we load component aspects later on, because this updated deps may update aspects.
     await (0, _pMapSeries().default)(components, async component => {
@@ -695,33 +832,22 @@ if you're willing to lose the history from the head to the specified version, us
     });
 
     // for new components these are not needed. coz when generating them we already add the aspects and the files.
-    await Promise.all([...existingComponents, ...newForkedComponents].map(async comp => {
+    await Promise.all(existingComponents.map(async comp => {
       const snapData = getSnapData(comp.id);
       if (snapData.aspects) await this.scope.addAspectsFromConfigObject(comp, snapData.aspects);
       if (snapData.files?.length) {
         await this.updateSourceFiles(comp, snapData.files);
       }
     }));
-    if (!this.workspace) {
-      // load the aspects user configured to set on the components. it creates capsules if needed.
-      // otherwise, when a user set a custom-env, it won't be loaded and the Version object will leave the
-      // teambit.envs/envs in a weird state. the config will be set correctly but the data will be set to the default
-      // node env.
-      await this.scope.loadManyCompsAspects(components);
 
-      // this is similar to what happens in the workspace. the "onLoad" is running and populating the "data" of the aspects.
-      await (0, _pMapSeries().default)(components, async comp => this.scope.executeOnCompAspectReCalcSlot(comp));
-    } else {
-      await this.workspace.clearCache();
-      // for the forked components, it's on the workspace, so all it is missing now is the installation
-      await this.install.install(undefined, {
-        dedupe: true,
-        import: false,
-        copyPeerToRuntimeOnRoot: true,
-        copyPeerToRuntimeOnComponents: false,
-        updateExisting: false
-      });
-    }
+    // load the aspects user configured to set on the components. it creates capsules if needed.
+    // otherwise, when a user set a custom-env, it won't be loaded and the Version object will leave the
+    // teambit.envs/envs in a weird state. the config will be set correctly but the data will be set to the default
+    // node env.
+    await this.scope.loadManyCompsAspects(components);
+
+    // this is similar to what happens in the workspace. the "onLoad" is running and populating the "data" of the aspects.
+    await (0, _pMapSeries().default)(components, async comp => this.scope.executeOnCompAspectReCalcSlot(comp));
     const consumerComponents = components.map(c => c.state._consumer);
     const ids = _componentId().ComponentIdList.fromArray(allCompIds);
     const results = await (0, _tagModelComponent().tagModelComponent)(_objectSpread(_objectSpread({}, params), {}, {