@atlaskit/eslint-plugin-platform 0.1.4 → 0.1.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/eslint-plugin-platform
 
+## 0.1.6
+
+### Patch Changes
+
+- [`e8a8808f299`](https://bitbucket.org/atlassian/atlassian-frontend/commits/e8a8808f299) - Add a new eslint rule that enforces prefixes on platform feature flags. Ignore existing usages.
+
+## 0.1.5
+
+### Patch Changes
+
+- [`b47e48ad163`](https://bitbucket.org/atlassian/atlassian-frontend/commits/b47e48ad163) - Adds an eslint rule to confirm that storybooks only get passed an object - to ensure that codemods work correctly.
+
 ## 0.1.4
 
 ### Patch Changes

package/dist/cjs/index.js

@@ -10,12 +10,16 @@ var _noPrePostInstalls = _interopRequireDefault(require("./rules/no-pre-post-ins
 var _ensureTestRunnerArguments = _interopRequireDefault(require("./rules/ensure-test-runner-arguments"));
 var _ensureTestRunnerNestedCount = _interopRequireDefault(require("./rules/ensure-test-runner-nested-count"));
 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"));
 var rules = {
   'ensure-feature-flag-registration': _ensureFeatureFlagRegistration.default,
+  'ensure-feature-flag-prefix': _ensureFeatureFlagPrefix.default,
   'ensure-test-runner-arguments': _ensureTestRunnerArguments.default,
   'ensure-test-runner-nested-count': _ensureTestRunnerNestedCount.default,
   'no-invalid-feature-flag-usage': _noInvalidFeatureFlagUsage.default,
-  'no-pre-post-install-scripts': _noPrePostInstalls.default
+  'no-pre-post-install-scripts': _noPrePostInstalls.default,
+  'no-invalid-storybook-decorator-usage': _noInvalidStorybookDecoratorUsage.default
 };
 exports.rules = rules;
 var configs = {
@@ -23,9 +27,13 @@ var configs = {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/ensure-feature-flag-prefix': ['error', {
+        allowedPrefixes: ['platform.']
+      }],
       '@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-feature-flag-usage': 'error',
+      '@atlaskit/platform/no-invalid-storybook-decorator-usage': 'error'
     }
   }
 };

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

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _registrationUtils = require("../util/registration-utils");
+var rule = {
+  meta: {
+    docs: {
+      recommended: false
+    },
+    type: 'problem',
+    messages: {
+      featureFlagIncorrectPrefix: "Please change your flag \"{{ featureFlag }}\" to have a valid prefix, options are [{{ allowedPrefixes }}]. See http://go/pff-eslint for details"
+    },
+    hasSuggestions: true,
+    schema: [{
+      type: 'object',
+      properties: {
+        allowedPrefixes: {
+          type: 'array',
+          items: [{
+            type: 'string'
+          }]
+        }
+      },
+      required: ['allowedPrefixes']
+    }]
+  },
+  create: function create(context) {
+    var _ref2, _context$options;
+    var _ref = (_ref2 = (_context$options = context.options) === null || _context$options === void 0 ? void 0 : _context$options[0]) !== null && _ref2 !== void 0 ? _ref2 : {},
+      allowedPrefixes = _ref.allowedPrefixes;
+    return Object.fromEntries(Object.keys(_registrationUtils.getterIdentifierToFlagTypeMap).map(function (getterIdentifier) {
+      return ["CallExpression[callee.name=/".concat(getterIdentifier, "/]"), function (node) {
+        // to make typescript happy
+        if (node.type === 'CallExpression') {
+          var args = node.arguments;
+          var filename = context.getFilename();
+          var _getMetadataForFilena = (0, _registrationUtils.getMetadataForFilename)(filename),
+            packageJson = _getMetadataForFilena.pkgJson;
+          var platformFeatureFlags = packageJson['platform-feature-flags'];
+
+          // existence of registration section is done in 'ensure-feature-flag-registration'
+          if (!platformFeatureFlags) {
+            return {};
+          }
+
+          // check registration section for valid feature flag prefixes.
+          // this checks all flags at every call site to ensure that new flags show errors as soon as possible.
+          var _loop = function _loop(featureFlag) {
+            if (!allowedPrefixes.some(function (prefix) {
+              return featureFlag.startsWith(prefix);
+            })) {
+              return {
+                v: context.report({
+                  node: args[0],
+                  messageId: 'featureFlagIncorrectPrefix',
+                  data: {
+                    allowedPrefixes: allowedPrefixes.map(function (p) {
+                      return "".concat(p);
+                    }).join(','),
+                    featureFlag: featureFlag
+                  }
+                })
+              };
+            }
+          };
+          for (var featureFlag in platformFeatureFlags) {
+            var _ret = _loop(featureFlag);
+            if ((0, _typeof2.default)(_ret) === "object") return _ret.v;
+          }
+        }
+        return {};
+      }];
+    }));
+  }
+};
+var _default = rule;
+exports.default = _default;

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

@@ -6,47 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _readPkgUp = _interopRequireDefault(require("read-pkg-up"));
-var _path = _interopRequireDefault(require("path"));
-var _fuse = _interopRequireDefault(require("fuse.js"));
+var _registrationUtils = require("../util/registration-utils");
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-// defines a "getter" to "type" map, if more types are required for feature flags (like string) add it here!
-// if you don't want to verify the type use `null` as the value
-var getterIdentifierToFlagTypeMap = {
-  getBooleanFF: 'boolean',
-  ffTest: '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();
-
-// get the ancestor package.json for a given file
-var getMetadataForFilename = function getMetadataForFilename(filename) {
-  var splitFilename = filename.split(_path.default.sep);
-  for (var i = 0; i < splitFilename.length; i++) {
-    // attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
-    var searchPath = _path.default.join.apply(_path.default, (0, _toConsumableArray2.default)(splitFilename.splice(0, i)));
-    var cachedMetaData = pkgJsonCache.get(searchPath);
-    if (cachedMetaData) {
-      return cachedMetaData;
-    }
-  }
-  var _ref = _readPkgUp.default.sync({
-      cwd: filename,
-      normalize: false
-    }),
-    packageJson = _ref.packageJson,
-    pkgJsonPath = _ref.path;
-  var pkgJson = packageJson;
-  var fuse = packageJson['platform-feature-flags'] == null ? null : new _fuse.default(Object.keys(pkgJson['platform-feature-flags']));
-  var metaData = {
-    pkgJson: pkgJson,
-    fuse: fuse
-  };
-  pkgJsonCache.set(pkgJsonPath, metaData);
-  return metaData;
-};
 var rule = {
   meta: {
     docs: {
@@ -62,13 +24,13 @@ var rule = {
     hasSuggestions: true
   },
   create: function create(context) {
-    return Object.fromEntries(Object.keys(getterIdentifierToFlagTypeMap).map(function (getterIdentifier) {
+    return Object.fromEntries(Object.keys(_registrationUtils.getterIdentifierToFlagTypeMap).map(function (getterIdentifier) {
       return ["CallExpression[callee.name=/".concat(getterIdentifier, "/]"), function (node) {
         // to make typescript happy
         if (node.type === 'CallExpression') {
           var args = node.arguments;
           var filename = context.getFilename();
-          var _getMetadataForFilena = getMetadataForFilename(filename),
+          var _getMetadataForFilena = (0, _registrationUtils.getMetadataForFilename)(filename),
             packageJson = _getMetadataForFilena.pkgJson,
             fuse = _getMetadataForFilena.fuse;
           var platformFeatureFlags = packageJson['platform-feature-flags'];
@@ -81,7 +43,7 @@ var rule = {
           if (args.length === 1 && args[0].type === 'Literal' && args[0].raw) {
             var featureFlag = args[0].value;
             var featureFlagRegistration = platformFeatureFlags[featureFlag];
-            var expectedType = getterIdentifierToFlagTypeMap[getterIdentifier];
+            var expectedType = _registrationUtils.getterIdentifierToFlagTypeMap[getterIdentifier];
 
             // ensure the flag type matches what is registered
             if (featureFlagRegistration != null && expectedType != null && (featureFlagRegistration === null || featureFlagRegistration === void 0 ? void 0 : featureFlagRegistration.type) !== expectedType) {

package/dist/cjs/rules/no-invalid-storybook-decorator-usage/index.js

@@ -0,0 +1,38 @@
+"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 STORYBOOK_DECORATOR_IDENTIFIER = 'withPlatformFeatureFlags';
+var rule = {
+  meta: {
+    hasSuggestions: false,
+    docs: {
+      recommended: false
+    },
+    type: 'problem',
+    messages: {
+      onlyObjectExpression: 'Only object literals allowed in the storybook decorator! See http://go/pff-eslint for more details'
+    }
+  },
+  create: function create(context) {
+    return (0, _defineProperty2.default)({}, "CallExpression[callee.name=/".concat(STORYBOOK_DECORATOR_IDENTIFIER, "/]"), function CallExpressionCalleeName(node) {
+      // to make typescript happy
+      if (node.type === 'CallExpression') {
+        var args = node.arguments;
+        if (args.length === 1 && args[0].type !== 'ObjectExpression') {
+          return context.report({
+            node: node,
+            messageId: 'onlyObjectExpression'
+          });
+        }
+      }
+      return {};
+    });
+  }
+};
+var _default = rule;
+exports.default = _default;

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

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getterIdentifierToFlagTypeMap = exports.getMetadataForFilename = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _readPkgUp = _interopRequireDefault(require("read-pkg-up"));
+var _path = _interopRequireDefault(require("path"));
+var _fuse = _interopRequireDefault(require("fuse.js"));
+// defines a "getter" to "type" map, if more types are required for feature flags (like string) add it here!
+// if you don't want to verify the type use `null` as the value
+var getterIdentifierToFlagTypeMap = {
+  getBooleanFF: 'boolean',
+  ffTest: 'boolean'
+};
+exports.getterIdentifierToFlagTypeMap = getterIdentifierToFlagTypeMap;
+// 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();
+// get the ancestor package.json for a given file
+var getMetadataForFilename = function getMetadataForFilename(filename) {
+  var splitFilename = filename.split(_path.default.sep);
+  for (var i = 0; i < splitFilename.length; i++) {
+    // attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
+    var searchPath = _path.default.join.apply(_path.default, (0, _toConsumableArray2.default)(splitFilename.splice(0, i)));
+    var cachedMetaData = pkgJsonCache.get(searchPath);
+    if (cachedMetaData) {
+      return cachedMetaData;
+    }
+  }
+  var _ref = _readPkgUp.default.sync({
+      cwd: filename,
+      normalize: false
+    }),
+    packageJson = _ref.packageJson,
+    pkgJsonPath = _ref.path;
+  var pkgJson = packageJson;
+  var fuse = packageJson['platform-feature-flags'] == null ? null : new _fuse.default(Object.keys(pkgJson['platform-feature-flags']));
+  var metaData = {
+    pkgJson: pkgJson,
+    fuse: fuse
+  };
+  pkgJsonCache.set(pkgJsonPath, metaData);
+  return metaData;
+};
+exports.getMetadataForFilename = getMetadataForFilename;

package/dist/cjs/version.json

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

package/dist/es2019/index.js

@@ -3,21 +3,29 @@ 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 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';
 export const rules = {
   'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
+  'ensure-feature-flag-prefix': ensureFeatureFlagPrefix,
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
-  'no-pre-post-install-scripts': noPreAndPostInstallScripts
+  'no-pre-post-install-scripts': noPreAndPostInstallScripts,
+  'no-invalid-storybook-decorator-usage': noInvalidStorybookDecoratorUsage
 };
 export const configs = {
   recommended: {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/ensure-feature-flag-prefix': ['error', {
+        allowedPrefixes: ['platform.']
+      }],
       '@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-feature-flag-usage': 'error',
+      '@atlaskit/platform/no-invalid-storybook-decorator-usage': 'error'
     }
   }
 };

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

@@ -0,0 +1,64 @@
+import { getMetadataForFilename, getterIdentifierToFlagTypeMap } from '../util/registration-utils';
+const rule = {
+  meta: {
+    docs: {
+      recommended: false
+    },
+    type: 'problem',
+    messages: {
+      featureFlagIncorrectPrefix: `Please change your flag "{{ featureFlag }}" to have a valid prefix, options are [{{ allowedPrefixes }}]. See http://go/pff-eslint for details`
+    },
+    hasSuggestions: true,
+    schema: [{
+      type: 'object',
+      properties: {
+        allowedPrefixes: {
+          type: 'array',
+          items: [{
+            type: 'string'
+          }]
+        }
+      },
+      required: ['allowedPrefixes']
+    }]
+  },
+  create(context) {
+    var _ref, _context$options;
+    const {
+      allowedPrefixes
+    } = (_ref = (_context$options = context.options) === null || _context$options === void 0 ? void 0 : _context$options[0]) !== null && _ref !== void 0 ? _ref : {};
+    return Object.fromEntries(Object.keys(getterIdentifierToFlagTypeMap).map(getterIdentifier => [`CallExpression[callee.name=/${getterIdentifier}/]`, node => {
+      // to make typescript happy
+      if (node.type === 'CallExpression') {
+        const args = node.arguments;
+        const filename = context.getFilename();
+        const {
+          pkgJson: packageJson
+        } = getMetadataForFilename(filename);
+        const platformFeatureFlags = packageJson['platform-feature-flags'];
+
+        // existence of registration section is done in 'ensure-feature-flag-registration'
+        if (!platformFeatureFlags) {
+          return {};
+        }
+
+        // check registration section for valid feature flag prefixes.
+        // this checks all flags at every call site to ensure that new flags show errors as soon as possible.
+        for (const featureFlag in platformFeatureFlags) {
+          if (!allowedPrefixes.some(prefix => featureFlag.startsWith(prefix))) {
+            return context.report({
+              node: args[0],
+              messageId: 'featureFlagIncorrectPrefix',
+              data: {
+                allowedPrefixes: allowedPrefixes.map(p => `${p}`).join(','),
+                featureFlag
+              }
+            });
+          }
+        }
+      }
+      return {};
+    }]));
+  }
+};
+export default rule;

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

@@ -1,43 +1,4 @@
-import readPkgUp from 'read-pkg-up';
-import path from 'path';
-import Fuse from 'fuse.js';
-
-// defines a "getter" to "type" map, if more types are required for feature flags (like string) add it here!
-// if you don't want to verify the type use `null` as the value
-const getterIdentifierToFlagTypeMap = {
-  getBooleanFF: 'boolean',
-  ffTest: 'boolean'
-};
-// make sure we cache reading the package.json so we don't end up reading it for every instance of this rule.
-const pkgJsonCache = new Map();
-
-// get the ancestor package.json for a given file
-const getMetadataForFilename = filename => {
-  const splitFilename = filename.split(path.sep);
-  for (let i = 0; i < splitFilename.length; i++) {
-    // attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
-    const searchPath = path.join(...splitFilename.splice(0, i));
-    const cachedMetaData = pkgJsonCache.get(searchPath);
-    if (cachedMetaData) {
-      return cachedMetaData;
-    }
-  }
-  const {
-    packageJson,
-    path: pkgJsonPath
-  } = readPkgUp.sync({
-    cwd: filename,
-    normalize: false
-  });
-  const pkgJson = packageJson;
-  const fuse = packageJson['platform-feature-flags'] == null ? null : new Fuse(Object.keys(pkgJson['platform-feature-flags']));
-  const metaData = {
-    pkgJson,
-    fuse
-  };
-  pkgJsonCache.set(pkgJsonPath, metaData);
-  return metaData;
-};
+import { getMetadataForFilename, getterIdentifierToFlagTypeMap } from '../util/registration-utils';
 const rule = {
   meta: {
     docs: {

package/dist/es2019/rules/no-invalid-storybook-decorator-usage/index.js

@@ -0,0 +1,31 @@
+const STORYBOOK_DECORATOR_IDENTIFIER = 'withPlatformFeatureFlags';
+const rule = {
+  meta: {
+    hasSuggestions: false,
+    docs: {
+      recommended: false
+    },
+    type: 'problem',
+    messages: {
+      onlyObjectExpression: 'Only object literals allowed in the storybook decorator! See http://go/pff-eslint for more details'
+    }
+  },
+  create(context) {
+    return {
+      [`CallExpression[callee.name=/${STORYBOOK_DECORATOR_IDENTIFIER}/]`]: node => {
+        // to make typescript happy
+        if (node.type === 'CallExpression') {
+          const args = node.arguments;
+          if (args.length === 1 && args[0].type !== 'ObjectExpression') {
+            return context.report({
+              node,
+              messageId: 'onlyObjectExpression'
+            });
+          }
+        }
+        return {};
+      }
+    };
+  }
+};
+export default rule;

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

@@ -0,0 +1,39 @@
+import readPkgUp from 'read-pkg-up';
+import path from 'path';
+import Fuse from 'fuse.js';
+
+// defines a "getter" to "type" map, if more types are required for feature flags (like string) add it here!
+// if you don't want to verify the type use `null` as the value
+export const getterIdentifierToFlagTypeMap = {
+  getBooleanFF: 'boolean',
+  ffTest: 'boolean'
+};
+// make sure we cache reading the package.json so we don't end up reading it for every instance of this rule.
+const pkgJsonCache = new Map();
+// get the ancestor package.json for a given file
+export const getMetadataForFilename = filename => {
+  const splitFilename = filename.split(path.sep);
+  for (let i = 0; i < splitFilename.length; i++) {
+    // attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
+    const searchPath = path.join(...splitFilename.splice(0, i));
+    const cachedMetaData = pkgJsonCache.get(searchPath);
+    if (cachedMetaData) {
+      return cachedMetaData;
+    }
+  }
+  const {
+    packageJson,
+    path: pkgJsonPath
+  } = readPkgUp.sync({
+    cwd: filename,
+    normalize: false
+  });
+  const pkgJson = packageJson;
+  const fuse = packageJson['platform-feature-flags'] == null ? null : new Fuse(Object.keys(pkgJson['platform-feature-flags']));
+  const metaData = {
+    pkgJson,
+    fuse
+  };
+  pkgJsonCache.set(pkgJsonPath, metaData);
+  return metaData;
+};

package/dist/es2019/version.json

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

package/dist/esm/index.js

@@ -3,21 +3,29 @@ 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 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';
 export var rules = {
   'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
+  'ensure-feature-flag-prefix': ensureFeatureFlagPrefix,
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
-  'no-pre-post-install-scripts': noPreAndPostInstallScripts
+  'no-pre-post-install-scripts': noPreAndPostInstallScripts,
+  'no-invalid-storybook-decorator-usage': noInvalidStorybookDecoratorUsage
 };
 export var configs = {
   recommended: {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/ensure-feature-flag-prefix': ['error', {
+        allowedPrefixes: ['platform.']
+      }],
       '@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-feature-flag-usage': 'error',
+      '@atlaskit/platform/no-invalid-storybook-decorator-usage': 'error'
     }
   }
 };

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

@@ -0,0 +1,75 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import { getMetadataForFilename, getterIdentifierToFlagTypeMap } from '../util/registration-utils';
+var rule = {
+  meta: {
+    docs: {
+      recommended: false
+    },
+    type: 'problem',
+    messages: {
+      featureFlagIncorrectPrefix: "Please change your flag \"{{ featureFlag }}\" to have a valid prefix, options are [{{ allowedPrefixes }}]. See http://go/pff-eslint for details"
+    },
+    hasSuggestions: true,
+    schema: [{
+      type: 'object',
+      properties: {
+        allowedPrefixes: {
+          type: 'array',
+          items: [{
+            type: 'string'
+          }]
+        }
+      },
+      required: ['allowedPrefixes']
+    }]
+  },
+  create: function create(context) {
+    var _ref2, _context$options;
+    var _ref = (_ref2 = (_context$options = context.options) === null || _context$options === void 0 ? void 0 : _context$options[0]) !== null && _ref2 !== void 0 ? _ref2 : {},
+      allowedPrefixes = _ref.allowedPrefixes;
+    return Object.fromEntries(Object.keys(getterIdentifierToFlagTypeMap).map(function (getterIdentifier) {
+      return ["CallExpression[callee.name=/".concat(getterIdentifier, "/]"), function (node) {
+        // to make typescript happy
+        if (node.type === 'CallExpression') {
+          var args = node.arguments;
+          var filename = context.getFilename();
+          var _getMetadataForFilena = getMetadataForFilename(filename),
+            packageJson = _getMetadataForFilena.pkgJson;
+          var platformFeatureFlags = packageJson['platform-feature-flags'];
+
+          // existence of registration section is done in 'ensure-feature-flag-registration'
+          if (!platformFeatureFlags) {
+            return {};
+          }
+
+          // check registration section for valid feature flag prefixes.
+          // this checks all flags at every call site to ensure that new flags show errors as soon as possible.
+          var _loop = function _loop(featureFlag) {
+            if (!allowedPrefixes.some(function (prefix) {
+              return featureFlag.startsWith(prefix);
+            })) {
+              return {
+                v: context.report({
+                  node: args[0],
+                  messageId: 'featureFlagIncorrectPrefix',
+                  data: {
+                    allowedPrefixes: allowedPrefixes.map(function (p) {
+                      return "".concat(p);
+                    }).join(','),
+                    featureFlag: featureFlag
+                  }
+                })
+              };
+            }
+          };
+          for (var featureFlag in platformFeatureFlags) {
+            var _ret = _loop(featureFlag);
+            if (_typeof(_ret) === "object") return _ret.v;
+          }
+        }
+        return {};
+      }];
+    }));
+  }
+};
+export default rule;

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

@@ -1,46 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-import readPkgUp from 'read-pkg-up';
-import path from 'path';
-import Fuse from 'fuse.js';
-
-// defines a "getter" to "type" map, if more types are required for feature flags (like string) add it here!
-// if you don't want to verify the type use `null` as the value
-var getterIdentifierToFlagTypeMap = {
-  getBooleanFF: 'boolean',
-  ffTest: '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();
-
-// get the ancestor package.json for a given file
-var getMetadataForFilename = function getMetadataForFilename(filename) {
-  var splitFilename = filename.split(path.sep);
-  for (var i = 0; i < splitFilename.length; i++) {
-    // attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
-    var searchPath = path.join.apply(path, _toConsumableArray(splitFilename.splice(0, i)));
-    var cachedMetaData = pkgJsonCache.get(searchPath);
-    if (cachedMetaData) {
-      return cachedMetaData;
-    }
-  }
-  var _ref = readPkgUp.sync({
-      cwd: filename,
-      normalize: false
-    }),
-    packageJson = _ref.packageJson,
-    pkgJsonPath = _ref.path;
-  var pkgJson = packageJson;
-  var fuse = packageJson['platform-feature-flags'] == null ? null : new Fuse(Object.keys(pkgJson['platform-feature-flags']));
-  var metaData = {
-    pkgJson: pkgJson,
-    fuse: fuse
-  };
-  pkgJsonCache.set(pkgJsonPath, metaData);
-  return metaData;
-};
+import { getMetadataForFilename, getterIdentifierToFlagTypeMap } from '../util/registration-utils';
 var rule = {
   meta: {
     docs: {

package/dist/esm/rules/no-invalid-storybook-decorator-usage/index.js

@@ -0,0 +1,30 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var STORYBOOK_DECORATOR_IDENTIFIER = 'withPlatformFeatureFlags';
+var rule = {
+  meta: {
+    hasSuggestions: false,
+    docs: {
+      recommended: false
+    },
+    type: 'problem',
+    messages: {
+      onlyObjectExpression: 'Only object literals allowed in the storybook decorator! See http://go/pff-eslint for more details'
+    }
+  },
+  create: function create(context) {
+    return _defineProperty({}, "CallExpression[callee.name=/".concat(STORYBOOK_DECORATOR_IDENTIFIER, "/]"), function CallExpressionCalleeName(node) {
+      // to make typescript happy
+      if (node.type === 'CallExpression') {
+        var args = node.arguments;
+        if (args.length === 1 && args[0].type !== 'ObjectExpression') {
+          return context.report({
+            node: node,
+            messageId: 'onlyObjectExpression'
+          });
+        }
+      }
+      return {};
+    });
+  }
+};
+export default rule;

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

@@ -0,0 +1,39 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import readPkgUp from 'read-pkg-up';
+import path from 'path';
+import Fuse from 'fuse.js';
+
+// defines a "getter" to "type" map, if more types are required for feature flags (like string) add it here!
+// if you don't want to verify the type use `null` as the value
+export var getterIdentifierToFlagTypeMap = {
+  getBooleanFF: 'boolean',
+  ffTest: '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();
+// get the ancestor package.json for a given file
+export var getMetadataForFilename = function getMetadataForFilename(filename) {
+  var splitFilename = filename.split(path.sep);
+  for (var i = 0; i < splitFilename.length; i++) {
+    // attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
+    var searchPath = path.join.apply(path, _toConsumableArray(splitFilename.splice(0, i)));
+    var cachedMetaData = pkgJsonCache.get(searchPath);
+    if (cachedMetaData) {
+      return cachedMetaData;
+    }
+  }
+  var _ref = readPkgUp.sync({
+      cwd: filename,
+      normalize: false
+    }),
+    packageJson = _ref.packageJson,
+    pkgJsonPath = _ref.path;
+  var pkgJson = packageJson;
+  var fuse = packageJson['platform-feature-flags'] == null ? null : new Fuse(Object.keys(pkgJson['platform-feature-flags']));
+  var metaData = {
+    pkgJson: pkgJson,
+    fuse: fuse
+  };
+  pkgJsonCache.set(pkgJsonPath, metaData);
+  return metaData;
+};

package/dist/esm/version.json

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

package/dist/types/index.d.ts

@@ -1,19 +1,25 @@
 import type { Linter } from 'eslint';
 export declare const rules: {
     'ensure-feature-flag-registration': import("eslint").Rule.RuleModule;
+    '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;
     '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;
 };
 export declare const configs: {
     recommended: {
         plugins: string[];
         rules: {
             '@atlaskit/platform/ensure-feature-flag-registration': string;
+            '@atlaskit/platform/ensure-feature-flag-prefix': (string | {
+                allowedPrefixes: string[];
+            })[];
             '@atlaskit/platform/ensure-test-runner-arguments': string;
             '@atlaskit/platform/ensure-test-runner-nested-count': string;
             '@atlaskit/platform/no-invalid-feature-flag-usage': string;
+            '@atlaskit/platform/no-invalid-storybook-decorator-usage': string;
         };
     };
 };

package/dist/types/rules/ensure-feature-flag-prefix/index.d.ts

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

package/dist/types/rules/no-invalid-storybook-decorator-usage/index.d.ts

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

package/dist/types/rules/util/registration-utils.d.ts

@@ -0,0 +1,19 @@
+import readPkgUp from 'read-pkg-up';
+import Fuse from 'fuse.js';
+export declare const getterIdentifierToFlagTypeMap: {
+    readonly getBooleanFF: "boolean";
+    readonly ffTest: "boolean";
+};
+export declare type PlatformFeatureFlagRegistrationSection = {
+    [key: string]: {
+        type: typeof getterIdentifierToFlagTypeMap[keyof typeof getterIdentifierToFlagTypeMap];
+    };
+};
+export declare type EnhancedPackageJson = readPkgUp.PackageJson & {
+    'platform-feature-flags'?: PlatformFeatureFlagRegistrationSection;
+};
+export declare type PkgJsonMetaData = {
+    pkgJson: EnhancedPackageJson;
+    fuse: Fuse<string> | null;
+};
+export declare const getMetadataForFilename: (filename: string) => PkgJsonMetaData;

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.1.4",
+  "version": "0.1.6",
   "author": "Atlassian Pty Ltd",
   "atlassian": {
     "team": "UIP - Platform Integration Trust (PITa)",

package/report.api.md

@@ -24,9 +24,16 @@ export const configs: {
     plugins: string[];
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': string;
+      '@atlaskit/platform/ensure-feature-flag-prefix': (
+        | string
+        | {
+            allowedPrefixes: string[];
+          }
+      )[];
       '@atlaskit/platform/ensure-test-runner-arguments': string;
       '@atlaskit/platform/ensure-test-runner-nested-count': string;
       '@atlaskit/platform/no-invalid-feature-flag-usage': string;
+      '@atlaskit/platform/no-invalid-storybook-decorator-usage': string;
     };
   };
 };
@@ -39,10 +46,12 @@ export const processors: {
 // @public (undocumented)
 export const rules: {
   'ensure-feature-flag-registration': Rule.RuleModule;
+  'ensure-feature-flag-prefix': Rule.RuleModule;
   'ensure-test-runner-arguments': Rule.RuleModule;
   'ensure-test-runner-nested-count': Rule.RuleModule;
   'no-invalid-feature-flag-usage': Rule.RuleModule;
   'no-pre-post-install-scripts': Rule.RuleModule;
+  'no-invalid-storybook-decorator-usage': Rule.RuleModule;
 };
 
 // (No @packageDocumentation comment for this package)

package/src/index.tsx

@@ -4,13 +4,17 @@ 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 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';
 
 export const rules = {
   'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
+  'ensure-feature-flag-prefix': ensureFeatureFlagPrefix,
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,
+  'no-invalid-storybook-decorator-usage': noInvalidStorybookDecoratorUsage,
 };
 
 export const configs = {
@@ -18,9 +22,14 @@ export const configs = {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/ensure-feature-flag-prefix': [
+        'error',
+        { allowedPrefixes: ['platform.'] },
+      ],
       '@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',
     },
   },
 };

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

@@ -0,0 +1,53 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+import { PackageJson } from 'read-pkg-up';
+
+let mockPath = 'test/package.json';
+
+let mockPackageJson: PackageJson = {
+  'platform-feature-flags': {
+    'test-flag': {
+      type: 'boolean',
+    },
+  },
+};
+jest.mock('read-pkg-up', () => ({
+  sync: () => ({
+    path: mockPath,
+    packageJson: mockPackageJson,
+  }),
+}));
+
+describe('with flag with invalid prefix', () => {
+  beforeEach(() => {
+    mockPath = 'test/package.json';
+
+    mockPackageJson = {
+      'platform-feature-flags': {
+        'no-prefix-flag': {
+          type: 'boolean',
+        },
+      },
+    };
+  });
+
+  // this isolates the invalid case so we can test the suggestion properly
+  tester.run('ensure-feature-flag-registration', rule, {
+    valid: [],
+    invalid: [
+      {
+        options: [{ allowedPrefixes: ['prefix'] }],
+        code: `ffTest('no-prefix-flag')`,
+        errors: [
+          {
+            messageId: 'featureFlagIncorrectPrefix',
+            data: {
+              featureFlag: 'no-prefix-flag',
+              allowedPrefixes: 'prefix',
+            },
+          },
+        ],
+      },
+    ],
+  });
+});

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

@@ -0,0 +1,91 @@
+import type { Rule } from 'eslint';
+import {
+  getMetadataForFilename,
+  getterIdentifierToFlagTypeMap,
+} from '../util/registration-utils';
+
+type RuleOptions = {
+  allowedPrefixes: string[];
+};
+
+const rule: Rule.RuleModule = {
+  meta: {
+    docs: {
+      recommended: false,
+    },
+    type: 'problem',
+    messages: {
+      featureFlagIncorrectPrefix: `Please change your flag "{{ featureFlag }}" to have a valid prefix, options are [{{ allowedPrefixes }}]. See http://go/pff-eslint for details`,
+    },
+    hasSuggestions: true,
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allowedPrefixes: {
+            type: 'array',
+            items: [
+              {
+                type: 'string',
+              },
+            ],
+          },
+        },
+        required: ['allowedPrefixes'],
+      },
+    ],
+  },
+  create(context) {
+    const { allowedPrefixes } = (context.options?.[0] as RuleOptions) ?? {};
+
+    return Object.fromEntries(
+      (
+        Object.keys(
+          getterIdentifierToFlagTypeMap,
+        ) as (keyof typeof getterIdentifierToFlagTypeMap)[]
+      ).map((getterIdentifier) => [
+        `CallExpression[callee.name=/${getterIdentifier}/]`,
+        (node: Rule.Node) => {
+          // to make typescript happy
+          if (node.type === 'CallExpression') {
+            const args = node.arguments;
+
+            const filename = context.getFilename();
+            const { pkgJson: packageJson } = getMetadataForFilename(filename);
+            const platformFeatureFlags = packageJson['platform-feature-flags'];
+
+            // existence of registration section is done in 'ensure-feature-flag-registration'
+            if (!platformFeatureFlags) {
+              return {};
+            }
+
+            // check registration section for valid feature flag prefixes.
+            // this checks all flags at every call site to ensure that new flags show errors as soon as possible.
+            for (const featureFlag in platformFeatureFlags) {
+              if (
+                !allowedPrefixes.some((prefix) =>
+                  featureFlag.startsWith(prefix),
+                )
+              ) {
+                return context.report({
+                  node: args[0],
+                  messageId: 'featureFlagIncorrectPrefix',
+                  data: {
+                    allowedPrefixes: allowedPrefixes
+                      .map((p) => `${p}`)
+                      .join(','),
+                    featureFlag,
+                  },
+                });
+              }
+            }
+          }
+
+          return {};
+        },
+      ]),
+    );
+  },
+};
+
+export default rule;

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

@@ -1,64 +1,8 @@
 import type { Rule } from 'eslint';
-import readPkgUp from 'read-pkg-up';
-import path from 'path';
-import Fuse from 'fuse.js';
-
-// defines a "getter" to "type" map, if more types are required for feature flags (like string) add it here!
-// if you don't want to verify the type use `null` as the value
-const getterIdentifierToFlagTypeMap = {
-  getBooleanFF: 'boolean' as const,
-  ffTest: 'boolean' as const,
-} as const;
-
-type PlatformFeatureFlagRegistrationSection = {
-  [key: string]: {
-    // get the values of the object above
-    type: typeof getterIdentifierToFlagTypeMap[keyof typeof getterIdentifierToFlagTypeMap];
-  };
-};
-
-type EnhancedPackageJson = readPkgUp.PackageJson & {
-  'platform-feature-flags'?: PlatformFeatureFlagRegistrationSection;
-};
-
-type PkgJsonMetaData = {
-  pkgJson: EnhancedPackageJson;
-  fuse: Fuse<string> | null;
-};
-
-// make sure we cache reading the package.json so we don't end up reading it for every instance of this rule.
-const pkgJsonCache = new Map<string, PkgJsonMetaData>();
-
-// get the ancestor package.json for a given file
-const getMetadataForFilename = (filename: string): PkgJsonMetaData => {
-  const splitFilename = filename.split(path.sep);
-  for (let i = 0; i < splitFilename.length; i++) {
-    // attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
-    const searchPath = path.join(...splitFilename.splice(0, i));
-    const cachedMetaData = pkgJsonCache.get(searchPath);
-
-    if (cachedMetaData) {
-      return cachedMetaData;
-    }
-  }
-
-  const { packageJson, path: pkgJsonPath } = readPkgUp.sync({
-    cwd: filename,
-    normalize: false,
-  })!;
-
-  const pkgJson = packageJson as EnhancedPackageJson;
-
-  const fuse =
-    packageJson['platform-feature-flags'] == null
-      ? null
-      : new Fuse(Object.keys(pkgJson['platform-feature-flags']!));
-
-  const metaData = { pkgJson, fuse };
-
-  pkgJsonCache.set(pkgJsonPath, metaData);
-  return metaData;
-};
+import {
+  getMetadataForFilename,
+  getterIdentifierToFlagTypeMap,
+} from '../util/registration-utils';
 
 const rule: Rule.RuleModule = {
   meta: {

package/src/rules/no-invalid-storybook-decorator-usage/__tests__/unit/rule.test.tsx

@@ -0,0 +1,18 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+describe('no-invalid-storybook-decorator-usage tests', () => {
+  tester.run('no-invalid-storybook-decorator-usage', rule, {
+    valid: [
+      {
+        code: `withPlatformFeatureFlags({})(<SampleComponent/>)`,
+      },
+    ],
+    invalid: [
+      {
+        code: `const flags = {'uip.sample.color': true}; withPlatformFeatureFlags(flags)(<SampleComponent/>)`,
+        errors: [{ messageId: 'onlyObjectExpression' }],
+      },
+    ],
+  });
+});

package/src/rules/no-invalid-storybook-decorator-usage/index.tsx

@@ -0,0 +1,40 @@
+import type { Rule } from 'eslint';
+
+const STORYBOOK_DECORATOR_IDENTIFIER = 'withPlatformFeatureFlags' as const;
+
+const rule: Rule.RuleModule = {
+  meta: {
+    hasSuggestions: false,
+    docs: {
+      recommended: false,
+    },
+    type: 'problem',
+    messages: {
+      onlyObjectExpression:
+        'Only object literals allowed in the storybook decorator! See http://go/pff-eslint for more details',
+    },
+  },
+  create(context) {
+    return {
+      [`CallExpression[callee.name=/${STORYBOOK_DECORATOR_IDENTIFIER}/]`]: (
+        node: Rule.Node,
+      ) => {
+        // to make typescript happy
+        if (node.type === 'CallExpression') {
+          const args = node.arguments;
+
+          if (args.length === 1 && args[0].type !== 'ObjectExpression') {
+            return context.report({
+              node,
+              messageId: 'onlyObjectExpression',
+            });
+          }
+        }
+
+        return {};
+      },
+    };
+  },
+};
+
+export default rule;

package/src/rules/util/registration-utils.ts

@@ -0,0 +1,58 @@
+import readPkgUp from 'read-pkg-up';
+import path from 'path';
+import Fuse from 'fuse.js';
+
+// defines a "getter" to "type" map, if more types are required for feature flags (like string) add it here!
+// if you don't want to verify the type use `null` as the value
+export const getterIdentifierToFlagTypeMap = {
+  getBooleanFF: 'boolean' as const,
+  ffTest: 'boolean' as const,
+} as const;
+
+export type PlatformFeatureFlagRegistrationSection = {
+  [key: string]: {
+    // get the values of the object above
+    type: typeof getterIdentifierToFlagTypeMap[keyof typeof getterIdentifierToFlagTypeMap];
+  };
+};
+
+export type EnhancedPackageJson = readPkgUp.PackageJson & {
+  'platform-feature-flags'?: PlatformFeatureFlagRegistrationSection;
+};
+
+export type PkgJsonMetaData = {
+  pkgJson: EnhancedPackageJson;
+  fuse: Fuse<string> | null;
+};
+// make sure we cache reading the package.json so we don't end up reading it for every instance of this rule.
+const pkgJsonCache = new Map<string, PkgJsonMetaData>();
+// get the ancestor package.json for a given file
+export const getMetadataForFilename = (filename: string): PkgJsonMetaData => {
+  const splitFilename = filename.split(path.sep);
+  for (let i = 0; i < splitFilename.length; i++) {
+    // attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
+    const searchPath = path.join(...splitFilename.splice(0, i));
+    const cachedMetaData = pkgJsonCache.get(searchPath);
+
+    if (cachedMetaData) {
+      return cachedMetaData;
+    }
+  }
+
+  const { packageJson, path: pkgJsonPath } = readPkgUp.sync({
+    cwd: filename,
+    normalize: false,
+  })!;
+
+  const pkgJson = packageJson as EnhancedPackageJson;
+
+  const fuse =
+    packageJson['platform-feature-flags'] == null
+      ? null
+      : new Fuse(Object.keys(pkgJson['platform-feature-flags']!));
+
+  const metaData = { pkgJson, fuse };
+
+  pkgJsonCache.set(pkgJsonPath, metaData);
+  return metaData;
+};

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

@@ -13,9 +13,13 @@ export const configs: {
         plugins: string[];
         rules: {
             '@atlaskit/platform/ensure-feature-flag-registration': string;
+            '@atlaskit/platform/ensure-feature-flag-prefix': (string | {
+                allowedPrefixes: string[];
+            })[];
             '@atlaskit/platform/ensure-test-runner-arguments': string;
             '@atlaskit/platform/ensure-test-runner-nested-count': string;
             '@atlaskit/platform/no-invalid-feature-flag-usage': string;
+            '@atlaskit/platform/no-invalid-storybook-decorator-usage': string;
         };
     };
 };
@@ -28,10 +32,12 @@ export const processors: {
 // @public (undocumented)
 export const rules: {
     'ensure-feature-flag-registration': Rule.RuleModule;
+    'ensure-feature-flag-prefix': Rule.RuleModule;
     'ensure-test-runner-arguments': Rule.RuleModule;
     'ensure-test-runner-nested-count': Rule.RuleModule;
     'no-invalid-feature-flag-usage': Rule.RuleModule;
     'no-pre-post-install-scripts': Rule.RuleModule;
+    'no-invalid-storybook-decorator-usage': Rule.RuleModule;
 };
 
 // (No @packageDocumentation comment for this package)