@teambit/scope 0.0.843 → 0.0.846

package/dist/exceptions/index.d.ts

@@ -1 +1,2 @@
 export { ComponentNotFound } from './component-not-found';
+export { NoIdMatchPattern } from './no-id-match-pattern';

package/dist/exceptions/index.js

@@ -9,6 +9,12 @@ Object.defineProperty(exports, "ComponentNotFound", {
     return _componentNotFound().ComponentNotFound;
   }
 });
+Object.defineProperty(exports, "NoIdMatchPattern", {
+  enumerable: true,
+  get: function () {
+    return _noIdMatchPattern().NoIdMatchPattern;
+  }
+});
 
 function _componentNotFound() {
   const data = require("./component-not-found");
@@ -20,4 +26,14 @@ function _componentNotFound() {
   return data;
 }
 
+function _noIdMatchPattern() {
+  const data = require("./no-id-match-pattern");
+
+  _noIdMatchPattern = function () {
+    return data;
+  };
+
+  return data;
+}
+
 //# sourceMappingURL=index.js.map

package/dist/exceptions/index.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export { ComponentNotFound } from './component-not-found';\n"],"mappings":";;;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA"}
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export { ComponentNotFound } from './component-not-found';\nexport { NoIdMatchPattern } from './no-id-match-pattern';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA"}

package/dist/exceptions/no-id-match-pattern.d.ts

@@ -0,0 +1,4 @@
+import { BitError } from '@teambit/bit-error';
+export declare class NoIdMatchPattern extends BitError {
+    constructor(pattern: string);
+}

package/dist/exceptions/no-id-match-pattern.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NoIdMatchPattern = void 0;
+
+function _bitError() {
+  const data = require("@teambit/bit-error");
+
+  _bitError = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class NoIdMatchPattern extends _bitError().BitError {
+  constructor(pattern) {
+    super(`unable to find any matching for "${pattern}" pattern`);
+  }
+
+}
+
+exports.NoIdMatchPattern = NoIdMatchPattern;
+
+//# sourceMappingURL=no-id-match-pattern.js.map

package/dist/exceptions/no-id-match-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NoIdMatchPattern","BitError","constructor","pattern"],"sources":["no-id-match-pattern.ts"],"sourcesContent":["import { BitError } from '@teambit/bit-error';\n\nexport class NoIdMatchPattern extends BitError {\n  constructor(pattern: string) {\n    super(`unable to find any matching for \"${pattern}\" pattern`);\n  }\n}\n"],"mappings":";;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,gBAAN,SAA+BC,oBAA/B,CAAwC;EAC7CC,WAAW,CAACC,OAAD,EAAkB;IAC3B,MAAO,oCAAmCA,OAAQ,WAAlD;EACD;;AAH4C"}

package/dist/get-scope-options.d.ts

@@ -5,4 +5,6 @@ export declare type GetScopeOptions = {
         scope: ScopeModel | undefined;
     };
     Corner?: ComponentType;
+    paneClassName?: string;
+    TargetScopeOverview?: ComponentType;
 };

package/dist/get-scope-options.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["get-scope-options.ts"],"sourcesContent":["import { ComponentType } from 'react';\nimport { ScopeModel } from '.';\n\nexport type GetScopeOptions = {\n  useScope?: () => { scope: ScopeModel | undefined };\n  Corner?: ComponentType;\n};\n"],"mappings":""}
+{"version":3,"names":[],"sources":["get-scope-options.ts"],"sourcesContent":["import { ComponentType } from 'react';\nimport { ScopeModel } from '.';\n\nexport type GetScopeOptions = {\n  useScope?: () => { scope: ScopeModel | undefined };\n  Corner?: ComponentType;\n  paneClassName?: string;\n  TargetScopeOverview?: ComponentType\n};\n"],"mappings":""}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { ScopeAspect } from './scope.aspect';
-export { ComponentNotFound } from './exceptions';
+export { ComponentNotFound, NoIdMatchPattern } from './exceptions';
 export { ScopeComponentCard } from './ui/scope-overview/scope-overview';
 export type { ScopeMain, OnTag, OnTagResults } from './scope.main.runtime';
 export type { ScopeModel } from '@teambit/scope.models.scope-model';

package/dist/index.js

@@ -9,6 +9,12 @@ Object.defineProperty(exports, "ComponentNotFound", {
     return _exceptions().ComponentNotFound;
   }
 });
+Object.defineProperty(exports, "NoIdMatchPattern", {
+  enumerable: true,
+  get: function () {
+    return _exceptions().NoIdMatchPattern;
+  }
+});
 Object.defineProperty(exports, "ScopeAspect", {
   enumerable: true,
   get: function () {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["ScopeAspect"],"sources":["index.ts"],"sourcesContent":["import { ScopeAspect } from './scope.aspect';\n\nexport { ComponentNotFound } from './exceptions';\nexport { ScopeComponentCard } from './ui/scope-overview/scope-overview';\nexport type { ScopeMain, OnTag, OnTagResults } from './scope.main.runtime';\nexport type { ScopeModel } from '@teambit/scope.models.scope-model';\nexport { ScopeContext } from '@teambit/scope.ui.hooks.scope-context';\nexport type { ScopeUI, ScopeBadgeSlot, ScopeOverview, ScopeOverviewSlot, OverviewLineSlot } from './scope.ui.runtime';\nexport { ScopeAspect };\nexport default ScopeAspect;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;eAGeA,oB"}
+{"version":3,"names":["ScopeAspect"],"sources":["index.ts"],"sourcesContent":["import { ScopeAspect } from './scope.aspect';\n\nexport { ComponentNotFound, NoIdMatchPattern } from './exceptions';\nexport { ScopeComponentCard } from './ui/scope-overview/scope-overview';\nexport type { ScopeMain, OnTag, OnTagResults } from './scope.main.runtime';\nexport type { ScopeModel } from '@teambit/scope.models.scope-model';\nexport { ScopeContext } from '@teambit/scope.ui.hooks.scope-context';\nexport type { ScopeUI, ScopeBadgeSlot, ScopeOverview, ScopeOverviewSlot, OverviewLineSlot } from './scope.ui.runtime';\nexport { ScopeAspect };\nexport default ScopeAspect;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;eAGeA,oB"}

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

@@ -173,13 +173,16 @@ export declare class ScopeMain implements ComponentFactory {
      * @param ids
      */
     groupAspectIdsByEnvOfTheList(ids: string[]): Promise<{
-        envs: string[];
-        other: string[];
+        envs?: string[];
+        other?: string[];
     }>;
     private getManifestsAndLoadAspects;
     getManifestsGraphRecursively(ids: string[], visited?: string[], throwOnError?: boolean, opts?: {
         packageManagerConfigRootDir?: string;
-    }): Promise<ManifestOrAspect[]>;
+    }): Promise<{
+        manifests: ManifestOrAspect[];
+        potentialPluginsIds: string[];
+    }>;
     private getNonLoadedAspects;
     private resolveLocalAspects;
     getResolvedAspects(components: Component[], opts?: {

package/dist/scope.main.runtime.js

@@ -453,6 +453,16 @@ function _stagedConfig() {
   return data;
 }
 
+function _noIdMatchPattern() {
+  const data = require("./exceptions/no-id-match-pattern");
+
+  _noIdMatchPattern = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2().default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
@@ -741,12 +751,20 @@ class ScopeMain {
   }
 
   async loadAspects(ids, throwOnError = false, neededFor) {
-    this.logger.info(`loadAspects, loading ${ids.length} aspects.
+    var _grouped$envs, _grouped$other;
+
+    // generate a random callId to be able to identify the call from the logs
+    const callId = Math.floor(Math.random() * 1000);
+    const loggerPrefix = `[${callId}] loadAspects,`;
+    this.logger.info(`${loggerPrefix} loading ${ids.length} aspects.
 ids: ${ids.join(', ')}
 needed-for: ${neededFor || '<unknown>'}`);
     const grouped = await this.groupAspectIdsByEnvOfTheList(ids);
+    this.logger.info(`${loggerPrefix} getManifestsAndLoadAspects for grouped.envs, total ${((_grouped$envs = grouped.envs) === null || _grouped$envs === void 0 ? void 0 : _grouped$envs.length) || 0}`);
     const envsManifestsIds = await this.getManifestsAndLoadAspects(grouped.envs, throwOnError);
+    this.logger.info(`${loggerPrefix} getManifestsAndLoadAspects for grouped.other, total ${((_grouped$other = grouped.other) === null || _grouped$other === void 0 ? void 0 : _grouped$other.length) || 0}`);
     const otherManifestsIds = await this.getManifestsAndLoadAspects(grouped.other, throwOnError);
+    this.logger.debug(`${loggerPrefix} finish loading aspects`);
     return envsManifestsIds.concat(otherManifestsIds);
   }
   /**
@@ -765,10 +783,18 @@ needed-for: ${neededFor || '<unknown>'}`);
     return grouped;
   }
 
-  async getManifestsAndLoadAspects(ids, throwOnError = false) {
-    const scopeManifests = await this.getManifestsGraphRecursively(ids, [], throwOnError);
+  async getManifestsAndLoadAspects(ids = [], throwOnError = false) {
+    const {
+      manifests: scopeManifests,
+      potentialPluginsIds
+    } = await this.getManifestsGraphRecursively(ids, [], throwOnError);
     await this.aspectLoader.loadExtensionsByManifests(scopeManifests);
-    return (0, _lodash().compact)(scopeManifests.map(manifest => manifest.id));
+    const {
+      manifests: scopePluginsManifests
+    } = await this.getManifestsGraphRecursively(potentialPluginsIds, [], throwOnError);
+    await this.aspectLoader.loadExtensionsByManifests(scopePluginsManifests);
+    const allManifests = scopeManifests.concat(scopePluginsManifests);
+    return (0, _lodash().compact)(allManifests.map(manifest => manifest.id));
   }
 
   async getManifestsGraphRecursively(ids, visited = [], throwOnError = false, opts = {}) {
@@ -777,12 +803,24 @@ needed-for: ${neededFor || '<unknown>'}`);
     const nonVisitedId = ids.filter(id => !visited.includes(id));
 
     if (!nonVisitedId.length) {
-      return [];
+      return {
+        manifests: [],
+        potentialPluginsIds: []
+      };
     }
 
-    const components = await this.getNonLoadedAspects(nonVisitedId);
+    const components = await this.getNonLoadedAspects(nonVisitedId); // Adding all the envs ids to the array to support case when one (or more) of the aspects has custom aspect env
+
+    const customEnvsIds = components.map(component => this.envs.getEnvId(component)).filter(envId => !this.aspectLoader.isCoreEnv(envId)); // In case there is custom env we need to load it right away, otherwise we will fail during the require aspects
+
+    await this.getManifestsAndLoadAspects(customEnvsIds);
     visited.push(...nonVisitedId);
     const manifests = await this.requireAspects(components, throwOnError, opts);
+    const potentialPluginsIds = (0, _lodash().compact)(manifests.map((manifest, index) => {
+      if (this.aspectLoader.isValidAspect(manifest)) return undefined; // return index;
+
+      return components[index].id.toString();
+    }));
     const depsToLoad = [];
     await (0, _pMapSeries().default)(manifests, async manifest => {
       depsToLoad.push(...(manifest.dependencies || [])); // @ts-ignore
@@ -791,10 +829,16 @@ needed-for: ${neededFor || '<unknown>'}`);
         depsToLoad.push(...(runtime.dependencies || []));
       });
       const depIds = depsToLoad.map(d => d.id).filter(id => id);
-      const loaded = await this.getManifestsGraphRecursively(depIds, visited, throwOnError);
+      this.logger.debug(`getManifestsGraphRecursively, id: ${manifest.id || '<unknown>'}, found ${depIds.length}: ${depIds.join(', ')}`);
+      const {
+        manifests: loaded
+      } = await this.getManifestsGraphRecursively(depIds, visited, throwOnError);
       manifests.push(...loaded);
     });
-    return manifests;
+    return {
+      manifests,
+      potentialPluginsIds
+    };
   }
 
   async getNonLoadedAspects(ids) {
@@ -985,7 +1029,8 @@ needed-for: ${neededFor || '<unknown>'}`);
         useNesting: true
       },
       host: this
-    }, this.legacyScope);
+    }, this.legacyScope); // @ts-ignore
+
     const capsules = network.seedersCapsules;
     const aspectDefs = await this.aspectLoader.resolveAspects(components, async component => {
       const capsule = capsules.getCapsule(component.id);
@@ -1323,7 +1368,7 @@ needed-for: ${neededFor || '<unknown>'}`);
     const idsFiltered = ids.filter(id => (0, _multimatch().default)(idsToCheck(id), patterns).length);
 
     if (throwForNoMatch && !idsFiltered.length) {
-      throw new (_bitError().BitError)(`unable to find any matching for "${pattern}" pattern`);
+      throw new (_noIdMatchPattern().NoIdMatchPattern)(pattern);
     }
 
     return idsFiltered;