@atlaskit/eslint-plugin-platform 0.6.1 → 0.7.0

package/dist/esm/rules/no-alias/index.js

@@ -0,0 +1,57 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { FEATURE_API_IMPORT_SOURCES, FEATURE_MOCKS_IMPORT_SOURCES, FEATURE_UTILS_IMPORT_SOURCES } from '../constants';
+import { isIdentifierImportedFrom } from '../utils';
+var IMPORT_SOURCES = new Set([].concat(_toConsumableArray(FEATURE_API_IMPORT_SOURCES), _toConsumableArray(FEATURE_MOCKS_IMPORT_SOURCES), _toConsumableArray(FEATURE_UTILS_IMPORT_SOURCES)));
+var rule = {
+  meta: {
+    docs: {
+      url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/ff/no-alias/README.md',
+      description: 'Disallow aliasing of feature flag utils to ensure feature flag usage is statically analyzable'
+    },
+    messages: {
+      noSpecifierAlias: 'Do not alias feature flag utils. Feature flag usage should be statically analyzable',
+      noNamespaceSpecifier: 'Destructure feature flag utils from import. Feature flag usage should be statically analyzable',
+      noReassignment: 'Do not reassign feature flag utils. Feature flag usage should be statically analyzable'
+    }
+  },
+  create: function create(context) {
+    return {
+      ImportDeclaration: function ImportDeclaration(node) {
+        var _node$specifiers;
+        if (typeof node.source.value === 'string' && !IMPORT_SOURCES.has(node.source.value)) {
+          return;
+        }
+        (_node$specifiers = node.specifiers) === null || _node$specifiers === void 0 || _node$specifiers.forEach(function (specifier) {
+          if (specifier.type === 'ImportSpecifier') {
+            var imported = specifier.imported,
+              local = specifier.local;
+            if (imported.name !== local.name) {
+              context.report({
+                messageId: 'noSpecifierAlias',
+                node: specifier
+              });
+            }
+          } else if (specifier.type === 'ImportNamespaceSpecifier') {
+            context.report({
+              messageId: 'noNamespaceSpecifier',
+              node: specifier
+            });
+          }
+        });
+      },
+      'VariableDeclaration[kind="const"] > VariableDeclarator[id.type="Identifier"][init.type="Identifier"]': function VariableDeclarationKindConstVariableDeclaratorIdTypeIdentifierInitTypeIdentifier(node) {
+        if (!node.init || node.init.type !== 'Identifier') {
+          return;
+        }
+        var isReassignment = isIdentifierImportedFrom(node.init.name, IMPORT_SOURCES, context);
+        if (isReassignment) {
+          context.report({
+            messageId: 'noReassignment',
+            node: node
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/rules/no-module-level-eval/index.js

@@ -0,0 +1,39 @@
+import { isAPIimport } from '../utils';
+var isInFunctionLevel = function isInFunctionLevel(context) {
+  var scope = context.getScope();
+  while (((_scope = scope) === null || _scope === void 0 ? void 0 : _scope.type) !== 'module' && ((_scope2 = scope) === null || _scope2 === void 0 ? void 0 : _scope2.type) !== 'global') {
+    var _scope, _scope2;
+    if (scope.type === 'function') {
+      return true;
+    }
+    if (scope.type === 'class-field-initializer') {
+      return !scope.block.parent.static;
+    }
+    scope = scope.upper;
+  }
+  return false;
+};
+var rule = {
+  meta: {
+    docs: {
+      description: 'Disallow feature flag usage at module level',
+      url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/ff/no-module-level-eval/README.md'
+    },
+    messages: {
+      noModuleLevelEval: 'Do not evaluate feature flags at module level, it will always resolve to false when server side rendered.'
+    }
+  },
+  create: function create(context) {
+    return {
+      'CallExpression[callee.type="Identifier"]': function CallExpressionCalleeTypeIdentifier(node) {
+        if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && isAPIimport(node.callee.name, context) && !isInFunctionLevel(context)) {
+          context.report({
+            messageId: 'noModuleLevelEval',
+            node: node
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/rules/no-preconditioning/index.js

@@ -0,0 +1,102 @@
+import { isAPIimport } from '../utils';
+var isAndExpression = function isAndExpression(node) {
+  return node.type === 'LogicalExpression' && node.operator === '&&';
+};
+var isExpUsage = function isExpUsage(calleeName) {
+  return calleeName === 'expVal' || calleeName === 'expValEquals';
+};
+var getGateType = function getGateType(node, context) {
+  var type = node.type;
+  if (type === 'BinaryExpression') {
+    return getGateType(node.left, context) || getGateType(node.right, context);
+  }
+  if (node.type === 'CallExpression') {
+    var callee = node.callee;
+    var isFeatureGate = type === 'CallExpression' && callee.type === 'Identifier' && (
+    // Experiments cannot have other experiments as preconditions, only gates
+    callee.name === 'fg' || isExpUsage(callee.name)) && isAPIimport(callee.name, context);
+    return isFeatureGate ? callee.name : '';
+  }
+  return '';
+};
+var getPreconditionStatus = function getPreconditionStatus(logicalExpression, context) {
+  var _ref = logicalExpression,
+    left = _ref.left;
+  // If left side is a nested AND expression then the left side node is on the nested's right
+  var leftGateType = getGateType(isAndExpression(left) ? left.right : left, context);
+  if (leftGateType) {
+    var rightGateType = getGateType(logicalExpression.right, context);
+    // Check this scenario: fg('gate') && isAdmin
+    if (!rightGateType) {
+      return 'early-exposure';
+    }
+
+    // Using experiment values in logical expressions in valid
+    // i.e. expVal() && expVal()
+    if (isExpUsage(leftGateType) && isExpUsage(rightGateType)) {
+      return '';
+    }
+
+    // Then is scenario: fg('gate1') && fg('gate2')
+    return 'unnecessary-gate';
+  }
+  return '';
+};
+var rule = {
+  meta: {
+    docs: {
+      description: 'Inform on how to use gates and experiments in logical expressions',
+      url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/ff/no-preconditioning/README.md'
+    },
+    messages: {
+      useConfig: 'Do not precondition gates or experiments with another gate. Configure this in Statsig instead to reduce unnecessary code and simplify cleanup.',
+      incorrectExposure: 'Evaluate gates or experiments at the end of your logical expression to ensure exposure is tracked correctly.'
+    }
+  },
+  create: function create(context) {
+    return {
+      'LogicalExpression[operator="&&"]': function LogicalExpressionOperator(node) {
+        var parent = node.parent;
+        // Don't analyze nested AND logical expressions
+        if (isAndExpression(parent)) {
+          return;
+        }
+        var isAssignmentStatement = parent.type !== 'IfStatement' && parent.type !== 'ConditionalExpression' &&
+        // @ts-expect-error — this isn't a valid statement but does fail tests when removed.
+        // When updating this rule please resolve this supression.
+        !(parent.type === 'LogicalExpression' && parent.operator === '||');
+        var nextLogicalExpression = node;
+        var exposureReported = false;
+        var configReported = false;
+        while (nextLogicalExpression) {
+          var preconditionStatus = getPreconditionStatus(nextLogicalExpression, context);
+          // Allow us to check for: fg('') && <Component />
+          var isReturningValue =
+          // Check if we are on the root logical expression
+          // as this is where the returning value is
+          // `node` is root logical expression
+          isAssignmentStatement && nextLogicalExpression === node;
+          if (!exposureReported && !isReturningValue && preconditionStatus === 'early-exposure') {
+            context.report({
+              messageId: 'incorrectExposure',
+              node: node
+            });
+            exposureReported = true;
+          }
+          if (!configReported && preconditionStatus === 'unnecessary-gate') {
+            context.report({
+              messageId: 'useConfig',
+              node: node
+            });
+            configReported = true;
+          }
+          if (exposureReported && configReported) {
+            return;
+          }
+          nextLogicalExpression = isAndExpression(nextLogicalExpression.left) ? nextLogicalExpression.left : undefined;
+        }
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/rules/prefer-fg/index.js

@@ -0,0 +1,99 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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 { FEATURE_API_IMPORT_SOURCES } from '../constants';
+var validateUsage = function validateUsage(node, utilName, context, changeMap) {
+  var _context$getScope$ref;
+  var resolved = (_context$getScope$ref = context.getScope().references.find(function (ref) {
+    return ref.identifier.name === utilName;
+  })) === null || _context$getScope$ref === void 0 ? void 0 : _context$getScope$ref.resolved;
+  var importSpecifierDefinition = resolved === null || resolved === void 0 ? void 0 : resolved.defs.find(function (def) {
+    var _def$node, _def$parent;
+    return ((_def$node = def.node) === null || _def$node === void 0 ? void 0 : _def$node.type) === 'ImportSpecifier' && FEATURE_API_IMPORT_SOURCES.has((_def$parent = def.parent) === null || _def$parent === void 0 ? void 0 : _def$parent.source.value);
+  });
+  if (importSpecifierDefinition) {
+    var _node$arguments = _slicedToArray(node.arguments, 1),
+      flagNameArg = _node$arguments[0];
+    context.report({
+      messageId: 'preferFG',
+      node: node,
+      fix: /*#__PURE__*/_regeneratorRuntime.mark(function fix(fixer) {
+        var importDeclaration, changeCounts;
+        return _regeneratorRuntime.wrap(function fix$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return fixer.replaceText(node, "fg(".concat(context.sourceCode.getText(flagNameArg), ")"));
+            case 2:
+              importDeclaration = importSpecifierDefinition.parent;
+              if (changeMap.has(importDeclaration)) {
+                changeCounts = changeMap.get(importDeclaration);
+                changeMap.set(importDeclaration, _objectSpread(_objectSpread({}, changeCounts), {}, _defineProperty({}, utilName, changeCounts[utilName] + 1 || 1)));
+              } else {
+                changeMap.set(importDeclaration, _defineProperty({}, utilName, 1));
+              }
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }, fix);
+      })
+    });
+  }
+};
+var rule = {
+  meta: {
+    docs: {
+      url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/ff/prefer-fg/README.md',
+      description: 'Keep usages of boolean feature flags consistent'
+    },
+    fixable: 'code',
+    messages: {
+      preferFG: 'Use `fg` instead for boolean feature flags',
+      autoFixImports: 'Use `fg` instead for boolean feature flags'
+    }
+  },
+  create: function create(context) {
+    var changeMap;
+    return {
+      'CallExpression[callee.name="getBooleanFF"]': function CallExpressionCalleeNameGetBooleanFF(node) {
+        if (node.type !== 'CallExpression') {
+          return;
+        }
+        changeMap = changeMap || new Map();
+        validateUsage(node, 'getBooleanFF', context, changeMap);
+      },
+      'Program:exit': function ProgramExit() {
+        var _changeMap;
+        if ((_changeMap = changeMap) !== null && _changeMap !== void 0 && _changeMap.size) {
+          changeMap.forEach(function (changeCounts, importDeclaration) {
+            var _context$getScope$chi = _slicedToArray(context.getScope().childScopes, 1),
+              moduleScope = _context$getScope$chi[0];
+            var importSpecifiers = new Set(importDeclaration.specifiers.map(function (_ref) {
+              var imported = _ref.imported;
+              return imported.name;
+            }));
+            importSpecifiers.add('fg');
+            Object.keys(changeCounts).forEach(function (utilName) {
+              var _moduleScope$set$get;
+              if (changeCounts[utilName] === ((_moduleScope$set$get = moduleScope.set.get(utilName)) === null || _moduleScope$set$get === void 0 ? void 0 : _moduleScope$set$get.references.length)) {
+                importSpecifiers.delete(utilName);
+              }
+            });
+            context.report({
+              messageId: 'autoFixImports',
+              node: importDeclaration,
+              fix: function fix(fixer) {
+                return fixer.replaceText(importDeclaration, "import { ".concat(Array.from(importSpecifiers).join(', '), " } from '").concat(importDeclaration.source.value, "';"));
+              }
+            });
+          });
+          changeMap.clear();
+        }
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/rules/static-feature-flags/index.js

@@ -0,0 +1,56 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { FEATURE_API_IMPORT_SOURCES } from '../constants';
+import { getDef, isIdentifierImportedFrom } from '../utils';
+var IMPORT_SOURCES = new Set([].concat(_toConsumableArray(FEATURE_API_IMPORT_SOURCES), ['@atlassian/jira-feature-flagging-utils', '@atlassian/jira-feature-gate-component', '@atlassian/jira-feature-gates-test-mocks', '@atlassian/jira-feature-gates-storybook-mocks']));
+
+// Any functions not in this list should be skipped for performance.
+var FUNCTION_NAMES = new Set(['ff', 'fg', 'getFeatureFlagValue', 'getMultivariateFeatureFlag', 'componentWithFF', 'componentWithFG', 'passGate', 'withGate', 'expVal', 'expValEquals', 'UNSAFE_noExposureExp', 'mockExp', 'withExp', 'wasExperimentManuallyExposed']);
+var STATSIG_ONLY_FUNCTION_NAMES = new Set(['fg', 'componentWithFG', 'passGate', 'withGate', 'expVal', 'expValEquals', 'UNSAFE_noExposureExp', 'mockExp', 'withExp', 'wasExperimentManuallyExposed']);
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/ff/static-feature-flags/README.md',
+      description: 'Ensure feature flags or gates are static string literals'
+    },
+    fixable: 'code',
+    messages: {
+      FFLiteral: 'Use static string literal for `featureFlagName`. See https://team.atlassian.com/project/ATLAS-46997/about'
+    }
+  },
+  create: function create(context) {
+    var targetedFunctionsSwitch = context.options[0] === 'ssOnly' ? STATSIG_ONLY_FUNCTION_NAMES : FUNCTION_NAMES;
+    return {
+      // When they're not literals, show a message
+      'CallExpression[callee.type="Identifier"][arguments.length>0][arguments.0.type!="Literal"]': function CallExpressionCalleeTypeIdentifierArgumentsLength0Arguments0TypeLiteral(node) {
+        if (node.type !== 'CallExpression') {
+          return;
+        }
+        if (node.callee.type === 'Identifier' && (!targetedFunctionsSwitch.has(node.callee.name) || !isIdentifierImportedFrom(node.callee.name, IMPORT_SOURCES, context))) {
+          return;
+        }
+        var nameArgument = node.arguments[0];
+        if (nameArgument.type === 'Identifier') {
+          var def = getDef(nameArgument.name, context);
+          if (def != null && def.type === 'Variable') {
+            var _ref = def.node.init,
+              value = _ref.value;
+            context.report({
+              node: nameArgument,
+              messageId: 'FFLiteral',
+              fix: function fix(fixer) {
+                return fixer.replaceText(nameArgument, "'".concat(value, "'"));
+              }
+            });
+            return;
+          }
+        }
+        context.report({
+          node: nameArgument,
+          messageId: 'FFLiteral'
+        });
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/rules/use-recommended-utils/index.js

@@ -0,0 +1,41 @@
+import { isIdentifierImportedFrom } from '../utils';
+var BANNED_IMPORTS_SET = new Set(['@atlaskit/feature-gate-js-client']);
+var rule = {
+  meta: {
+    docs: {
+      url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/ff/use-recommended-utils/README.md',
+      description: 'Prefer using the feature flag abstraction over direct statsig library.'
+    },
+    messages: {
+      notSupported: 'Experimentation is not suported in platform feature flags, reach out to #help-statsig-switcheroo.',
+      useRecommended: 'Please do not use FeatureGates.{{util}}, use {{recommended}} from {{lib}} instead.'
+    },
+    type: 'problem'
+  },
+  create: function create(context) {
+    return {
+      'CallExpression > MemberExpression:matches([property.name="checkGate"])': function CallExpressionMemberExpressionMatchesPropertyNameCheckGate(node) {
+        if (node.object.type === 'Identifier' && isIdentifierImportedFrom(node.object.name, BANNED_IMPORTS_SET, context)) {
+          context.report({
+            messageId: 'useRecommended',
+            node: node,
+            data: {
+              lib: '`@atlaskit/platform-feature-flags`',
+              util: node.property.name,
+              recommended: '`fg`'
+            }
+          });
+        }
+      },
+      'CallExpression > MemberExpression:matches([property.name="getExperimentValue"])': function CallExpressionMemberExpressionMatchesPropertyNameGetExperimentValue(node) {
+        if (node.object.type === 'Identifier' && isIdentifierImportedFrom(node.object.name, BANNED_IMPORTS_SET, context)) {
+          context.report({
+            messageId: 'notSupported',
+            node: node
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/rules/util/registration-utils.js

@@ -7,7 +7,8 @@ import Fuse from 'fuse.js';
 // if you don't want to verify the type use `null` as the value
 export var getterIdentifierToFlagTypeMap = {
   getBooleanFF: 'boolean',
-  ffTest: 'boolean'
+  ffTest: 'boolean',
+  fg: 'boolean'
 };
 // make sure we cache reading the package.json so we don't end up reading it for every instance of this rule.
 var pkgJsonCache = new Map();

package/dist/esm/rules/utils.js

@@ -0,0 +1,45 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { FEATURE_API_IMPORT_SOURCES } from './constants';
+export function isIdentifierImportedFrom(identifierName, sources, context) {
+  if (sources.size > 0) {
+    var _context$getScope$ref, _context$getScope$ref2;
+    return (_context$getScope$ref = (_context$getScope$ref2 = context.getScope().references.find(function (ref) {
+      return ref.identifier.name === identifierName;
+    })) === null || _context$getScope$ref2 === void 0 || (_context$getScope$ref2 = _context$getScope$ref2.resolved) === null || _context$getScope$ref2 === void 0 ? void 0 : _context$getScope$ref2.defs.some(function (def) {
+      var _def$parent;
+      return ((_def$parent = def.parent) === null || _def$parent === void 0 ? void 0 : _def$parent.type) === 'ImportDeclaration' && sources.has(def.parent.source.value + '');
+    })) !== null && _context$getScope$ref !== void 0 ? _context$getScope$ref : false;
+  }
+  return false;
+}
+export function isAPIimport(functionName, context) {
+  return isIdentifierImportedFrom(functionName, FEATURE_API_IMPORT_SOURCES, context);
+}
+
+// returns the definition node of a variable if it's declared within the scope of the file
+export function getDef(name, context) {
+  var scope = context.getScope();
+  while (scope && scope.type !== 'global') {
+    var _iterator = _createForOfIteratorHelper(scope.variables),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var variable = _step.value;
+        if (variable.name === name) {
+          var definition = variable.defs.find(function (def) {
+            return def.node && def.node.type === 'VariableDeclarator';
+          });
+          return definition;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    scope = scope.upper;
+  }
+  return null;
+}

package/dist/types/index.d.ts

@@ -6,12 +6,20 @@ export declare const rules: {
     'ensure-test-runner-nested-count': import("eslint").Rule.RuleModule;
     'ensure-atlassian-team': import("eslint").Rule.RuleModule;
     'ensure-critical-dependency-resolutions': import("eslint").Rule.RuleModule;
+    'ensure-valid-emotion-css-prop': import("eslint").Rule.RuleModule;
     'no-duplicate-dependencies': import("eslint").Rule.RuleModule;
     'no-invalid-feature-flag-usage': import("eslint").Rule.RuleModule;
     '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;
+    'static-feature-flags': import("eslint").Rule.RuleModule;
+    'no-preconditioning': import("eslint").Rule.RuleModule;
+    'inline-usage': import("eslint").Rule.RuleModule;
+    'prefer-fg': import("eslint").Rule.RuleModule;
+    'no-alias': import("eslint").Rule.RuleModule;
+    'use-recommended-utils': import("eslint").Rule.RuleModule;
 };
 export declare const configs: {
     recommended: {
@@ -26,9 +34,16 @@ export declare const configs: {
             '@atlaskit/platform/no-invalid-feature-flag-usage': string;
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': string;
             '@atlaskit/platform/ensure-atlassian-team': string;
+            '@atlaskit/platform/no-module-level-eval': string;
+            '@atlaskit/platform/static-feature-flags': string;
+            '@atlaskit/platform/no-preconditioning': string;
+            '@atlaskit/platform/inline-usage': string;
+            '@atlaskit/platform/prefer-fg': string;
+            '@atlaskit/platform/no-alias': string;
         };
     };
 };
 export declare const processors: {
     'package-json-processor': Linter.Processor<string | Linter.ProcessorFile>;
+    'package-json-processor-for-flat-config': Linter.Processor<string | Linter.ProcessorFile>;
 };

package/dist/types/rules/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FEATURE_API_IMPORT_SOURCES: Set<string>;
+export declare const FEATURE_MOCKS_IMPORT_SOURCES: Set<string>;
+export declare const FEATURE_UTILS_IMPORT_SOURCES: Set<string>;

package/dist/types/rules/ensure-valid-emotion-css-prop/index.d.ts

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

package/dist/types/rules/inline-usage/index.d.ts

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

package/dist/types/rules/no-alias/index.d.ts

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

package/dist/types/rules/no-module-level-eval/index.d.ts

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

package/dist/types/rules/no-preconditioning/index.d.ts

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

package/dist/types/rules/prefer-fg/index.d.ts

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

package/dist/types/rules/static-feature-flags/index.d.ts

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

package/dist/types/rules/use-recommended-utils/index.d.ts

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

package/dist/types/rules/util/registration-utils.d.ts

@@ -3,6 +3,7 @@ import Fuse from 'fuse.js';
 export declare const getterIdentifierToFlagTypeMap: {
     readonly getBooleanFF: "boolean";
     readonly ffTest: "boolean";
+    readonly fg: "boolean";
 };
 export type PlatformFeatureFlagRegistrationSection = {
     [key: string]: {

package/dist/types/rules/utils.d.ts

@@ -0,0 +1,7 @@
+import type { Rule, Scope } from 'eslint';
+export declare function isIdentifierImportedFrom(identifierName: string, sources: Set<string>, context: Rule.RuleContext): boolean;
+export declare function isAPIimport(functionName: string, context: Rule.RuleContext): boolean;
+export declare function getDef(name: string, context: Rule.RuleContext): Scope.Definition | null | undefined;
+export type Node<T extends Rule.Node['type']> = Extract<Rule.Node, {
+    type: T;
+}>;

package/dist/types-ts4.5/index.d.ts

@@ -6,12 +6,20 @@ export declare const rules: {
     'ensure-test-runner-nested-count': import("eslint").Rule.RuleModule;
     'ensure-atlassian-team': import("eslint").Rule.RuleModule;
     'ensure-critical-dependency-resolutions': import("eslint").Rule.RuleModule;
+    'ensure-valid-emotion-css-prop': import("eslint").Rule.RuleModule;
     'no-duplicate-dependencies': import("eslint").Rule.RuleModule;
     'no-invalid-feature-flag-usage': import("eslint").Rule.RuleModule;
     '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;
+    'static-feature-flags': import("eslint").Rule.RuleModule;
+    'no-preconditioning': import("eslint").Rule.RuleModule;
+    'inline-usage': import("eslint").Rule.RuleModule;
+    'prefer-fg': import("eslint").Rule.RuleModule;
+    'no-alias': import("eslint").Rule.RuleModule;
+    'use-recommended-utils': import("eslint").Rule.RuleModule;
 };
 export declare const configs: {
     recommended: {
@@ -26,9 +34,16 @@ export declare const configs: {
             '@atlaskit/platform/no-invalid-feature-flag-usage': string;
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': string;
             '@atlaskit/platform/ensure-atlassian-team': string;
+            '@atlaskit/platform/no-module-level-eval': string;
+            '@atlaskit/platform/static-feature-flags': string;
+            '@atlaskit/platform/no-preconditioning': string;
+            '@atlaskit/platform/inline-usage': string;
+            '@atlaskit/platform/prefer-fg': string;
+            '@atlaskit/platform/no-alias': string;
         };
     };
 };
 export declare const processors: {
     'package-json-processor': Linter.Processor<string | Linter.ProcessorFile>;
+    'package-json-processor-for-flat-config': Linter.Processor<string | Linter.ProcessorFile>;
 };

package/dist/types-ts4.5/rules/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FEATURE_API_IMPORT_SOURCES: Set<string>;
+export declare const FEATURE_MOCKS_IMPORT_SOURCES: Set<string>;
+export declare const FEATURE_UTILS_IMPORT_SOURCES: Set<string>;

package/dist/types-ts4.5/rules/ensure-valid-emotion-css-prop/index.d.ts

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

package/dist/types-ts4.5/rules/inline-usage/index.d.ts

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

package/dist/types-ts4.5/rules/no-alias/index.d.ts

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

package/dist/types-ts4.5/rules/no-module-level-eval/index.d.ts

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

package/dist/types-ts4.5/rules/no-preconditioning/index.d.ts

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

package/dist/types-ts4.5/rules/prefer-fg/index.d.ts

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

package/dist/types-ts4.5/rules/static-feature-flags/index.d.ts

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

package/dist/types-ts4.5/rules/use-recommended-utils/index.d.ts

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