@atlaskit/eslint-plugin-platform 0.0.7 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/eslint-plugin-platform
 
+## 0.1.1
+
+### Patch Changes
+
+- [`7edd9e8b4b1`](https://bitbucket.org/atlassian/atlassian-frontend/commits/7edd9e8b4b1) - Add suggestion to change feature flag to the closest matching feature flag using fuzzy search
+
+## 0.1.0
+
+### Minor Changes
+
+- [`6339334e3ac`](https://bitbucket.org/atlassian/atlassian-frontend/commits/6339334e3ac) - Adds new rule to disallow pre/post install scripts in package.json.
+
 ## 0.0.7
 
 ### Patch Changes

package/dist/cjs/index.js

@@ -4,8 +4,9 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.rules = exports.configs = void 0;
+exports.rules = exports.processors = exports.configs = void 0;
 var _ensureFeatureFlagRegistration = _interopRequireDefault(require("./rules/ensure-feature-flag-registration"));
+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 _noInvalidFeatureFlagUsage = _interopRequireDefault(require("./rules/no-invalid-feature-flag-usage"));
@@ -13,7 +14,8 @@ var rules = {
   'ensure-feature-flag-registration': _ensureFeatureFlagRegistration.default,
   'ensure-test-runner-arguments': _ensureTestRunnerArguments.default,
   'ensure-test-runner-nested-count': _ensureTestRunnerNestedCount.default,
-  'no-invalid-feature-flag-usage': _noInvalidFeatureFlagUsage.default
+  'no-invalid-feature-flag-usage': _noInvalidFeatureFlagUsage.default,
+  'no-pre-post-install-scripts': _noPrePostInstalls.default
 };
 exports.rules = rules;
 var configs = {
@@ -21,10 +23,23 @@ var configs = {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/no-pre-post-install-scripts': 'error',
       '@atlaskit/platform/ensure-test-runner-arguments': 'error',
       '@atlaskit/platform/ensure-test-runner-nested-count': 'warn',
       '@atlaskit/platform/no-invalid-feature-flag-usage': 'error'
     }
   }
 };
-exports.configs = configs;
+exports.configs = configs;
+var processors = {
+  'package-json-processor': {
+    preprocess: function preprocess(source) {
+      // augment the json into a js file
+      return ["/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, @typescript-eslint/semi, no-template-curly-in-string */ module.exports = ".concat(source.trim())];
+    },
+    postprocess: function postprocess(errors) {
+      return errors[0];
+    }
+  }
+};
+exports.processors = processors;

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

@@ -5,21 +5,29 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 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"));
+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!
+var getterIdentifierToFlagTypeMap = {
+  getBooleanFF: '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 getPackageJsonForFileName = function getPackageJsonForFileName(filename) {
+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 cachedPkgJson = pkgJsonCache.get(searchPath);
-    if (cachedPkgJson) {
-      return cachedPkgJson;
+    var cachedMetaData = pkgJsonCache.get(searchPath);
+    if (cachedMetaData) {
+      return cachedMetaData;
     }
   }
   var _ref = _readPkgUp.default.sync({
@@ -28,29 +36,38 @@ var getPackageJsonForFileName = function getPackageJsonForFileName(filename) {
     }),
     packageJson = _ref.packageJson,
     pkgJsonPath = _ref.path;
-  pkgJsonCache.set(pkgJsonPath, packageJson);
-  return packageJson;
+  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: {
-    hasSuggestions: false,
     docs: {
       recommended: false
     },
     type: 'problem',
     messages: {
       registrationSectionMissing: 'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
-      featureFlagMissing: "Please add a \"{{ featureFlag }}\" section to the \"platform-feature-flags\" section in your package.json. See http://go/pff-eslint for more details"
-    }
+      featureFlagMissing: "Please add a \"{{ featureFlag }}\" section to the \"platform-feature-flags\" section in your package.json. See http://go/pff-eslint for more details",
+      changeFeatureFlag: "Change flag key to \"{{ closestFlag }}\" already defined in package.json"
+    },
+    hasSuggestions: true
   },
   create: function create(context) {
-    return {
-      'CallExpression[callee.name=/getBooleanFF/]': function CallExpressionCalleeNameGetBooleanFF(node) {
+    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 packageJson = getPackageJsonForFileName(filename);
+          var _getMetadataForFilena = getMetadataForFilename(filename),
+            packageJson = _getMetadataForFilena.pkgJson,
+            fuse = _getMetadataForFilena.fuse;
           var platformFeatureFlags = packageJson['platform-feature-flags'];
           if (!platformFeatureFlags) {
             return context.report({
@@ -62,19 +79,38 @@ var rule = {
             var featureFlag = args[0].value;
             var featureFlagRegistration = platformFeatureFlags[featureFlag];
             if (!featureFlagRegistration) {
-              return context.report({
-                node: node,
+              // find the closest match in existing section for suggestion text
+              var closestMatchFix = null;
+              if (fuse) {
+                var closestFlagMatches = fuse.search(featureFlag);
+                if (closestFlagMatches.length > 0) {
+                  var closestFlag = closestFlagMatches[0].item;
+                  closestMatchFix = {
+                    messageId: 'changeFeatureFlag',
+                    data: {
+                      closestFlag: closestFlag
+                    },
+                    fix: function fix(fixer) {
+                      return fixer.replaceText(node.arguments[0], "'".concat(closestFlag, "'"));
+                    }
+                  };
+                }
+              }
+              return context.report(_objectSpread({
+                node: args[0],
                 messageId: 'featureFlagMissing',
                 data: {
                   featureFlag: featureFlag
                 }
-              });
+              }, closestMatchFix != null ? {
+                suggest: [closestMatchFix]
+              } : {}));
             }
           }
         }
         return {};
-      }
-    };
+      }];
+    }));
   }
 };
 var _default = rule;

package/dist/cjs/rules/no-pre-post-installs/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'This rule disallows public packages to have pre/post install scripts as installations can happen on different environments',
+      recommended: false
+    },
+    hasSuggestions: false,
+    messages: {
+      prePostInstallScriptsNotAllowed: 'pre/post install scripts not allowed in package.json'
+    }
+  },
+  create: function create(context) {
+    return {
+      'ObjectExpression Property[key.value=scripts] Property[key.value=/^(pre|post)install$/]': function ObjectExpressionPropertyKeyValueScriptsPropertyKeyValuePrePostInstall$(node) {
+        if (!context.getFilename().endsWith('/package.json')) {
+          return;
+        }
+        return context.report({
+          node: node,
+          messageId: 'prePostInstallScriptsNotAllowed'
+        });
+      }
+    };
+  }
+};
+var _default = rule;
+exports.default = _default;

package/dist/cjs/version.json

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

package/dist/es2019/index.js

@@ -1,4 +1,5 @@
 import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registration';
+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';
@@ -6,16 +7,27 @@ export const rules = {
   'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
-  'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage
+  'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
+  'no-pre-post-install-scripts': noPreAndPostInstallScripts
 };
 export const configs = {
   recommended: {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/no-pre-post-install-scripts': 'error',
       '@atlaskit/platform/ensure-test-runner-arguments': 'error',
       '@atlaskit/platform/ensure-test-runner-nested-count': 'warn',
       '@atlaskit/platform/no-invalid-feature-flag-usage': 'error'
     }
   }
+};
+export const processors = {
+  'package-json-processor': {
+    preprocess: source => {
+      // augment the json into a js file
+      return [`/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, @typescript-eslint/semi, no-template-curly-in-string */ module.exports = ${source.trim()}`];
+    },
+    postprocess: errors => errors[0]
+  }
 };

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

@@ -1,17 +1,23 @@
 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!
+const getterIdentifierToFlagTypeMap = {
+  getBooleanFF: '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 getPackageJsonForFileName = filename => {
+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 cachedPkgJson = pkgJsonCache.get(searchPath);
-    if (cachedPkgJson) {
-      return cachedPkgJson;
+    const cachedMetaData = pkgJsonCache.get(searchPath);
+    if (cachedMetaData) {
+      return cachedMetaData;
     }
   }
   const {
@@ -21,53 +27,82 @@ const getPackageJsonForFileName = filename => {
     cwd: filename,
     normalize: false
   });
-  pkgJsonCache.set(pkgJsonPath, packageJson);
-  return packageJson;
+  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;
 };
 const rule = {
   meta: {
-    hasSuggestions: false,
     docs: {
       recommended: false
     },
     type: 'problem',
     messages: {
       registrationSectionMissing: 'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
-      featureFlagMissing: `Please add a "{{ featureFlag }}" section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details`
-    }
+      featureFlagMissing: `Please add a "{{ featureFlag }}" section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details`,
+      changeFeatureFlag: `Change flag key to "{{ closestFlag }}" already defined in package.json`
+    },
+    hasSuggestions: true
   },
   create(context) {
-    return {
-      'CallExpression[callee.name=/getBooleanFF/]': node => {
-        // to make typescript happy
-        if (node.type === 'CallExpression') {
-          const args = node.arguments;
-          const filename = context.getFilename();
-          const packageJson = getPackageJsonForFileName(filename);
-          const platformFeatureFlags = packageJson['platform-feature-flags'];
-          if (!platformFeatureFlags) {
+    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,
+          fuse
+        } = getMetadataForFilename(filename);
+        const platformFeatureFlags = packageJson['platform-feature-flags'];
+        if (!platformFeatureFlags) {
+          return context.report({
+            node: node,
+            messageId: 'registrationSectionMissing'
+          });
+        }
+        if (args.length === 1 && args[0].type === 'Literal' && args[0].raw) {
+          const featureFlag = args[0].value;
+          const featureFlagRegistration = platformFeatureFlags[featureFlag];
+          if (!featureFlagRegistration) {
+            // find the closest match in existing section for suggestion text
+            let closestMatchFix = null;
+            if (fuse) {
+              const closestFlagMatches = fuse.search(featureFlag);
+              if (closestFlagMatches.length > 0) {
+                const closestFlag = closestFlagMatches[0].item;
+                closestMatchFix = {
+                  messageId: 'changeFeatureFlag',
+                  data: {
+                    closestFlag
+                  },
+                  fix: fixer => {
+                    return fixer.replaceText(node.arguments[0], `'${closestFlag}'`);
+                  }
+                };
+              }
+            }
             return context.report({
-              node,
-              messageId: 'registrationSectionMissing'
+              node: args[0],
+              messageId: 'featureFlagMissing',
+              data: {
+                featureFlag
+              },
+              // only suggest if we have a close flag to match
+              ...(closestMatchFix != null ? {
+                suggest: [closestMatchFix]
+              } : {})
             });
           }
-          if (args.length === 1 && args[0].type === 'Literal' && args[0].raw) {
-            const featureFlag = args[0].value;
-            const featureFlagRegistration = platformFeatureFlags[featureFlag];
-            if (!featureFlagRegistration) {
-              return context.report({
-                node,
-                messageId: 'featureFlagMissing',
-                data: {
-                  featureFlag
-                }
-              });
-            }
-          }
         }
-        return {};
       }
-    };
+      return {};
+    }]));
   }
 };
 export default rule;

package/dist/es2019/rules/no-pre-post-installs/index.js

@@ -0,0 +1,27 @@
+const rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'This rule disallows public packages to have pre/post install scripts as installations can happen on different environments',
+      recommended: false
+    },
+    hasSuggestions: false,
+    messages: {
+      prePostInstallScriptsNotAllowed: 'pre/post install scripts not allowed in package.json'
+    }
+  },
+  create(context) {
+    return {
+      'ObjectExpression Property[key.value=scripts] Property[key.value=/^(pre|post)install$/]': node => {
+        if (!context.getFilename().endsWith('/package.json')) {
+          return;
+        }
+        return context.report({
+          node,
+          messageId: 'prePostInstallScriptsNotAllowed'
+        });
+      }
+    };
+  }
+};
+export default rule;

package/dist/es2019/version.json

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

package/dist/esm/index.js

@@ -1,4 +1,5 @@
 import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registration';
+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';
@@ -6,16 +7,29 @@ export var rules = {
   'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
-  'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage
+  'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
+  'no-pre-post-install-scripts': noPreAndPostInstallScripts
 };
 export var configs = {
   recommended: {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/no-pre-post-install-scripts': 'error',
       '@atlaskit/platform/ensure-test-runner-arguments': 'error',
       '@atlaskit/platform/ensure-test-runner-nested-count': 'warn',
       '@atlaskit/platform/no-invalid-feature-flag-usage': 'error'
     }
   }
+};
+export var processors = {
+  'package-json-processor': {
+    preprocess: function preprocess(source) {
+      // augment the json into a js file
+      return ["/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, @typescript-eslint/semi, no-template-curly-in-string */ module.exports = ".concat(source.trim())];
+    },
+    postprocess: function postprocess(errors) {
+      return errors[0];
+    }
+  }
 };

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

@@ -1,18 +1,27 @@
+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!
+var getterIdentifierToFlagTypeMap = {
+  getBooleanFF: '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 getPackageJsonForFileName = function getPackageJsonForFileName(filename) {
+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 cachedPkgJson = pkgJsonCache.get(searchPath);
-    if (cachedPkgJson) {
-      return cachedPkgJson;
+    var cachedMetaData = pkgJsonCache.get(searchPath);
+    if (cachedMetaData) {
+      return cachedMetaData;
     }
   }
   var _ref = readPkgUp.sync({
@@ -21,29 +30,38 @@ var getPackageJsonForFileName = function getPackageJsonForFileName(filename) {
     }),
     packageJson = _ref.packageJson,
     pkgJsonPath = _ref.path;
-  pkgJsonCache.set(pkgJsonPath, packageJson);
-  return packageJson;
+  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;
 };
 var rule = {
   meta: {
-    hasSuggestions: false,
     docs: {
       recommended: false
     },
     type: 'problem',
     messages: {
       registrationSectionMissing: 'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
-      featureFlagMissing: "Please add a \"{{ featureFlag }}\" section to the \"platform-feature-flags\" section in your package.json. See http://go/pff-eslint for more details"
-    }
+      featureFlagMissing: "Please add a \"{{ featureFlag }}\" section to the \"platform-feature-flags\" section in your package.json. See http://go/pff-eslint for more details",
+      changeFeatureFlag: "Change flag key to \"{{ closestFlag }}\" already defined in package.json"
+    },
+    hasSuggestions: true
   },
   create: function create(context) {
-    return {
-      'CallExpression[callee.name=/getBooleanFF/]': function CallExpressionCalleeNameGetBooleanFF(node) {
+    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 packageJson = getPackageJsonForFileName(filename);
+          var _getMetadataForFilena = getMetadataForFilename(filename),
+            packageJson = _getMetadataForFilena.pkgJson,
+            fuse = _getMetadataForFilena.fuse;
           var platformFeatureFlags = packageJson['platform-feature-flags'];
           if (!platformFeatureFlags) {
             return context.report({
@@ -55,19 +73,38 @@ var rule = {
             var featureFlag = args[0].value;
             var featureFlagRegistration = platformFeatureFlags[featureFlag];
             if (!featureFlagRegistration) {
-              return context.report({
-                node: node,
+              // find the closest match in existing section for suggestion text
+              var closestMatchFix = null;
+              if (fuse) {
+                var closestFlagMatches = fuse.search(featureFlag);
+                if (closestFlagMatches.length > 0) {
+                  var closestFlag = closestFlagMatches[0].item;
+                  closestMatchFix = {
+                    messageId: 'changeFeatureFlag',
+                    data: {
+                      closestFlag: closestFlag
+                    },
+                    fix: function fix(fixer) {
+                      return fixer.replaceText(node.arguments[0], "'".concat(closestFlag, "'"));
+                    }
+                  };
+                }
+              }
+              return context.report(_objectSpread({
+                node: args[0],
                 messageId: 'featureFlagMissing',
                 data: {
                   featureFlag: featureFlag
                 }
-              });
+              }, closestMatchFix != null ? {
+                suggest: [closestMatchFix]
+              } : {}));
             }
           }
         }
         return {};
-      }
-    };
+      }];
+    }));
   }
 };
 export default rule;

package/dist/esm/rules/no-pre-post-installs/index.js

@@ -0,0 +1,27 @@
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'This rule disallows public packages to have pre/post install scripts as installations can happen on different environments',
+      recommended: false
+    },
+    hasSuggestions: false,
+    messages: {
+      prePostInstallScriptsNotAllowed: 'pre/post install scripts not allowed in package.json'
+    }
+  },
+  create: function create(context) {
+    return {
+      'ObjectExpression Property[key.value=scripts] Property[key.value=/^(pre|post)install$/]': function ObjectExpressionPropertyKeyValueScriptsPropertyKeyValuePrePostInstall$(node) {
+        if (!context.getFilename().endsWith('/package.json')) {
+          return;
+        }
+        return context.report({
+          node: node,
+          messageId: 'prePostInstallScriptsNotAllowed'
+        });
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/version.json

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

package/dist/types/index.d.ts

@@ -1,17 +1,23 @@
+import type { Linter } from 'eslint';
 export declare const rules: {
     'ensure-feature-flag-registration': 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;
 };
 export declare const configs: {
     recommended: {
         plugins: string[];
         rules: {
             '@atlaskit/platform/ensure-feature-flag-registration': string;
+            '@atlaskit/platform/no-pre-post-install-scripts': string;
             '@atlaskit/platform/ensure-test-runner-arguments': string;
             '@atlaskit/platform/ensure-test-runner-nested-count': string;
             '@atlaskit/platform/no-invalid-feature-flag-usage': string;
         };
     };
 };
+export declare const processors: {
+    'package-json-processor': Linter.Processor<string | Linter.ProcessorFile>;
+};

package/dist/types/rules/no-pre-post-installs/index.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaskit/eslint-plugin-platform",
   "description": "The essential plugin for use with Atlassian frontend platform tools",
-  "version": "0.0.7",
+  "version": "0.1.1",
   "author": "Atlassian Pty Ltd",
   "atlassian": {
     "team": "UIP - Platform Integration Trust (PITa)",
@@ -23,6 +23,7 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
+    "fuse.js": "^6.6.2",
     "read-pkg-up": "^7.0.1"
   },
   "devDependencies": {

package/report.api.md

@@ -15,6 +15,7 @@
 <!--SECTION START: Main Entry Types-->
 
 ```ts
+import type { Linter } from 'eslint';
 import { Rule } from 'eslint';
 
 // @public (undocumented)
@@ -23,6 +24,7 @@ export const configs: {
     plugins: string[];
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': string;
+      '@atlaskit/platform/no-pre-post-install-scripts': string;
       '@atlaskit/platform/ensure-test-runner-arguments': string;
       '@atlaskit/platform/ensure-test-runner-nested-count': string;
       '@atlaskit/platform/no-invalid-feature-flag-usage': string;
@@ -30,12 +32,18 @@ export const configs: {
   };
 };
 
+// @public (undocumented)
+export const processors: {
+  'package-json-processor': Linter.Processor<Linter.ProcessorFile | string>;
+};
+
 // @public (undocumented)
 export const rules: {
   'ensure-feature-flag-registration': 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 @packageDocumentation comment for this package)

package/src/__tests__/utils/_tester.tsx

@@ -16,6 +16,7 @@ import { RuleTester } from 'eslint';
     method();
   });
 };
+
 export const tester = new RuleTester({
   parser: require.resolve('babel-eslint'),
   parserOptions: {

package/src/index.tsx

@@ -1,4 +1,6 @@
+import type { Linter } from 'eslint';
 import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registration';
+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';
@@ -8,6 +10,7 @@ export const rules = {
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
+  'no-pre-post-install-scripts': noPreAndPostInstallScripts,
 };
 
 export const configs = {
@@ -15,9 +18,22 @@ export const configs = {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/no-pre-post-install-scripts': 'error',
       '@atlaskit/platform/ensure-test-runner-arguments': 'error',
       '@atlaskit/platform/ensure-test-runner-nested-count': 'warn',
       '@atlaskit/platform/no-invalid-feature-flag-usage': 'error',
     },
   },
 };
+
+export const processors = {
+  'package-json-processor': {
+    preprocess: (source: string) => {
+      // augment the json into a js file
+      return [
+        `/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, @typescript-eslint/semi, no-template-curly-in-string */ module.exports = ${source.trim()}`,
+      ];
+    },
+    postprocess: (errors) => errors[0],
+  } as Linter.Processor,
+};

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

@@ -31,6 +31,7 @@ describe('with existing platform-feature-flags section', () => {
     };
   });
 
+  // this isolates the invalid case so we can test the suggestion properly
   tester.run('ensure-feature-flag-registration', rule, {
     valid: [
       {
@@ -40,7 +41,20 @@ describe('with existing platform-feature-flags section', () => {
     invalid: [
       {
         code: `getBooleanFF('invalid-flag')`,
-        errors: [{ messageId: 'featureFlagMissing' }],
+        errors: [
+          {
+            messageId: 'featureFlagMissing',
+            suggestions: [
+              {
+                messageId: 'changeFeatureFlag',
+                data: {
+                  closestFlag: 'test-flag',
+                },
+                output: `getBooleanFF('test-flag')`,
+              },
+            ],
+          },
+        ],
       },
     ],
   });

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

@@ -1,26 +1,42 @@
 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!
+const getterIdentifierToFlagTypeMap = {
+  getBooleanFF: 'boolean' as const,
+} as const;
 
 type PlatformFeatureFlagRegistrationSection = {
   [key: string]: {
-    type: 'boolean';
+    // 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, readPkgUp.PackageJson>();
+const pkgJsonCache = new Map<string, PkgJsonMetaData>();
 
 // get the ancestor package.json for a given file
-const getPackageJsonForFileName = (filename: string): readPkgUp.PackageJson => {
+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 cachedPkgJson = pkgJsonCache.get(searchPath);
+    const cachedMetaData = pkgJsonCache.get(searchPath);
 
-    if (cachedPkgJson) {
-      return cachedPkgJson;
+    if (cachedMetaData) {
+      return cachedMetaData;
     }
   }
 
@@ -29,13 +45,21 @@ const getPackageJsonForFileName = (filename: string): readPkgUp.PackageJson => {
     normalize: false,
   })!;
 
-  pkgJsonCache.set(pkgJsonPath, packageJson);
-  return packageJson;
+  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;
 };
 
 const rule: Rule.RuleModule = {
   meta: {
-    hasSuggestions: false,
     docs: {
       recommended: false,
     },
@@ -44,47 +68,88 @@ const rule: Rule.RuleModule = {
       registrationSectionMissing:
         'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
       featureFlagMissing: `Please add a "{{ featureFlag }}" section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details`,
+      changeFeatureFlag: `Change flag key to "{{ closestFlag }}" already defined in package.json`,
     },
+
+    hasSuggestions: true,
   },
   create(context) {
-    return {
-      'CallExpression[callee.name=/getBooleanFF/]': (node: Rule.Node) => {
-        // to make typescript happy
-        if (node.type === 'CallExpression') {
-          const args = node.arguments;
-
-          const filename = context.getFilename();
-          const packageJson = getPackageJsonForFileName(filename);
-          const platformFeatureFlags = packageJson[
-            'platform-feature-flags'
-          ] as PlatformFeatureFlagRegistrationSection;
-
-          if (!platformFeatureFlags) {
-            return context.report({
-              node,
-              messageId: 'registrationSectionMissing',
-            });
-          }
+    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;
 
-          if (args.length === 1 && args[0].type === 'Literal' && args[0].raw) {
-            const featureFlag = args[0].value as string;
-            const featureFlagRegistration = platformFeatureFlags[featureFlag];
+            const filename = context.getFilename();
+            const { pkgJson: packageJson, fuse } =
+              getMetadataForFilename(filename);
+            const platformFeatureFlags = packageJson['platform-feature-flags'];
 
-            if (!featureFlagRegistration) {
+            if (!platformFeatureFlags) {
               return context.report({
-                node,
-                messageId: 'featureFlagMissing',
-                data: {
-                  featureFlag,
-                },
+                node: node,
+                messageId: 'registrationSectionMissing',
               });
             }
+
+            if (
+              args.length === 1 &&
+              args[0].type === 'Literal' &&
+              args[0].raw
+            ) {
+              const featureFlag = args[0].value as string;
+              const featureFlagRegistration = platformFeatureFlags[featureFlag];
+
+              if (!featureFlagRegistration) {
+                // find the closest match in existing section for suggestion text
+                let closestMatchFix: Rule.SuggestionReportDescriptor | null =
+                  null;
+
+                if (fuse) {
+                  const closestFlagMatches = fuse.search(featureFlag);
+                  if (closestFlagMatches.length > 0) {
+                    const closestFlag = closestFlagMatches[0].item;
+
+                    closestMatchFix = {
+                      messageId: 'changeFeatureFlag',
+                      data: {
+                        closestFlag,
+                      },
+                      fix: (fixer) => {
+                        return fixer.replaceText(
+                          node.arguments[0],
+                          `'${closestFlag}'`,
+                        );
+                      },
+                    };
+                  }
+                }
+
+                return context.report({
+                  node: args[0],
+                  messageId: 'featureFlagMissing',
+                  data: {
+                    featureFlag,
+                  },
+                  // only suggest if we have a close flag to match
+                  ...(closestMatchFix != null
+                    ? { suggest: [closestMatchFix] }
+                    : {}),
+                });
+              }
+            }
           }
-        }
 
-        return {};
-      },
-    };
+          return {};
+        },
+      ]),
+    );
   },
 };
 

package/src/rules/no-pre-post-installs/__tests__/unit/rule.test.ts

@@ -0,0 +1,41 @@
+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 = { "scripts": { "preinstall": 1, "postinstall": 2 }}`,
+        filename: 'hello/foo.ts',
+      },
+      {
+        code: `const foo = { "scripts": { "preinstall": 1, "postinstall": 2 }}`,
+        filename: 'foo/dummy.json',
+      },
+      {
+        code: `const foo = { "scripts": { "bar": 1, "dummy": 'echo 1' }}`,
+        filename: 'foo/package.json',
+      },
+      {
+        code: `module.exports = { "scripts": { "fakePreinstall": 1 }};`,
+        filename: 'bar/package.json',
+      },
+      {
+        code: `module.exports = { "scripts": { "fakePostinstall": 1 }};`,
+        filename: 'bar/package.json',
+      },
+    ],
+    invalid: [
+      {
+        code: `module.exports = { "scripts": { "preinstall": 1 }};`,
+        filename: 'bar/package.json',
+        errors: [{ messageId: 'prePostInstallScriptsNotAllowed' }],
+      },
+      {
+        code: `const foo = { "scripts": { "postinstall": 1 }}`,
+        filename: 'baz/package.json',
+        errors: [{ messageId: 'prePostInstallScriptsNotAllowed' }],
+      },
+    ],
+  });
+});

package/src/rules/no-pre-post-installs/index.ts

@@ -0,0 +1,34 @@
+import type { Rule } from 'eslint';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'This rule disallows public packages to have pre/post install scripts as installations can happen on different environments',
+      recommended: false,
+    },
+    hasSuggestions: false,
+    messages: {
+      prePostInstallScriptsNotAllowed:
+        'pre/post install scripts not allowed in package.json',
+    },
+  },
+  create(context) {
+    return {
+      'ObjectExpression Property[key.value=scripts] Property[key.value=/^(pre|post)install$/]':
+        (node: Rule.Node) => {
+          if (!context.getFilename().endsWith('/package.json')) {
+            return;
+          }
+
+          return context.report({
+            node,
+            messageId: 'prePostInstallScriptsNotAllowed',
+          });
+        },
+    };
+  },
+};
+
+export default rule;

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

@@ -4,6 +4,7 @@
 
 ```ts
 
+import type { Linter } from 'eslint';
 import { Rule } from 'eslint';
 
 // @public (undocumented)
@@ -12,6 +13,7 @@ export const configs: {
         plugins: string[];
         rules: {
             '@atlaskit/platform/ensure-feature-flag-registration': string;
+            '@atlaskit/platform/no-pre-post-install-scripts': string;
             '@atlaskit/platform/ensure-test-runner-arguments': string;
             '@atlaskit/platform/ensure-test-runner-nested-count': string;
             '@atlaskit/platform/no-invalid-feature-flag-usage': string;
@@ -19,12 +21,18 @@ export const configs: {
     };
 };
 
+// @public (undocumented)
+export const processors: {
+    'package-json-processor': Linter.Processor<Linter.ProcessorFile | string>;
+};
+
 // @public (undocumented)
 export const rules: {
     'ensure-feature-flag-registration': 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 @packageDocumentation comment for this package)