@atlaskit/eslint-plugin-platform 0.0.4 → 0.0.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atlaskit/eslint-plugin-platform
 
+## 0.0.5
+
+### Patch Changes
+
+- [`aeb52cac34c`](https://bitbucket.org/atlassian/atlassian-frontend/commits/aeb52cac34c) - Split feature flag registration rule into two to more easily use it in products
+
 ## 0.0.4
 
 ### Patch Changes

package/dist/cjs/index.js

@@ -6,15 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.rules = exports.configs = void 0;
 var _ensureFeatureFlagRegistration = _interopRequireDefault(require("./rules/ensure-feature-flag-registration"));
+var _noInvalidFeatureFlagUsage = _interopRequireDefault(require("./rules/no-invalid-feature-flag-usage"));
 var rules = {
-  'ensure-feature-flag-registration': _ensureFeatureFlagRegistration.default
+  'ensure-feature-flag-registration': _ensureFeatureFlagRegistration.default,
+  'no-invalid-feature-flag-usage': _noInvalidFeatureFlagUsage.default
 };
 exports.rules = rules;
 var configs = {
   recommended: {
     plugins: ['@atlaskit/platform'],
     rules: {
-      '@atlaskit/platform/ensure-feature-flag-registration': 'error'
+      '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/no-invalid-feature-flag-usage': 'error'
     }
   }
 };

package/dist/cjs/rules/ensure-feature-flag-registration/index.js

@@ -31,34 +31,6 @@ var getPackageJsonForFileName = function getPackageJsonForFileName(filename) {
   pkgJsonCache.set(pkgJsonPath, packageJson);
   return packageJson;
 };
-var __isOnlyOneFlagCheckInExpression = function __isOnlyOneFlagCheckInExpression(root, ignoredNode) {
-  switch (root.type) {
-    case 'IfStatement':
-      return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
-    case 'CallExpression':
-      if (root === ignoredNode) {
-        return true;
-      }
-      return !(root.callee.type === 'Identifier' && root.callee.name === 'getBooleanFF');
-
-    // shouldn't ever get here but just in case
-    case 'Identifier':
-      return root.name !== 'getBooleanFF';
-    case 'BinaryExpression':
-    case 'LogicalExpression':
-      return __isOnlyOneFlagCheckInExpression(root.left, ignoredNode) && __isOnlyOneFlagCheckInExpression(root.right, ignoredNode);
-    default:
-      return true;
-  }
-};
-var isOnlyOneFlagCheckInExpression = function isOnlyOneFlagCheckInExpression(node) {
-  var root = node.parent;
-  // find the root node of the expression
-  while (root.type === 'LogicalExpression') {
-    root = root.parent;
-  }
-  return __isOnlyOneFlagCheckInExpression(root, node);
-};
 var rule = {
   meta: {
     hasSuggestions: false,
@@ -67,11 +39,8 @@ var rule = {
     },
     type: 'problem',
     messages: {
-      onlyInlineIf: "Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
-      onlyStringLiteral: "Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
       registrationSectionMissing: 'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
-      featureFlagMissing: "Please add a \"{{ featureFlag }}\" section to the \"platform-feature-flags\" section in your package.json. See http://go/pff-eslint for more details",
-      multipleFlagCheckInExpression: "Only check one flag per expression! See http://go/pff-eslint for more details"
+      featureFlagMissing: "Please add a \"{{ featureFlag }}\" section to the \"platform-feature-flags\" section in your package.json. See http://go/pff-eslint for more details"
     }
   },
   create: function create(context) {
@@ -79,33 +48,7 @@ var rule = {
       'CallExpression[callee.name=/getBooleanFF/]': function CallExpressionCalleeNameGetBooleanFF(node) {
         // to make typescript happy
         if (node.type === 'CallExpression') {
-          var _node$parent;
           var args = node.arguments;
-          if (args.length === 1 && args[0].type !== 'Literal') {
-            return context.report({
-              node: node,
-              messageId: 'onlyStringLiteral'
-            });
-          }
-          switch ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) {
-            case 'IfStatement':
-            case 'ConditionalExpression':
-              break;
-            case 'LogicalExpression':
-              if (!isOnlyOneFlagCheckInExpression(node)) {
-                context.report({
-                  node: node,
-                  messageId: 'multipleFlagCheckInExpression'
-                });
-              }
-              break;
-            default:
-              return context.report({
-                node: node,
-                messageId: 'onlyInlineIf'
-              });
-              break;
-          }
           var filename = context.getFilename();
           var packageJson = getPackageJsonForFileName(filename);
           var platformFeatureFlags = packageJson['platform-feature-flags'];

package/dist/cjs/rules/no-invalid-feature-flag-usage/index.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var FF_GETTER_BOOLEAN_IDENTIFIER = 'getBooleanFF';
+var __isOnlyOneFlagCheckInExpression = function __isOnlyOneFlagCheckInExpression(root, ignoredNode) {
+  switch (root.type) {
+    case 'IfStatement':
+      return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
+    case 'CallExpression':
+      if (root === ignoredNode) {
+        return true;
+      }
+      return !(root.callee.type === 'Identifier' && root.callee.name === FF_GETTER_BOOLEAN_IDENTIFIER);
+
+    // shouldn't ever get here but just in case
+    case 'Identifier':
+      return root.name !== FF_GETTER_BOOLEAN_IDENTIFIER;
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      return __isOnlyOneFlagCheckInExpression(root.left, ignoredNode) && __isOnlyOneFlagCheckInExpression(root.right, ignoredNode);
+    default:
+      return true;
+  }
+};
+var isOnlyOneFlagCheckInExpression = function isOnlyOneFlagCheckInExpression(node) {
+  var root = node.parent;
+  // find the root node of the expression
+  while (root.type === 'LogicalExpression') {
+    root = root.parent;
+  }
+  return __isOnlyOneFlagCheckInExpression(root, node);
+};
+var rule = {
+  meta: {
+    hasSuggestions: false,
+    docs: {
+      recommended: false
+    },
+    type: 'problem',
+    messages: {
+      onlyInlineIf: "Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
+      onlyStringLiteral: "Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
+      multipleFlagCheckInExpression: "Only check one flag per expression! See http://go/pff-eslint for more details"
+    }
+  },
+  create: function create(context) {
+    return (0, _defineProperty2.default)({}, "CallExpression[callee.name=/".concat(FF_GETTER_BOOLEAN_IDENTIFIER, "/]"), function CallExpressionCalleeName(node) {
+      // to make typescript happy
+      if (node.type === 'CallExpression') {
+        var _node$parent;
+        var args = node.arguments;
+        if (args.length === 1 && args[0].type !== 'Literal') {
+          return context.report({
+            node: node,
+            messageId: 'onlyStringLiteral'
+          });
+        }
+        switch ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) {
+          case 'IfStatement':
+          case 'ConditionalExpression':
+            break;
+          case 'LogicalExpression':
+            if (!isOnlyOneFlagCheckInExpression(node)) {
+              context.report({
+                node: node,
+                messageId: 'multipleFlagCheckInExpression'
+              });
+            }
+            break;
+          default:
+            return context.report({
+              node: node,
+              messageId: 'onlyInlineIf'
+            });
+        }
+      }
+      return {};
+    });
+  }
+};
+var _default = rule;
+exports.default = _default;

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/eslint-plugin-platform",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"sideEffects": false
 }

package/dist/es2019/index.js

@@ -1,12 +1,15 @@
 import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registration';
+import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 export const rules = {
-  'ensure-feature-flag-registration': ensureFeatureFlagRegistration
+  'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
+  'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage
 };
 export const configs = {
   recommended: {
     plugins: ['@atlaskit/platform'],
     rules: {
-      '@atlaskit/platform/ensure-feature-flag-registration': 'error'
+      '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/no-invalid-feature-flag-usage': 'error'
     }
   }
 };

package/dist/es2019/rules/ensure-feature-flag-registration/index.js

@@ -24,34 +24,6 @@ const getPackageJsonForFileName = filename => {
   pkgJsonCache.set(pkgJsonPath, packageJson);
   return packageJson;
 };
-const __isOnlyOneFlagCheckInExpression = (root, ignoredNode) => {
-  switch (root.type) {
-    case 'IfStatement':
-      return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
-    case 'CallExpression':
-      if (root === ignoredNode) {
-        return true;
-      }
-      return !(root.callee.type === 'Identifier' && root.callee.name === 'getBooleanFF');
-
-    // shouldn't ever get here but just in case
-    case 'Identifier':
-      return root.name !== 'getBooleanFF';
-    case 'BinaryExpression':
-    case 'LogicalExpression':
-      return __isOnlyOneFlagCheckInExpression(root.left, ignoredNode) && __isOnlyOneFlagCheckInExpression(root.right, ignoredNode);
-    default:
-      return true;
-  }
-};
-const isOnlyOneFlagCheckInExpression = node => {
-  let root = node.parent;
-  // find the root node of the expression
-  while (root.type === 'LogicalExpression') {
-    root = root.parent;
-  }
-  return __isOnlyOneFlagCheckInExpression(root, node);
-};
 const rule = {
   meta: {
     hasSuggestions: false,
@@ -60,11 +32,8 @@ const rule = {
     },
     type: 'problem',
     messages: {
-      onlyInlineIf: "Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
-      onlyStringLiteral: "Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
       registrationSectionMissing: 'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
-      featureFlagMissing: `Please add a "{{ featureFlag }}" section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details`,
-      multipleFlagCheckInExpression: `Only check one flag per expression! See http://go/pff-eslint for more details`
+      featureFlagMissing: `Please add a "{{ featureFlag }}" section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details`
     }
   },
   create(context) {
@@ -72,33 +41,7 @@ const rule = {
       'CallExpression[callee.name=/getBooleanFF/]': node => {
         // to make typescript happy
         if (node.type === 'CallExpression') {
-          var _node$parent;
           const args = node.arguments;
-          if (args.length === 1 && args[0].type !== 'Literal') {
-            return context.report({
-              node,
-              messageId: 'onlyStringLiteral'
-            });
-          }
-          switch ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) {
-            case 'IfStatement':
-            case 'ConditionalExpression':
-              break;
-            case 'LogicalExpression':
-              if (!isOnlyOneFlagCheckInExpression(node)) {
-                context.report({
-                  node,
-                  messageId: 'multipleFlagCheckInExpression'
-                });
-              }
-              break;
-            default:
-              return context.report({
-                node,
-                messageId: 'onlyInlineIf'
-              });
-              break;
-          }
           const filename = context.getFilename();
           const packageJson = getPackageJsonForFileName(filename);
           const platformFeatureFlags = packageJson['platform-feature-flags'];

package/dist/es2019/rules/no-invalid-feature-flag-usage/index.js

@@ -0,0 +1,80 @@
+const FF_GETTER_BOOLEAN_IDENTIFIER = 'getBooleanFF';
+const __isOnlyOneFlagCheckInExpression = (root, ignoredNode) => {
+  switch (root.type) {
+    case 'IfStatement':
+      return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
+    case 'CallExpression':
+      if (root === ignoredNode) {
+        return true;
+      }
+      return !(root.callee.type === 'Identifier' && root.callee.name === FF_GETTER_BOOLEAN_IDENTIFIER);
+
+    // shouldn't ever get here but just in case
+    case 'Identifier':
+      return root.name !== FF_GETTER_BOOLEAN_IDENTIFIER;
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      return __isOnlyOneFlagCheckInExpression(root.left, ignoredNode) && __isOnlyOneFlagCheckInExpression(root.right, ignoredNode);
+    default:
+      return true;
+  }
+};
+const isOnlyOneFlagCheckInExpression = node => {
+  let root = node.parent;
+  // find the root node of the expression
+  while (root.type === 'LogicalExpression') {
+    root = root.parent;
+  }
+  return __isOnlyOneFlagCheckInExpression(root, node);
+};
+const rule = {
+  meta: {
+    hasSuggestions: false,
+    docs: {
+      recommended: false
+    },
+    type: 'problem',
+    messages: {
+      onlyInlineIf: "Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
+      onlyStringLiteral: "Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
+      multipleFlagCheckInExpression: `Only check one flag per expression! See http://go/pff-eslint for more details`
+    }
+  },
+  create(context) {
+    return {
+      [`CallExpression[callee.name=/${FF_GETTER_BOOLEAN_IDENTIFIER}/]`]: node => {
+        // to make typescript happy
+        if (node.type === 'CallExpression') {
+          var _node$parent;
+          const args = node.arguments;
+          if (args.length === 1 && args[0].type !== 'Literal') {
+            return context.report({
+              node,
+              messageId: 'onlyStringLiteral'
+            });
+          }
+          switch ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) {
+            case 'IfStatement':
+            case 'ConditionalExpression':
+              break;
+            case 'LogicalExpression':
+              if (!isOnlyOneFlagCheckInExpression(node)) {
+                context.report({
+                  node,
+                  messageId: 'multipleFlagCheckInExpression'
+                });
+              }
+              break;
+            default:
+              return context.report({
+                node,
+                messageId: 'onlyInlineIf'
+              });
+          }
+        }
+        return {};
+      }
+    };
+  }
+};
+export default rule;

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/eslint-plugin-platform",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"sideEffects": false
 }

package/dist/esm/index.js

@@ -1,12 +1,15 @@
 import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registration';
+import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 export var rules = {
-  'ensure-feature-flag-registration': ensureFeatureFlagRegistration
+  'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
+  'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage
 };
 export var configs = {
   recommended: {
     plugins: ['@atlaskit/platform'],
     rules: {
-      '@atlaskit/platform/ensure-feature-flag-registration': 'error'
+      '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/no-invalid-feature-flag-usage': 'error'
     }
   }
 };

package/dist/esm/rules/ensure-feature-flag-registration/index.js

@@ -24,34 +24,6 @@ var getPackageJsonForFileName = function getPackageJsonForFileName(filename) {
   pkgJsonCache.set(pkgJsonPath, packageJson);
   return packageJson;
 };
-var __isOnlyOneFlagCheckInExpression = function __isOnlyOneFlagCheckInExpression(root, ignoredNode) {
-  switch (root.type) {
-    case 'IfStatement':
-      return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
-    case 'CallExpression':
-      if (root === ignoredNode) {
-        return true;
-      }
-      return !(root.callee.type === 'Identifier' && root.callee.name === 'getBooleanFF');
-
-    // shouldn't ever get here but just in case
-    case 'Identifier':
-      return root.name !== 'getBooleanFF';
-    case 'BinaryExpression':
-    case 'LogicalExpression':
-      return __isOnlyOneFlagCheckInExpression(root.left, ignoredNode) && __isOnlyOneFlagCheckInExpression(root.right, ignoredNode);
-    default:
-      return true;
-  }
-};
-var isOnlyOneFlagCheckInExpression = function isOnlyOneFlagCheckInExpression(node) {
-  var root = node.parent;
-  // find the root node of the expression
-  while (root.type === 'LogicalExpression') {
-    root = root.parent;
-  }
-  return __isOnlyOneFlagCheckInExpression(root, node);
-};
 var rule = {
   meta: {
     hasSuggestions: false,
@@ -60,11 +32,8 @@ var rule = {
     },
     type: 'problem',
     messages: {
-      onlyInlineIf: "Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
-      onlyStringLiteral: "Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
       registrationSectionMissing: 'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
-      featureFlagMissing: "Please add a \"{{ featureFlag }}\" section to the \"platform-feature-flags\" section in your package.json. See http://go/pff-eslint for more details",
-      multipleFlagCheckInExpression: "Only check one flag per expression! See http://go/pff-eslint for more details"
+      featureFlagMissing: "Please add a \"{{ featureFlag }}\" section to the \"platform-feature-flags\" section in your package.json. See http://go/pff-eslint for more details"
     }
   },
   create: function create(context) {
@@ -72,33 +41,7 @@ var rule = {
       'CallExpression[callee.name=/getBooleanFF/]': function CallExpressionCalleeNameGetBooleanFF(node) {
         // to make typescript happy
         if (node.type === 'CallExpression') {
-          var _node$parent;
           var args = node.arguments;
-          if (args.length === 1 && args[0].type !== 'Literal') {
-            return context.report({
-              node: node,
-              messageId: 'onlyStringLiteral'
-            });
-          }
-          switch ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) {
-            case 'IfStatement':
-            case 'ConditionalExpression':
-              break;
-            case 'LogicalExpression':
-              if (!isOnlyOneFlagCheckInExpression(node)) {
-                context.report({
-                  node: node,
-                  messageId: 'multipleFlagCheckInExpression'
-                });
-              }
-              break;
-            default:
-              return context.report({
-                node: node,
-                messageId: 'onlyInlineIf'
-              });
-              break;
-          }
           var filename = context.getFilename();
           var packageJson = getPackageJsonForFileName(filename);
           var platformFeatureFlags = packageJson['platform-feature-flags'];

package/dist/esm/rules/no-invalid-feature-flag-usage/index.js

@@ -0,0 +1,79 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var FF_GETTER_BOOLEAN_IDENTIFIER = 'getBooleanFF';
+var __isOnlyOneFlagCheckInExpression = function __isOnlyOneFlagCheckInExpression(root, ignoredNode) {
+  switch (root.type) {
+    case 'IfStatement':
+      return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
+    case 'CallExpression':
+      if (root === ignoredNode) {
+        return true;
+      }
+      return !(root.callee.type === 'Identifier' && root.callee.name === FF_GETTER_BOOLEAN_IDENTIFIER);
+
+    // shouldn't ever get here but just in case
+    case 'Identifier':
+      return root.name !== FF_GETTER_BOOLEAN_IDENTIFIER;
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      return __isOnlyOneFlagCheckInExpression(root.left, ignoredNode) && __isOnlyOneFlagCheckInExpression(root.right, ignoredNode);
+    default:
+      return true;
+  }
+};
+var isOnlyOneFlagCheckInExpression = function isOnlyOneFlagCheckInExpression(node) {
+  var root = node.parent;
+  // find the root node of the expression
+  while (root.type === 'LogicalExpression') {
+    root = root.parent;
+  }
+  return __isOnlyOneFlagCheckInExpression(root, node);
+};
+var rule = {
+  meta: {
+    hasSuggestions: false,
+    docs: {
+      recommended: false
+    },
+    type: 'problem',
+    messages: {
+      onlyInlineIf: "Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
+      onlyStringLiteral: "Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
+      multipleFlagCheckInExpression: "Only check one flag per expression! See http://go/pff-eslint for more details"
+    }
+  },
+  create: function create(context) {
+    return _defineProperty({}, "CallExpression[callee.name=/".concat(FF_GETTER_BOOLEAN_IDENTIFIER, "/]"), function CallExpressionCalleeName(node) {
+      // to make typescript happy
+      if (node.type === 'CallExpression') {
+        var _node$parent;
+        var args = node.arguments;
+        if (args.length === 1 && args[0].type !== 'Literal') {
+          return context.report({
+            node: node,
+            messageId: 'onlyStringLiteral'
+          });
+        }
+        switch ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) {
+          case 'IfStatement':
+          case 'ConditionalExpression':
+            break;
+          case 'LogicalExpression':
+            if (!isOnlyOneFlagCheckInExpression(node)) {
+              context.report({
+                node: node,
+                messageId: 'multipleFlagCheckInExpression'
+              });
+            }
+            break;
+          default:
+            return context.report({
+              node: node,
+              messageId: 'onlyInlineIf'
+            });
+        }
+      }
+      return {};
+    });
+  }
+};
+export default rule;

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/eslint-plugin-platform",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"sideEffects": false
 }

package/dist/types/index.d.ts

@@ -1,11 +1,13 @@
 export declare const rules: {
     'ensure-feature-flag-registration': import("eslint").Rule.RuleModule;
+    'no-invalid-feature-flag-usage': import("eslint").Rule.RuleModule;
 };
 export declare const configs: {
     recommended: {
         plugins: string[];
         rules: {
             '@atlaskit/platform/ensure-feature-flag-registration': string;
+            '@atlaskit/platform/no-invalid-feature-flag-usage': string;
         };
     };
 };

package/dist/types/rules/no-invalid-feature-flag-usage/index.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaskit/eslint-plugin-platform",
   "description": "The essential plugin for use with Atlassian frontend platform tools",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "author": "Atlassian Pty Ltd",
   "atlassian": {
     "team": "UIP - Platform Integration Trust (PITa)",

package/report.api.md

@@ -23,6 +23,7 @@ export const configs: {
     plugins: string[];
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': string;
+      '@atlaskit/platform/no-invalid-feature-flag-usage': string;
     };
   };
 };
@@ -30,6 +31,7 @@ export const configs: {
 // @public (undocumented)
 export const rules: {
   'ensure-feature-flag-registration': Rule.RuleModule;
+  'no-invalid-feature-flag-usage': Rule.RuleModule;
 };
 
 // (No @packageDocumentation comment for this package)

package/src/index.tsx

@@ -1,7 +1,9 @@
 import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registration';
+import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 
 export const rules = {
   'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
+  'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
 };
 
 export const configs = {
@@ -9,6 +11,7 @@ export const configs = {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/no-invalid-feature-flag-usage': 'error',
     },
   },
 };

package/src/rules/ensure-feature-flag-registration/__tests__/unit/rule.test.tsx

@@ -34,49 +34,14 @@ describe('with existing platform-feature-flags section', () => {
   tester.run('ensure-feature-flag-registration', rule, {
     valid: [
       {
-        // IfStatement
-        code: `if(getBooleanFF('test-flag')) { }`,
-      },
-      {
-        // ConditionalExpression
-        code: `const val = getBooleanFF('test-flag') ? 'yay' : 'no';`,
-      },
-      {
-        // LogicalExpression
-        code: `const val = 100 + (getBooleanFF('test-flag') && 50 || 10);`,
+        code: `getBooleanFF('test-flag')`,
       },
     ],
     invalid: [
       {
-        code: `getBooleanFF('test-flag')`,
-        errors: [{ messageId: 'onlyInlineIf' }],
-      },
-      {
-        code: `const val = getBooleanFF('test-flag')`,
-        errors: [{ messageId: 'onlyInlineIf' }],
-      },
-      {
-        code: `if(getBooleanFF('invalid-flag')) { }`,
+        code: `getBooleanFF('invalid-flag')`,
         errors: [{ messageId: 'featureFlagMissing' }],
       },
-      {
-        code: `const ff = "test-flag"; if(getBooleanFF(ff)) { }`,
-        errors: [{ messageId: 'onlyStringLiteral' }],
-      },
-      {
-        code: `if(getBooleanFF('test-flag') && getBooleanFF('test-flag')) { }`,
-        errors: [
-          { messageId: 'multipleFlagCheckInExpression' },
-          { messageId: 'multipleFlagCheckInExpression' },
-        ],
-      },
-      {
-        code: `if((getBooleanFF('test-flag') || 1 == true) && getBooleanFF('test-flag')) { }`,
-        errors: [
-          { messageId: 'multipleFlagCheckInExpression' },
-          { messageId: 'multipleFlagCheckInExpression' },
-        ],
-      },
     ],
   });
 });

package/src/rules/ensure-feature-flag-registration/index.tsx

@@ -33,51 +33,6 @@ const getPackageJsonForFileName = (filename: string): readPkgUp.PackageJson => {
   return packageJson;
 };
 
-const __isOnlyOneFlagCheckInExpression = (
-  root: Rule.Node,
-  ignoredNode: Rule.Node,
-): boolean => {
-  switch (root.type) {
-    case 'IfStatement':
-      return __isOnlyOneFlagCheckInExpression(
-        root.test as Rule.Node,
-        ignoredNode,
-      );
-
-    case 'CallExpression':
-      if (root === ignoredNode) {
-        return true;
-      }
-      return !(
-        root.callee.type === 'Identifier' && root.callee.name === 'getBooleanFF'
-      );
-
-    // shouldn't ever get here but just in case
-    case 'Identifier':
-      return root.name !== 'getBooleanFF';
-
-    case 'BinaryExpression':
-    case 'LogicalExpression':
-      return (
-        __isOnlyOneFlagCheckInExpression(root.left as Rule.Node, ignoredNode) &&
-        __isOnlyOneFlagCheckInExpression(root.right as Rule.Node, ignoredNode)
-      );
-
-    default:
-      return true;
-  }
-};
-
-const isOnlyOneFlagCheckInExpression = (node: Rule.Node): boolean => {
-  let root = node.parent;
-  // find the root node of the expression
-  while (root.type === 'LogicalExpression') {
-    root = root.parent;
-  }
-
-  return __isOnlyOneFlagCheckInExpression(root, node);
-};
-
 const rule: Rule.RuleModule = {
   meta: {
     hasSuggestions: false,
@@ -86,14 +41,9 @@ const rule: Rule.RuleModule = {
     },
     type: 'problem',
     messages: {
-      onlyInlineIf:
-        "Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
-      onlyStringLiteral:
-        "Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
       registrationSectionMissing:
         'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
       featureFlagMissing: `Please add a "{{ featureFlag }}" section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details`,
-      multipleFlagCheckInExpression: `Only check one flag per expression! See http://go/pff-eslint for more details`,
     },
   },
   create(context) {
@@ -103,33 +53,6 @@ const rule: Rule.RuleModule = {
         if (node.type === 'CallExpression') {
           const args = node.arguments;
 
-          if (args.length === 1 && args[0].type !== 'Literal') {
-            return context.report({
-              node,
-              messageId: 'onlyStringLiteral',
-            });
-          }
-
-          switch (node.parent?.type) {
-            case 'IfStatement':
-            case 'ConditionalExpression':
-              break;
-            case 'LogicalExpression':
-              if (!isOnlyOneFlagCheckInExpression(node)) {
-                context.report({
-                  node,
-                  messageId: 'multipleFlagCheckInExpression',
-                });
-              }
-              break;
-            default:
-              return context.report({
-                node,
-                messageId: 'onlyInlineIf',
-              });
-              break;
-          }
-
           const filename = context.getFilename();
           const packageJson = getPackageJsonForFileName(filename);
           const platformFeatureFlags = packageJson[

package/src/rules/no-invalid-feature-flag-usage/__tests__/unit/rule.test.tsx

@@ -0,0 +1,49 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+describe('enforce-feature-flag-usage-structure tests', () => {
+  tester.run('ensure-feature-flag-registration', rule, {
+    valid: [
+      {
+        // IfStatement
+        code: `if(getBooleanFF('test-flag')) { }`,
+      },
+      {
+        // ConditionalExpression
+        code: `const val = getBooleanFF('test-flag') ? 'yay' : 'no';`,
+      },
+      {
+        // LogicalExpression
+        code: `const val = 100 + (getBooleanFF('test-flag') && 50 || 10);`,
+      },
+    ],
+    invalid: [
+      {
+        code: `getBooleanFF('test-flag')`,
+        errors: [{ messageId: 'onlyInlineIf' }],
+      },
+      {
+        code: `const val = getBooleanFF('test-flag')`,
+        errors: [{ messageId: 'onlyInlineIf' }],
+      },
+      {
+        code: `const ff = "test-flag"; if(getBooleanFF(ff)) { }`,
+        errors: [{ messageId: 'onlyStringLiteral' }],
+      },
+      {
+        code: `if(getBooleanFF('test-flag') && getBooleanFF('test-flag')) { }`,
+        errors: [
+          { messageId: 'multipleFlagCheckInExpression' },
+          { messageId: 'multipleFlagCheckInExpression' },
+        ],
+      },
+      {
+        code: `if((getBooleanFF('test-flag') || 1 == true) && getBooleanFF('test-flag')) { }`,
+        errors: [
+          { messageId: 'multipleFlagCheckInExpression' },
+          { messageId: 'multipleFlagCheckInExpression' },
+        ],
+      },
+    ],
+  });
+});

package/src/rules/no-invalid-feature-flag-usage/index.tsx

@@ -0,0 +1,108 @@
+import type { Rule } from 'eslint';
+
+const FF_GETTER_BOOLEAN_IDENTIFIER = 'getBooleanFF' as const;
+
+const __isOnlyOneFlagCheckInExpression = (
+  root: Rule.Node,
+  ignoredNode: Rule.Node,
+): boolean => {
+  switch (root.type) {
+    case 'IfStatement':
+      return __isOnlyOneFlagCheckInExpression(
+        root.test as Rule.Node,
+        ignoredNode,
+      );
+
+    case 'CallExpression':
+      if (root === ignoredNode) {
+        return true;
+      }
+      return !(
+        root.callee.type === 'Identifier' &&
+        root.callee.name === FF_GETTER_BOOLEAN_IDENTIFIER
+      );
+
+    // shouldn't ever get here but just in case
+    case 'Identifier':
+      return root.name !== FF_GETTER_BOOLEAN_IDENTIFIER;
+
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      return (
+        __isOnlyOneFlagCheckInExpression(root.left as Rule.Node, ignoredNode) &&
+        __isOnlyOneFlagCheckInExpression(root.right as Rule.Node, ignoredNode)
+      );
+
+    default:
+      return true;
+  }
+};
+
+const isOnlyOneFlagCheckInExpression = (node: Rule.Node): boolean => {
+  let root = node.parent;
+  // find the root node of the expression
+  while (root.type === 'LogicalExpression') {
+    root = root.parent;
+  }
+
+  return __isOnlyOneFlagCheckInExpression(root, node);
+};
+
+const rule: Rule.RuleModule = {
+  meta: {
+    hasSuggestions: false,
+    docs: {
+      recommended: false,
+    },
+    type: 'problem',
+    messages: {
+      onlyInlineIf:
+        "Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
+      onlyStringLiteral:
+        "Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
+      multipleFlagCheckInExpression: `Only check one flag per expression! See http://go/pff-eslint for more details`,
+    },
+  },
+  create(context) {
+    return {
+      [`CallExpression[callee.name=/${FF_GETTER_BOOLEAN_IDENTIFIER}/]`]: (
+        node: Rule.Node,
+      ) => {
+        // to make typescript happy
+        if (node.type === 'CallExpression') {
+          const args = node.arguments;
+
+          if (args.length === 1 && args[0].type !== 'Literal') {
+            return context.report({
+              node,
+              messageId: 'onlyStringLiteral',
+            });
+          }
+
+          switch (node.parent?.type) {
+            case 'IfStatement':
+            case 'ConditionalExpression':
+              break;
+            case 'LogicalExpression':
+              if (!isOnlyOneFlagCheckInExpression(node)) {
+                context.report({
+                  node,
+                  messageId: 'multipleFlagCheckInExpression',
+                });
+              }
+              break;
+            default:
+              return context.report({
+                node,
+                messageId: 'onlyInlineIf',
+              });
+          }
+        }
+
+        return {};
+      },
+    };
+  },
+};
+
+export default rule;

package/tmp/api-report-tmp.d.ts

@@ -12,6 +12,7 @@ export const configs: {
         plugins: string[];
         rules: {
             '@atlaskit/platform/ensure-feature-flag-registration': string;
+            '@atlaskit/platform/no-invalid-feature-flag-usage': string;
         };
     };
 };
@@ -19,6 +20,7 @@ export const configs: {
 // @public (undocumented)
 export const rules: {
     'ensure-feature-flag-registration': Rule.RuleModule;
+    'no-invalid-feature-flag-usage': Rule.RuleModule;
 };
 
 // (No @packageDocumentation comment for this package)