@teambit/snapping 1.0.336 → 1.0.338

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

@@ -23,6 +23,7 @@ import { BasicTagParams, BasicTagSnapParams } from './tag-model-component';
 import { TagDataPerCompRaw } from './tag-from-scope.cmd';
 import { SnapDataPerCompRaw, FileData } from './snap-from-scope.cmd';
 import { untagResult } from './reset-component';
+import { ApplicationMain } from '@teambit/application';
 export type TagDataPerComp = {
     componentId: ComponentID;
     dependencies: ComponentID[];
@@ -78,8 +79,9 @@ export declare class SnappingMain {
     private builder;
     private importer;
     private deps;
+    private application;
     private objectsRepo;
-    constructor(workspace: Workspace, logger: Logger, issues: IssuesMain, insights: InsightsMain, dependencyResolver: DependencyResolverMain, scope: ScopeMain, exporter: ExportMain, builder: BuilderMain, importer: ImporterMain, deps: DependenciesMain);
+    constructor(workspace: Workspace, logger: Logger, issues: IssuesMain, insights: InsightsMain, dependencyResolver: DependencyResolverMain, scope: ScopeMain, exporter: ExportMain, builder: BuilderMain, importer: ImporterMain, deps: DependenciesMain, application: ApplicationMain);
     /**
      * tag the given component ids or all modified/new components if "all" param is set.
      * tag is a similar operation as a snap, which saves the changes into the local scope, but it also creates an alias
@@ -161,7 +163,6 @@ export declare class SnappingMain {
     _getObjectsToEnrichComp(consumerComponent: ConsumerComponent, modifiedLog?: Log): Promise<BitObject[]>;
     private transformArtifactsFromVinylToSource;
     private loadComponentsForTagOrSnap;
-    private throwForComponentIssues;
     private throwForPendingImport;
     private throwForLegacyDependenciesInsideHarmony;
     /**
@@ -183,7 +184,7 @@ export declare class SnappingMain {
     static slots: never[];
     static dependencies: import("@teambit/harmony").Aspect[];
     static runtime: import("@teambit/harmony").RuntimeDefinition;
-    static provider([workspace, cli, loggerMain, issues, insights, dependencyResolver, scope, exporter, builder, importer, globalConfig, deps,]: [
+    static provider([workspace, cli, loggerMain, issues, insights, dependencyResolver, scope, exporter, builder, importer, globalConfig, deps, application,]: [
         Workspace,
         CLIMain,
         LoggerMain,
@@ -195,7 +196,8 @@ export declare class SnappingMain {
         BuilderMain,
         ImporterMain,
         GlobalConfigMain,
-        DependenciesMain
+        DependenciesMain,
+        ApplicationMain
     ]): Promise<SnappingMain>;
 }
 export default SnappingMain;

package/dist/snapping.main.runtime.js

@@ -256,13 +256,6 @@ function _tagCmd() {
   };
   return data;
 }
-function _componentsHaveIssues() {
-  const data = require("./components-have-issues");
-  _componentsHaveIssues = function () {
-    return data;
-  };
-  return data;
-}
 function _resetCmd() {
   const data = _interopRequireDefault(require("./reset-cmd"));
   _resetCmd = function () {
@@ -319,6 +312,13 @@ function _resetComponent() {
   };
   return data;
 }
+function _application() {
+  const data = require("@teambit/application");
+  _application = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -326,7 +326,7 @@ function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 class SnappingMain {
-  constructor(workspace, logger, issues, insights, dependencyResolver, scope, exporter, builder, importer, deps) {
+  constructor(workspace, logger, issues, insights, dependencyResolver, scope, exporter, builder, importer, deps, application) {
     this.workspace = workspace;
     this.logger = logger;
     this.issues = issues;
@@ -337,6 +337,7 @@ class SnappingMain {
     this.builder = builder;
     this.importer = importer;
     this.deps = deps;
+    this.application = application;
     _defineProperty(this, "objectsRepo", void 0);
     this.objectsRepo = this.scope?.legacyScope?.objects;
   }
@@ -905,19 +906,22 @@ in case you're unsure about the pattern syntax, use "bit pattern [--help]"`);
     const componentsToCheck = components.filter(c => !c.isDeleted());
     const consumerComponents = componentsToCheck.map(c => c.state._consumer);
     await this.throwForLegacyDependenciesInsideHarmony(consumerComponents);
-    await this.throwForComponentIssues(componentsToCheck, ignoreIssues);
+    await this.builder.throwForComponentIssues(componentsToCheck, ignoreIssues);
     this.throwForPendingImport(consumerComponents);
   }
   async throwForDepsFromAnotherLaneForComp(component, allIds, lane, throwForMissingObjects = false) {
+    const depsFromModel = component.componentFromModel?.getAllDependencies();
+    const depsFromModelIds = depsFromModel ? _componentId().ComponentIdList.fromArray(depsFromModel.map(d => d.id)) : new (_componentId().ComponentIdList)();
     const deps = component.getAllDependencies();
     const missingDeps = [];
     await Promise.all(deps.map(async dep => {
       if (!this.scope.isExported(dep.id) || !dep.id.hasVersion()) return;
       if ((0, _componentVersion().isTag)(dep.id.version)) return;
       if (allIds.hasWithoutVersion(dep.id)) return; // it's tagged/snapped now.
+      if (depsFromModelIds.has(dep.id)) return; // this dep is not new, it was already snapped/tagged with it before.
       let isPartOfHistory;
       try {
-        isPartOfHistory = lane ? (await this.scope.legacyScope.isPartOfLaneHistory(dep.id, lane)) || (await this.scope.legacyScope.isPartOfMainHistory(dep.id)) : await this.scope.legacyScope.isPartOfMainHistory(dep.id);
+        isPartOfHistory = lane ? await this.scope.legacyScope.isPartOfLaneHistoryOrMain(dep.id, lane) : await this.scope.legacyScope.isPartOfMainHistory(dep.id);
       } catch (err) {
         if (throwForMissingObjects) throw err;
         if (err instanceof _exceptions().VersionNotFound || err instanceof _exceptions().ComponentNotFound || err instanceof _exceptions().HeadNotFound || err instanceof _exceptions().ParentNotFound) {
@@ -1132,33 +1136,16 @@ another option, in case this dependency is not in main yet is to remove all refe
     return artifacts;
   }
   async loadComponentsForTagOrSnap(ids, shouldClearCacheFirst = true) {
+    const idsWithoutVersions = ids.map(id => id.changeVersion(undefined));
+    const appIds = await this.application.loadAllAppsAsAspects(idsWithoutVersions);
     if (shouldClearCacheFirst) {
       await this.workspace.consumer.componentFsCache.deleteAllDependenciesDataCache();
       // don't clear only the cache of these ids. we need also the auto-tag. so it's safer to just clear all.
       this.workspace.clearAllComponentsCache();
+    } else {
+      appIds.forEach(id => this.workspace.clearComponentCache(id));
     }
-    return this.workspace.getMany(ids.map(id => id.changeVersion(undefined)));
-  }
-  async throwForComponentIssues(components, ignoreIssues) {
-    if (ignoreIssues === '*') {
-      // ignore all issues
-      return;
-    }
-    const issuesToIgnoreFromFlag = ignoreIssues?.split(',').map(issue => issue.trim()) || [];
-    const issuesToIgnoreFromConfig = this.issues.getIssuesToIgnoreGlobally();
-    const issuesToIgnore = [...issuesToIgnoreFromFlag, ...issuesToIgnoreFromConfig];
-    await this.issues.triggerAddComponentIssues(components, issuesToIgnore);
-    this.issues.removeIgnoredIssuesFromComponents(components, issuesToIgnore);
-    const legacyComponents = components.map(c => c.state._consumer);
-    const componentsWithBlockingIssues = legacyComponents.filter(component => component.issues?.shouldBlockTagging());
-    if (componentsWithBlockingIssues.length) {
-      throw new (_componentsHaveIssues().ComponentsHaveIssues)(componentsWithBlockingIssues);
-    }
-    const workspaceIssues = this.workspace.getWorkspaceIssues();
-    if (workspaceIssues.length) {
-      const issuesStr = workspaceIssues.map(issueErr => issueErr.message).join('\n');
-      throw new (_bitError().BitError)(`the workspace has the following issues:\n${issuesStr}`);
-    }
+    return this.workspace.getMany(idsWithoutVersions);
   }
   throwForPendingImport(components) {
     const componentsMissingFromScope = components.filter(c => !c.componentFromModel && this.scope.isExported(c.id)).map(c => c.id.toString());
@@ -1341,9 +1328,9 @@ another option, in case this dependency is not in main yet is to remove all refe
       warnings
     };
   }
-  static async provider([workspace, cli, loggerMain, issues, insights, dependencyResolver, scope, exporter, builder, importer, globalConfig, deps]) {
+  static async provider([workspace, cli, loggerMain, issues, insights, dependencyResolver, scope, exporter, builder, importer, globalConfig, deps, application]) {
     const logger = loggerMain.createLogger(_snapping().SnappingAspect.id);
-    const snapping = new SnappingMain(workspace, logger, issues, insights, dependencyResolver, scope, exporter, builder, importer, deps);
+    const snapping = new SnappingMain(workspace, logger, issues, insights, dependencyResolver, scope, exporter, builder, importer, deps, application);
     const snapCmd = new (_snapCmd().SnapCmd)(snapping, logger, globalConfig);
     const tagCmd = new (_tagCmd().TagCmd)(snapping, logger, globalConfig);
     const tagFromScopeCmd = new (_tagFromScope().TagFromScopeCmd)(snapping, logger);
@@ -1356,7 +1343,7 @@ another option, in case this dependency is not in main yet is to remove all refe
 }
 exports.SnappingMain = SnappingMain;
 _defineProperty(SnappingMain, "slots", []);
-_defineProperty(SnappingMain, "dependencies", [_workspace().WorkspaceAspect, _cli().CLIAspect, _logger().LoggerAspect, _issues().IssuesAspect, _insights().InsightsAspect, _dependencyResolver().DependencyResolverAspect, _scope().ScopeAspect, _export().ExportAspect, _builder().BuilderAspect, _importer().ImporterAspect, _globalConfig().GlobalConfigAspect, _dependencies().DependenciesAspect]);
+_defineProperty(SnappingMain, "dependencies", [_workspace().WorkspaceAspect, _cli().CLIAspect, _logger().LoggerAspect, _issues().IssuesAspect, _insights().InsightsAspect, _dependencyResolver().DependencyResolverAspect, _scope().ScopeAspect, _export().ExportAspect, _builder().BuilderAspect, _importer().ImporterAspect, _globalConfig().GlobalConfigAspect, _dependencies().DependenciesAspect, _application().ApplicationAspect]);
 _defineProperty(SnappingMain, "runtime", _cli().MainRuntime);
 _snapping().SnappingAspect.addRuntime(SnappingMain);
 var _default = exports.default = SnappingMain;