@teambit/workspace 0.0.537 → 0.0.545

package/dist/workspace.js

@@ -75,6 +75,16 @@ function _component() {
   return data;
 }
 
+function _importer() {
+  const data = require("@teambit/importer");
+
+  _importer = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _dependencyResolver() {
   const data = require("@teambit/dependency-resolver");
 
@@ -165,6 +175,16 @@ function _legacyBitId() {
   return data;
 }
 
+function _laneId() {
+  const data = require("@teambit/legacy/dist/lane-id/lane-id");
+
+  _laneId = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _consumer2() {
   const data = require("@teambit/legacy/dist/consumer");
 
@@ -225,16 +245,6 @@ function _extensionData() {
   return data;
 }
 
-function _componentsGraph() {
-  const data = require("@teambit/legacy/dist/scope/graph/components-graph");
-
-  _componentsGraph = function () {
-    return data;
-  };
-
-  return data;
-}
-
 function _utils() {
   const data = require("@teambit/legacy/dist/utils");
 
@@ -365,6 +375,16 @@ function _incorrectEnvAspect() {
   return data;
 }
 
+function _buildGraphFromFs() {
+  const data = require("./build-graph-from-fs");
+
+  _buildGraphFromFs = function () {
+    return data;
+  };
+
+  return data;
+}
+
 const ComponentAdded = 'componentAdded';
 exports.ComponentAdded = ComponentAdded;
 const ComponentChanged = 'componentChanged';
@@ -640,7 +660,7 @@ class Workspace {
   async getLegacyGraph(ids) {
     if (!ids || ids.length < 1) ids = await this.listIds();
     const legacyIds = ids.map(id => id._legacy);
-    const legacyGraph = await (0, _componentsGraph().buildOneGraphForComponents)(legacyIds, this.consumer);
+    const legacyGraph = await this.buildOneGraphForComponents(legacyIds);
     return legacyGraph;
   }
 
@@ -799,6 +819,27 @@ class Workspace {
   getCurrentLaneId() {
     return this.consumer.getCurrentLaneId();
   }
+  /**
+   * if checked out to a lane, return the remote lane id (name+scope). otherwise, return null.
+   */
+
+
+  getCurrentRemoteLaneId() {
+    const currentLane = this.getCurrentLaneId();
+
+    if (currentLane.isDefault()) {
+      return null;
+    }
+
+    const trackData = this.scope.legacyScope.lanes.getRemoteTrackedDataByLocalLane(currentLane.name);
+    const remoteLaneName = trackData === null || trackData === void 0 ? void 0 : trackData.remoteLane;
+
+    if (!remoteLaneName) {
+      return null;
+    }
+
+    return _laneId().RemoteLaneId.from(remoteLaneName, trackData.remoteScope);
+  }
 
   getDefaultExtensions() {
     if (!this.config.extensions) {
@@ -875,7 +916,9 @@ class Workspace {
 
 
   async importAndGetMany(ids, forCapsule = false) {
-    await this.scope.import(ids);
+    await this.scope.import(ids, {
+      reFetchUnBuiltVersion: shouldReFetchUnBuiltVersion()
+    });
     return this.componentLoader.getMany(ids, forCapsule);
   }
   /**
@@ -1192,7 +1235,7 @@ class Workspace {
     return componentConfigFile;
   }
 
-  async getGraphWithoutCore(components) {
+  async getAspectsGraphWithoutCore(components, isAspect) {
     const ids = components.map(component => component.id._legacy);
     const coreAspectsStringIds = this.aspectLoader.getCoreAspectIds();
     const coreAspectsComponentIds = coreAspectsStringIds.map(id => _legacyBitId().BitId.parse(id, true));
@@ -1216,7 +1259,7 @@ class Workspace {
 
 
     const ignoredIds = coreAspectsBitIds.concat([]);
-    return (0, _componentsGraph().buildOneGraphForComponents)(ids, this.consumer, undefined, _bitId().BitIds.fromArray(ignoredIds));
+    return this.buildOneGraphForComponents(ids, _bitId().BitIds.fromArray(ignoredIds), isAspect);
   }
   /**
    * load aspects from the workspace and if not exists in the workspace, load from the scope.
@@ -1232,15 +1275,12 @@ class Workspace {
     const idsWithoutCore = (0, _lodash().difference)(notLoadedIds, coreAspectsStringIds);
     const componentIds = await this.resolveMultipleComponentIds(idsWithoutCore);
     const components = await this.importAndGetAspects(componentIds);
-    const graph = await this.getGraphWithoutCore(components);
-    const allIdsP = graph.nodes().map(async id => {
-      return this.resolveComponentId(id);
-    });
-    const allIds = await Promise.all(allIdsP);
-    const allComponents = await this.getMany(allIds);
-    const aspects = allComponents.filter(component => {
+
+    const isAspect = async bitId => {
       var _component$config$ext;
 
+      const id = await this.resolveComponentId(bitId);
+      const component = await this.get(id);
       let data = (_component$config$ext = component.config.extensions.findExtension(_envs().EnvsAspect.id)) === null || _component$config$ext === void 0 ? void 0 : _component$config$ext.data;
 
       if (!data) {
@@ -1264,14 +1304,16 @@ class Workspace {
       }
 
       return data.type === 'aspect';
-    }); // no need to filter core aspects as they are not included in the graph
-    // here we are trying to load extensions from the workspace.
+    };
 
+    const graph = await this.getAspectsGraphWithoutCore(components, isAspect);
+    const idsStr = graph.nodes();
+    const compIds = await this.resolveMultipleComponentIds(idsStr);
+    const aspects = await this.getMany(compIds);
     const {
       workspaceComps,
       scopeComps
-    } = await this.groupComponentsByWorkspaceAndScope(aspects); // load the scope first because we might need it for custom envs that extend external aspects
-
+    } = await this.groupComponentsByWorkspaceAndScope(aspects);
     const scopeIds = scopeComps.map(aspect => aspect.id.toString());
     const workspaceAspects = await this.requireComponents(workspaceComps);
     const workspaceManifests = await this.aspectLoader.getManifestsFromRequireableExtensions(workspaceAspects, throwOnError);
@@ -1280,6 +1322,17 @@ class Workspace {
     const allManifests = [...scopeManifests, ...workspaceManifests];
     await this.aspectLoader.loadExtensionsByManifests(allManifests, throwOnError);
   }
+  /**
+   * Note - this gets called from Harmony only.
+   * returns one graph that includes all dependencies types. each edge has a label of the dependency
+   * type. the nodes content is the Component object.
+   */
+
+
+  async buildOneGraphForComponents(ids, ignoreIds, shouldIgnoreFunc) {
+    const graphFromFsBuilder = new (_buildGraphFromFs().GraphFromFsBuilder)(this, this.logger, ignoreIds, shouldIgnoreFunc);
+    return graphFromFsBuilder.buildGraph(ids);
+  }
 
   async resolveAspects(runtimeName, componentIds) {
     let missingPaths = false;
@@ -1541,6 +1594,10 @@ class Workspace {
   }
 
   async link(options) {
+    if (options !== null && options !== void 0 && options.fetchObject) {
+      await this.importObjects();
+    }
+
     const compDirMap = await this.getComponentsDirectory([]);
     const mergedRootPolicy = this.dependencyResolver.getWorkspacePolicy();
     const linker = this.dependencyResolver.getLinker({
@@ -1615,9 +1672,10 @@ your workspace.jsonc has this component-id set. you might want to remove/change
       importDependenciesDirectly: false,
       importDependents: false
     };
+    const importer = new (_importer().Importer)(this, this.dependencyResolver);
 
     try {
-      const res = await (0, _consumer().importAction)(importOptions, []);
+      const res = await importer.import(importOptions, []);
       return res;
     } catch (err) {
       // TODO: this is a hack since the legacy throw an error, we should provide a way to not throw this error from the legacy
@@ -1803,8 +1861,23 @@ your workspace.jsonc has this component-id set. you might want to remove/change
   }
 
 }
+/**
+ * this is a super hacky way to do it. problem is that loadAspect is running as onStart hook, where we don't
+ * have the CLI fully loaded yet, so we can't get the command from the CLI aspect, we have to retrieve it from
+ * process.argv.
+ * in general, we don't want every command to try again and again fetching un-built versions. otherwise, every time
+ * Bit loads (even bit --help), it'll fetch them and slow down everything.
+ * instead, long-running commands and those that need the artifacts from the Version objects, should try to re-fetch.
+ */
+
 
 exports.Workspace = Workspace;
+
+function shouldReFetchUnBuiltVersion() {
+  const commandsToReFetch = ['build', 'show', 'start', 'tag', 'install', 'link', 'import'];
+  return commandsToReFetch.includes(process.argv[2]);
+}
+
 var _default = Workspace;
 exports.default = _default;