@atlaskit/eslint-plugin-platform 0.6.1 → 0.7.0

package/dist/es2019/index.js

@@ -9,9 +9,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 const rules = {
   'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
   'ensure-feature-flag-prefix': ensureFeatureFlagPrefix,
@@ -19,12 +27,20 @@ export const 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 const configs = {
   recommended: {
@@ -38,11 +54,18 @@ export const 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'
     }
   }
 };
 const jsonPrefix = '/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, @typescript-eslint/semi, no-template-curly-in-string */ module.exports = ';
+const jsonPrefixForFlatConfig = '/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, no-template-curly-in-string */ module.exports = ';
 export const processors = {
   'package-json-processor': {
     preprocess: source => {
@@ -68,5 +91,32 @@ export const 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: source => {
+      // augment the json into a js file
+      return [jsonPrefixForFlatConfig + source.trim()];
+    },
+    postprocess: messages => {
+      return messages[0].map(message => {
+        const {
+          fix
+        } = message;
+        if (!fix) {
+          return message;
+        }
+        const offset = jsonPrefixForFlatConfig.length;
+        return {
+          ...message,
+          fix: {
+            ...fix,
+            range: [fix.range[0] - offset, fix.range[1] - offset]
+          }
+        };
+      });
+    },
+    supportsAutofix: true
   }
 };

package/dist/es2019/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 const 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 const FEATURE_MOCKS_IMPORT_SOURCES = new Set(['@atlassian/jira-feature-flagging-mocks', '@atlassian/jira-feature-gates-test-mocks', '@atlassian/jira-feature-gates-storybook-mocks']);
+export const FEATURE_UTILS_IMPORT_SOURCES = new Set(['@atlassian/jira-feature-flagging-utils', '@atlassian/jira-feature-gate-component']);

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

@@ -8,26 +8,63 @@ import { getObjectPropertyAsObject } from '../util/handle-ast-object';
 //
 const 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']
 };
 const matchMinorVersion = (desiredVersion, versionInResolutions) => {
   const 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);
 };
-const verifyResolutionFromObject = (node, pkg, version, optional) => {
+const verifyResolutionFromObject = ({
+  resolutions,
+  dependencies,
+  devDependencies,
+  pkg,
+  version,
+  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
-  const resolutionExist = node.properties.some(p => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg);
+  const resolutionExist = resolutions.properties.some(p => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg);
+  isDependencyPresent({
+    resolutions,
+    dependencies,
+    devDependencies,
+    pkg
+  });
   if (!resolutionExist) {
+    // when package is not a part of dependencies/devDependencies
+    if (optional === false && !isDependencyPresent({
+      resolutions,
+      dependencies,
+      devDependencies,
+      pkg
+    })) {
+      return true;
+    }
     return optional;
   }
-  const resolutionExistAndMatch = node.properties.some(p => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg && p.value.type === 'Literal' && matchMinorVersion(version, p.value.value));
+  const resolutionExistAndMatch = resolutions.properties.some(p => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg && p.value.type === 'Literal' && matchMinorVersion(version, p.value.value));
   return resolutionExistAndMatch;
 };
+const isDependencyPresent = ({
+  resolutions,
+  dependencies,
+  devDependencies,
+  pkg
+}) => {
+  const dependencyExist = dependencies !== null && dependencies.properties.some(p => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg);
+  const devDependencyExist = devDependencies !== null && devDependencies.properties.some(p => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg);
+  return dependencyExist || devDependencyExist;
+};
 const rule = {
   meta: {
     type: 'problem',
@@ -48,12 +85,21 @@ const rule = {
           return;
         }
         const packageResolutions = getObjectPropertyAsObject(node, 'resolutions');
+        const packageDependencies = getObjectPropertyAsObject(node, 'dependencies');
+        const packageDevDependencies = getObjectPropertyAsObject(node, 'devDependencies');
         const rootDir = findRootSync(process.cwd());
         const isRootPackageJson = fileName.endsWith(`${rootDir}/package.json`);
         if (packageResolutions !== null) {
           for (const [key, values] of Object.entries(DESIRED_PKG_VERSIONS)) {
             if (!values.some(value => {
-              return verifyResolutionFromObject(packageResolutions, key, value, !isRootPackageJson);
+              return verifyResolutionFromObject({
+                resolutions: packageResolutions,
+                dependencies: packageDependencies,
+                devDependencies: packageDevDependencies,
+                pkg: key,
+                version: value,
+                optional: !isRootPackageJson
+              });
             })) {
               return context.report({
                 node,

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

@@ -65,7 +65,7 @@ const rule = {
             });
             continue;
           }
-          const exportValueViolations = getExportValueViolation(pkgName, afExportsKey, afExportsValue, nativeExports);
+          const exportValueViolations = getExportValueViolation(afExportsKey, afExportsValue, nativeExports);
           if (exportValueViolations) {
             context.report({
               data: {
@@ -83,7 +83,7 @@ const rule = {
   }
 };
 function getExportKeyViolation(afExportsKey, afExportsValue, nativeExports) {
-  const afExportsValueHasExtension = path.extname(afExportsValue);
+  const afExportsValueHasExtension = path.extname(afExportsValue) !== '';
   if (afExportsValueHasExtension && !nativeExports.hasOwnProperty(afExportsKey)) {
     return {
       messageId: 'missingExportsKey',
@@ -106,15 +106,23 @@ function getExportKeyViolation(afExportsKey, afExportsValue, nativeExports) {
     };
   }
 }
-function getExportValueViolation(pkgName, afExportsKey, afExportsValue, nativeExports) {
-  const afExportsValueHasExtension = path.extname(afExportsValue);
+function getNativeExportsValue(afExportsKey, afExportsValueHasExtension, nativeExports) {
+  const nativeExportsKey = afExportsValueHasExtension ? afExportsKey : `${afExportsKey}/*`;
+  if (typeof nativeExports[nativeExportsKey] === 'object') {
+    return nativeExports[nativeExportsKey].default;
+  }
+  return nativeExports[nativeExportsKey];
+}
+function getExportValueViolation(afExportsKey, afExportsValue, nativeExports) {
+  const afExportsValueHasExtension = path.extname(afExportsValue) !== '';
+  const nativeExportsValue = getNativeExportsValue(afExportsKey, afExportsValueHasExtension, nativeExports);
 
   // Some entrypoints have been updated to an index.js file that registers ts-node
   // Use path.basename to get the file name to see if it is equal to 'index.js'
-  if (afExportsValueHasExtension && path.basename(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
@@ -122,7 +130,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[`${afExportsKey}/*`].startsWith(`${afExportsValue}/*`)) {
+  if (!afExportsValueHasExtension && !nativeExportsValue.startsWith(`${afExportsValue}/*`)) {
     return {
       key: `${afExportsKey}/*`,
       expectedValue: `${afExportsValue}/*`

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

@@ -0,0 +1,87 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+const 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(context) {
+    let emotionJsxImported = false;
+    let emotionJsxImportPosition;
+    let emotionCssImported = false;
+    let cssPropExpressonUsed = false;
+
+    // Ignore files in these directories
+    if (/example|__tests__|__fixtures__/.test(context.filename)) {
+      return {};
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === '@emotion/react') {
+          node.specifiers.forEach(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(node) {
+        const {
+          name,
+          value
+        } = node;
+
+        // Only run on emotion css props
+        if (!emotionJsxImported) return;
+        if (name.name !== 'css') return;
+        if (value.type === 'JSXExpressionContainer' && value.expression.type === 'ObjectExpression') {
+          cssPropExpressonUsed = true;
+          let containsFunctionExpression = false;
+
+          // Iterate over the properties of the object
+          value.expression.properties.forEach(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,
+              messageId: 'noEmotionCssPropFunctionCall'
+            });
+          }
+        }
+      },
+      'Program:exit'() {
+        if (emotionJsxImported && cssPropExpressonUsed && !emotionCssImported) {
+          context.report({
+            messageId: 'noEmotionCssImport',
+            loc: emotionJsxImportPosition || {
+              line: 1,
+              column: 0
+            }
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

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

@@ -0,0 +1,90 @@
+import { isAPIimport } from '../utils';
+const FUNCTION_NAMES = new Set(['ff', 'fg', 'expVal', 'expValEquals', 'UNSAFE_noExposureExp']);
+const STATSIG_ONLY_FUNCTION_NAMES = new Set(['fg', 'expVal', 'expValEquals', 'UNSAFE_noExposureExp']);
+const findDefinitionDeclaration = node => node.type === 'VariableDeclaration' || node.type === 'FunctionDeclaration' ? node : findDefinitionDeclaration(node.parent);
+const validateCallExpression = (node, context) => {
+  const targetedFunctionsSwitch = context.options[0] === 'ssOnly' ? STATSIG_ONLY_FUNCTION_NAMES : FUNCTION_NAMES;
+  const {
+    callee
+  } = node;
+  const shouldWarn = callee.type === 'Identifier' && targetedFunctionsSwitch.has(callee.name) && isAPIimport(callee.name, context);
+  if (shouldWarn) {
+    const defDeclaration = findDefinitionDeclaration(node.parent);
+    context.report({
+      messageId: 'inlineUsage',
+      node: defDeclaration.parent.type === 'ExportNamedDeclaration' ? defDeclaration.parent : defDeclaration
+    });
+    return true;
+  }
+  return false;
+};
+const 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);
+    }
+  }
+};
+const validateReturnExpression = ({
+  body
+}, context) => {
+  if (body.length !== 1) {
+    return;
+  }
+  const [statement] = body;
+  if (statement.type === 'ReturnStatement') {
+    const {
+      argument
+    } = statement;
+    if (argument && argument.type === 'CallExpression') {
+      validateCallExpression(argument, context);
+    } else if (argument && argument.type === 'BinaryExpression') {
+      validateBinaryExpression(argument, context);
+    }
+  }
+};
+const 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:
+  }
+};
+const 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(context) {
+    return {
+      'VariableDeclaration[declarations.length=1] > VariableDeclarator[id.type="Identifier"]:matches([init.type="ArrowFunctionExpression"], [init.type="FunctionExpression"]) > *.init': ({
+        body
+      }) => {
+        validateFunctionBody(body, context);
+      },
+      FunctionDeclaration: ({
+        body
+      }) => {
+        validateFunctionBody(body, context);
+      }
+    };
+  }
+};
+export default rule;

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

@@ -0,0 +1,58 @@
+import { FEATURE_API_IMPORT_SOURCES, FEATURE_MOCKS_IMPORT_SOURCES, FEATURE_UTILS_IMPORT_SOURCES } from '../constants';
+import { isIdentifierImportedFrom } from '../utils';
+const IMPORT_SOURCES = new Set([...FEATURE_API_IMPORT_SOURCES, ...FEATURE_MOCKS_IMPORT_SOURCES, ...FEATURE_UTILS_IMPORT_SOURCES]);
+const 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(context) {
+    return {
+      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 ? void 0 : _node$specifiers.forEach(specifier => {
+          if (specifier.type === 'ImportSpecifier') {
+            const {
+              imported,
+              local
+            } = specifier;
+            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"]': node => {
+        if (!node.init || node.init.type !== 'Identifier') {
+          return;
+        }
+        const isReassignment = isIdentifierImportedFrom(node.init.name, IMPORT_SOURCES, context);
+        if (isReassignment) {
+          context.report({
+            messageId: 'noReassignment',
+            node
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

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

@@ -0,0 +1,39 @@
+import { isAPIimport } from '../utils';
+const isInFunctionLevel = context => {
+  let 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;
+};
+const 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(context) {
+    return {
+      'CallExpression[callee.type="Identifier"]': node => {
+        if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && isAPIimport(node.callee.name, context) && !isInFunctionLevel(context)) {
+          context.report({
+            messageId: 'noModuleLevelEval',
+            node
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

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

@@ -0,0 +1,105 @@
+import { isAPIimport } from '../utils';
+const isAndExpression = node => node.type === 'LogicalExpression' && node.operator === '&&';
+const isExpUsage = calleeName => calleeName === 'expVal' || calleeName === 'expValEquals';
+const getGateType = (node, context) => {
+  const {
+    type
+  } = node;
+  if (type === 'BinaryExpression') {
+    return getGateType(node.left, context) || getGateType(node.right, context);
+  }
+  if (node.type === 'CallExpression') {
+    const {
+      callee
+    } = node;
+    const 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 '';
+};
+const getPreconditionStatus = (logicalExpression, context) => {
+  const {
+    left
+  } = logicalExpression;
+  // If left side is a nested AND expression then the left side node is on the nested's right
+  const leftGateType = getGateType(isAndExpression(left) ? left.right : left, context);
+  if (leftGateType) {
+    const 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 '';
+};
+const 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(context) {
+    return {
+      'LogicalExpression[operator="&&"]': node => {
+        const {
+          parent
+        } = node;
+        // Don't analyze nested AND logical expressions
+        if (isAndExpression(parent)) {
+          return;
+        }
+        const 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 === '||');
+        let nextLogicalExpression = node;
+        let exposureReported = false;
+        let configReported = false;
+        while (nextLogicalExpression) {
+          const preconditionStatus = getPreconditionStatus(nextLogicalExpression, context);
+          // Allow us to check for: fg('') && <Component />
+          const 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
+            });
+            exposureReported = true;
+          }
+          if (!configReported && preconditionStatus === 'unnecessary-gate') {
+            context.report({
+              messageId: 'useConfig',
+              node
+            });
+            configReported = true;
+          }
+          if (exposureReported && configReported) {
+            return;
+          }
+          nextLogicalExpression = isAndExpression(nextLogicalExpression.left) ? nextLogicalExpression.left : undefined;
+        }
+      }
+    };
+  }
+};
+export default rule;