@atlaskit/eslint-plugin-platform 2.7.2 → 2.9.0

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');
+}
+
+/**
+ * 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

@@ -15,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;
@@ -25,10 +24,18 @@ 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;
+    'visit-example-type-import-required': import("eslint").Rule.RuleModule;
+    'ensure-use-sync-external-store-server-snapshot': import("eslint").Rule.RuleModule;
 };
 declare const plugin: {
     meta: {
@@ -51,7 +58,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;
@@ -61,10 +67,18 @@ 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;
+        'visit-example-type-import-required': import("eslint").Rule.RuleModule;
+        'ensure-use-sync-external-store-server-snapshot': import("eslint").Rule.RuleModule;
     };
     configs: {
         recommended: {
@@ -76,9 +90,11 @@ 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-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";
@@ -107,9 +123,11 @@ 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-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";
@@ -131,6 +149,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";
@@ -155,6 +174,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";
@@ -187,9 +207,11 @@ 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-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";
@@ -218,9 +240,11 @@ 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-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";
@@ -242,6 +266,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";
@@ -266,6 +291,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/feature-gating/valid-gate-name/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-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;