@atlaskit/eslint-plugin-platform 2.7.2 → 2.8.0

package/dist/types-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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;

package/dist/types-ts4.5/rules/import/shared/types.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Directory entry returned by readdirSync with withFileTypes option.
+ */
+export interface DirectoryEntry {
+    name: string;
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
+/**
+ * State for the package registry cache.
+ * This is used to cache package name to directory mappings for efficient lookups.
+ */
+export interface PackageRegistryCache {
+    /** Map of package name to absolute directory path */
+    packageNameToDir: Map<string, string>;
+    /** Set of directories that have been scanned (including those without packages) */
+    scannedDirectories: Set<string>;
+    /** yarn.lock mtime when cache was built (for invalidation) */
+    yarnLockMtime: number;
+    /** The workspace root this cache was built for (from package registry perspective) */
+    workspaceRoot: string | null;
+}
+/**
+ * Cache structure for file system operations.
+ * Contains both package registry cache and workspace root cache.
+ */
+export interface FileSystemCache extends Partial<PackageRegistryCache> {
+    /** Cached git repository root (from git rev-parse --show-toplevel) */
+    gitRepoRoot?: string;
+    /**
+     * Cache of parsed package.json exports maps keyed by absolute package directory.
+     * This avoids repeated reads/parses during IDE lint runs.
+     */
+    packageExportsByDir?: Map<string, {
+        /** mtimeMs of package.json when this entry was computed. null means unknown (forces re-read). */
+        packageJsonMtimeMs: number | null;
+        exportsMap: Map<string, string>;
+    }>;
+    /**
+     * Cache of read file contents keyed by absolute file path.
+     * Used by barrel parsing to avoid repeated reads in IDE lint runs.
+     */
+    fileContentByPath?: Map<string, {
+        /** mtimeMs when this entry was cached. null means unknown (forces re-read). */
+        mtimeMs: number | null;
+        content: string;
+    }>;
+    /**
+     * Cache of parsed barrel exports keyed by barrel file path.
+     * Stores the barrel file mtime at time of parsing to support invalidation.
+     */
+    barrelExportsByPath?: Map<string, {
+        mtimeMs: number;
+        exports: Map<string, ExportInfo>;
+    }>;
+    /**
+     * Cache for resolveImportPath results keyed by basedir + importPath.
+     */
+    resolvedImportPathByKey?: Map<string, string | null>;
+    /**
+     * Optional perf counters and timers for debugging and optimization.
+     * Enabled by setting INTERNAL_ESLINT_BARREL_PERF.
+     */
+    perf?: {
+        installedExitHook: boolean;
+        counters: Record<string, number>;
+        timers: Record<string, number>;
+    };
+}
+/**
+ * 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.
+ */
+export interface FileSystem {
+    existsSync(path: string): boolean;
+    readFileSync(path: string, encoding: 'utf-8'): string;
+    realpathSync(path: string): string;
+    statSync(path: string): {
+        isFile(): boolean;
+        mtimeMs?: number;
+    };
+    readdirSync(path: string, options: {
+        withFileTypes: true;
+    }): DirectoryEntry[];
+    /** Execute a command synchronously and return stdout. Returns null on error. */
+    execSync(command: string, options?: {
+        cwd?: string;
+    }): string | null;
+    /** Cache for package resolution and workspace root - will be populated lazily */
+    cache: FileSystemCache;
+}
+/**
+ * Real file system implementation using Node.js fs module.
+ */
+export declare const realFileSystem: FileSystem;
+/**
+ * Information about cross-package re-export origin.
+ */
+export interface CrossPackageSource {
+    /** The package name (e.g., '@atlassian/package-b') */
+    packageName: string;
+    /** The export path within the package (e.g., '.' or './utils') */
+    exportPath: string;
+}
+/**
+ * Information about where an export originates.
+ */
+export interface ExportInfo {
+    /** The absolute path to the file where this export originates */
+    path: string;
+    /** Whether this is a type-only export */
+    isTypeOnly: boolean;
+    /** Whether this is a re-export of a default export */
+    isDefaultExport?: boolean;
+    /** The original name of the symbol in the source file (for aliased exports) */
+    originalName?: string;
+    /** Information about cross-package re-export origin, if applicable */
+    crossPackageSource?: CrossPackageSource;
+}
+/**
+ * Context for package resolution operations.
+ */
+export interface PackageResolutionContext {
+    packageName: string;
+    packageDir: string;
+    exportPath: string;
+    entryFilePath: string;
+    exportsMap: Map<string, string>;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@atlaskit/eslint-plugin-platform",
 	"description": "The essential plugin for use with Atlassian frontend platform tools",
-	"version": "2.7.2",
+	"version": "2.8.0",
 	"author": "Atlassian Pty Ltd",
 	"atlassian": {
 		"team": "Build Infra",
@@ -36,9 +36,11 @@
 		"@manypkg/find-root": "^1.1.0",
 		"@manypkg/get-packages": "^1.1.3",
 		"fuse.js": "^6.6.2",
-		"read-pkg-up": "^7.0.1"
+		"read-pkg-up": "^7.0.1",
+		"typescript": "5.9.2"
 	},
 	"devDependencies": {
+		"@atlassian/eslint-utils": "^0.5.0",
 		"@atlassian/ts-loader": "^0.1.0",
 		"@types/eslint": "^8.56.6",
 		"eslint": "^8.57.0",

package/dist/cjs/rules/ensure-native-and-af-exports-synced/index.js

@@ -1,158 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _path = _interopRequireDefault(require("path"));
-var _registrationUtils = require("../util/registration-utils");
-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) { (0, _defineProperty2.default)(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; }
-var exportsValidationExceptions = {
-  '@af/yarn-workspace': {
-    ignoredAfExportKeys: ['./lock-parser']
-  },
-  '@atlaskit/tokens': {
-    ignoredAfExportKeys: ['./babel-plugin']
-  },
-  '@atlaskit/storybook-addon-design-system': {
-    ignoredAfExportKeys: ['.']
-  },
-  '@atlassian/react-async': {
-    ignoredAfExportKeys: ['./mock']
-  }
-};
-var rule = {
-  meta: {
-    docs: {
-      recommended: false
-    },
-    type: 'problem',
-    messages: {
-      missingExportsProperty: "The exports property must be defined for {{pkgName}}; it most likely can just be a duplicate of the \"af:exports\" property. See http://go/eslint-exports for details",
-      missingExportsKey: "Missing package.json exports key \"{{expectedKey}}\" in {{pkgName}}. The exports entry should be \"{{expectedKey}}\": \"{{expectedValue}}\". See http://go/eslint-exports for details",
-      unexpectedExportsKey: "Unexpected package.json exports key \"{{key}}\" in {{pkgName}}. The exports entry should be \"{{expectedKey}}\": \"{{expectedValue}}\". See http://go/eslint-exports for details",
-      unexpectedExportsValue: "Unexpected package.json exports value in {{pkgName}} for the \"{{key}}\" key. The exports entry should be \"{{key}}\": \"{{expectedValue}}\". See http://go/eslint-exports for details"
-    }
-  },
-  create: function create(context) {
-    var fileName = context.getFilename();
-    if (!fileName.endsWith('package.json')) {
-      return {};
-    }
-    var _getMetadataForFilena = (0, _registrationUtils.getMetadataForFilename)(fileName),
-      packageJson = _getMetadataForFilena.pkgJson;
-    var pkgName = packageJson.name;
-    if (!pkgName || !packageJson['af:exports']) {
-      return {};
-    }
-    if (!packageJson['exports']) {
-      context.report({
-        node: context.getSourceCode().ast,
-        messageId: 'missingExportsProperty',
-        data: {
-          pkgName: pkgName
-        }
-      });
-      return {};
-    }
-    var afExports = packageJson['af:exports'];
-    var nativeExports = packageJson['exports'];
-    return {
-      Program: function Program(node) {
-        for (var _i = 0, _Object$entries = Object.entries(afExports); _i < _Object$entries.length; _i++) {
-          var _exportsValidationExc;
-          var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2),
-            afExportsKey = _Object$entries$_i[0],
-            afExportsValue = _Object$entries$_i[1];
-          if ((_exportsValidationExc = exportsValidationExceptions[pkgName]) !== null && _exportsValidationExc !== void 0 && _exportsValidationExc.ignoredAfExportKeys.includes(afExportsKey)) {
-            continue;
-          }
-          var exportKeyViolations = getExportKeyViolation(afExportsKey, afExportsValue, nativeExports);
-          if (exportKeyViolations) {
-            context.report({
-              data: _objectSpread(_objectSpread({}, exportKeyViolations), {}, {
-                key: afExportsKey,
-                pkgName: pkgName
-              }),
-              node: node,
-              messageId: exportKeyViolations.messageId
-            });
-            continue;
-          }
-          var exportValueViolations = getExportValueViolation(afExportsKey, afExportsValue, nativeExports);
-          if (exportValueViolations) {
-            context.report({
-              data: _objectSpread(_objectSpread({}, exportValueViolations), {}, {
-                pkgName: pkgName
-              }),
-              node: node,
-              messageId: 'unexpectedExportsValue'
-            });
-            continue;
-          }
-        }
-      }
-    };
-  }
-};
-function getExportKeyViolation(afExportsKey, afExportsValue, nativeExports) {
-  var afExportsValueHasExtension = _path.default.extname(afExportsValue) !== '';
-  if (afExportsValueHasExtension && !nativeExports.hasOwnProperty(afExportsKey)) {
-    return {
-      messageId: 'missingExportsKey',
-      expectedKey: afExportsKey,
-      expectedValue: afExportsValue
-    };
-  }
-  if (!afExportsValueHasExtension && nativeExports.hasOwnProperty(afExportsKey)) {
-    return {
-      messageId: 'unexpectedExportsKey',
-      expectedKey: "".concat(afExportsKey, "/*"),
-      expectedValue: "".concat(afExportsValue, "/*")
-    };
-  }
-  if (!afExportsValueHasExtension && !nativeExports.hasOwnProperty("".concat(afExportsKey, "/*"))) {
-    return {
-      messageId: 'missingExportsKey',
-      expectedKey: "".concat(afExportsKey, "/*"),
-      expectedValue: "".concat(afExportsValue, "/*")
-    };
-  }
-}
-function getNativeExportsValue(afExportsKey, afExportsValueHasExtension, nativeExports) {
-  var nativeExportsKey = afExportsValueHasExtension ? afExportsKey : "".concat(afExportsKey, "/*");
-  if ((0, _typeof2.default)(nativeExports[nativeExportsKey]) === 'object') {
-    return nativeExports[nativeExportsKey].default;
-  }
-  return nativeExports[nativeExportsKey];
-}
-function getExportValueViolation(afExportsKey, afExportsValue, nativeExports) {
-  var afExportsValueHasExtension = _path.default.extname(afExportsValue) !== '';
-  var nativeExportsValue = getNativeExportsValue(afExportsKey, afExportsValueHasExtension, nativeExports);
-
-  // Some entrypoints have been updated to an index.js file that registers ts-node
-  // Use path.basename to get the file name to see if it is equal to 'index.js'
-  if (afExportsValueHasExtension && _path.default.basename(nativeExportsValue) === 'index.js') {
-    return;
-  }
-  if (afExportsValueHasExtension && nativeExportsValue !== afExportsValue) {
-    return {
-      key: afExportsKey,
-      expectedValue: afExportsValue
-    };
-  }
-
-  // af:exports entrypoints without a file extension export the whole directory so check to ensure the exports value includes the wildcard
-  if (!afExportsValueHasExtension && !nativeExportsValue.startsWith("".concat(afExportsValue, "/*"))) {
-    return {
-      key: "".concat(afExportsKey, "/*"),
-      expectedValue: "".concat(afExportsValue, "/*")
-    };
-  }
-}
-var _default = exports.default = rule;

package/dist/es2019/rules/ensure-native-and-af-exports-synced/index.js

@@ -1,146 +0,0 @@
-import path from 'path';
-import { getMetadataForFilename } from '../util/registration-utils';
-const exportsValidationExceptions = {
-  '@af/yarn-workspace': {
-    ignoredAfExportKeys: ['./lock-parser']
-  },
-  '@atlaskit/tokens': {
-    ignoredAfExportKeys: ['./babel-plugin']
-  },
-  '@atlaskit/storybook-addon-design-system': {
-    ignoredAfExportKeys: ['.']
-  },
-  '@atlassian/react-async': {
-    ignoredAfExportKeys: ['./mock']
-  }
-};
-const rule = {
-  meta: {
-    docs: {
-      recommended: false
-    },
-    type: 'problem',
-    messages: {
-      missingExportsProperty: `The exports property must be defined for {{pkgName}}; it most likely can just be a duplicate of the "af:exports" property. See http://go/eslint-exports for details`,
-      missingExportsKey: `Missing package.json exports key "{{expectedKey}}" in {{pkgName}}. The exports entry should be "{{expectedKey}}": "{{expectedValue}}". See http://go/eslint-exports for details`,
-      unexpectedExportsKey: `Unexpected package.json exports key "{{key}}" in {{pkgName}}. The exports entry should be "{{expectedKey}}": "{{expectedValue}}". See http://go/eslint-exports for details`,
-      unexpectedExportsValue: `Unexpected package.json exports value in {{pkgName}} for the "{{key}}" key. The exports entry should be "{{key}}": "{{expectedValue}}". See http://go/eslint-exports for details`
-    }
-  },
-  create(context) {
-    const fileName = context.getFilename();
-    if (!fileName.endsWith('package.json')) {
-      return {};
-    }
-    const {
-      pkgJson: packageJson
-    } = getMetadataForFilename(fileName);
-    const pkgName = packageJson.name;
-    if (!pkgName || !packageJson['af:exports']) {
-      return {};
-    }
-    if (!packageJson['exports']) {
-      context.report({
-        node: context.getSourceCode().ast,
-        messageId: 'missingExportsProperty',
-        data: {
-          pkgName
-        }
-      });
-      return {};
-    }
-    const afExports = packageJson['af:exports'];
-    const nativeExports = packageJson['exports'];
-    return {
-      Program(node) {
-        for (const [afExportsKey, afExportsValue] of Object.entries(afExports)) {
-          var _exportsValidationExc;
-          if ((_exportsValidationExc = exportsValidationExceptions[pkgName]) !== null && _exportsValidationExc !== void 0 && _exportsValidationExc.ignoredAfExportKeys.includes(afExportsKey)) {
-            continue;
-          }
-          const exportKeyViolations = getExportKeyViolation(afExportsKey, afExportsValue, nativeExports);
-          if (exportKeyViolations) {
-            context.report({
-              data: {
-                ...exportKeyViolations,
-                key: afExportsKey,
-                pkgName
-              },
-              node,
-              messageId: exportKeyViolations.messageId
-            });
-            continue;
-          }
-          const exportValueViolations = getExportValueViolation(afExportsKey, afExportsValue, nativeExports);
-          if (exportValueViolations) {
-            context.report({
-              data: {
-                ...exportValueViolations,
-                pkgName
-              },
-              node,
-              messageId: 'unexpectedExportsValue'
-            });
-            continue;
-          }
-        }
-      }
-    };
-  }
-};
-function getExportKeyViolation(afExportsKey, afExportsValue, nativeExports) {
-  const afExportsValueHasExtension = path.extname(afExportsValue) !== '';
-  if (afExportsValueHasExtension && !nativeExports.hasOwnProperty(afExportsKey)) {
-    return {
-      messageId: 'missingExportsKey',
-      expectedKey: afExportsKey,
-      expectedValue: afExportsValue
-    };
-  }
-  if (!afExportsValueHasExtension && nativeExports.hasOwnProperty(afExportsKey)) {
-    return {
-      messageId: 'unexpectedExportsKey',
-      expectedKey: `${afExportsKey}/*`,
-      expectedValue: `${afExportsValue}/*`
-    };
-  }
-  if (!afExportsValueHasExtension && !nativeExports.hasOwnProperty(`${afExportsKey}/*`)) {
-    return {
-      messageId: 'missingExportsKey',
-      expectedKey: `${afExportsKey}/*`,
-      expectedValue: `${afExportsValue}/*`
-    };
-  }
-}
-function getNativeExportsValue(afExportsKey, afExportsValueHasExtension, nativeExports) {
-  const nativeExportsKey = afExportsValueHasExtension ? afExportsKey : `${afExportsKey}/*`;
-  if (typeof nativeExports[nativeExportsKey] === 'object') {
-    return nativeExports[nativeExportsKey].default;
-  }
-  return nativeExports[nativeExportsKey];
-}
-function getExportValueViolation(afExportsKey, afExportsValue, nativeExports) {
-  const afExportsValueHasExtension = path.extname(afExportsValue) !== '';
-  const nativeExportsValue = getNativeExportsValue(afExportsKey, afExportsValueHasExtension, nativeExports);
-
-  // Some entrypoints have been updated to an index.js file that registers ts-node
-  // Use path.basename to get the file name to see if it is equal to 'index.js'
-  if (afExportsValueHasExtension && path.basename(nativeExportsValue) === 'index.js') {
-    return;
-  }
-  if (afExportsValueHasExtension && nativeExportsValue !== afExportsValue) {
-    return {
-      key: afExportsKey,
-      expectedValue: afExportsValue
-    };
-  }
-
-  // af:exports entrypoints without a file extension export the whole directory so check to ensure the exports value includes the wildcard
-  if (!afExportsValueHasExtension && !nativeExportsValue.startsWith(`${afExportsValue}/*`)) {
-    return {
-      key: `${afExportsKey}/*`,
-      expectedValue: `${afExportsValue}/*`
-    };
-  }
-}
-export default rule;