@atlaskit/eslint-plugin-platform 2.8.0 → 2.9.1

package/dist/esm/rules/visit-example-type-import-required/index.js

@@ -0,0 +1,402 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+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 fs from 'fs';
+import path from 'path';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { simpleTraverse } from '@typescript-eslint/typescript-estree';
+export var RULE_NAME = 'visit-example-type-import-required';
+var messages = {
+  missingTypeofImport: 'visitExample must use typeof import(...) generic type parameter. ' + 'Use visitExample<typeof import("path/to/example.tsx")>(groupId, packageId, exampleId).',
+  invalidTypeParameter: 'visitExample generic type parameter must be a typeof import(...) expression.',
+  pathMismatch: 'The import path "{{ importPath }}" does not match the expected example file for ' + 'visitExample({{ groupId }}, {{ packageId }}, {{ exampleId }}). ' + 'Expected import to resolve to: {{ expectedPath }}',
+  noPackageImports: 'Package imports (e.g., @atlaskit/...) are not allowed in visitExample type parameters. Use a relative import path.',
+  typeAliasNotInlined: 'Type aliases for typeof import(...) must be inlined directly into the visitExample call. ' + 'Use visitExample<typeof import("...")>(...) instead of defining a type alias.',
+  suggestFixPath: 'Update import path to match visitExample arguments'
+};
+function isTargetFile(filename) {
+  return filename.endsWith('.spec.tsx') || filename.endsWith('.spec.ts');
+}
+
+/**
+ * Extracts the import path string from a TSTypeQuery node of the form `typeof import('...')`.
+ * Returns null if the node doesn't match that shape.
+ */
+function extractImportPathFromTypeQuery(typeQuery) {
+  // TSTypeQuery { exprName: TSImportType { argument: TSLiteralType { literal: Literal } } }
+  var exprName = typeQuery.exprName;
+  if (exprName.type !== AST_NODE_TYPES.TSImportType) {
+    return null;
+  }
+  var argument = exprName.argument;
+  if (argument.type === AST_NODE_TYPES.TSLiteralType && argument.literal.type === AST_NODE_TYPES.Literal && typeof argument.literal.value === 'string') {
+    return argument.literal.value;
+  }
+  return null;
+}
+/**
+ * Builds a map of all TSTypeAliasDeclaration nodes in the file, keyed by name.
+ * Each entry records whether the alias is at the top level of the program (file-level).
+ */
+function collectTypeAliases(ast) {
+  var result = new Map();
+
+  // Cast through unknown to work around a version mismatch: @typescript-eslint/utils
+  // vendors its own copy of @typescript-eslint/types (v7) while the root node_modules
+  // has a different version (v5). The TSESTree types are structurally identical at
+  // runtime — the cast is safe.
+  simpleTraverse(ast, {
+    enter: function enter(node, parent) {
+      // A type alias is "file-level" if its immediate parent is the Program,
+      // or if it's the declaration of a top-level ExportNamedDeclaration.
+      if (node.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
+        var isFileLevel = (parent === null || parent === void 0 ? void 0 : parent.type) === AST_NODE_TYPES.Program || (parent === null || parent === void 0 ? void 0 : parent.type) === AST_NODE_TYPES.ExportNamedDeclaration;
+        result.set(node.id.name, {
+          node: node,
+          isFileLevel: isFileLevel
+        });
+      }
+    }
+  });
+  return result;
+}
+
+/**
+ * Resolves a top-level `const foo = 'literal'` declaration to its string value.
+ * Returns null for non-const, non-string, or not-found variables.
+ */
+function resolveVariableToConstant(programBody, variableName, cache) {
+  if (cache.has(variableName)) {
+    var _cache$get;
+    return (_cache$get = cache.get(variableName)) !== null && _cache$get !== void 0 ? _cache$get : null;
+  }
+  var _iterator = _createForOfIteratorHelper(programBody),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var node = _step.value;
+      if (node.type !== AST_NODE_TYPES.VariableDeclaration || node.kind !== 'const') {
+        continue;
+      }
+      var _iterator2 = _createForOfIteratorHelper(node.declarations),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _declarator$init;
+          var declarator = _step2.value;
+          if (declarator.id.type === AST_NODE_TYPES.Identifier && declarator.id.name === variableName && ((_declarator$init = declarator.init) === null || _declarator$init === void 0 ? void 0 : _declarator$init.type) === AST_NODE_TYPES.Literal && typeof declarator.init.value === 'string') {
+            cache.set(variableName, declarator.init.value);
+            return declarator.init.value;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  cache.set(variableName, null);
+  return null;
+}
+/**
+ * Extracts the (groupId, packageId, exampleId) string arguments from a visitExample call.
+ * Each argument may be a string literal or a reference to a top-level const string variable.
+ * Returns null for any argument that can't be statically resolved.
+ */
+function extractCallArgs(node, programBody, variableCache) {
+  if (node.arguments.length < 3) {
+    return null;
+  }
+  function resolveArg(arg) {
+    if (arg.type === AST_NODE_TYPES.Literal && typeof arg.value === 'string') {
+      return arg.value;
+    }
+    if (arg.type === AST_NODE_TYPES.Identifier) {
+      return resolveVariableToConstant(programBody, arg.name, variableCache);
+    }
+    return null;
+  }
+  var groupId = resolveArg(node.arguments[0]);
+  var packageId = resolveArg(node.arguments[1]);
+  var exampleId = resolveArg(node.arguments[2]);
+  if (!groupId || !packageId || !exampleId) {
+    return null;
+  }
+  return {
+    groupId: groupId,
+    packageId: packageId,
+    exampleId: exampleId
+  };
+}
+function getPackagesBasePath(testFilePath) {
+  var testFileDir = path.dirname(testFilePath);
+  var testFileSegments = testFileDir.split(path.sep);
+  var packagesIndex = testFileSegments.findIndex(function (seg) {
+    return seg === 'packages';
+  });
+  if (packagesIndex === -1) {
+    return null;
+  }
+  var baseSegments = testFileSegments.slice(0, packagesIndex + 1);
+  var basePath = path.isAbsolute(testFilePath) ? path.resolve.apply(path, ['/'].concat(_toConsumableArray(baseSegments))) : path.resolve.apply(path, [process.cwd()].concat(_toConsumableArray(baseSegments)));
+  return {
+    basePath: basePath,
+    packagesIndex: packagesIndex
+  };
+}
+
+/**
+ * Resolves the expected example file path from visitExample arguments.
+ *
+ * visitExample('groupId', 'packageId', 'exampleId') maps to:
+ *   packages/{groupId}/{packageId}/examples/{exampleId}.tsx
+ *
+ * Example files may also have a numeric sort prefix, e.g.:
+ *   packages/{groupId}/{packageId}/examples/00-{exampleId}.tsx
+ *
+ * We scan the examples directory once and match against all candidates.
+ * Falls back to the bare `{exampleId}.tsx` name when the directory can't
+ * be read (e.g. in unit-test environments where the files don't exist).
+ */
+function resolveExamplePathFromArgs(groupId, packageId, exampleId, testFilePath) {
+  var packagesBase = getPackagesBasePath(testFilePath);
+  if (!packagesBase) {
+    return null;
+  }
+  var examplesDir = path.resolve(packagesBase.basePath, groupId, packageId, 'examples');
+  var fallback = path.resolve(examplesDir, "".concat(exampleId, ".tsx"));
+
+  // Match: exact name OR numeric-prefixed variant, with optional `.examples` infix
+  var candidateRe = new RegExp("^(?:\\d+-)?".concat(exampleId, "(?:\\.examples?)?\\.tsx$"));
+  try {
+    var match = fs.readdirSync(examplesDir).find(function (f) {
+      return candidateRe.test(f);
+    });
+    if (match) {
+      return path.resolve(examplesDir, match);
+    }
+  } catch (_unused) {
+    // Directory doesn't exist or can't be read (e.g. in test environments)
+  }
+  return fallback;
+}
+
+/**
+ * Computes a relative import path from one file to another
+ */
+function computeRelativeImportPath(fromFile, toFile) {
+  var fromDir = path.dirname(fromFile);
+  var relativePath = path.relative(fromDir, toFile);
+  // Normalize to forward slashes for import statements (standard in JavaScript/TypeScript)
+  relativePath = relativePath.replace(/\\/g, '/');
+  // Ensure relative imports start with ./ or ../
+  if (!relativePath.startsWith('.') && !relativePath.startsWith('/')) {
+    relativePath = "./".concat(relativePath);
+  }
+  return relativePath;
+}
+/**
+ * Extracts the generic type argument from a `visitExample<...>(...)` call expression
+ * using the AST directly (no regex on source text).
+ *
+ * Returns:
+ *   { type: 'inline', importPath } — for `visitExample<typeof import('...')>(...)`
+ *   { type: 'alias', name }        — for `visitExample<SomeTypeAlias>(...)`
+ *   null                           — if no generic type parameter is present
+ */
+function extractGenericType(node) {
+  var _params, _ref, _node$typeArguments;
+  // `typeArguments` is the current property name; `typeParameters` is the deprecated alias.
+  // We fall back to `typeParameters` for compatibility with older parser versions.
+  var params = (_params = (_ref = (_node$typeArguments = node.typeArguments) !== null && _node$typeArguments !== void 0 ? _node$typeArguments : node.typeParameters) === null || _ref === void 0 ? void 0 : _ref.params) !== null && _params !== void 0 ? _params : [];
+  if (params.length === 0) {
+    return null;
+  }
+  var _params2 = _slicedToArray(params, 1),
+    typeParam = _params2[0];
+
+  // `typeof import('...')` → TSTypeQuery { exprName: TSImportType { ... } }
+  if (typeParam.type === AST_NODE_TYPES.TSTypeQuery) {
+    var importPath = extractImportPathFromTypeQuery(typeParam);
+    if (importPath !== null) {
+      return {
+        type: 'inline',
+        importPath: importPath
+      };
+    }
+  }
+
+  // `SomeTypeAlias` → TSTypeReference { typeName: Identifier { name } }
+  if (typeParam.type === AST_NODE_TYPES.TSTypeReference && typeParam.typeName.type === AST_NODE_TYPES.Identifier) {
+    return {
+      type: 'alias',
+      name: typeParam.typeName.name
+    };
+  }
+  return null;
+}
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Ensures that visitExample uses a typeof import(...) generic and that the import path matches the example file resolved from the call arguments.'
+    },
+    fixable: 'code',
+    messages: messages,
+    schema: []
+  },
+  create: function create(context) {
+    var filename = context.filename;
+    var ast = context.sourceCode.ast;
+    var programBody = ast.body;
+
+    // Build the type alias map once per file (lazily on first visitExample call)
+    var typeAliases = null;
+    function getTypeAliases() {
+      if (!typeAliases) {
+        typeAliases = collectTypeAliases(ast);
+      }
+      return typeAliases;
+    }
+    var variableCache = new Map();
+    return {
+      CallExpression: function CallExpression(estreeNode) {
+        if (!isTargetFile(filename)) {
+          return;
+        }
+        var node = estreeNode;
+        // Only handle `<anything>.visitExample(...)` calls
+        if (node.callee.type !== AST_NODE_TYPES.MemberExpression || node.callee.property.type !== AST_NODE_TYPES.Identifier || node.callee.property.name !== 'visitExample') {
+          return;
+        }
+
+        // Narrow callee — we've confirmed property is an Identifier above
+        var callee = node.callee;
+        // reportCallee is typed as estree.Node for context.report compatibility
+        var reportCallee = estreeNode.callee;
+        var genericType = extractGenericType(node);
+
+        // ── Case 1: No generic type parameter ────────────────────────────────
+        if (genericType === null) {
+          var _args = extractCallArgs(node, programBody, variableCache);
+          context.report({
+            node: reportCallee,
+            messageId: 'missingTypeofImport',
+            fix: function fix(fixer) {
+              if (!_args) {
+                return null;
+              }
+              var examplePath = resolveExamplePathFromArgs(_args.groupId, _args.packageId, _args.exampleId, filename);
+              if (!examplePath) {
+                return null;
+              }
+              var importPath = computeRelativeImportPath(filename, examplePath);
+              var _ref2 = callee.property.range,
+                _ref3 = _slicedToArray(_ref2, 2),
+                start = _ref3[0],
+                end = _ref3[1];
+              return fixer.insertTextAfterRange([start, end], "<typeof import('".concat(importPath, "')>"));
+            }
+          });
+          return;
+        }
+
+        // ── Case 2: Generic is a type alias reference (`visitExample<Foo>`) ──
+        var importPath;
+        if (genericType.type === 'alias') {
+          var found = getTypeAliases().get(genericType.name);
+          if (!found) {
+            // Unknown type alias — not a typeof import
+            context.report({
+              node: reportCallee,
+              messageId: 'missingTypeofImport'
+            });
+            return;
+          }
+          if (found.isFileLevel) {
+            // Top-level `type Foo = typeof import(...)` is disallowed
+            context.report({
+              node: reportCallee,
+              messageId: 'typeAliasNotInlined'
+            });
+            return;
+          }
+          var typeAnnotation = found.node.typeAnnotation;
+          if (typeAnnotation.type !== AST_NODE_TYPES.TSTypeQuery) {
+            context.report({
+              node: reportCallee,
+              messageId: 'missingTypeofImport'
+            });
+            return;
+          }
+          var resolved = extractImportPathFromTypeQuery(typeAnnotation);
+          if (!resolved) {
+            context.report({
+              node: reportCallee,
+              messageId: 'missingTypeofImport'
+            });
+            return;
+          }
+          importPath = resolved;
+        } else {
+          // ── Case 3: Inline `typeof import('...')` ────────────────────────
+          importPath = genericType.importPath;
+        }
+
+        // Package-scoped imports (e.g. @atlaskit/foo/examples/...) are not allowed
+        if (importPath.startsWith('@')) {
+          context.report({
+            node: reportCallee,
+            messageId: 'noPackageImports'
+          });
+          return;
+        }
+
+        // Validate that the import path matches the arguments
+        var args = extractCallArgs(node, programBody, variableCache);
+        if (!args) {
+          // Dynamic arguments — can't validate statically
+          return;
+        }
+        var expectedPath = resolveExamplePathFromArgs(args.groupId, args.packageId, args.exampleId, filename);
+        if (!expectedPath) {
+          return;
+        }
+        var resolvedImport = path.normalize(path.resolve(path.dirname(filename), importPath));
+        var resolvedExpected = path.normalize(expectedPath);
+
+        // Compare without extensions so `.tsx` vs no extension doesn't matter
+        if (resolvedImport.replace(/\.(tsx?|jsx?)$/, '') !== resolvedExpected.replace(/\.(tsx?|jsx?)$/, '')) {
+          context.report({
+            node: estreeNode.arguments[0],
+            messageId: 'pathMismatch',
+            data: {
+              importPath: importPath,
+              groupId: args.groupId,
+              packageId: args.packageId,
+              exampleId: args.exampleId,
+              expectedPath: resolvedExpected
+            },
+            fix: function fix(fixer) {
+              var _node$typeArguments2;
+              var correctedPath = computeRelativeImportPath(filename, resolvedExpected);
+              var typeParams = (_node$typeArguments2 = node.typeArguments) !== null && _node$typeArguments2 !== void 0 ? _node$typeArguments2 : node.typeParameters;
+              if (!(typeParams !== null && typeParams !== void 0 && typeParams.range)) {
+                return null;
+              }
+              return fixer.replaceTextRange(typeParams.range, "<typeof import('".concat(correctedPath, "')>"));
+            }
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

package/dist/types/index.d.ts

@@ -29,11 +29,14 @@ declare const rules: {
     'no-direct-document-usage': import("eslint").Rule.RuleModule;
     'no-set-immediate': import("eslint").Rule.RuleModule;
     'prefer-crypto-random-uuid': import("eslint").Rule.RuleModule;
+    'no-restricted-fedramp-imports': import("eslint").Rule.RuleModule;
     'no-barrel-entry-imports': import("eslint").Rule.RuleModule;
     'no-barrel-entry-jest-mock': import("eslint").Rule.RuleModule;
     'no-jest-mock-barrel-files': import("eslint").Rule.RuleModule;
     'no-relative-barrel-file-imports': import("eslint").Rule.RuleModule;
     'no-conversation-assistant-barrel-imports': import("eslint").Rule.RuleModule;
+    'visit-example-type-import-required': import("eslint").Rule.RuleModule;
+    'ensure-use-sync-external-store-server-snapshot': import("eslint").Rule.RuleModule;
 };
 declare const plugin: {
     meta: {
@@ -70,11 +73,14 @@ declare const plugin: {
         'no-direct-document-usage': import("eslint").Rule.RuleModule;
         'no-set-immediate': import("eslint").Rule.RuleModule;
         'prefer-crypto-random-uuid': import("eslint").Rule.RuleModule;
+        'no-restricted-fedramp-imports': import("eslint").Rule.RuleModule;
         'no-barrel-entry-imports': import("eslint").Rule.RuleModule;
         'no-barrel-entry-jest-mock': import("eslint").Rule.RuleModule;
         'no-jest-mock-barrel-files': import("eslint").Rule.RuleModule;
         'no-relative-barrel-file-imports': import("eslint").Rule.RuleModule;
         'no-conversation-assistant-barrel-imports': import("eslint").Rule.RuleModule;
+        'visit-example-type-import-required': import("eslint").Rule.RuleModule;
+        'ensure-use-sync-external-store-server-snapshot': import("eslint").Rule.RuleModule;
     };
     configs: {
         recommended: {
@@ -90,6 +96,7 @@ declare const plugin: {
                 '@atlaskit/platform/ensure-feature-flag-registration': "error";
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+                '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
                 '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
                 '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -122,6 +129,7 @@ declare const plugin: {
                 '@atlaskit/platform/ensure-feature-flag-registration': "error";
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+                '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
                 '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
                 '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -143,6 +151,7 @@ declare const plugin: {
             rules: {
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+                '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
                 '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
                 '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -167,6 +176,7 @@ declare const plugin: {
             rules: {
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+                '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
                 '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
                 '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -203,6 +213,7 @@ declare const configs: {
             '@atlaskit/platform/ensure-feature-flag-registration': "error";
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+            '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
             '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -235,6 +246,7 @@ declare const configs: {
             '@atlaskit/platform/ensure-feature-flag-registration': "error";
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+            '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
             '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -256,6 +268,7 @@ declare const configs: {
         rules: {
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+            '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
             '@atlaskit/platform/ensure-atlassian-team': "error";
@@ -280,6 +293,7 @@ declare const configs: {
         rules: {
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
+            '@atlaskit/platform/ensure-use-sync-external-store-server-snapshot': "error";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': "error";
             '@atlaskit/platform/ensure-atlassian-team': "error";

package/dist/types/rules/ensure-use-sync-external-store-server-snapshot/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types/rules/import/shared/jest-utils.d.ts

@@ -33,6 +33,14 @@ export declare function findJestRequireMockCalls({ ast, matchPath, }: {
     ast: TSESTree.Program;
     matchPath: (candidatePath: string) => boolean;
 }): TSESTree.CallExpression[];
+/**
+ * Find all jest.requireActual() calls in the AST whose import path matches a given target.
+ * Works identically to findJestRequireMockCalls but for requireActual.
+ */
+export declare function findJestRequireActualCalls({ ast, matchPath, }: {
+    ast: TSESTree.Program;
+    matchPath: (candidatePath: string) => boolean;
+}): TSESTree.CallExpression[];
 /**
  * Determine the best new import path for a jest.requireMock() call by inspecting
  * the destructured symbols or property access at the call site.

package/dist/types/rules/import/shared/package-resolution.d.ts

@@ -6,14 +6,59 @@ export declare function parsePackageExports({ packageDir, fs, }: {
     packageDir: string;
     fs: FileSystem;
 }): Map<string, string>;
+export interface ExportMatchResult {
+    exportPath: string;
+    /**
+     * When resolved through an entry-point wrapper, the name under which
+     * the symbol is exported from the entry-point file.
+     * Callers use this to override the barrel's `originalName` so the
+     * generated import matches the entry-point's export shape.
+     */
+    entryPointExportName?: string;
+}
+/**
+ * Check whether a subpath export key (e.g. `"./checkbox-select"`) is kebab-case.
+ *
+ * A key is considered kebab-case when the portion after the leading `"./"` prefix
+ * consists only of lowercase letters, digits, hyphens, dots, and forward-slash
+ * separators — i.e. no uppercase letters, underscores, or camelCase humps.
+ */
+export declare function isKebabCaseExportKey(key: string): boolean;
 /**
  * Find a matching export entry for a given source file path.
  * Returns the export path (e.g., "./controllers/analytics") or null if not found.
+ *
+ * When multiple export paths resolve to the same source file **and** point to an
+ * entry-point file, kebab-case keys are preferred over other casing styles.
+ *
+ * When `fs` is provided, also checks entry-point wrapper files. If an export resolves
+ * to a file inside a recognized entry-points folder (entry-points, entrypoints, etc.),
+ * the wrapper is parsed to see if it re-exports from `sourceFilePath`.
+ *
+ * `sourceExportName` is the name under which the symbol is exported from the source file
+ * (e.g. `'default'`). Used to look up the corresponding entry-point export name so the
+ * caller can generate the correct import style.
  */
-export declare function findExportForSourceFile({ sourceFilePath, exportsMap, }: {
+export declare function findExportForSourceFile({ sourceFilePath, exportsMap, fs, sourceExportName, }: {
     sourceFilePath: string;
     exportsMap: Map<string, string>;
-}): string | null;
+    fs?: FileSystem;
+    sourceExportName?: string;
+}): ExportMatchResult | null;
+/**
+ * When a symbol reaches the consumer through a barrel package that re-exports from
+ * `crossPackageName`, find a `package.json` export subpath of that barrel whose entry
+ * file directly re-exports the symbol from `crossPackageName` (named exports only).
+ *
+ * This enables rewriting imports to `@scope/barrel/subpath` instead of
+ * `@scope/cross-package/...` when the barrel exposes such a subpath (e.g. `@atlaskit/select/react-select`).
+ */
+export declare function findCrossPackageBridgeExportPath({ exportsMap, crossPackageName, exportedName, fs, }: {
+    exportsMap: Map<string, string>;
+    crossPackageName: string;
+    exportedName: string;
+    fs: FileSystem;
+}): ExportMatchResult | null;
 /**
  * Extract the package name and subpath from an import specifier.
  * Returns null if the import is not a scoped package import.

package/dist/types/rules/no-restricted-fedramp-imports/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types/rules/visit-example-type-import-required/index.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+export declare const RULE_NAME = "visit-example-type-import-required";
+declare const rule: Rule.RuleModule;
+export default rule;