@atlaskit/eslint-plugin-platform 0.6.1 → 0.7.0

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

@@ -0,0 +1,81 @@
+import { FEATURE_API_IMPORT_SOURCES } from '../constants';
+const validateUsage = (node, utilName, context, changeMap) => {
+  var _context$getScope$ref;
+  const resolved = (_context$getScope$ref = context.getScope().references.find(ref => ref.identifier.name === utilName)) === null || _context$getScope$ref === void 0 ? void 0 : _context$getScope$ref.resolved;
+  const importSpecifierDefinition = resolved === null || resolved === void 0 ? void 0 : resolved.defs.find(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) {
+    const [flagNameArg] = node.arguments;
+    context.report({
+      messageId: 'preferFG',
+      node,
+      *fix(fixer) {
+        yield fixer.replaceText(node, `fg(${context.sourceCode.getText(flagNameArg)})`);
+        const importDeclaration = importSpecifierDefinition.parent;
+        if (changeMap.has(importDeclaration)) {
+          const changeCounts = changeMap.get(importDeclaration);
+          changeMap.set(importDeclaration, {
+            ...changeCounts,
+            [utilName]: changeCounts[utilName] + 1 || 1
+          });
+        } else {
+          changeMap.set(importDeclaration, {
+            [utilName]: 1
+          });
+        }
+      }
+    });
+  }
+};
+const 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(context) {
+    let changeMap;
+    return {
+      'CallExpression[callee.name="getBooleanFF"]': node => {
+        if (node.type !== 'CallExpression') {
+          return;
+        }
+        changeMap = changeMap || new Map();
+        validateUsage(node, 'getBooleanFF', context, changeMap);
+      },
+      'Program:exit': () => {
+        var _changeMap;
+        if ((_changeMap = changeMap) !== null && _changeMap !== void 0 && _changeMap.size) {
+          changeMap.forEach((changeCounts, importDeclaration) => {
+            const [moduleScope] = context.getScope().childScopes;
+            const importSpecifiers = new Set(importDeclaration.specifiers.map(({
+              imported
+            }) => imported.name));
+            importSpecifiers.add('fg');
+            Object.keys(changeCounts).forEach(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: fixer => fixer.replaceText(importDeclaration, `import { ${Array.from(importSpecifiers).join(', ')} } from '${importDeclaration.source.value}';`)
+            });
+          });
+          changeMap.clear();
+        }
+      }
+    };
+  }
+};
+export default rule;

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

@@ -0,0 +1,54 @@
+import { FEATURE_API_IMPORT_SOURCES } from '../constants';
+import { getDef, isIdentifierImportedFrom } from '../utils';
+const IMPORT_SOURCES = new Set([...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.
+const FUNCTION_NAMES = new Set(['ff', 'fg', 'getFeatureFlagValue', 'getMultivariateFeatureFlag', 'componentWithFF', 'componentWithFG', 'passGate', 'withGate', 'expVal', 'expValEquals', 'UNSAFE_noExposureExp', 'mockExp', 'withExp', 'wasExperimentManuallyExposed']);
+const STATSIG_ONLY_FUNCTION_NAMES = new Set(['fg', 'componentWithFG', 'passGate', 'withGate', 'expVal', 'expValEquals', 'UNSAFE_noExposureExp', 'mockExp', 'withExp', 'wasExperimentManuallyExposed']);
+const 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(context) {
+    const 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"]': node => {
+        if (node.type !== 'CallExpression') {
+          return;
+        }
+        if (node.callee.type === 'Identifier' && (!targetedFunctionsSwitch.has(node.callee.name) || !isIdentifierImportedFrom(node.callee.name, IMPORT_SOURCES, context))) {
+          return;
+        }
+        const nameArgument = node.arguments[0];
+        if (nameArgument.type === 'Identifier') {
+          const def = getDef(nameArgument.name, context);
+          if (def != null && def.type === 'Variable') {
+            const {
+              value
+            } = def.node.init;
+            context.report({
+              node: nameArgument,
+              messageId: 'FFLiteral',
+              fix: fixer => fixer.replaceText(nameArgument, `'${value}'`)
+            });
+            return;
+          }
+        }
+        context.report({
+          node: nameArgument,
+          messageId: 'FFLiteral'
+        });
+      }
+    };
+  }
+};
+export default rule;

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

@@ -0,0 +1,41 @@
+import { isIdentifierImportedFrom } from '../utils';
+const BANNED_IMPORTS_SET = new Set(['@atlaskit/feature-gate-js-client']);
+const 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(context) {
+    return {
+      'CallExpression > MemberExpression:matches([property.name="checkGate"])': node => {
+        if (node.object.type === 'Identifier' && isIdentifierImportedFrom(node.object.name, BANNED_IMPORTS_SET, context)) {
+          context.report({
+            messageId: 'useRecommended',
+            node,
+            data: {
+              lib: '`@atlaskit/platform-feature-flags`',
+              util: node.property.name,
+              recommended: '`fg`'
+            }
+          });
+        }
+      },
+      'CallExpression > MemberExpression:matches([property.name="getExperimentValue"])': node => {
+        if (node.object.type === 'Identifier' && isIdentifierImportedFrom(node.object.name, BANNED_IMPORTS_SET, context)) {
+          context.report({
+            messageId: 'notSupported',
+            node
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

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

@@ -6,7 +6,8 @@ import Fuse from 'fuse.js';
 // if you don't want to verify the type use `null` as the value
 export const 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.
 const pkgJsonCache = new Map();

package/dist/es2019/rules/utils.js

@@ -0,0 +1,29 @@
+import { FEATURE_API_IMPORT_SOURCES } from './constants';
+export function isIdentifierImportedFrom(identifierName, sources, context) {
+  if (sources.size > 0) {
+    var _context$getScope$ref, _context$getScope$ref2, _context$getScope$ref3;
+    return (_context$getScope$ref = (_context$getScope$ref2 = context.getScope().references.find(ref => ref.identifier.name === identifierName)) === null || _context$getScope$ref2 === void 0 ? void 0 : (_context$getScope$ref3 = _context$getScope$ref2.resolved) === null || _context$getScope$ref3 === void 0 ? void 0 : _context$getScope$ref3.defs.some(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) {
+  let scope = context.getScope();
+  while (scope && scope.type !== 'global') {
+    for (const variable of scope.variables) {
+      if (variable.name === name) {
+        const definition = variable.defs.find(def => def.node && def.node.type === 'VariableDeclarator');
+        return definition;
+      }
+    }
+    scope = scope.upper;
+  }
+  return null;
+}

package/dist/esm/index.js

@@ -12,9 +12,17 @@ import noDuplicateDependencies from './rules/no-duplicate-dependencies';
 import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 import ensureFeatureFlagPrefix from './rules/ensure-feature-flag-prefix';
 import ensureCriticalDependencyResolutions from './rules/ensure-critical-dependency-resolutions';
+import ensureValidEmotionCssProp from './rules/ensure-valid-emotion-css-prop';
 import noInvalidStorybookDecoratorUsage from './rules/no-invalid-storybook-decorator-usage';
 import ensurePublishValid from './rules/ensure-publish-valid';
 import ensureNativeAndAfExportsSynced from './rules/ensure-native-and-af-exports-synced';
+import noModuleLevelEval from './rules/no-module-level-eval';
+import staticFeatureFlags from './rules/static-feature-flags';
+import noPreconditioning from './rules/no-preconditioning';
+import inlineUsage from './rules/inline-usage';
+import preferFG from './rules/prefer-fg';
+import noAlias from './rules/no-alias';
+import useRecommendedUtils from './rules/use-recommended-utils';
 export var rules = {
   'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
   'ensure-feature-flag-prefix': ensureFeatureFlagPrefix,
@@ -22,12 +30,20 @@ export var rules = {
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'ensure-atlassian-team': ensureAtlassianTeam,
   'ensure-critical-dependency-resolutions': ensureCriticalDependencyResolutions,
+  'ensure-valid-emotion-css-prop': ensureValidEmotionCssProp,
   'no-duplicate-dependencies': noDuplicateDependencies,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,
   'no-invalid-storybook-decorator-usage': noInvalidStorybookDecoratorUsage,
   'ensure-publish-valid': ensurePublishValid,
-  'ensure-native-and-af-exports-synced': ensureNativeAndAfExportsSynced
+  'ensure-native-and-af-exports-synced': ensureNativeAndAfExportsSynced,
+  'no-module-level-eval': noModuleLevelEval,
+  'static-feature-flags': staticFeatureFlags,
+  'no-preconditioning': noPreconditioning,
+  'inline-usage': inlineUsage,
+  'prefer-fg': preferFG,
+  'no-alias': noAlias,
+  'use-recommended-utils': useRecommendedUtils
 };
 export var configs = {
   recommended: {
@@ -41,11 +57,18 @@ export var configs = {
       '@atlaskit/platform/ensure-test-runner-nested-count': 'warn',
       '@atlaskit/platform/no-invalid-feature-flag-usage': 'error',
       '@atlaskit/platform/no-invalid-storybook-decorator-usage': 'error',
-      '@atlaskit/platform/ensure-atlassian-team': 'error'
+      '@atlaskit/platform/ensure-atlassian-team': 'error',
+      '@atlaskit/platform/no-module-level-eval': 'error',
+      '@atlaskit/platform/static-feature-flags': 'error',
+      '@atlaskit/platform/no-preconditioning': 'error',
+      '@atlaskit/platform/inline-usage': 'error',
+      '@atlaskit/platform/prefer-fg': 'error',
+      '@atlaskit/platform/no-alias': 'error'
     }
   }
 };
 var jsonPrefix = '/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, @typescript-eslint/semi, no-template-curly-in-string */ module.exports = ';
+var jsonPrefixForFlatConfig = '/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, no-template-curly-in-string */ module.exports = ';
 export var processors = {
   'package-json-processor': {
     preprocess: function preprocess(source) {
@@ -67,5 +90,28 @@ export var processors = {
       });
     },
     supportsAutofix: true
+  },
+  // This processor is used for ESLint FlatConfig,
+  // once we roll out FlatConfig, we can remove the above processor
+  'package-json-processor-for-flat-config': {
+    preprocess: function preprocess(source) {
+      // augment the json into a js file
+      return [jsonPrefixForFlatConfig + source.trim()];
+    },
+    postprocess: function postprocess(messages) {
+      return messages[0].map(function (message) {
+        var fix = message.fix;
+        if (!fix) {
+          return message;
+        }
+        var offset = jsonPrefixForFlatConfig.length;
+        return _objectSpread(_objectSpread({}, message), {}, {
+          fix: _objectSpread(_objectSpread({}, fix), {}, {
+            range: [fix.range[0] - offset, fix.range[1] - offset]
+          })
+        });
+      });
+    },
+    supportsAutofix: true
   }
 };

package/dist/esm/rules/constants.js

@@ -0,0 +1,5 @@
+// List of libraries that we maintain or have worked on
+// - eg `@atlaskit/feature-gate-js-client` shouldn't be included in here
+export var FEATURE_API_IMPORT_SOURCES = new Set(['@atlassian/jira-feature-flagging', '@atlassian/jira-feature-flagging-using-meta', '@atlassian/jira-feature-gating', '@atlassian/jira-feature-experiments', '@atlaskit/platform-feature-flags']);
+export var FEATURE_MOCKS_IMPORT_SOURCES = new Set(['@atlassian/jira-feature-flagging-mocks', '@atlassian/jira-feature-gates-test-mocks', '@atlassian/jira-feature-gates-storybook-mocks']);
+export var FEATURE_UTILS_IMPORT_SOURCES = new Set(['@atlassian/jira-feature-flagging-utils', '@atlassian/jira-feature-gate-component']);

package/dist/esm/rules/ensure-critical-dependency-resolutions/index.js

@@ -9,30 +9,69 @@ import { getObjectPropertyAsObject } from '../util/handle-ast-object';
 //
 var DESIRED_PKG_VERSIONS = {
   typescript: ['5.4'],
-  '@types/react': ['16.14', '18.2']
+  tslib: ['2.6'],
+  '@types/react': ['16.14', '18.2'],
+  'react-relay': ['npm:atl-react-relay@0.0.0-main-2ccd6998'],
+  'relay-compiler': ['npm:atl-relay-compiler@0.0.0-main-2ccd6998'],
+  'relay-runtime': ['npm:atl-relay-runtime@0.0.0-main-2ccd6998'],
+  'relay-test-utils': ['npm:atl-relay-test-utils@0.0.0-main-2ccd6998']
 };
 var matchMinorVersion = function matchMinorVersion(desiredVersion, versionInResolutions) {
   var firstChar = versionInResolutions[0];
   // The version is invalid if it doesn't start with a number or ~
-  if (!/^\d$/.test(firstChar) && firstChar !== '~') {
+  if (!/^\d$/.test(firstChar) && firstChar !== '~' && !versionInResolutions.startsWith('npm:')) {
     return false;
   }
   return versionInResolutions.startsWith(desiredVersion) || versionInResolutions.startsWith('~' + desiredVersion);
 };
-var verifyResolutionFromObject = function verifyResolutionFromObject(node, pkg, version, optional) {
+var verifyResolutionFromObject = function verifyResolutionFromObject(_ref) {
+  var resolutions = _ref.resolutions,
+    dependencies = _ref.dependencies,
+    devDependencies = _ref.devDependencies,
+    pkg = _ref.pkg,
+    version = _ref.version,
+    optional = _ref.optional;
   // For root package.json, we require the critical packages' resolutions exist and with matching version
   // For individual package's package.json, it's ok if resolutions don't exist. But if they do, the version should match
-  var resolutionExist = node.properties.some(function (p) {
+  var resolutionExist = resolutions.properties.some(function (p) {
     return p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg;
   });
+  isDependencyPresent({
+    resolutions: resolutions,
+    dependencies: dependencies,
+    devDependencies: devDependencies,
+    pkg: pkg
+  });
   if (!resolutionExist) {
+    // when package is not a part of dependencies/devDependencies
+    if (optional === false && !isDependencyPresent({
+      resolutions: resolutions,
+      dependencies: dependencies,
+      devDependencies: devDependencies,
+      pkg: pkg
+    })) {
+      return true;
+    }
     return optional;
   }
-  var resolutionExistAndMatch = node.properties.some(function (p) {
+  var resolutionExistAndMatch = resolutions.properties.some(function (p) {
     return p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg && p.value.type === 'Literal' && matchMinorVersion(version, p.value.value);
   });
   return resolutionExistAndMatch;
 };
+var isDependencyPresent = function isDependencyPresent(_ref2) {
+  var resolutions = _ref2.resolutions,
+    dependencies = _ref2.dependencies,
+    devDependencies = _ref2.devDependencies,
+    pkg = _ref2.pkg;
+  var dependencyExist = dependencies !== null && dependencies.properties.some(function (p) {
+    return p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg;
+  });
+  var devDependencyExist = devDependencies !== null && devDependencies.properties.some(function (p) {
+    return p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg;
+  });
+  return dependencyExist || devDependencyExist;
+};
 var rule = {
   meta: {
     type: 'problem',
@@ -61,6 +100,8 @@ var rule = {
           return;
         }
         var packageResolutions = getObjectPropertyAsObject(node, 'resolutions');
+        var packageDependencies = getObjectPropertyAsObject(node, 'dependencies');
+        var packageDevDependencies = getObjectPropertyAsObject(node, 'devDependencies');
         var rootDir = findRootSync(process.cwd());
         var isRootPackageJson = fileName.endsWith("".concat(rootDir, "/package.json"));
         if (packageResolutions !== null) {
@@ -69,7 +110,14 @@ var rule = {
                 key = _Object$entries$_i[0],
                 values = _Object$entries$_i[1];
               if (!values.some(function (value) {
-                return verifyResolutionFromObject(packageResolutions, key, value, !isRootPackageJson);
+                return verifyResolutionFromObject({
+                  resolutions: packageResolutions,
+                  dependencies: packageDependencies,
+                  devDependencies: packageDevDependencies,
+                  pkg: key,
+                  version: value,
+                  optional: !isRootPackageJson
+                });
               })) {
                 return {
                   v: context.report({

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

@@ -1,3 +1,4 @@
+import _typeof from "@babel/runtime/helpers/typeof";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 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; }
@@ -70,7 +71,7 @@ var rule = {
             });
             continue;
           }
-          var exportValueViolations = getExportValueViolation(pkgName, afExportsKey, afExportsValue, nativeExports);
+          var exportValueViolations = getExportValueViolation(afExportsKey, afExportsValue, nativeExports);
           if (exportValueViolations) {
             context.report({
               data: _objectSpread(_objectSpread({}, exportValueViolations), {}, {
@@ -87,7 +88,7 @@ var rule = {
   }
 };
 function getExportKeyViolation(afExportsKey, afExportsValue, nativeExports) {
-  var afExportsValueHasExtension = path.extname(afExportsValue);
+  var afExportsValueHasExtension = path.extname(afExportsValue) !== '';
   if (afExportsValueHasExtension && !nativeExports.hasOwnProperty(afExportsKey)) {
     return {
       messageId: 'missingExportsKey',
@@ -110,15 +111,23 @@ function getExportKeyViolation(afExportsKey, afExportsValue, nativeExports) {
     };
   }
 }
-function getExportValueViolation(pkgName, afExportsKey, afExportsValue, nativeExports) {
-  var afExportsValueHasExtension = path.extname(afExportsValue);
+function getNativeExportsValue(afExportsKey, afExportsValueHasExtension, nativeExports) {
+  var nativeExportsKey = afExportsValueHasExtension ? afExportsKey : "".concat(afExportsKey, "/*");
+  if (_typeof(nativeExports[nativeExportsKey]) === 'object') {
+    return nativeExports[nativeExportsKey].default;
+  }
+  return nativeExports[nativeExportsKey];
+}
+function getExportValueViolation(afExportsKey, afExportsValue, nativeExports) {
+  var afExportsValueHasExtension = path.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.basename(nativeExports[afExportsKey]) === 'index.js') {
+  if (afExportsValueHasExtension && path.basename(nativeExportsValue) === 'index.js') {
     return;
   }
-  if (afExportsValueHasExtension && nativeExports[afExportsKey] !== afExportsValue) {
+  if (afExportsValueHasExtension && nativeExportsValue !== afExportsValue) {
     return {
       key: afExportsKey,
       expectedValue: afExportsValue
@@ -126,7 +135,7 @@ function getExportValueViolation(pkgName, afExportsKey, afExportsValue, nativeEx
   }
 
   // af:exports entrypoints without a file extension export the whole directory so check to ensure the exports value includes the wildcard
-  if (!afExportsValueHasExtension && !nativeExports["".concat(afExportsKey, "/*")].startsWith("".concat(afExportsValue, "/*"))) {
+  if (!afExportsValueHasExtension && !nativeExportsValue.startsWith("".concat(afExportsValue, "/*"))) {
     return {
       key: "".concat(afExportsKey, "/*"),
       expectedValue: "".concat(afExportsValue, "/*")

package/dist/esm/rules/ensure-valid-emotion-css-prop/index.js

@@ -0,0 +1,85 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Ensure valid use of the `css` prop from `@emotion/react`',
+      recommended: true
+    },
+    messages: {
+      noEmotionCssImport: 'Must import `css` from `@emotion/react` when using the `css` prop.',
+      noEmotionCssPropFunctionCall: 'No function calls allowed when passing an object directly to the `css` prop with `@emotion/react`.'
+    }
+  },
+  create: function create(context) {
+    var emotionJsxImported = false;
+    var emotionJsxImportPosition;
+    var emotionCssImported = false;
+    var cssPropExpressonUsed = false;
+
+    // Ignore files in these directories
+    if (/example|__tests__|__fixtures__/.test(context.filename)) {
+      return {};
+    }
+    return {
+      ImportDeclaration: function ImportDeclaration(node) {
+        if (node.source.value === '@emotion/react') {
+          node.specifiers.forEach(function (specifier) {
+            if (specifier.type === 'ImportSpecifier') {
+              if (specifier.imported.name === 'jsx') {
+                var _specifier$loc;
+                emotionJsxImported = true;
+                emotionJsxImportPosition = (_specifier$loc = specifier.loc) === null || _specifier$loc === void 0 ? void 0 : _specifier$loc.start;
+              }
+              if (specifier.imported.name === 'css') {
+                emotionCssImported = true;
+              }
+            }
+          });
+        }
+      },
+      JSXAttribute: function JSXAttribute(node) {
+        var name = node.name,
+          value = node.value;
+
+        // Only run on emotion css props
+        if (!emotionJsxImported) return;
+        if (name.name !== 'css') return;
+        if (value.type === 'JSXExpressionContainer' && value.expression.type === 'ObjectExpression') {
+          cssPropExpressonUsed = true;
+          var containsFunctionExpression = false;
+
+          // Iterate over the properties of the object
+          value.expression.properties.forEach(function (prop) {
+            var _prop$value, _prop$value2, _prop$value3;
+            // Check for function expressions directly within the object literal
+            if (((_prop$value = prop.value) === null || _prop$value === void 0 ? void 0 : _prop$value.type) === 'ArrowFunctionExpression' || ((_prop$value2 = prop.value) === null || _prop$value2 === void 0 ? void 0 : _prop$value2.type) === 'FunctionExpression' || ((_prop$value3 = prop.value) === null || _prop$value3 === void 0 ? void 0 : _prop$value3.type) === 'CallExpression') {
+              containsFunctionExpression = true;
+            }
+          });
+
+          // If a function expression is found within the direct object literal, report an error
+          if (containsFunctionExpression) {
+            context.report({
+              node: node,
+              messageId: 'noEmotionCssPropFunctionCall'
+            });
+          }
+        }
+      },
+      'Program:exit': function ProgramExit() {
+        if (emotionJsxImported && cssPropExpressonUsed && !emotionCssImported) {
+          context.report({
+            messageId: 'noEmotionCssImport',
+            loc: emotionJsxImportPosition || {
+              line: 1,
+              column: 0
+            }
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/rules/inline-usage/index.js

@@ -0,0 +1,87 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { isAPIimport } from '../utils';
+var FUNCTION_NAMES = new Set(['ff', 'fg', 'expVal', 'expValEquals', 'UNSAFE_noExposureExp']);
+var STATSIG_ONLY_FUNCTION_NAMES = new Set(['fg', 'expVal', 'expValEquals', 'UNSAFE_noExposureExp']);
+var findDefinitionDeclaration = function findDefinitionDeclaration(node) {
+  return node.type === 'VariableDeclaration' || node.type === 'FunctionDeclaration' ? node : findDefinitionDeclaration(node.parent);
+};
+var validateCallExpression = function validateCallExpression(node, context) {
+  var targetedFunctionsSwitch = context.options[0] === 'ssOnly' ? STATSIG_ONLY_FUNCTION_NAMES : FUNCTION_NAMES;
+  var callee = node.callee;
+  var shouldWarn = callee.type === 'Identifier' && targetedFunctionsSwitch.has(callee.name) && isAPIimport(callee.name, context);
+  if (shouldWarn) {
+    var defDeclaration = findDefinitionDeclaration(node.parent);
+    context.report({
+      messageId: 'inlineUsage',
+      node: defDeclaration.parent.type === 'ExportNamedDeclaration' ? defDeclaration.parent : defDeclaration
+    });
+    return true;
+  }
+  return false;
+};
+var validateBinaryExpression = function validateBinaryExpression(node, context) {
+  // Match all comparator operators i.e ===, >=, <
+  if (node.operator.match(/^[=|<|>]/)) {
+    if (node.left.type === 'CallExpression' && validateCallExpression(node.left, context)) {
+      return;
+    }
+    if (node.right.type === 'CallExpression') {
+      validateCallExpression(node.right, context);
+    }
+  }
+};
+var validateReturnExpression = function validateReturnExpression(_ref, context) {
+  var body = _ref.body;
+  if (body.length !== 1) {
+    return;
+  }
+  var _body = _slicedToArray(body, 1),
+    statement = _body[0];
+  if (statement.type === 'ReturnStatement') {
+    var argument = statement.argument;
+    if (argument && argument.type === 'CallExpression') {
+      validateCallExpression(argument, context);
+    } else if (argument && argument.type === 'BinaryExpression') {
+      validateBinaryExpression(argument, context);
+    }
+  }
+};
+var validateFunctionBody = function validateFunctionBody(body, context) {
+  switch (body.type) {
+    case 'CallExpression':
+      validateCallExpression(body, context);
+      break;
+    case 'BinaryExpression':
+      validateBinaryExpression(body, context);
+      break;
+    case 'BlockStatement':
+      validateReturnExpression(body, context);
+      break;
+    default:
+  }
+};
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Ensure feature flags/gates and experiments are inlined so that they can be statically analyzable.',
+      url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/ff/inline-usage/README.md'
+    },
+    messages: {
+      inlineUsage: 'Do not export or wrap feature flags/gates and experiments usages. Inline calls at the callsite to ensure it is statically analyzable.'
+    }
+  },
+  create: function create(context) {
+    return {
+      'VariableDeclaration[declarations.length=1] > VariableDeclarator[id.type="Identifier"]:matches([init.type="ArrowFunctionExpression"], [init.type="FunctionExpression"]) > *.init': function VariableDeclarationDeclarationsLength1VariableDeclaratorIdTypeIdentifierMatchesInitTypeArrowFunctionExpressionInitTypeFunctionExpressionInit(_ref2) {
+        var body = _ref2.body;
+        validateFunctionBody(body, context);
+      },
+      FunctionDeclaration: function FunctionDeclaration(_ref3) {
+        var body = _ref3.body;
+        validateFunctionBody(body, context);
+      }
+    };
+  }
+};
+export default rule;