@teambit/workspace 1.0.967 → 1.0.969

package/dist/{preview-1777325174526.js → preview-1777488239091.js}

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

package/dist/types.d.ts

@@ -81,5 +81,22 @@ export interface WorkspaceExtConfig {
      * Example: ["oxlint.config.json", "biome.json", "*.bak"]
      */
     ignoredFiles?: string[];
+    /**
+     * If set to `true`, Bit auto-syncs the local `.bitmap` to the latest scope HEAD versions
+     * whenever the git HEAD has moved since the last sync (sentinel-driven, runs once per
+     * `git pull`). Designed for repos with strict branch-protection rules: combined with
+     * `bit ci merge --no-bitmap-commit`, the CI never commits `.bitmap` to the default
+     * branch — every developer's first Bit command after `git pull` reconciles their
+     * local `.bitmap` with the latest exported scope versions automatically.
+     *
+     * The mechanism is a no-op when:
+     * - the workspace is not inside a git repo,
+     * - the workspace is on a lane (lanes have their own sync flow),
+     * - git HEAD is unchanged since the last successful reconciliation.
+     *
+     * On a failed remote-scope fetch, the command continues with the cached `.bitmap`
+     * state and the sentinel is NOT advanced, so the next command retries.
+     */
+    bitmapAutoSync?: boolean;
 }
 export {};

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["interface VendorConfig {\n  directory: string;\n}\n\nexport interface WorkspaceExtConfig {\n  /**\n   * name of the workspace.\n   */\n  name: string;\n\n  /**\n   * path to icon.\n   */\n  icon: string;\n\n  /**\n   * set the default scope when there is no matching for the component in the components array.\n   */\n  defaultScope: string;\n\n  /**\n   * set the default directory when there is no matching for the component in the components array.\n   */\n  defaultDirectory: string;\n\n  /**\n   * sets the location of the root components directory.\n   * The location is a relative path to the workspace root and should use linux path separators (/).\n   */\n  rootComponentsDirectory?: string;\n\n  /**\n   * set the default structure of components in your project\n   */\n  vendor: VendorConfig;\n\n  /**\n   * All component extensions applied by default on all components in the workspace (except vendor components)\n   */\n  extensions: { [extensionsId: string]: string };\n\n  /**\n   * If set to\n   * `true`, it allows the workspace to resolve scope's aspects from node modules\n   * installed in the workspace's `node_modules` directory. If not set or set to `false`, aspects will only be resolved\n   * from the scope aspects capsule.\n   */\n  resolveAspectsFromNodeModules?: boolean;\n\n  /**\n   * If set to `true`, it allows the workspace to resolve envs from node modules\n   * installed in the workspace's `node_modules` directory.\n   * the envs will be resolved from the node_modules of the env's root (workspace/node_modules/.bit_roots/{envId})\n   * and if not found (usually when the env was hoisted to the root node_modules) then from the node_modules of the\n   * workspace.\n   * If not set or set to `false`, envs will only be resolved from the scope envs capsule.\n   */\n  resolveEnvsFromRoots?: boolean;\n\n  /**\n   * If set to `true`, bit will try to load aspects dependencies automatically.\n   * even if the aspects dependencies are not configured in the workspace.jsonc root config.\n   * for example having the aspect\n   * main aspect\n   * export class MainAspectMain {\n   *  ...\n   *   static dependencies = [MyDepAspect];\n   * }\n   * and the in the workspace.jsonc file:\n   * {\n   *  ...\n   *   main-aspect: {}\n   * }\n   * when set to true, bit will try to load MyDepAspect automatically.\n   */\n  autoLoadAspectsDeps?: boolean;\n\n  /**\n   * If set to `true`, enables external package manager mode. When enabled:\n   * - `bit install` will not install dependencies and will prompt the user to use their package manager.\n   * - Other commands that trigger installation (e.g., `bit import`, `bit checkout`) will skip the installation and print a warning.\n   * When this prop is set by bit to `true`, the following properties are automatically set to `false`:\n   * - `rootComponent`.\n   * - `enableWorkspaceConfigWrite`.\n   */\n  externalPackageManager?: boolean;\n\n  /**\n   * List of file patterns to ignore from all components in the workspace.\n   * Uses gitignore syntax.\n   * Example: [\"oxlint.config.json\", \"biome.json\", \"*.bak\"]\n   */\n  ignoredFiles?: string[];\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["interface VendorConfig {\n  directory: string;\n}\n\nexport interface WorkspaceExtConfig {\n  /**\n   * name of the workspace.\n   */\n  name: string;\n\n  /**\n   * path to icon.\n   */\n  icon: string;\n\n  /**\n   * set the default scope when there is no matching for the component in the components array.\n   */\n  defaultScope: string;\n\n  /**\n   * set the default directory when there is no matching for the component in the components array.\n   */\n  defaultDirectory: string;\n\n  /**\n   * sets the location of the root components directory.\n   * The location is a relative path to the workspace root and should use linux path separators (/).\n   */\n  rootComponentsDirectory?: string;\n\n  /**\n   * set the default structure of components in your project\n   */\n  vendor: VendorConfig;\n\n  /**\n   * All component extensions applied by default on all components in the workspace (except vendor components)\n   */\n  extensions: { [extensionsId: string]: string };\n\n  /**\n   * If set to\n   * `true`, it allows the workspace to resolve scope's aspects from node modules\n   * installed in the workspace's `node_modules` directory. If not set or set to `false`, aspects will only be resolved\n   * from the scope aspects capsule.\n   */\n  resolveAspectsFromNodeModules?: boolean;\n\n  /**\n   * If set to `true`, it allows the workspace to resolve envs from node modules\n   * installed in the workspace's `node_modules` directory.\n   * the envs will be resolved from the node_modules of the env's root (workspace/node_modules/.bit_roots/{envId})\n   * and if not found (usually when the env was hoisted to the root node_modules) then from the node_modules of the\n   * workspace.\n   * If not set or set to `false`, envs will only be resolved from the scope envs capsule.\n   */\n  resolveEnvsFromRoots?: boolean;\n\n  /**\n   * If set to `true`, bit will try to load aspects dependencies automatically.\n   * even if the aspects dependencies are not configured in the workspace.jsonc root config.\n   * for example having the aspect\n   * main aspect\n   * export class MainAspectMain {\n   *  ...\n   *   static dependencies = [MyDepAspect];\n   * }\n   * and the in the workspace.jsonc file:\n   * {\n   *  ...\n   *   main-aspect: {}\n   * }\n   * when set to true, bit will try to load MyDepAspect automatically.\n   */\n  autoLoadAspectsDeps?: boolean;\n\n  /**\n   * If set to `true`, enables external package manager mode. When enabled:\n   * - `bit install` will not install dependencies and will prompt the user to use their package manager.\n   * - Other commands that trigger installation (e.g., `bit import`, `bit checkout`) will skip the installation and print a warning.\n   * When this prop is set by bit to `true`, the following properties are automatically set to `false`:\n   * - `rootComponent`.\n   * - `enableWorkspaceConfigWrite`.\n   */\n  externalPackageManager?: boolean;\n\n  /**\n   * List of file patterns to ignore from all components in the workspace.\n   * Uses gitignore syntax.\n   * Example: [\"oxlint.config.json\", \"biome.json\", \"*.bak\"]\n   */\n  ignoredFiles?: string[];\n\n  /**\n   * If set to `true`, Bit auto-syncs the local `.bitmap` to the latest scope HEAD versions\n   * whenever the git HEAD has moved since the last sync (sentinel-driven, runs once per\n   * `git pull`). Designed for repos with strict branch-protection rules: combined with\n   * `bit ci merge --no-bitmap-commit`, the CI never commits `.bitmap` to the default\n   * branch — every developer's first Bit command after `git pull` reconciles their\n   * local `.bitmap` with the latest exported scope versions automatically.\n   *\n   * The mechanism is a no-op when:\n   * - the workspace is not inside a git repo,\n   * - the workspace is on a lane (lanes have their own sync flow),\n   * - git HEAD is unchanged since the last successful reconciliation.\n   *\n   * On a failed remote-scope fetch, the command continues with the cached `.bitmap`\n   * state and the sentinel is NOT advanced, so the next command retries.\n   */\n  bitmapAutoSync?: boolean;\n}\n"],"mappings":"","ignoreList":[]}

package/dist/workspace.d.ts

@@ -439,6 +439,23 @@ export declare class Workspace implements ComponentFactory {
      */
     importCurrentObjects(compIds?: ComponentID[]): Promise<void>;
     importCurrentLaneIfMissing(): Promise<Lane | undefined>;
+    /**
+     * When `bitmapAutoSync` is enabled in workspace.jsonc, reconcile `.bitmap` with the
+     * latest scope HEAD versions on the first Bit command after `git pull`. The sentinel
+     * file at `.bit/last-pull-sync` makes subsequent commands at the same git HEAD a no-op.
+     *
+     * On a failed remote-scope fetch the sentinel is NOT advanced, so the next command
+     * retries.
+     */
+    reconcileBitmapWithScopeIfNeeded(): Promise<void>;
+    /**
+     * Resolve the current git HEAD. Tries a direct read of `.git/HEAD` (+ the loose ref
+     * file it points at) for the common case to avoid forking a process. Falls back to
+     * `git rev-parse HEAD` for packed-refs, git worktrees / submodules (where `.git` is
+     * a file pointing at the real gitdir, not a directory), and any other layout. Returns
+     * null when HEAD can't be resolved at all — the caller treats that as "skip auto-sync."
+     */
+    private readCurrentGitHead;
     use(aspectIdStr: string): Promise<string>;
     unuse(aspectIdStr: string): Promise<boolean>;
     write(component: Component, rootPath?: string): Promise<void>;

package/dist/workspace.js

@@ -298,6 +298,27 @@ function _componentStatusLoader() {
   };
   return data;
 }
+function _execa() {
+  const data = _interopRequireDefault(require("execa"));
+  _execa = function () {
+    return data;
+  };
+  return data;
+}
+function _gitModules() {
+  const data = require("@teambit/git.modules.git-executable");
+  _gitModules = function () {
+    return data;
+  };
+  return data;
+}
+function _objects() {
+  const data = require("@teambit/objects");
+  _objects = function () {
+    return data;
+  };
+  return data;
+}
 function _autoTag() {
   const data = require("./auto-tag");
   _autoTag = function () {
@@ -1409,6 +1430,162 @@ the following envs are used in this workspace: ${(0, _lodash().uniq)(availableEn
     });
     return lane;
   }
+
+  /**
+   * When `bitmapAutoSync` is enabled in workspace.jsonc, reconcile `.bitmap` with the
+   * latest scope HEAD versions on the first Bit command after `git pull`. The sentinel
+   * file at `.bit/last-pull-sync` makes subsequent commands at the same git HEAD a no-op.
+   *
+   * On a failed remote-scope fetch the sentinel is NOT advanced, so the next command
+   * retries.
+   */
+  async reconcileBitmapWithScopeIfNeeded() {
+    if (!this.config.bitmapAutoSync) return;
+    if (!this.consumer.isOnMain()) return;
+    if (!(await _fsExtra().default.pathExists(_path().default.join(this.path, '.git')))) return;
+
+    // Read the sentinel before resolving git HEAD — most invocations are cached and
+    // exit cheaply here without forking a git subprocess. ENOENT (no sentinel yet) is
+    // the normal first-run path; any other read error (EACCES, EIO, etc.) indicates
+    // a genuine problem and should surface rather than be silently swallowed — masking
+    // it would put every subsequent command on the slow full-fetch path with no signal.
+    const sentinelPath = _path().default.join(this.path, '.bit', 'last-pull-sync');
+    let sentinelHead;
+    try {
+      sentinelHead = (await _fsExtra().default.readFile(sentinelPath, 'utf-8')).trim();
+    } catch (err) {
+      if (err?.code !== 'ENOENT') throw err;
+    }
+    const currentGitHead = await this.readCurrentGitHead();
+    if (!currentGitHead) return;
+    if (sentinelHead === currentGitHead) return;
+    this.logger.debug(`bitmapAutoSync: git HEAD changed since last sync, reconciling .bitmap with scope`);
+
+    // Resolve every bitmap entry to a "lookup id" that has scope filled in. New
+    // components (added via `bit add` on a feature branch but tagged only by CI) have
+    // an empty `scope` in the bitmap — only `defaultScope` is set. We must resolve
+    // those before the import, because the scope import filters out IDs without scope
+    // and the model lookup below needs scope to find the component.
+    //
+    // Related: `ComponentLoader._handleOutOfSyncScenarios` in
+    // components/legacy/consumer-component/component-loader.ts uses the same primitives
+    // (`getModelComponentIfExist`, `bitMap.updateComponentId`) to fix per-component
+    // out-of-sync states during component loading. It does NOT handle:
+    //   - scope HEAD has advanced past bitmap's version when that version still exists
+    //     in scope (the main case `bitmapAutoSync` is built for),
+    //   - bitmap entries with empty `scope` field (it doesn't fall back to defaultScope),
+    //   - triggering the import itself with `includeUnexported: true` for components
+    //     not yet in local scope.
+    // This reconcile fills those gaps; afterwards `_handleOutOfSyncScenarios` is a
+    // no-op for the same components (bitmap is already aligned with scope).
+    const lookupIds = [];
+    for (const bitmapId of this.consumer.bitMap.getAllIdsAvailableOnLane()) {
+      if (bitmapId.hasScope()) {
+        lookupIds.push(bitmapId);
+        continue;
+      }
+      const componentMap = this.consumer.bitMap.getComponentIfExist(bitmapId);
+      const defaultScope = componentMap?.defaultScope;
+      if (!defaultScope) continue;
+      lookupIds.push(bitmapId.changeScope(defaultScope));
+    }
+
+    // Fetch the latest scope HEADs from remote for all of these. Use the lower-level
+    // scope importer with `includeUnexported: true` — `importCurrentObjects` filters
+    // out IDs that aren't already in the local scope, which would skip brand-new
+    // components introduced by another teammate's PR (they exist on remote but the
+    // current workspace's local scope has never seen them).
+    const scopeComponentsImporter = _legacy7().ScopeComponentsImporter.getInstance(this.scope.legacyScope);
+    const idList = _componentId().ComponentIdList.fromArray(lookupIds);
+    try {
+      await scopeComponentsImporter.importWithoutDeps(idList.toVersionLatest(), {
+        cache: false,
+        includeVersionHistory: true,
+        fetchHeadIfLocalIsBehind: true,
+        ignoreMissingHead: true,
+        includeUnexported: true,
+        reason: 'bitmapAutoSync: latest scope HEAD'
+      });
+      await scopeComponentsImporter.importMany({
+        ids: idList,
+        ignoreMissingHead: true,
+        preferDependencyGraph: true,
+        reFetchUnBuiltVersion: true,
+        throwForSeederNotFound: false,
+        includeUnexported: true,
+        reason: 'bitmapAutoSync: dependencies for sync'
+      });
+    } catch (err) {
+      this.logger.warn(`bitmapAutoSync: failed to fetch latest scope objects: ${err?.message ?? err}. ` + `Continuing with the cached state. The next bit command will re-attempt the sync.`);
+      // Sentinel stays at the previous HEAD so the next command retries the fetch.
+      return;
+    }
+    const updatedIds = (0, _lodash().compact)(await (0, _pMap().default)(lookupIds, async lookupId => {
+      const modelComponent = await this.scope.legacyScope.getModelComponentIfExist(lookupId.changeVersion(undefined));
+      if (!modelComponent) return undefined;
+      let scopeHead;
+      try {
+        scopeHead = modelComponent.getHeadRegardlessOfLaneAsTagOrHash(true);
+      } catch {
+        return undefined;
+      }
+      if (!scopeHead || scopeHead === _objects().VERSION_ZERO) return undefined;
+      if (lookupId.version === scopeHead) return undefined;
+      const newId = lookupId.changeVersion(scopeHead);
+      this.consumer.bitMap.updateComponentId(newId);
+      return newId;
+    }, {
+      concurrency: 30
+    }));
+    if (updatedIds.length > 0) {
+      await this.bitMap.write('bitmapAutoSync: reconciled with scope HEAD');
+      this.logger.console(`bitmapAutoSync: synced ${updatedIds.length} component(s) to scope HEAD`);
+    }
+
+    // Let a sentinel write failure throw — `.bit/` was already written above (bitmap
+    // and scope objects), so a permission failure here means something is genuinely
+    // broken. Catching would silently leave the sentinel stale and force every later
+    // command into the slow full-fetch path with no signal to the user.
+    await _fsExtra().default.outputFile(sentinelPath, currentGitHead);
+  }
+
+  /**
+   * Resolve the current git HEAD. Tries a direct read of `.git/HEAD` (+ the loose ref
+   * file it points at) for the common case to avoid forking a process. Falls back to
+   * `git rev-parse HEAD` for packed-refs, git worktrees / submodules (where `.git` is
+   * a file pointing at the real gitdir, not a directory), and any other layout. Returns
+   * null when HEAD can't be resolved at all — the caller treats that as "skip auto-sync."
+   */
+  async readCurrentGitHead() {
+    const gitPath = _path().default.join(this.path, '.git');
+    let gitIsDir = false;
+    try {
+      gitIsDir = (await _fsExtra().default.stat(gitPath)).isDirectory();
+    } catch {
+      return null;
+    }
+    if (gitIsDir) {
+      try {
+        const headContent = (await _fsExtra().default.readFile(_path().default.join(gitPath, 'HEAD'), 'utf-8')).trim();
+        if (!headContent.startsWith('ref: ')) return headContent; // detached HEAD
+        const refName = headContent.slice('ref: '.length);
+        return (await _fsExtra().default.readFile(_path().default.join(gitPath, refName), 'utf-8')).trim();
+      } catch {
+        // Loose ref missing (likely packed) or some other unusual state. Fall through.
+      }
+    }
+
+    // Fallback: invoke git itself. Handles worktrees (where `.git` is a file with
+    // `gitdir:` indirection), packed-refs, submodules, and any other layout.
+    try {
+      const result = await (0, _execa().default)((0, _gitModules().getGitExecutablePath)(), ['rev-parse', 'HEAD'], {
+        cwd: this.path
+      });
+      return result.stdout.trim();
+    } catch {
+      return null;
+    }
+  }
   async use(aspectIdStr) {
     const workspaceAspectsLoader = this.getWorkspaceAspectsLoader();
     return workspaceAspectsLoader.use(aspectIdStr);