@atlaskit/eslint-plugin-platform 2.7.1 → 2.8.0

package/dist/esm/rules/import/shared/types.js

@@ -0,0 +1,61 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; }
+import { execSync as _execSync } from 'child_process';
+import { existsSync, readdirSync as _readdirSync, readFileSync, realpathSync, statSync } from 'fs';
+
+/**
+ * Directory entry returned by readdirSync with withFileTypes option.
+ */
+
+/**
+ * State for the package registry cache.
+ * This is used to cache package name to directory mappings for efficient lookups.
+ */
+
+/**
+ * Cache structure for file system operations.
+ * Contains both package registry cache and workspace root cache.
+ */
+
+/**
+ * File system abstraction for testability.
+ * This interface allows the core logic to be tested with mock file systems.
+ * The cache property holds package resolution state and can be passed as an empty
+ * object for tests to ensure fresh state for each test case.
+ */
+
+/**
+ * Real file system implementation using Node.js fs module.
+ */
+export var realFileSystem = {
+  existsSync: existsSync,
+  readFileSync: readFileSync,
+  realpathSync: realpathSync,
+  statSync: statSync,
+  readdirSync: function readdirSync(path, options) {
+    return _readdirSync(path, options);
+  },
+  execSync: function execSync(command, options) {
+    try {
+      return _execSync(command, _objectSpread(_objectSpread({}, options), {}, {
+        encoding: 'utf-8'
+      })).trim();
+    } catch (_unused) {
+      return null;
+    }
+  },
+  cache: {}
+};
+
+/**
+ * Information about cross-package re-export origin.
+ */
+
+/**
+ * Information about where an export originates.
+ */
+
+/**
+ * Context for package resolution operations.
+ */

package/dist/esm/rules/no-invalid-storybook-decorator-usage/index.js

@@ -1,7 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 // eslint-disable-next-line import/no-extraneous-dependencies
 
-var STORYBOOK_DECORATOR_IDENTIFIER = 'withPlatformFeatureFlags';
+var STORYBOOK_DECORATOR_IDENTIFIER = 'withPlatformFeatureGates';
 var rule = {
   meta: {
     hasSuggestions: false,

package/dist/esm/rules/no-sparse-checkout/index.js

@@ -1,7 +1,7 @@
 // We will be removing sparse checkout from pipelines in CI completely due to the load it causes on BBC.
 // We will be incrementally removing sparse-checkout from the files below as it is probably unnecessasry.
 // If you must add an exception below, please go through the chopper process before doing so
-var sparseCheckoutExceptions = ['bitbucket-pipelines/pipelines/custom/run-issue-automat.ts', 'bitbucket-pipelines/pipelines/custom/marketplace/utils.ts', 'bitbucket-pipelines/pipelines/custom/confluence/utils/index.ts', 'bitbucket-pipelines/pipelines/custom/afm-tools/upload-afm-dependency-graph-cache.ts', 'bitbucket-pipelines/pipelines/custom/afm-tools/default-afm-tools.ts', 'bitbucket-pipelines/pipelines/custom/marketplace/utils.ts', 'bitbucket-pipelines/pipelines/custom/afm-git-hooks.ts', 'bitbucket-pipelines/pipelines/custom/update-codeowners-and-teams-gen.ts', 'bitbucket-pipelines/pipelines/custom/run-issue-automat.ts'];
+var sparseCheckoutExceptions = ['pipeline-definitions/pipelines/custom/run-issue-automat.ts', 'pipeline-definitions/pipelines/custom/marketplace/utils.ts', 'pipeline-definitions/pipelines/custom/confluence/utils/index.ts', 'pipeline-definitions/pipelines/custom/afm-tools/upload-afm-dependency-graph-cache.ts', 'pipeline-definitions/pipelines/custom/afm-tools/default-afm-tools.ts', 'pipeline-definitions/pipelines/custom/marketplace/utils.ts', 'pipeline-definitions/pipelines/custom/afm-git-hooks.ts', 'pipeline-definitions/pipelines/custom/update-codeowners-and-teams-gen.ts', 'pipeline-definitions/pipelines/custom/run-issue-automat.ts'];
 var rule = {
   meta: {
     docs: {

package/dist/esm/rules/prefer-crypto-random-uuid/index.js

@@ -0,0 +1,81 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+var rule = {
+  meta: {
+    type: 'problem',
+    // Problem type = can be error
+    docs: {
+      description: 'Prefer crypto.randomUUID() over uuid library. The uuid package causes Jest mocking issues.',
+      recommended: true
+    },
+    fixable: 'code',
+    // Enables --fix
+    messages: {
+      preferCryptoRandomUUID: 'Use crypto.randomUUID() instead of the uuid library. Run `eslint --fix` to auto-migrate.'
+    }
+  },
+  create: function create(context) {
+    var uuidImports = new Map(); // Track imported names
+
+    return {
+      ImportDeclaration: function ImportDeclaration(node) {
+        if (node.type !== 'ImportDeclaration') {
+          return;
+        }
+        var source = node.source.value;
+        if (typeof source === 'string' && (source === 'uuid' || /^uuid\/v[14]$/.test(source))) {
+          // Track imported name (e.g., uuid, v4, etc.)
+          var specifier = node.specifiers[0];
+          if (specifier) {
+            uuidImports.set(specifier.local.name, node);
+          }
+          context.report({
+            node: node,
+            messageId: 'preferCryptoRandomUUID',
+            fix: function fix(fixer) {
+              // Remove the import - usages will be fixed separately
+              return fixer.remove(node);
+            }
+          });
+        }
+      },
+      CallExpression: function CallExpression(node) {
+        var _node$arguments$;
+        if (node.type !== 'CallExpression') {
+          return;
+        }
+
+        // Handle direct uuid() or v4() calls
+        if (node.callee.type === 'Identifier') {
+          var calleeName = node.callee.name;
+          if (uuidImports.has(calleeName)) {
+            context.report({
+              node: node,
+              messageId: 'preferCryptoRandomUUID',
+              fix: function fix(fixer) {
+                // Replace uuid() with crypto.randomUUID()
+                return fixer.replaceText(node.callee, 'crypto.randomUUID');
+              }
+            });
+          }
+        }
+
+        // Handle require('uuid')
+        if (node.callee.type === 'Identifier' && node.callee.name === 'require' && ((_node$arguments$ = node.arguments[0]) === null || _node$arguments$ === void 0 ? void 0 : _node$arguments$.type) === 'Literal') {
+          var arg = node.arguments[0].value;
+          if (typeof arg === 'string' && (arg === 'uuid' || /^uuid\/v[14]$/.test(arg))) {
+            context.report({
+              node: node,
+              messageId: 'preferCryptoRandomUUID'
+              // require() needs manual refactoring
+            });
+          }
+        }
+      },
+      'Program:exit': function ProgramExit() {
+        uuidImports.clear();
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/rules/use-entrypoints-in-examples/index.js

@@ -1,7 +1,7 @@
 var rule = {
   meta: {
     docs: {
-      url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/use-entrypoints-in-examples/README.md',
+      url: 'https://bitbucket.org/atlassian/atlassian-frontend-monorepo/src/master/platform/packages/platform/eslint-plugin/src/rules/use-entrypoints-in-examples/README.md',
       description: 'Encourage usage of package entrypoints in examples.'
     },
     messages: {

package/dist/types/index.d.ts

@@ -1,7 +1,6 @@
 import type { ESLint, Linter } from 'eslint';
 declare const rules: {
     'ensure-feature-flag-registration': import("eslint").Rule.RuleModule;
-    'ensure-feature-flag-prefix': import("eslint").Rule.RuleModule;
     'ensure-test-runner-arguments': import("eslint").Rule.RuleModule;
     'ensure-test-runner-nested-count': import("eslint").Rule.RuleModule;
     'ensure-atlassian-team': import("eslint").Rule.RuleModule;
@@ -16,7 +15,6 @@ declare const rules: {
     'no-pre-post-install-scripts': import("eslint").Rule.RuleModule;
     'no-invalid-storybook-decorator-usage': import("eslint").Rule.RuleModule;
     'ensure-publish-valid': import("eslint").Rule.RuleModule;
-    'ensure-native-and-af-exports-synced': import("eslint").Rule.RuleModule;
     'no-module-level-eval': import("eslint").Rule.RuleModule;
     'no-module-level-eval-nav4': import("eslint").Rule.RuleModule;
     'static-feature-flags': import("eslint").Rule.RuleModule;
@@ -26,9 +24,16 @@ declare const rules: {
     'no-alias': import("eslint").Rule.RuleModule;
     'use-entrypoints-in-examples': import("eslint").Rule.RuleModule;
     'use-recommended-utils': import("eslint").Rule.RuleModule;
+    'valid-gate-name': import("eslint").Rule.RuleModule;
     'no-sparse-checkout': import("eslint").Rule.RuleModule;
     'no-direct-document-usage': import("eslint").Rule.RuleModule;
     'no-set-immediate': import("eslint").Rule.RuleModule;
+    'prefer-crypto-random-uuid': 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;
 };
 declare const plugin: {
     meta: {
@@ -37,7 +42,6 @@ declare const plugin: {
     };
     rules: {
         'ensure-feature-flag-registration': import("eslint").Rule.RuleModule;
-        'ensure-feature-flag-prefix': import("eslint").Rule.RuleModule;
         'ensure-test-runner-arguments': import("eslint").Rule.RuleModule;
         'ensure-test-runner-nested-count': import("eslint").Rule.RuleModule;
         'ensure-atlassian-team': import("eslint").Rule.RuleModule;
@@ -52,7 +56,6 @@ declare const plugin: {
         'no-pre-post-install-scripts': import("eslint").Rule.RuleModule;
         'no-invalid-storybook-decorator-usage': import("eslint").Rule.RuleModule;
         'ensure-publish-valid': import("eslint").Rule.RuleModule;
-        'ensure-native-and-af-exports-synced': import("eslint").Rule.RuleModule;
         'no-module-level-eval': import("eslint").Rule.RuleModule;
         'no-module-level-eval-nav4': import("eslint").Rule.RuleModule;
         'static-feature-flags': import("eslint").Rule.RuleModule;
@@ -62,9 +65,16 @@ declare const plugin: {
         'no-alias': import("eslint").Rule.RuleModule;
         'use-entrypoints-in-examples': import("eslint").Rule.RuleModule;
         'use-recommended-utils': import("eslint").Rule.RuleModule;
+        'valid-gate-name': import("eslint").Rule.RuleModule;
         'no-sparse-checkout': import("eslint").Rule.RuleModule;
         'no-direct-document-usage': import("eslint").Rule.RuleModule;
         'no-set-immediate': import("eslint").Rule.RuleModule;
+        'prefer-crypto-random-uuid': 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;
     };
     configs: {
         recommended: {
@@ -76,10 +86,8 @@ declare const plugin: {
                 '@atlaskit/platform/inline-usage': "error";
                 '@atlaskit/platform/prefer-fg': "error";
                 '@atlaskit/platform/no-alias': "error";
+                '@atlaskit/platform/valid-gate-name': "error";
                 '@atlaskit/platform/ensure-feature-flag-registration': "error";
-                '@atlaskit/platform/ensure-feature-flag-prefix': ["warn", {
-                    allowedPrefixes: string[];
-                }];
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
@@ -110,10 +118,8 @@ declare const plugin: {
                 '@atlaskit/platform/inline-usage': "error";
                 '@atlaskit/platform/prefer-fg': "error";
                 '@atlaskit/platform/no-alias': "error";
+                '@atlaskit/platform/valid-gate-name': "error";
                 '@atlaskit/platform/ensure-feature-flag-registration': "error";
-                '@atlaskit/platform/ensure-feature-flag-prefix': ["warn", {
-                    allowedPrefixes: string[];
-                }];
                 '@atlaskit/platform/ensure-test-runner-arguments': "error";
                 '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
                 '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
@@ -193,10 +199,8 @@ declare const configs: {
             '@atlaskit/platform/inline-usage': "error";
             '@atlaskit/platform/prefer-fg': "error";
             '@atlaskit/platform/no-alias': "error";
+            '@atlaskit/platform/valid-gate-name': "error";
             '@atlaskit/platform/ensure-feature-flag-registration': "error";
-            '@atlaskit/platform/ensure-feature-flag-prefix': ["warn", {
-                allowedPrefixes: string[];
-            }];
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";
@@ -227,10 +231,8 @@ declare const configs: {
             '@atlaskit/platform/inline-usage': "error";
             '@atlaskit/platform/prefer-fg': "error";
             '@atlaskit/platform/no-alias': "error";
+            '@atlaskit/platform/valid-gate-name': "error";
             '@atlaskit/platform/ensure-feature-flag-registration': "error";
-            '@atlaskit/platform/ensure-feature-flag-prefix': ["warn", {
-                allowedPrefixes: string[];
-            }];
             '@atlaskit/platform/ensure-test-runner-arguments': "error";
             '@atlaskit/platform/ensure-test-runner-nested-count': "warn";
             '@atlaskit/platform/no-invalid-feature-flag-usage': "error";

package/dist/types/rules/import/no-barrel-entry-imports/index.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from 'eslint';
+import { type FileSystem } from '../shared/types';
+/**
+ * Factory function to create the ESLint rule with a given file system.
+ * This enables testing with mock file systems.
+ */
+export declare function createRule(fs: FileSystem): Rule.RuleModule;
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types/rules/import/no-barrel-entry-jest-mock/index.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from 'eslint';
+import { type FileSystem } from '../shared/types';
+/**
+ * Factory function to create the ESLint rule with a given file system.
+ * This enables testing with mock file systems.
+ */
+export declare function createRule(fs: FileSystem): Rule.RuleModule;
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types/rules/import/no-conversation-assistant-barrel-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/import/no-jest-mock-barrel-files/index.d.ts

@@ -0,0 +1,22 @@
+import type { Rule } from 'eslint';
+import { type ExportInfo, type FileSystem } from '../shared/types';
+/**
+ * Validate and resolve a barrel file from an import path
+ * Returns null if not a valid relative barrel import
+ */
+export declare function validateAndResolveBarrelFile({ importPath, basedir, workspaceRoot, fs, }: {
+    importPath: string;
+    basedir: string;
+    workspaceRoot: string;
+    fs: FileSystem;
+}): {
+    resolvedPath: string;
+    exportMap: Map<string, ExportInfo>;
+} | null;
+/**
+ * Factory function to create the ESLint rule with a given file system.
+ * This enables testing with mock file systems.
+ */
+export declare function createRule(fs: FileSystem): Rule.RuleModule;
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types/rules/import/no-relative-barrel-file-imports/index.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from 'eslint';
+import { type FileSystem } from '../shared/types';
+export declare function createRule(fs: FileSystem): Rule.RuleModule;
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types/rules/import/shared/barrel-parsing.d.ts

@@ -0,0 +1,30 @@
+import type { ExportInfo, FileSystem } from './types';
+/**
+ * Get all named exports from a file.
+ * This extracts what names are exported from a file for star exports.
+ */
+export declare function getNamedExportsFromFile({ filePath, fs, }: {
+    filePath: string;
+    fs: FileSystem;
+}): Set<string>;
+/**
+ * Check if an export map represents a barrel file (has re-exports from other files)
+ */
+export declare function hasReExportsFromOtherFiles({ exportMap, sourceFilePath, }: {
+    exportMap: Map<string, ExportInfo>;
+    sourceFilePath: string;
+}): boolean;
+/**
+ * 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 declare function parseBarrelExports({ barrelFilePath, depth, fs, workspaceRoot, visitedPackages, }: {
+    barrelFilePath: string;
+    depth?: number;
+    fs: FileSystem;
+    workspaceRoot?: string;
+    visitedPackages?: Set<string>;
+}): Map<string, ExportInfo>;

package/dist/types/rules/import/shared/file-system.d.ts

@@ -0,0 +1,38 @@
+import type { FileSystem } from './types';
+/**
+ * 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 declare const DEFAULT_TARGET_FOLDERS: string[];
+/**
+ * Try to read file contents with error handling.
+ * Returns null if file cannot be read.
+ */
+export declare function readFileContent({ filePath, fs, }: {
+    filePath: string;
+    fs: FileSystem;
+}): string | null;
+/**
+ * Check if a path is a relative import (starts with ./ or ../)
+ */
+export declare function isRelativeImport(importPath: string): boolean;
+/**
+ * Resolve the actual file path from an import path.
+ * Handles extension inference and index file resolution.
+ */
+export declare function resolveImportPath({ basedir, importPath, fs, }: {
+    basedir: string;
+    importPath: string;
+    fs: FileSystem;
+}): string | 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 declare function findWorkspaceRoot({ startPath, fs, applyToImportsFrom, }: {
+    startPath: string;
+    fs: FileSystem;
+    applyToImportsFrom?: string[];
+}): string;

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

@@ -0,0 +1,47 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Shared utilities for jest.mock-related lint rules.
+ *
+ * These helpers are used by both `no-barrel-entry-jest-mock` (cross-package)
+ * and `no-jest-mock-barrel-files` (relative imports).
+ */
+/**
+ * Check if a CallExpression node is a jest.mock() call
+ */
+export declare function isJestMockCall(node: TSESTree.CallExpression): boolean;
+/**
+ * Check if a node is a jest.requireActual() call
+ */
+export declare function isJestRequireActual(node: TSESTree.Node): boolean;
+/**
+ * Check if a node is a jest.requireMock() call
+ */
+export declare function isJestRequireMock(node: TSESTree.Node): boolean;
+/**
+ * Extract the import path string from a jest.mock/jest.requireMock/jest.requireActual call's arguments.
+ * Returns null if the path cannot be statically determined.
+ */
+export declare function extractImportPath(node: TSESTree.CallExpression): string | null;
+/**
+ * Find all jest.requireMock() calls in the AST whose import path matches a given target.
+ *
+ * The `matchPath` callback allows callers to provide their own path-matching strategy:
+ * - Cross-package rules can use simple string equality
+ * - Relative import rules can use normalized/resolved path comparison
+ */
+export declare function findJestRequireMockCalls({ 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.
+ *
+ * @param requireMockNode - The jest.requireMock() CallExpression node
+ * @param symbolToNewPath - Map from symbol name to the new mock path that provides it
+ * @returns The resolved new path, or null if it cannot be determined
+ */
+export declare function resolveNewPathForRequireMock({ requireMockNode, symbolToNewPath, }: {
+    requireMockNode: TSESTree.CallExpression;
+    symbolToNewPath: Map<string, string>;
+}): string | null;

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

@@ -0,0 +1,26 @@
+import type { FileSystem } from './types';
+/**
+ * Find the package directory for a given package name.
+ * Returns the absolute path to the package directory or null if not found.
+ *
+ * This function uses lazy scanning - it will scan platform/packages on first lookup
+ * and cache results in fs.cache for subsequent lookups.
+ *
+ * Note: Package resolution is NOT constrained by applyToImportsFrom. Any package under
+ * platform/packages can be resolved. Use isPackageInApplyToImportsFrom to check if a
+ * package should be processed by the lint rule.
+ */
+export declare function findPackageInRegistry({ packageName, workspaceRoot, fs, }: {
+    packageName: string;
+    workspaceRoot: string;
+    fs: FileSystem;
+}): string | null;
+/**
+ * Check if a package is within one of the applyToImportsFrom folders.
+ * This can be used to quickly filter out packages that shouldn't be checked.
+ */
+export declare function isPackageInApplyToImportsFrom({ packageDir, workspaceRoot, applyToImportsFrom, }: {
+    packageDir: string;
+    workspaceRoot: string;
+    applyToImportsFrom?: string[];
+}): boolean;

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

@@ -0,0 +1,38 @@
+import type { FileSystem } from './types';
+/**
+ * Parse the package.json exports field and return a map of export paths to resolved file paths.
+ */
+export declare function parsePackageExports({ packageDir, fs, }: {
+    packageDir: string;
+    fs: FileSystem;
+}): Map<string, string>;
+/**
+ * Find a matching export entry for a given source file path.
+ * Returns the export path (e.g., "./controllers/analytics") or null if not found.
+ */
+export declare function findExportForSourceFile({ sourceFilePath, exportsMap, }: {
+    sourceFilePath: string;
+    exportsMap: Map<string, string>;
+}): string | null;
+/**
+ * Extract the package name and subpath from an import specifier.
+ * Returns null if the import is not a scoped package import.
+ */
+export declare function extractPackageNameFromImport(moduleSpecifier: string): {
+    packageName: string;
+    subPath: string;
+} | null;
+/**
+ * Resolve a cross-package import to its package directory and export info.
+ * Returns null if the package is not in the target folder or cannot be resolved.
+ */
+export declare function resolveCrossPackageImport({ moduleSpecifier, workspaceRoot, fs, }: {
+    moduleSpecifier: string;
+    workspaceRoot: string;
+    fs: FileSystem;
+}): {
+    packageName: string;
+    packageDir: string;
+    exportPath: string;
+    entryFilePath: string;
+} | null;

package/dist/types/rules/import/shared/perf.d.ts

@@ -0,0 +1,13 @@
+import type { FileSystem } from './types';
+export declare const PERF_ENV_VAR = "INTERNAL_ESLINT_BARREL_PERF";
+export declare function isPerfEnabled(): boolean;
+export declare function perfInc({ fs, key, by }: {
+    fs: FileSystem;
+    key: string;
+    by?: number;
+}): void;
+export declare function perfTime<T>({ fs, key, fn }: {
+    fs: FileSystem;
+    key: string;
+    fn: () => T;
+}): T;