@atlaskit/eslint-plugin-platform 0.6.1 → 0.7.0

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

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _utils = require("../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) && (0, _utils.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 = (0, _slicedToArray2.default)(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);
+      }
+    };
+  }
+};
+var _default = exports.default = rule;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/cjs/rules/utils.js

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