@atlaskit/eslint-plugin-platform 0.0.6 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/eslint-plugin-platform
 
+## 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
+
+- [`0cab60b90c3`](https://bitbucket.org/atlassian/atlassian-frontend/commits/0cab60b90c3) - Add fix to eslint rule on the arguments of nested test runner
+
 ## 0.0.6
 
 ### 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-test-runner-arguments/index.js

@@ -13,11 +13,12 @@ var rule = {
       recommended: false
     },
     type: 'problem',
+    fixable: 'code',
     messages: {
       onlyInlineFeatureFlag: 'Only pass in feature flag as string literal, please replace {{identifierName}} with its value.',
       onlyInlineTestFunction: 'Only pass in test functions/cases in an inline manner. Test functions/cases should be passed in directly, instead of as variables. Please replace {{identifierName}} with its own definition.',
-      passDownExistingFeatureFlagParam: 'Existing feature flags need to be passed down as params when calling nested test runner. See examples in the package which declares this function.',
-      passDownExistingFeatureFlagArgument: 'Existing feature flags need to be passed in as argument when calling nested test runner. See examples in the package which declares this function.',
+      passDownExistingFeatureFlagParam: 'An argument symbolising existing FFs needs to be passed down as param when calling nested test runner. See examples in the package which declares this function.',
+      passDownExistingFeatureFlagArgument: 'An argument symbolising existing FFs needs to be passed in as argument when calling nested test runner. See examples in the package which declares this function.',
       passDownExistingFeatureFlagNamesMatch: 'Argument names not matching when passing down existing feature flags. See examples in the package which declares this function.'
     }
   },
@@ -64,25 +65,35 @@ var rule = {
           // Not pass in ff to the function that calls test runner
           if (!node.parent.params[0] || node.parent.params[0].type !== 'Identifier') {
             return context.report({
-              node: node,
-              messageId: 'passDownExistingFeatureFlagParam'
+              node: node.parent,
+              messageId: 'passDownExistingFeatureFlagParam',
+              fix: function fix(fixer) {
+                var parentNodeRange = node.parent.range;
+                return [fixer.replaceTextRange([parentNodeRange[0], parentNodeRange[0] + 2], 'ff'), node.arguments[3] ? fixer.replaceText(node.arguments[3], 'ff') : fixer.insertTextAfter(node.arguments[2], ', ff')];
+              }
             });
           }
 
           // Not pass in ff to test runner as 4th argument
+          var paramName = node.parent.params[0].name;
           if (!node.arguments[3] || node.arguments[3].type !== 'Identifier') {
             return context.report({
               node: node,
-              messageId: 'passDownExistingFeatureFlagArgument'
+              messageId: 'passDownExistingFeatureFlagArgument',
+              fix: function fix(fixer) {
+                return node.arguments[3] ? fixer.replaceText(node.arguments[3], paramName) : fixer.insertTextAfter(node.arguments[2], ", ".concat(paramName));
+              }
             });
           }
           // Pass in the above two, but names don't match
-          var paramName = node.parent.params[0].name;
           var arguName = node.arguments[3].name;
           if (paramName !== arguName) {
             return context.report({
-              node: node,
-              messageId: 'passDownExistingFeatureFlagNamesMatch'
+              node: node.parent,
+              messageId: 'passDownExistingFeatureFlagNamesMatch',
+              fix: function fix(fixer) {
+                return fixer.replaceText(node.arguments[3], paramName);
+              }
             });
           }
         }

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.6",
+	"version": "0.1.0",
 	"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-test-runner-arguments/index.js

@@ -5,11 +5,12 @@ const rule = {
       recommended: false
     },
     type: 'problem',
+    fixable: 'code',
     messages: {
       onlyInlineFeatureFlag: 'Only pass in feature flag as string literal, please replace {{identifierName}} with its value.',
       onlyInlineTestFunction: 'Only pass in test functions/cases in an inline manner. Test functions/cases should be passed in directly, instead of as variables. Please replace {{identifierName}} with its own definition.',
-      passDownExistingFeatureFlagParam: 'Existing feature flags need to be passed down as params when calling nested test runner. See examples in the package which declares this function.',
-      passDownExistingFeatureFlagArgument: 'Existing feature flags need to be passed in as argument when calling nested test runner. See examples in the package which declares this function.',
+      passDownExistingFeatureFlagParam: 'An argument symbolising existing FFs needs to be passed down as param when calling nested test runner. See examples in the package which declares this function.',
+      passDownExistingFeatureFlagArgument: 'An argument symbolising existing FFs needs to be passed in as argument when calling nested test runner. See examples in the package which declares this function.',
       passDownExistingFeatureFlagNamesMatch: 'Argument names not matching when passing down existing feature flags. See examples in the package which declares this function.'
     }
   },
@@ -57,25 +58,35 @@ const rule = {
             // Not pass in ff to the function that calls test runner
             if (!node.parent.params[0] || node.parent.params[0].type !== 'Identifier') {
               return context.report({
-                node,
-                messageId: 'passDownExistingFeatureFlagParam'
+                node: node.parent,
+                messageId: 'passDownExistingFeatureFlagParam',
+                fix: function (fixer) {
+                  const parentNodeRange = node.parent.range;
+                  return [fixer.replaceTextRange([parentNodeRange[0], parentNodeRange[0] + 2], 'ff'), node.arguments[3] ? fixer.replaceText(node.arguments[3], 'ff') : fixer.insertTextAfter(node.arguments[2], ', ff')];
+                }
               });
             }
 
             // Not pass in ff to test runner as 4th argument
+            const paramName = node.parent.params[0].name;
             if (!node.arguments[3] || node.arguments[3].type !== 'Identifier') {
               return context.report({
                 node,
-                messageId: 'passDownExistingFeatureFlagArgument'
+                messageId: 'passDownExistingFeatureFlagArgument',
+                fix: function (fixer) {
+                  return node.arguments[3] ? fixer.replaceText(node.arguments[3], paramName) : fixer.insertTextAfter(node.arguments[2], `, ${paramName}`);
+                }
               });
             }
             // Pass in the above two, but names don't match
-            const paramName = node.parent.params[0].name;
             const arguName = node.arguments[3].name;
             if (paramName !== arguName) {
               return context.report({
-                node,
-                messageId: 'passDownExistingFeatureFlagNamesMatch'
+                node: node.parent,
+                messageId: 'passDownExistingFeatureFlagNamesMatch',
+                fix: function (fixer) {
+                  return fixer.replaceText(node.arguments[3], paramName);
+                }
               });
             }
           }

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.6",
+	"version": "0.1.0",
 	"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-test-runner-arguments/index.js

@@ -6,11 +6,12 @@ var rule = {
       recommended: false
     },
     type: 'problem',
+    fixable: 'code',
     messages: {
       onlyInlineFeatureFlag: 'Only pass in feature flag as string literal, please replace {{identifierName}} with its value.',
       onlyInlineTestFunction: 'Only pass in test functions/cases in an inline manner. Test functions/cases should be passed in directly, instead of as variables. Please replace {{identifierName}} with its own definition.',
-      passDownExistingFeatureFlagParam: 'Existing feature flags need to be passed down as params when calling nested test runner. See examples in the package which declares this function.',
-      passDownExistingFeatureFlagArgument: 'Existing feature flags need to be passed in as argument when calling nested test runner. See examples in the package which declares this function.',
+      passDownExistingFeatureFlagParam: 'An argument symbolising existing FFs needs to be passed down as param when calling nested test runner. See examples in the package which declares this function.',
+      passDownExistingFeatureFlagArgument: 'An argument symbolising existing FFs needs to be passed in as argument when calling nested test runner. See examples in the package which declares this function.',
       passDownExistingFeatureFlagNamesMatch: 'Argument names not matching when passing down existing feature flags. See examples in the package which declares this function.'
     }
   },
@@ -57,25 +58,35 @@ var rule = {
           // Not pass in ff to the function that calls test runner
           if (!node.parent.params[0] || node.parent.params[0].type !== 'Identifier') {
             return context.report({
-              node: node,
-              messageId: 'passDownExistingFeatureFlagParam'
+              node: node.parent,
+              messageId: 'passDownExistingFeatureFlagParam',
+              fix: function fix(fixer) {
+                var parentNodeRange = node.parent.range;
+                return [fixer.replaceTextRange([parentNodeRange[0], parentNodeRange[0] + 2], 'ff'), node.arguments[3] ? fixer.replaceText(node.arguments[3], 'ff') : fixer.insertTextAfter(node.arguments[2], ', ff')];
+              }
             });
           }
 
           // Not pass in ff to test runner as 4th argument
+          var paramName = node.parent.params[0].name;
           if (!node.arguments[3] || node.arguments[3].type !== 'Identifier') {
             return context.report({
               node: node,
-              messageId: 'passDownExistingFeatureFlagArgument'
+              messageId: 'passDownExistingFeatureFlagArgument',
+              fix: function fix(fixer) {
+                return node.arguments[3] ? fixer.replaceText(node.arguments[3], paramName) : fixer.insertTextAfter(node.arguments[2], ", ".concat(paramName));
+              }
             });
           }
           // Pass in the above two, but names don't match
-          var paramName = node.parent.params[0].name;
           var arguName = node.arguments[3].name;
           if (paramName !== arguName) {
             return context.report({
-              node: node,
-              messageId: 'passDownExistingFeatureFlagNamesMatch'
+              node: node.parent,
+              messageId: 'passDownExistingFeatureFlagNamesMatch',
+              fix: function fix(fixer) {
+                return fixer.replaceText(node.arguments[3], paramName);
+              }
             });
           }
         }

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

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/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-test-runner-arguments/__tests__/unit/rule.test.tsx

@@ -145,6 +145,32 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
+        output: `ffTest(
+          'uip.sample.color',
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              ff,
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ff,
+            ),
+        );
+        `,
         errors: [
           {
             messageId: 'passDownExistingFeatureFlagParam',
@@ -177,6 +203,31 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
+        output: `ffTest(
+          'uip.sample.color',
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              }, ff,
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ff,
+            ),
+        );
+        `,
         errors: [
           {
             messageId: 'passDownExistingFeatureFlagArgument',
@@ -210,6 +261,32 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
+        output: `ffTest(
+          'uip.sample.color',
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              ff,
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ff,
+            ),
+        );
+        `,
         errors: [
           {
             messageId: 'passDownExistingFeatureFlagNamesMatch',

package/src/rules/ensure-test-runner-arguments/index.tsx

@@ -8,15 +8,16 @@ const rule: Rule.RuleModule = {
       recommended: false,
     },
     type: 'problem',
+    fixable: 'code',
     messages: {
       onlyInlineFeatureFlag:
         'Only pass in feature flag as string literal, please replace {{identifierName}} with its value.',
       onlyInlineTestFunction:
         'Only pass in test functions/cases in an inline manner. Test functions/cases should be passed in directly, instead of as variables. Please replace {{identifierName}} with its own definition.',
       passDownExistingFeatureFlagParam:
-        'Existing feature flags need to be passed down as params when calling nested test runner. See examples in the package which declares this function.',
+        'An argument symbolising existing FFs needs to be passed down as param when calling nested test runner. See examples in the package which declares this function.',
       passDownExistingFeatureFlagArgument:
-        'Existing feature flags need to be passed in as argument when calling nested test runner. See examples in the package which declares this function.',
+        'An argument symbolising existing FFs needs to be passed in as argument when calling nested test runner. See examples in the package which declares this function.',
       passDownExistingFeatureFlagNamesMatch:
         'Argument names not matching when passing down existing feature flags. See examples in the package which declares this function.',
     },
@@ -78,25 +79,48 @@ const rule: Rule.RuleModule = {
               node.parent.params[0].type !== 'Identifier'
             ) {
               return context.report({
-                node,
+                node: node.parent,
                 messageId: 'passDownExistingFeatureFlagParam',
+                fix: function (fixer) {
+                  const parentNodeRange = node.parent.range as [number, number];
+                  return [
+                    fixer.replaceTextRange(
+                      [parentNodeRange[0], parentNodeRange[0] + 2],
+                      'ff',
+                    ),
+                    node.arguments[3]
+                      ? fixer.replaceText(node.arguments[3], 'ff')
+                      : fixer.insertTextAfter(node.arguments[2], ', ff'),
+                  ];
+                },
               });
             }
 
             // Not pass in ff to test runner as 4th argument
+            const paramName = node.parent.params[0].name;
             if (!node.arguments[3] || node.arguments[3].type !== 'Identifier') {
               return context.report({
                 node,
                 messageId: 'passDownExistingFeatureFlagArgument',
+                fix: function (fixer) {
+                  return node.arguments[3]
+                    ? fixer.replaceText(node.arguments[3], paramName)
+                    : fixer.insertTextAfter(
+                        node.arguments[2],
+                        `, ${paramName}`,
+                      );
+                },
               });
             }
             // Pass in the above two, but names don't match
-            const paramName = node.parent.params[0].name;
             const arguName = node.arguments[3].name;
             if (paramName !== arguName) {
               return context.report({
-                node,
+                node: node.parent,
                 messageId: 'passDownExistingFeatureFlagNamesMatch',
+                fix: function (fixer) {
+                  return fixer.replaceText(node.arguments[3], paramName);
+                },
               });
             }
           }

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)