@atlaskit/eslint-plugin-platform 2.7.1 → 2.8.0

package/dist/esm/rules/import/shared/barrel-parsing.js

@@ -0,0 +1,500 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { dirname } from 'path';
+import * as ts from 'typescript';
+import { isRelativeImport, readFileContent, resolveImportPath } from './file-system';
+import { resolveCrossPackageImport } from './package-resolution';
+import { perfInc, perfTime } from './perf';
+/**
+ * Maximum depth to traverse when looking for source files in barrel exports.
+ * Can be adjusted based on project structure needs.
+ */
+var MAX_BARREL_DEPTH = 10;
+
+/**
+ * Get all named exports from a file.
+ * This extracts what names are exported from a file for star exports.
+ */
+export function getNamedExportsFromFile(_ref) {
+  var filePath = _ref.filePath,
+    fs = _ref.fs;
+  var names = new Set();
+  var content = readFileContent({
+    filePath: filePath,
+    fs: fs
+  });
+  if (!content) {
+    return names;
+  }
+  try {
+    var sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    ts.forEachChild(sourceFile, function (node) {
+      if (ts.isExportDeclaration(node)) {
+        if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+          node.exportClause.elements.forEach(function (e) {
+            return names.add(e.name.text);
+          });
+        }
+      } else if (ts.isExportAssignment(node)) {
+        names.add('default');
+      } else if (ts.isVariableStatement(node)) {
+        if (node.modifiers && node.modifiers.some(function (m) {
+          return m.kind === ts.SyntaxKind.ExportKeyword;
+        })) {
+          node.declarationList.declarations.forEach(function (d) {
+            if (ts.isIdentifier(d.name)) {
+              names.add(d.name.text);
+            }
+          });
+        }
+      } else if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) {
+        if (node.modifiers && node.modifiers.some(function (m) {
+          return m.kind === ts.SyntaxKind.ExportKeyword;
+        })) {
+          if (node.name && ts.isIdentifier(node.name)) {
+            names.add(node.name.text);
+          }
+        }
+      }
+    });
+  } catch (_unused) {
+    // Ignore parsing errors
+  }
+  return names;
+}
+
+/**
+ * Check if an export map represents a barrel file (has re-exports from other files)
+ */
+export function hasReExportsFromOtherFiles(_ref2) {
+  var exportMap = _ref2.exportMap,
+    sourceFilePath = _ref2.sourceFilePath;
+  return Array.from(exportMap.values()).some(function (info) {
+    return info.path !== sourceFilePath;
+  });
+}
+
+/**
+ * Process a named export element with cross-package support and add it to the exports map
+ */
+function processNamedExportElementWithCrossPackage(_ref3) {
+  var element = _ref3.element,
+    resolvedSource = _ref3.resolvedSource,
+    nestedExports = _ref3.nestedExports,
+    isStatementTypeOnly = _ref3.isStatementTypeOnly,
+    exports = _ref3.exports,
+    crossPackageSource = _ref3.crossPackageSource;
+  var localName = element.name.text;
+  var propertyName = element.propertyName ? element.propertyName.text : localName;
+  var isElementTypeOnly = isStatementTypeOnly || element.isTypeOnly;
+  var isDefaultExport = propertyName === 'default';
+  // Track if this export is aliased (exported name differs from source name)
+  var isAliased = element.propertyName !== undefined && localName !== propertyName;
+  if (nestedExports) {
+    var deepSource = nestedExports.get(propertyName);
+    if (deepSource) {
+      var _deepSource$originalN;
+      exports.set(localName, {
+        path: deepSource.path,
+        isTypeOnly: isElementTypeOnly || deepSource.isTypeOnly,
+        isDefaultExport: deepSource.isDefaultExport,
+        // Use deep source's original name if available, otherwise use propertyName if aliased
+        originalName: (_deepSource$originalN = deepSource.originalName) !== null && _deepSource$originalN !== void 0 ? _deepSource$originalN : isAliased ? propertyName : undefined,
+        // Preserve existing crossPackageSource from nested exports, or use the one from this level
+        crossPackageSource: deepSource.crossPackageSource || crossPackageSource
+      });
+    } else {
+      exports.set(localName, {
+        path: resolvedSource,
+        isTypeOnly: isElementTypeOnly,
+        isDefaultExport: isDefaultExport,
+        originalName: isAliased ? propertyName : undefined,
+        crossPackageSource: crossPackageSource
+      });
+    }
+  } else {
+    exports.set(localName, {
+      path: resolvedSource,
+      isTypeOnly: isElementTypeOnly,
+      isDefaultExport: isDefaultExport,
+      originalName: isAliased ? propertyName : undefined,
+      crossPackageSource: crossPackageSource
+    });
+  }
+}
+
+/**
+ * Handle star exports with cross-package support (export * from '...')
+ */
+function processStarExportWithCrossPackage(_ref4) {
+  var resolvedSource = _ref4.resolvedSource,
+    nestedExports = _ref4.nestedExports,
+    exports = _ref4.exports,
+    fs = _ref4.fs,
+    crossPackageSource = _ref4.crossPackageSource;
+  if (nestedExports) {
+    var _iterator = _createForOfIteratorHelper(nestedExports),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 2),
+          name = _step$value[0],
+          info = _step$value[1];
+        if (name !== 'default') {
+          // Preserve existing crossPackageSource from nested exports, or use the one from this level
+          exports.set(name, _objectSpread(_objectSpread({}, info), {}, {
+            crossPackageSource: info.crossPackageSource || crossPackageSource
+          }));
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  } else {
+    var nonBarrelExports = getNamedExportsFromFile({
+      filePath: resolvedSource,
+      fs: fs
+    });
+    var _iterator2 = _createForOfIteratorHelper(nonBarrelExports),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _name = _step2.value;
+        if (_name !== 'default') {
+          exports.set(_name, {
+            path: resolvedSource,
+            isTypeOnly: false,
+            crossPackageSource: crossPackageSource
+          });
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+}
+
+/**
+ * Process export declarations that have module specifiers (export ... from '...')
+ */
+function processExportWithModuleSpecifier(_ref5) {
+  var statement = _ref5.statement,
+    resolveModule = _ref5.resolveModule,
+    depth = _ref5.depth,
+    exports = _ref5.exports,
+    fs = _ref5.fs,
+    workspaceRoot = _ref5.workspaceRoot,
+    visitedPackages = _ref5.visitedPackages;
+  if (!statement.moduleSpecifier || !ts.isStringLiteral(statement.moduleSpecifier)) {
+    return;
+  }
+  var modulePath = statement.moduleSpecifier.text;
+
+  // Try relative resolution first (existing behavior)
+  var resolvedSource = resolveModule(modulePath);
+  var crossPackageSource;
+
+  // If not a relative import, try cross-package resolution
+  if (!resolvedSource && !isRelativeImport(modulePath) && workspaceRoot) {
+    var crossPackageInfo = resolveCrossPackageImport({
+      moduleSpecifier: modulePath,
+      workspaceRoot: workspaceRoot,
+      fs: fs
+    });
+    if (crossPackageInfo) {
+      // Check for circular dependencies
+      if (visitedPackages !== null && visitedPackages !== void 0 && visitedPackages.has(crossPackageInfo.packageName)) {
+        return;
+      }
+      resolvedSource = crossPackageInfo.entryFilePath;
+      crossPackageSource = {
+        packageName: crossPackageInfo.packageName,
+        exportPath: crossPackageInfo.exportPath
+      };
+    }
+  }
+  if (!resolvedSource) {
+    return;
+  }
+  var isStatementTypeOnly = statement.isTypeOnly;
+
+  // For cross-package imports, track visited packages to prevent circular deps
+  var newVisitedPackages = visitedPackages ? new Set(visitedPackages) : new Set();
+  if (crossPackageSource) {
+    newVisitedPackages.add(crossPackageSource.packageName);
+  }
+
+  // Always trace through nested barrels and cross-package exports to find the ultimate source
+  var potentialNestedExports = parseBarrelExports({
+    barrelFilePath: resolvedSource,
+    depth: depth + 1,
+    fs: fs,
+    workspaceRoot: workspaceRoot,
+    visitedPackages: newVisitedPackages
+  });
+  var nestedExports = hasReExportsFromOtherFiles({
+    exportMap: potentialNestedExports,
+    sourceFilePath: resolvedSource
+  }) ? potentialNestedExports : null;
+  if (statement.exportClause) {
+    if (ts.isNamedExports(statement.exportClause)) {
+      var _iterator3 = _createForOfIteratorHelper(statement.exportClause.elements),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var element = _step3.value;
+          processNamedExportElementWithCrossPackage({
+            element: element,
+            resolvedSource: resolvedSource,
+            nestedExports: nestedExports,
+            isStatementTypeOnly: isStatementTypeOnly,
+            exports: exports,
+            crossPackageSource: crossPackageSource
+          });
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    } else if (ts.isNamespaceExport(statement.exportClause)) {
+      var name = statement.exportClause.name.text;
+      exports.set(name, {
+        path: resolvedSource,
+        isTypeOnly: isStatementTypeOnly,
+        crossPackageSource: crossPackageSource
+      });
+    }
+  } else {
+    processStarExportWithCrossPackage({
+      resolvedSource: resolvedSource,
+      nestedExports: nestedExports,
+      exports: exports,
+      fs: fs,
+      crossPackageSource: crossPackageSource
+    });
+  }
+}
+
+/**
+ * Process local export statements (no module specifier)
+ */
+function processLocalExportDeclaration(_ref6) {
+  var statement = _ref6.statement,
+    barrelFilePath = _ref6.barrelFilePath,
+    exports = _ref6.exports;
+  if (!statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+    return;
+  }
+  var isStatementTypeOnly = statement.isTypeOnly;
+  var _iterator4 = _createForOfIteratorHelper(statement.exportClause.elements),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var element = _step4.value;
+      var isElementTypeOnly = isStatementTypeOnly || element.isTypeOnly;
+      exports.set(element.name.text, {
+        path: barrelFilePath,
+        isTypeOnly: isElementTypeOnly
+      });
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+}
+
+/**
+ * Process various declaration statements with export modifiers
+ */
+function processExportedDeclaration(_ref7) {
+  var statement = _ref7.statement,
+    barrelFilePath = _ref7.barrelFilePath,
+    exports = _ref7.exports;
+  if (ts.isExportAssignment(statement)) {
+    exports.set('default', {
+      path: barrelFilePath,
+      isTypeOnly: false
+    });
+    return;
+  }
+  var hasExportModifier = 'modifiers' in statement && Array.isArray(statement.modifiers) && statement.modifiers.some(function (m) {
+    return m.kind === ts.SyntaxKind.ExportKeyword;
+  });
+  if (!hasExportModifier) {
+    return;
+  }
+  if (ts.isVariableStatement(statement)) {
+    var _iterator5 = _createForOfIteratorHelper(statement.declarationList.declarations),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var decl = _step5.value;
+        if (ts.isIdentifier(decl.name)) {
+          exports.set(decl.name.text, {
+            path: barrelFilePath,
+            isTypeOnly: false
+          });
+        }
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+  } else if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) {
+    if (statement.name && ts.isIdentifier(statement.name)) {
+      exports.set(statement.name.text, {
+        path: barrelFilePath,
+        isTypeOnly: false
+      });
+    }
+  } else if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
+    if (statement.name && ts.isIdentifier(statement.name)) {
+      exports.set(statement.name.text, {
+        path: barrelFilePath,
+        isTypeOnly: true
+      });
+    }
+  } else if (ts.isEnumDeclaration(statement)) {
+    if (statement.name && ts.isIdentifier(statement.name)) {
+      exports.set(statement.name.text, {
+        path: barrelFilePath,
+        isTypeOnly: false
+      });
+    }
+  }
+}
+
+/**
+ * Parse export statements from a file to find where each export comes from.
+ * Returns a map of export name -> ExportInfo.
+ *
+ * This function recursively traces through nested barrels and cross-package re-exports
+ * to find the ultimate source file for each export.
+ */
+export function parseBarrelExports(_ref8) {
+  var barrelFilePath = _ref8.barrelFilePath,
+    _ref8$depth = _ref8.depth,
+    depth = _ref8$depth === void 0 ? 0 : _ref8$depth,
+    fs = _ref8.fs,
+    workspaceRoot = _ref8.workspaceRoot,
+    visitedPackages = _ref8.visitedPackages;
+  perfInc({
+    fs: fs,
+    key: 'parseBarrelExports.calls'
+  });
+  return perfTime({
+    fs: fs,
+    key: 'parseBarrelExports.totalMs',
+    fn: function fn() {
+      if (depth > MAX_BARREL_DEPTH) {
+        return new Map();
+      }
+      if (!fs.cache.barrelExportsByPath) {
+        fs.cache.barrelExportsByPath = new Map();
+      }
+      var currentMtimeMs = 0;
+      try {
+        var _fs$statSync$mtimeMs;
+        currentMtimeMs = (_fs$statSync$mtimeMs = fs.statSync(barrelFilePath).mtimeMs) !== null && _fs$statSync$mtimeMs !== void 0 ? _fs$statSync$mtimeMs : 0;
+      } catch (_unused2) {
+        currentMtimeMs = 0;
+      }
+      var cached = fs.cache.barrelExportsByPath.get(barrelFilePath);
+      if (cached && cached.mtimeMs === currentMtimeMs) {
+        perfInc({
+          fs: fs,
+          key: 'parseBarrelExports.cacheHit'
+        });
+        return cached.exports;
+      }
+      perfInc({
+        fs: fs,
+        key: 'parseBarrelExports.cacheMiss'
+      });
+      var exports = new Map();
+      var content = readFileContent({
+        filePath: barrelFilePath,
+        fs: fs
+      });
+      if (!content) {
+        return exports;
+      }
+      var sourceFile;
+      try {
+        sourceFile = perfTime({
+          fs: fs,
+          key: 'parseBarrelExports.tsCreateSourceFileMs',
+          fn: function fn() {
+            return ts.createSourceFile(barrelFilePath, content, ts.ScriptTarget.Latest, true);
+          }
+        });
+      } catch (_unused3) {
+        return exports;
+      }
+      var barrelDir = dirname(barrelFilePath);
+      var resolveModule = function resolveModule(moduleSpecifier) {
+        if (!isRelativeImport(moduleSpecifier)) {
+          return null;
+        }
+        return resolveImportPath({
+          basedir: barrelDir,
+          importPath: moduleSpecifier,
+          fs: fs
+        });
+      };
+      var _iterator6 = _createForOfIteratorHelper(sourceFile.statements),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var statement = _step6.value;
+          if (ts.isExportDeclaration(statement)) {
+            if (statement.moduleSpecifier) {
+              processExportWithModuleSpecifier({
+                statement: statement,
+                resolveModule: resolveModule,
+                depth: depth,
+                exports: exports,
+                fs: fs,
+                workspaceRoot: workspaceRoot,
+                visitedPackages: visitedPackages
+              });
+            } else {
+              processLocalExportDeclaration({
+                statement: statement,
+                barrelFilePath: barrelFilePath,
+                exports: exports
+              });
+            }
+          } else {
+            processExportedDeclaration({
+              statement: statement,
+              barrelFilePath: barrelFilePath,
+              exports: exports
+            });
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      fs.cache.barrelExportsByPath.set(barrelFilePath, {
+        mtimeMs: currentMtimeMs,
+        exports: exports
+      });
+      return exports;
+    }
+  });
+}

package/dist/esm/rules/import/shared/file-system.js

@@ -0,0 +1,176 @@
+import { dirname, join, resolve } from 'path';
+/**
+ * The default folder paths that barrel import rules apply to.
+ * Only imports from packages within these folders will be checked.
+ * This can be overridden via lint rule options.
+ */
+export var DEFAULT_TARGET_FOLDERS = ['platform/packages/ai-mate', 'platform/packages/search'];
+
+/**
+ * Try to read file contents with error handling.
+ * Returns null if file cannot be read.
+ */
+export function readFileContent(_ref) {
+  var filePath = _ref.filePath,
+    fs = _ref.fs;
+  if (!fs.cache.fileContentByPath) {
+    fs.cache.fileContentByPath = new Map();
+  }
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    var currentMtimeMs = null;
+    try {
+      var _fs$statSync$mtimeMs;
+      currentMtimeMs = (_fs$statSync$mtimeMs = fs.statSync(filePath).mtimeMs) !== null && _fs$statSync$mtimeMs !== void 0 ? _fs$statSync$mtimeMs : null;
+    } catch (_unused) {
+      // If stat fails, use null to force a re-read (don't use cached value)
+      currentMtimeMs = null;
+    }
+    var cached = fs.cache.fileContentByPath.get(filePath);
+    // Only use cache if we have a valid mtime and it matches
+    if (cached && currentMtimeMs !== null && cached.mtimeMs === currentMtimeMs) {
+      return cached.content;
+    }
+    var content = fs.readFileSync(filePath, 'utf-8');
+    fs.cache.fileContentByPath.set(filePath, {
+      mtimeMs: currentMtimeMs,
+      content: content
+    });
+    return content;
+  } catch (_unused2) {
+    // Silently fail if file cannot be read
+  }
+  return null;
+}
+
+/**
+ * Check if a path is a relative import (starts with ./ or ../)
+ */
+export function isRelativeImport(importPath) {
+  return importPath.startsWith('./') || importPath.startsWith('../');
+}
+
+/**
+ * Resolve the actual file path from an import path.
+ * Handles extension inference and index file resolution.
+ */
+export function resolveImportPath(_ref2) {
+  var basedir = _ref2.basedir,
+    importPath = _ref2.importPath,
+    fs = _ref2.fs;
+  if (!fs.cache.resolvedImportPathByKey) {
+    fs.cache.resolvedImportPathByKey = new Map();
+  }
+  var cacheKey = "".concat(basedir, "::").concat(importPath);
+  if (fs.cache.resolvedImportPathByKey.has(cacheKey)) {
+    var _fs$cache$resolvedImp;
+    return (_fs$cache$resolvedImp = fs.cache.resolvedImportPathByKey.get(cacheKey)) !== null && _fs$cache$resolvedImp !== void 0 ? _fs$cache$resolvedImp : null;
+  }
+  var possibleExtensions = ['.ts', '.tsx', '.js', '.jsx'];
+  var absolutePath = resolve(basedir, importPath);
+
+  // Check exact path first (for explicit extensions)
+  if (fs.existsSync(absolutePath)) {
+    try {
+      var stats = fs.statSync(absolutePath);
+      if (stats.isFile()) {
+        var resolvedPath = fs.realpathSync(absolutePath);
+        fs.cache.resolvedImportPathByKey.set(cacheKey, resolvedPath);
+        return resolvedPath;
+      }
+    } catch (_unused3) {
+      // Ignore errors
+    }
+  }
+
+  // Try with extensions
+  for (var _i = 0, _possibleExtensions = possibleExtensions; _i < _possibleExtensions.length; _i++) {
+    var ext = _possibleExtensions[_i];
+    var pathWithExt = absolutePath + ext;
+    if (fs.existsSync(pathWithExt)) {
+      try {
+        var _resolvedPath = fs.realpathSync(pathWithExt);
+        fs.cache.resolvedImportPathByKey.set(cacheKey, _resolvedPath);
+        return _resolvedPath;
+      } catch (_unused4) {
+        fs.cache.resolvedImportPathByKey.set(cacheKey, pathWithExt);
+        return pathWithExt;
+      }
+    }
+  }
+
+  // Try as directory with index
+  for (var _i2 = 0, _possibleExtensions2 = possibleExtensions; _i2 < _possibleExtensions2.length; _i2++) {
+    var _ext = _possibleExtensions2[_i2];
+    var indexPath = join(absolutePath, "index".concat(_ext));
+    if (fs.existsSync(indexPath)) {
+      try {
+        var _resolvedPath2 = fs.realpathSync(indexPath);
+        fs.cache.resolvedImportPathByKey.set(cacheKey, _resolvedPath2);
+        return _resolvedPath2;
+      } catch (_unused5) {
+        fs.cache.resolvedImportPathByKey.set(cacheKey, indexPath);
+        return indexPath;
+      }
+    }
+  }
+  fs.cache.resolvedImportPathByKey.set(cacheKey, null);
+  return null;
+}
+
+/**
+ * Find the workspace root using git rev-parse --show-toplevel.
+ * The result is cached on fs.cache.gitRepoRoot to avoid repeated shell calls.
+ * Falls back to directory traversal if git command fails.
+ */
+export function findWorkspaceRoot(_ref3) {
+  var startPath = _ref3.startPath,
+    fs = _ref3.fs,
+    _ref3$applyToImportsF = _ref3.applyToImportsFrom,
+    applyToImportsFrom = _ref3$applyToImportsF === void 0 ? DEFAULT_TARGET_FOLDERS : _ref3$applyToImportsF;
+  // Return cached value if available
+  if (fs.cache.gitRepoRoot) {
+    return fs.cache.gitRepoRoot;
+  }
+
+  // Try to get the git repository root
+  var gitRoot = fs.execSync('git rev-parse --show-toplevel', {
+    cwd: startPath
+  });
+  if (gitRoot) {
+    fs.cache.gitRepoRoot = gitRoot;
+    return gitRoot;
+  }
+
+  // Fallback: traverse up looking for workspace markers
+  var current = startPath;
+  var maxDepth = 20;
+  var depth = 0;
+  while (depth < maxDepth) {
+    // Check if we've found the platform folder (which contains the target folders)
+    if (applyToImportsFrom.some(function (folder) {
+      return fs.existsSync(join(current, folder));
+    })) {
+      fs.cache.gitRepoRoot = current;
+      return current;
+    }
+
+    // Check for root-level indicators
+    var hasRootPackageJson = fs.existsSync(join(current, 'package.json'));
+    var hasYarnLock = fs.existsSync(join(current, 'yarn.lock'));
+    if (hasRootPackageJson && hasYarnLock) {
+      fs.cache.gitRepoRoot = current;
+      return current;
+    }
+    var parent = dirname(current);
+    if (parent === current) {
+      // Reached filesystem root
+      return startPath;
+    }
+    current = parent;
+    depth++;
+  }
+  return startPath;
+}