@teambit/workspace 1.0.660 → 1.0.662

package/dist/{preview-1753371029341.js → preview-1753450414416.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.workspace_workspace@1.0.660/dist/workspace.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.workspace_workspace@1.0.660/dist/workspace.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.workspace_workspace@1.0.662/dist/workspace.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.workspace_workspace@1.0.662/dist/workspace.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/dist/ui/workspace/use-workspace.d.ts

@@ -8,21 +8,20 @@ type UseWorkspaceOptions = {
 };
 export declare function useWorkspace(options?: UseWorkspaceOptions): {
     error?: import("@apollo/client").ApolloError | undefined;
-    errors?: ReadonlyArray<import("graphql").GraphQLFormattedError> | undefined;
     loading: boolean;
-    client: import("@apollo/client").ApolloClient<any>;
     variables: import("@apollo/client").OperationVariables | undefined;
-    observable: import("@apollo/client").ObservableQuery<any, import("@apollo/client").OperationVariables>;
-    networkStatus: import("@apollo/client").NetworkStatus;
-    called: boolean;
     startPolling: (pollInterval: number) => void;
     stopPolling: () => void;
-    updateQuery: (mapFn: import("@apollo/client").UpdateQueryMapFn<any, import("@apollo/client").OperationVariables>) => void;
+    updateQuery: <TVars = import("@apollo/client").OperationVariables>(mapFn: (previousQueryResult: any, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, any>, "variables">) => any) => void;
     reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("@apollo/client").OperationVariables, any>> | undefined, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<any>>;
+    client: import("@apollo/client").ApolloClient<any>;
+    observable: import("@apollo/client").ObservableQuery<any, import("@apollo/client").OperationVariables>;
+    networkStatus: import("@apollo/client").NetworkStatus;
+    called: boolean;
     previousData?: any;
     fetchMore: (options: import("@apollo/client").FetchMoreQueryOptions<import("@apollo/client").OperationVariables, any>) => Promise<import("@apollo/client").ApolloQueryResult<any>>;
     refetch: (variables?: Partial<import("@apollo/client").OperationVariables> | undefined) => Promise<import("@apollo/client").ApolloQueryResult<any>>;
     workspace: Workspace | undefined;
-    subscribeToMore: import("@apollo/client").SubscribeToMoreFunction<any, import("@apollo/client").OperationVariables>;
+    subscribeToMore: <TSubscriptionData = any, TSubscriptionVariables = import("@apollo/client").OperationVariables>(options: import("@apollo/client").SubscribeToMoreOptions<any, TSubscriptionVariables, TSubscriptionData>) => () => void;
 };
 export {};

package/dist/workspace.d.ts

@@ -396,6 +396,35 @@ export declare class Workspace implements ComponentFactory {
      * @param ids
      */
     importAndGetMany(ids: Array<ComponentID>, reason?: string, loadOpts?: ComponentLoadOptions, throwOnError?: boolean): Promise<Component[]>;
+    /**
+     * This is happening when the user is running "git pull", which updates ".bitmap" file, but the local scope objects
+     * are not updated yet ("bit import" is not run yet).
+     * Although it might happen on a lane. This is rare. Because using git with bit normally means that locally you don't have
+     * any lane. The CI is the one that creates the lanes.
+     * The following conditions are checked:
+     * 1. we're on main.
+     * 2. git is enabled.
+     * 3. components on .bitmap has tags that are not in the local scope.
+     *
+     * It is designed to be performant. On mac M1 with 337 components, it takes around 100ms.
+     *
+     * @returns array of component IDs that have tags in .bitmap but not in local scope, or empty array if not outdated
+     */
+    private getOutdatedIdsAgainstGit;
+    /**
+     * This is relevant when the user is running "git pull", which updates ".bitmap" file, but the local scope objects
+     * are not updated yet ("bit import" is not run yet). In case it found outdated components, it imports them.
+     *
+     * Important: this is only for main (not lanes) and only when using git and only for tags, not snaps.
+     * see `getOutdatedIdsAgainstGit` for more info.
+     */
+    importObjectsIfOutdatedAgainstBitmap(): Promise<void>;
+    /**
+     * This is pretty much the same as `importer.importCurrentObjects`.
+     * The reason for the duplication is that many aspects can't depend on the `importer` aspect, due to circular dependencies.
+     * The importer aspect is reacher in a way that it shows the results of what was imported by comparing the before and after.
+     */
+    importCurrentObjects(compIds?: ComponentID[]): Promise<void>;
     importCurrentLaneIfMissing(): Promise<Lane | undefined>;
     use(aspectIdStr: string): Promise<string>;
     unuse(aspectIdStr: string): Promise<boolean>;

package/dist/workspace.js

@@ -18,6 +18,13 @@ function _pMapSeries() {
   };
   return data;
 }
+function _pMap() {
+  const data = _interopRequireDefault(require("p-map"));
+  _pMap = function () {
+    return data;
+  };
+  return data;
+}
 function _graph() {
   const data = require("@teambit/graph.cleargraph");
   _graph = function () {
@@ -1279,6 +1286,90 @@ the following envs are used in this workspace: ${(0, _lodash().uniq)(availableEn
     });
     return this.getMany(ids, loadOpts, throwOnError);
   }
+
+  /**
+   * This is happening when the user is running "git pull", which updates ".bitmap" file, but the local scope objects
+   * are not updated yet ("bit import" is not run yet).
+   * Although it might happen on a lane. This is rare. Because using git with bit normally means that locally you don't have
+   * any lane. The CI is the one that creates the lanes.
+   * The following conditions are checked:
+   * 1. we're on main.
+   * 2. git is enabled.
+   * 3. components on .bitmap has tags that are not in the local scope.
+   *
+   * It is designed to be performant. On mac M1 with 337 components, it takes around 100ms.
+   *
+   * @returns array of component IDs that have tags in .bitmap but not in local scope, or empty array if not outdated
+   */
+  async getOutdatedIdsAgainstGit() {
+    if (!this.consumer.isOnMain()) {
+      return [];
+    }
+    if (!(await _fsExtra().default.pathExists(_path().default.join(this.path, '.git')))) {
+      return [];
+    }
+
+    // Collect bitmap components that have tags not in local scope
+    const bitmapIds = this.consumer.bitMap.getAllIdsAvailableOnLane();
+    const outdatedIds = await (0, _pMap().default)(bitmapIds, async bitmapId => {
+      if (!bitmapId.version) return;
+      const modelComponent = await this.scope.legacyScope.getModelComponentIfExist(bitmapId.changeVersion(undefined));
+      if (!modelComponent || !modelComponent.hasTag(bitmapId.version)) {
+        // Component doesn't exist in scope or exists but this tag version is missing
+        return bitmapId;
+      }
+      return null;
+    }, {
+      concurrency: 30
+    });
+    return (0, _lodash().compact)(outdatedIds);
+  }
+
+  /**
+   * This is relevant when the user is running "git pull", which updates ".bitmap" file, but the local scope objects
+   * are not updated yet ("bit import" is not run yet). In case it found outdated components, it imports them.
+   *
+   * Important: this is only for main (not lanes) and only when using git and only for tags, not snaps.
+   * see `getOutdatedIdsAgainstGit` for more info.
+   */
+  async importObjectsIfOutdatedAgainstBitmap() {
+    const outdatedIds = await this.getOutdatedIdsAgainstGit();
+    if (outdatedIds.length) {
+      await this.importCurrentObjects(outdatedIds);
+      this.logger.setStatusLine(`imported ${outdatedIds.length} components that were outdated against bitmap`);
+    }
+  }
+
+  /**
+   * This is pretty much the same as `importer.importCurrentObjects`.
+   * The reason for the duplication is that many aspects can't depend on the `importer` aspect, due to circular dependencies.
+   * The importer aspect is reacher in a way that it shows the results of what was imported by comparing the before and after.
+   */
+  async importCurrentObjects(compIds) {
+    const lane = await this.importCurrentLaneIfMissing();
+    if (lane) {
+      return; // it was all imported in the function above.
+    }
+    const scopeComponentsImporter = _legacy7().ScopeComponentsImporter.getInstance(this.scope.legacyScope);
+    const allIds = compIds || this.consumer.bitMap.getAllBitIdsFromAllLanes();
+    const ids = _componentId().ComponentIdList.fromArray(allIds.filter(id => id.hasScope()));
+    await scopeComponentsImporter.importWithoutDeps(ids.toVersionLatest(), {
+      cache: false,
+      includeVersionHistory: true,
+      fetchHeadIfLocalIsBehind: true,
+      ignoreMissingHead: true,
+      reason: `of their latest on main`
+    });
+    this.logger.setStatusLine(`import ${ids.length} components with their dependencies (if missing)`);
+    await scopeComponentsImporter.importMany({
+      ids,
+      ignoreMissingHead: true,
+      preferDependencyGraph: true,
+      reFetchUnBuiltVersion: true,
+      throwForSeederNotFound: false,
+      reason: 'for getting all dependencies'
+    });
+  }
   async importCurrentLaneIfMissing() {
     const laneId = this.getCurrentLaneId();
     const laneObj = await this.scope.legacyScope.getCurrentLaneObject();