@atlaskit/eslint-plugin-platform 0.2.2 → 0.2.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/eslint-plugin-platform
 
+## 0.2.4
+
+### Patch Changes
+
+- [`eb64cbdd681`](https://bitbucket.org/atlassian/atlassian-frontend/commits/eb64cbdd681) - Add a new rule to verify that the atlassian team is defined if the relevant section exists in the package.json
+
+## 0.2.3
+
+### Patch Changes
+
+- [`0bf64fb3dd0`](https://bitbucket.org/atlassian/atlassian-frontend/commits/0bf64fb3dd0) - Update to support unary expressions like negation
+
 ## 0.2.2
 
 ### Patch Changes

package/dist/cjs/index.js

@@ -9,6 +9,7 @@ var _ensureFeatureFlagRegistration = _interopRequireDefault(require("./rules/ens
 var _noPrePostInstalls = _interopRequireDefault(require("./rules/no-pre-post-installs"));
 var _ensureTestRunnerArguments = _interopRequireDefault(require("./rules/ensure-test-runner-arguments"));
 var _ensureTestRunnerNestedCount = _interopRequireDefault(require("./rules/ensure-test-runner-nested-count"));
+var _ensureAtlassianTeam = _interopRequireDefault(require("./rules/ensure-atlassian-team"));
 var _noInvalidFeatureFlagUsage = _interopRequireDefault(require("./rules/no-invalid-feature-flag-usage"));
 var _ensureFeatureFlagPrefix = _interopRequireDefault(require("./rules/ensure-feature-flag-prefix"));
 var _noInvalidStorybookDecoratorUsage = _interopRequireDefault(require("./rules/no-invalid-storybook-decorator-usage"));
@@ -17,6 +18,7 @@ var rules = {
   'ensure-feature-flag-prefix': _ensureFeatureFlagPrefix.default,
   'ensure-test-runner-arguments': _ensureTestRunnerArguments.default,
   'ensure-test-runner-nested-count': _ensureTestRunnerNestedCount.default,
+  'ensure-atlassian-team': _ensureAtlassianTeam.default,
   'no-invalid-feature-flag-usage': _noInvalidFeatureFlagUsage.default,
   'no-pre-post-install-scripts': _noPrePostInstalls.default,
   'no-invalid-storybook-decorator-usage': _noInvalidStorybookDecoratorUsage.default
@@ -33,7 +35,8 @@ var configs = {
       '@atlaskit/platform/ensure-test-runner-arguments': 'error',
       '@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/no-invalid-storybook-decorator-usage': 'error',
+      '@atlaskit/platform/ensure-atlassian-team': 'error'
     }
   }
 };

package/dist/cjs/rules/ensure-atlassian-team/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'This rule ensures that the internal packages have a responsible team attached.',
+      recommended: true
+    },
+    hasSuggestions: false,
+    messages: {
+      atlassianTeamRequired: 'The atlassian.team property is required'
+    }
+  },
+  create: function create(context) {
+    return {
+      ObjectExpression: function ObjectExpression(node) {
+        if (!context.getFilename().endsWith('package.json') || node.type !== 'ObjectExpression') {
+          return;
+        }
+        var atlassianProp = node.properties.find(function (p) {
+          return p.type === 'Property' && p.key.type === 'Literal' && p.key.value === 'atlassian';
+        });
+        if (!atlassianProp) {
+          return;
+        }
+        if (atlassianProp.type !== 'Property' || atlassianProp.value.type !== 'ObjectExpression') {
+          return;
+        }
+        var teamProp = atlassianProp.value.properties.find(function (p) {
+          return p.type === 'Property' && p.key.type === 'Literal' && p.key.value === 'team';
+        });
+
+        // this just checks for existence, we can potentially cross-reference it with teams.json to make sure its valid in the future.
+        if (!teamProp) {
+          return context.report({
+            node: node,
+            messageId: 'atlassianTeamRequired'
+          });
+        }
+      }
+    };
+  }
+};
+var _default = rule;
+exports.default = _default;

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

@@ -11,6 +11,8 @@ var __isOnlyOneFlagCheckInExpression = function __isOnlyOneFlagCheckInExpression
   switch (root.type) {
     case 'IfStatement':
       return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
+    case 'UnaryExpression':
+      return __isOnlyOneFlagCheckInExpression(root.argument, ignoredNode);
     case 'CallExpression':
       if (root === ignoredNode) {
         return true;
@@ -30,7 +32,8 @@ var __isOnlyOneFlagCheckInExpression = function __isOnlyOneFlagCheckInExpression
 var isOnlyOneFlagCheckInExpression = function isOnlyOneFlagCheckInExpression(node) {
   var root = node.parent;
   // find the root node of the expression
-  while (root.type === 'LogicalExpression') {
+  // NOTE: This is not an exhaustive check for all ESTree.Expression types but is good enough
+  while (root.type.endsWith('Expression')) {
     root = root.parent;
   }
   return __isOnlyOneFlagCheckInExpression(root, node);
@@ -64,6 +67,7 @@ var rule = {
           case 'IfStatement':
           case 'ConditionalExpression':
             break;
+          case 'UnaryExpression':
           case 'LogicalExpression':
             if (!isOnlyOneFlagCheckInExpression(node)) {
               context.report({

package/dist/cjs/version.json

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

package/dist/es2019/index.js

@@ -2,6 +2,7 @@ import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registrat
 import noPreAndPostInstallScripts from './rules/no-pre-post-installs';
 import ensureTestRunnerArguments from './rules/ensure-test-runner-arguments';
 import ensureTestRunnerNestedCount from './rules/ensure-test-runner-nested-count';
+import ensureAtlassianTeam from './rules/ensure-atlassian-team';
 import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 import ensureFeatureFlagPrefix from './rules/ensure-feature-flag-prefix';
 import noInvalidStorybookDecoratorUsage from './rules/no-invalid-storybook-decorator-usage';
@@ -10,6 +11,7 @@ export const rules = {
   'ensure-feature-flag-prefix': ensureFeatureFlagPrefix,
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
+  'ensure-atlassian-team': ensureAtlassianTeam,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,
   'no-invalid-storybook-decorator-usage': noInvalidStorybookDecoratorUsage
@@ -25,7 +27,8 @@ export const configs = {
       '@atlaskit/platform/ensure-test-runner-arguments': 'error',
       '@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/no-invalid-storybook-decorator-usage': 'error',
+      '@atlaskit/platform/ensure-atlassian-team': 'error'
     }
   }
 };

package/dist/es2019/rules/ensure-atlassian-team/index.js

@@ -0,0 +1,39 @@
+const rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'This rule ensures that the internal packages have a responsible team attached.',
+      recommended: true
+    },
+    hasSuggestions: false,
+    messages: {
+      atlassianTeamRequired: 'The atlassian.team property is required'
+    }
+  },
+  create(context) {
+    return {
+      ObjectExpression: node => {
+        if (!context.getFilename().endsWith('package.json') || node.type !== 'ObjectExpression') {
+          return;
+        }
+        const atlassianProp = node.properties.find(p => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === 'atlassian');
+        if (!atlassianProp) {
+          return;
+        }
+        if (atlassianProp.type !== 'Property' || atlassianProp.value.type !== 'ObjectExpression') {
+          return;
+        }
+        const teamProp = atlassianProp.value.properties.find(p => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === 'team');
+
+        // this just checks for existence, we can potentially cross-reference it with teams.json to make sure its valid in the future.
+        if (!teamProp) {
+          return context.report({
+            node,
+            messageId: 'atlassianTeamRequired'
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

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

@@ -3,6 +3,8 @@ const __isOnlyOneFlagCheckInExpression = (root, ignoredNode) => {
   switch (root.type) {
     case 'IfStatement':
       return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
+    case 'UnaryExpression':
+      return __isOnlyOneFlagCheckInExpression(root.argument, ignoredNode);
     case 'CallExpression':
       if (root === ignoredNode) {
         return true;
@@ -22,7 +24,8 @@ const __isOnlyOneFlagCheckInExpression = (root, ignoredNode) => {
 const isOnlyOneFlagCheckInExpression = node => {
   let root = node.parent;
   // find the root node of the expression
-  while (root.type === 'LogicalExpression') {
+  // NOTE: This is not an exhaustive check for all ESTree.Expression types but is good enough
+  while (root.type.endsWith('Expression')) {
     root = root.parent;
   }
   return __isOnlyOneFlagCheckInExpression(root, node);
@@ -57,6 +60,7 @@ const rule = {
             case 'IfStatement':
             case 'ConditionalExpression':
               break;
+            case 'UnaryExpression':
             case 'LogicalExpression':
               if (!isOnlyOneFlagCheckInExpression(node)) {
                 context.report({

package/dist/es2019/version.json

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

package/dist/esm/index.js

@@ -2,6 +2,7 @@ import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registrat
 import noPreAndPostInstallScripts from './rules/no-pre-post-installs';
 import ensureTestRunnerArguments from './rules/ensure-test-runner-arguments';
 import ensureTestRunnerNestedCount from './rules/ensure-test-runner-nested-count';
+import ensureAtlassianTeam from './rules/ensure-atlassian-team';
 import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 import ensureFeatureFlagPrefix from './rules/ensure-feature-flag-prefix';
 import noInvalidStorybookDecoratorUsage from './rules/no-invalid-storybook-decorator-usage';
@@ -10,6 +11,7 @@ export var rules = {
   'ensure-feature-flag-prefix': ensureFeatureFlagPrefix,
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
+  'ensure-atlassian-team': ensureAtlassianTeam,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,
   'no-invalid-storybook-decorator-usage': noInvalidStorybookDecoratorUsage
@@ -25,7 +27,8 @@ export var configs = {
       '@atlaskit/platform/ensure-test-runner-arguments': 'error',
       '@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/no-invalid-storybook-decorator-usage': 'error',
+      '@atlaskit/platform/ensure-atlassian-team': 'error'
     }
   }
 };

package/dist/esm/rules/ensure-atlassian-team/index.js

@@ -0,0 +1,43 @@
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'This rule ensures that the internal packages have a responsible team attached.',
+      recommended: true
+    },
+    hasSuggestions: false,
+    messages: {
+      atlassianTeamRequired: 'The atlassian.team property is required'
+    }
+  },
+  create: function create(context) {
+    return {
+      ObjectExpression: function ObjectExpression(node) {
+        if (!context.getFilename().endsWith('package.json') || node.type !== 'ObjectExpression') {
+          return;
+        }
+        var atlassianProp = node.properties.find(function (p) {
+          return p.type === 'Property' && p.key.type === 'Literal' && p.key.value === 'atlassian';
+        });
+        if (!atlassianProp) {
+          return;
+        }
+        if (atlassianProp.type !== 'Property' || atlassianProp.value.type !== 'ObjectExpression') {
+          return;
+        }
+        var teamProp = atlassianProp.value.properties.find(function (p) {
+          return p.type === 'Property' && p.key.type === 'Literal' && p.key.value === 'team';
+        });
+
+        // this just checks for existence, we can potentially cross-reference it with teams.json to make sure its valid in the future.
+        if (!teamProp) {
+          return context.report({
+            node: node,
+            messageId: 'atlassianTeamRequired'
+          });
+        }
+      }
+    };
+  }
+};
+export default rule;

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

@@ -4,6 +4,8 @@ var __isOnlyOneFlagCheckInExpression = function __isOnlyOneFlagCheckInExpression
   switch (root.type) {
     case 'IfStatement':
       return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
+    case 'UnaryExpression':
+      return __isOnlyOneFlagCheckInExpression(root.argument, ignoredNode);
     case 'CallExpression':
       if (root === ignoredNode) {
         return true;
@@ -23,7 +25,8 @@ var __isOnlyOneFlagCheckInExpression = function __isOnlyOneFlagCheckInExpression
 var isOnlyOneFlagCheckInExpression = function isOnlyOneFlagCheckInExpression(node) {
   var root = node.parent;
   // find the root node of the expression
-  while (root.type === 'LogicalExpression') {
+  // NOTE: This is not an exhaustive check for all ESTree.Expression types but is good enough
+  while (root.type.endsWith('Expression')) {
     root = root.parent;
   }
   return __isOnlyOneFlagCheckInExpression(root, node);
@@ -57,6 +60,7 @@ var rule = {
           case 'IfStatement':
           case 'ConditionalExpression':
             break;
+          case 'UnaryExpression':
           case 'LogicalExpression':
             if (!isOnlyOneFlagCheckInExpression(node)) {
               context.report({

package/dist/esm/version.json

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

package/dist/types/index.d.ts

@@ -4,6 +4,7 @@ export declare const rules: {
     'ensure-feature-flag-prefix': import("eslint").Rule.RuleModule;
     'ensure-test-runner-arguments': import("eslint").Rule.RuleModule;
     'ensure-test-runner-nested-count': import("eslint").Rule.RuleModule;
+    'ensure-atlassian-team': import("eslint").Rule.RuleModule;
     'no-invalid-feature-flag-usage': import("eslint").Rule.RuleModule;
     'no-pre-post-install-scripts': import("eslint").Rule.RuleModule;
     'no-invalid-storybook-decorator-usage': import("eslint").Rule.RuleModule;
@@ -20,6 +21,7 @@ export declare const configs: {
             '@atlaskit/platform/ensure-test-runner-nested-count': string;
             '@atlaskit/platform/no-invalid-feature-flag-usage': string;
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': string;
+            '@atlaskit/platform/ensure-atlassian-team': string;
         };
     };
 };

package/dist/types/rules/ensure-atlassian-team/index.d.ts

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

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

@@ -4,6 +4,7 @@ export declare const rules: {
     'ensure-feature-flag-prefix': import("eslint").Rule.RuleModule;
     'ensure-test-runner-arguments': import("eslint").Rule.RuleModule;
     'ensure-test-runner-nested-count': import("eslint").Rule.RuleModule;
+    'ensure-atlassian-team': import("eslint").Rule.RuleModule;
     'no-invalid-feature-flag-usage': import("eslint").Rule.RuleModule;
     'no-pre-post-install-scripts': import("eslint").Rule.RuleModule;
     'no-invalid-storybook-decorator-usage': import("eslint").Rule.RuleModule;
@@ -20,6 +21,7 @@ export declare const configs: {
             '@atlaskit/platform/ensure-test-runner-nested-count': string;
             '@atlaskit/platform/no-invalid-feature-flag-usage': string;
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': string;
+            '@atlaskit/platform/ensure-atlassian-team': string;
         };
     };
 };

package/dist/types-ts4.5/rules/ensure-atlassian-team/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.2.2",
+  "version": "0.2.4",
   "author": "Atlassian Pty Ltd",
   "atlassian": {
     "team": "UIP - Platform Integration Trust (PITa)",

package/report.api.md

@@ -34,6 +34,7 @@ export const configs: {
       '@atlaskit/platform/ensure-test-runner-nested-count': string;
       '@atlaskit/platform/no-invalid-feature-flag-usage': string;
       '@atlaskit/platform/no-invalid-storybook-decorator-usage': string;
+      '@atlaskit/platform/ensure-atlassian-team': string;
     };
   };
 };
@@ -49,6 +50,7 @@ export const rules: {
   'ensure-feature-flag-prefix': Rule.RuleModule;
   'ensure-test-runner-arguments': Rule.RuleModule;
   'ensure-test-runner-nested-count': Rule.RuleModule;
+  'ensure-atlassian-team': Rule.RuleModule;
   'no-invalid-feature-flag-usage': Rule.RuleModule;
   'no-pre-post-install-scripts': Rule.RuleModule;
   'no-invalid-storybook-decorator-usage': Rule.RuleModule;

package/src/index.tsx

@@ -3,6 +3,7 @@ import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registrat
 import noPreAndPostInstallScripts from './rules/no-pre-post-installs';
 import ensureTestRunnerArguments from './rules/ensure-test-runner-arguments';
 import ensureTestRunnerNestedCount from './rules/ensure-test-runner-nested-count';
+import ensureAtlassianTeam from './rules/ensure-atlassian-team';
 import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 import ensureFeatureFlagPrefix from './rules/ensure-feature-flag-prefix';
 import noInvalidStorybookDecoratorUsage from './rules/no-invalid-storybook-decorator-usage';
@@ -12,6 +13,7 @@ export const rules = {
   'ensure-feature-flag-prefix': ensureFeatureFlagPrefix,
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
+  'ensure-atlassian-team': ensureAtlassianTeam,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,
   'no-invalid-storybook-decorator-usage': noInvalidStorybookDecoratorUsage,
@@ -30,6 +32,7 @@ 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',
     },
   },
 };

package/src/rules/ensure-atlassian-team/__tests__/unit/rule.test.ts

@@ -0,0 +1,24 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+describe('test no-pre-post-installs rule', () => {
+  tester.run('no-pre-post-installs', rule, {
+    valid: [
+      {
+        code: `const foo = {}`,
+        filename: 'package.json',
+      },
+      {
+        code: `const foo = { "atlassian": { "team": "bar" } }`,
+        filename: 'foo/package.json',
+      },
+    ],
+    invalid: [
+      {
+        code: `const foo = { "atlassian": {} }`,
+        filename: 'foo/package.json',
+        errors: [{ messageId: 'atlassianTeamRequired' }],
+      },
+    ],
+  });
+});

package/src/rules/ensure-atlassian-team/index.ts

@@ -0,0 +1,63 @@
+import type { Rule } from 'eslint';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'This rule ensures that the internal packages have a responsible team attached.',
+      recommended: true,
+    },
+    hasSuggestions: false,
+    messages: {
+      atlassianTeamRequired: 'The atlassian.team property is required',
+    },
+  },
+  create(context) {
+    return {
+      ObjectExpression: (node: Rule.Node) => {
+        if (
+          !context.getFilename().endsWith('package.json') ||
+          node.type !== 'ObjectExpression'
+        ) {
+          return;
+        }
+
+        const atlassianProp = node.properties.find(
+          (p) =>
+            p.type === 'Property' &&
+            p.key.type === 'Literal' &&
+            p.key.value === 'atlassian',
+        );
+
+        if (!atlassianProp) {
+          return;
+        }
+
+        if (
+          atlassianProp.type !== 'Property' ||
+          atlassianProp.value.type !== 'ObjectExpression'
+        ) {
+          return;
+        }
+
+        const teamProp = atlassianProp.value.properties.find(
+          (p) =>
+            p.type === 'Property' &&
+            p.key.type === 'Literal' &&
+            p.key.value === 'team',
+        );
+
+        // this just checks for existence, we can potentially cross-reference it with teams.json to make sure its valid in the future.
+        if (!teamProp) {
+          return context.report({
+            node,
+            messageId: 'atlassianTeamRequired',
+          });
+        }
+      },
+    };
+  },
+};
+
+export default rule;

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

@@ -8,6 +8,10 @@ describe('enforce-feature-flag-usage-structure tests', () => {
         // IfStatement
         code: `if(getBooleanFF('test-flag')) { }`,
       },
+      {
+        // negated IfStatement
+        code: `if(!getBooleanFF('test-flag')) { }`,
+      },
       {
         // ConditionalExpression
         code: `const val = getBooleanFF('test-flag') ? 'yay' : 'no';`,
@@ -38,7 +42,14 @@ describe('enforce-feature-flag-usage-structure tests', () => {
         ],
       },
       {
-        code: `if((getBooleanFF('test-flag') || 1 == true) && getBooleanFF('test-flag')) { }`,
+        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

@@ -1,17 +1,17 @@
 import type { Rule } from 'eslint';
+import type { Node, Expression } from 'estree';
 
 const FF_GETTER_BOOLEAN_IDENTIFIER = 'getBooleanFF' as const;
 
 const __isOnlyOneFlagCheckInExpression = (
-  root: Rule.Node,
-  ignoredNode: Rule.Node,
+  root: Node | Expression,
+  ignoredNode: Node,
 ): boolean => {
   switch (root.type) {
     case 'IfStatement':
-      return __isOnlyOneFlagCheckInExpression(
-        root.test as Rule.Node,
-        ignoredNode,
-      );
+      return __isOnlyOneFlagCheckInExpression(root.test, ignoredNode);
+    case 'UnaryExpression':
+      return __isOnlyOneFlagCheckInExpression(root.argument, ignoredNode);
 
     case 'CallExpression':
       if (root === ignoredNode) {
@@ -29,8 +29,8 @@ const __isOnlyOneFlagCheckInExpression = (
     case 'BinaryExpression':
     case 'LogicalExpression':
       return (
-        __isOnlyOneFlagCheckInExpression(root.left as Rule.Node, ignoredNode) &&
-        __isOnlyOneFlagCheckInExpression(root.right as Rule.Node, ignoredNode)
+        __isOnlyOneFlagCheckInExpression(root.left, ignoredNode) &&
+        __isOnlyOneFlagCheckInExpression(root.right, ignoredNode)
       );
 
     default:
@@ -41,7 +41,8 @@ const __isOnlyOneFlagCheckInExpression = (
 const isOnlyOneFlagCheckInExpression = (node: Rule.Node): boolean => {
   let root = node.parent;
   // find the root node of the expression
-  while (root.type === 'LogicalExpression') {
+  // NOTE: This is not an exhaustive check for all ESTree.Expression types but is good enough
+  while (root.type.endsWith('Expression')) {
     root = root.parent;
   }
 
@@ -83,6 +84,7 @@ const rule: Rule.RuleModule = {
             case 'IfStatement':
             case 'ConditionalExpression':
               break;
+            case 'UnaryExpression':
             case 'LogicalExpression':
               if (!isOnlyOneFlagCheckInExpression(node)) {
                 context.report({

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

@@ -20,6 +20,7 @@ export const configs: {
             '@atlaskit/platform/ensure-test-runner-nested-count': string;
             '@atlaskit/platform/no-invalid-feature-flag-usage': string;
             '@atlaskit/platform/no-invalid-storybook-decorator-usage': string;
+            '@atlaskit/platform/ensure-atlassian-team': string;
         };
     };
 };
@@ -35,6 +36,7 @@ export const rules: {
     'ensure-feature-flag-prefix': Rule.RuleModule;
     'ensure-test-runner-arguments': Rule.RuleModule;
     'ensure-test-runner-nested-count': Rule.RuleModule;
+    'ensure-atlassian-team': Rule.RuleModule;
     'no-invalid-feature-flag-usage': Rule.RuleModule;
     'no-pre-post-install-scripts': Rule.RuleModule;
     'no-invalid-storybook-decorator-usage': Rule.RuleModule;