@blumintinc/eslint-plugin-blumint 0.1.0

package/README.md

@@ -0,0 +1,60 @@
+# eslint-plugin-blumint
+
+Custom eslint rules for use at BluMint
+
+## Installation
+
+You'll first need to install [ESLint](https://eslint.org/):
+
+```sh
+npm i eslint --save-dev
+```
+
+Next, install `eslint-plugin-blumint`:
+
+```sh
+npm install eslint-plugin-blumint --save-dev
+```
+
+## Usage
+
+Add `blumint` to the plugins section of your `.eslintrc` configuration file. You can omit the `eslint-plugin-` prefix:
+
+```json
+{
+    "plugins": [
+        "blumint"
+    ]
+}
+```
+
+
+Then configure the rules you want to use under the rules section.
+
+```json
+{
+    "rules": {
+        "blumint/rule-name": "error"
+    }
+}
+```
+
+## Rules
+
+<!-- begin auto-generated rules list -->
+
+🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).
+
+| Name                                                                   | Description                                                                               | 🔧 |
+| :--------------------------------------------------------------------- | :---------------------------------------------------------------------------------------- | :- |
+| [array-methods-this-context](docs/rules/array-methods-this-context.md) | Disallow async callbacks for Array.filter                                                 | 🔧 |
+| [generic-starts-with-t](docs/rules/generic-starts-with-t.md)           | Enforce TypeScript generic types to start with T                                          | 🔧 |
+| [no-async-array-filter](docs/rules/no-async-array-filter.md)           | Disallow async callbacks for Array.filter                                                 | 🔧 |
+| [no-filter-without-return](docs/rules/no-filter-without-return.md)     | Disallow Array.filter callbacks without an explicit return (if part of a block statement) | 🔧 |
+| [no-unpinned-dependencies](docs/rules/no-unpinned-dependencies.md)     | Enforces pinned dependencies                                                              | 🔧 |
+| [prefer-fragment-shorthand](docs/rules/prefer-fragment-shorthand.md)   | Prefer <> shorthand for <React.Fragment>                                                  | 🔧 |
+| [prefer-type-over-interface](docs/rules/prefer-type-over-interface.md) | Prefer using type alias over interface                                                    | 🔧 |
+
+<!-- end auto-generated rules list -->
+
+

package/docs/rules/array-methods-this-context.md

@@ -0,0 +1,26 @@
+# Disallow 'this' context in array methods (`blumint/array-methods-this-context`)
+
+This rule disallows the direct use of class methods in Array methods like 'map', 'filter', 'forEach', 'reduce', 'some', 'every'. Instead, arrow functions should be used to preserve the 'this' context.
+
+## Rule Details
+
+This rule enforces that no class methods are directly used in Array methods. It also prefers the use of arrow functions over `bind(this)`
+
+### Examples of incorrect code for this rule:
+
+```typescript
+['a', 'b', 'c'].map(this.processItem)
+['a', 'b', 'c'].map(this.processItem, otherArgument)
+['a', 'b', 'c'].filter(this.checkItem)
+['a', 'b', 'c'].forEach(this.printItem)
+['a', 'b', 'c'].some(this.testItem)
+['a', 'b', 'c'].every(this.validateItem)
+['a', 'b', 'c'].reduce(this.combineItems)
+['a', 'b', 'c'].map(function(item) { return this.processItem(item) }.bind(this))
+```
+
+### Examples of correct code for this rule:
+```typescript
+['a', 'b', 'c'].map((item) => this.processItem(item))
+['a', 'b', 'c'].map(processItem)
+```

package/docs/rules/generic-starts-with-t.md

@@ -0,0 +1,31 @@
+# Enforce TypeScript generic types to start with T (`blumint/generic-starts-with-t`)
+
+<!-- end auto-generated rule header -->
+
+This rule enforces that all TypeScript generic types start with the letter "T".
+
+## Rule Details
+
+Generics are a way of creating reusable code components that work with a variety of types as opposed to a single one. By convention, generic type parameters often start with the letter "T". This makes it easier to recognize them as generic types and not regular variables or types.
+
+This rule enforces that all TypeScript generic types start with the letter "T".
+
+Examples of **incorrect** code for this rule:
+
+```typescript
+type GenericType<Param> = Param[];
+type GenericType<TParam, Param> = [TParam, Param];
+type GenericType<P> = P[];
+```
+
+Examples of **correct** code for this rule:
+
+```typescript
+type GenericType<TParam> = TParam[];
+type GenericType<TParam1, TParam2> = [TParam1, TParam2];
+type GenericType<T> = T[];
+```
+
+## When Not To Use It
+If you have a different convention for naming generic types in your codebase, you may want to disable this rule.
+

package/docs/rules/no-async-array-filter.md

@@ -0,0 +1,30 @@
+# Disallow async callbacks for Array.filter (`blumint/no-async-array-filter`)
+
+<!-- end auto-generated rule header -->
+
+Async callbacks in array filters are dangerous and not picked up by the standard eslint rules.
+
+## Rule Details
+
+This rule prevents the use of async callbacks in Array.filter. These will return a Promise object, which is truthy, thus rendering the filter function useless.
+
+Examples of **incorrect** code for this rule:
+
+```typescript
+
+['a'].filter(async (x) => true)
+['a'].filter(async function(x) {
+        return true
+      })
+```
+
+Examples of **correct** code for this rule:
+
+```typescript
+
+['a'].filter((x) => true)
+['a'].filter(function (x) {
+      return true
+    })
+```
+

package/docs/rules/no-filter-without-return.md

@@ -0,0 +1,41 @@
+# Disallow Array.filter callbacks without an explicit return (if part of a block statement) (`blumint/no-filter-without-return`)
+
+<!-- end auto-generated rule header -->
+
+This rule disallows the use of `Array.filter` callbacks that are part of a block statement but do not contain an explicit return statement. When using `Array.filter`, it's common to return a boolean value directly from a concise arrow function. However, if you're using a block statement (enclosed in `{}`), an explicit `return` statement is required.
+
+## Rule Details
+
+This rule is aimed at ensuring that there is an explicit return statement in `Array.filter` callbacks that are part of a block statement.
+
+Examples of **incorrect** code for this rule:
+
+```typescript
+['a'].filter((x) => {console.log(x)})
+['a'].filter((x) => {if (x) {
+    return true
+}
+else {}
+}
+)
+['a'].filter((x) => { if (x !== 'a') { console.log(x) } else { return true } })
+```
+
+Examples of **correct** code for this rule:
+
+```typescript
+['a'].filter((x) => !x)
+['a'].filter((x) => !!x)
+['a'].filter((x) => {
+    if (x === 'test') {
+        return true
+    }
+    else {
+        return false
+    }
+})
+['a'].filter(function (x) {
+  return true
+})
+['a'].filter((x) => x === 'a' ? true : false)
+```

package/docs/rules/no-unpinned-dependencies.md

@@ -0,0 +1,32 @@
+# Enforces pinned dependencies (`blumint/no-unpinned-dependencies`)
+
+🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+Unpinned dependencies can cause problems, including hard to diagnose breaking changes.
+
+## Rule Details
+
+This rule aims to prevent the use of unpinned dependencies.
+
+Examples of **incorrect** code for this rule:
+
+```json
+
+{dependencies: {eslint: "^8.19.0"}}
+{dependencies: {eslint: "~8.19.0"}}
+
+```
+
+Examples of **correct** code for this rule:
+
+```json
+
+{dependencies: {eslint: "8.19.0"}}
+
+```
+
+## When Not To Use It
+
+If pinned dependencies are ok in your codebase.

package/docs/rules/prefer-fragment-shorthand.md

@@ -0,0 +1,23 @@
+# Prefer <> shorthand for <React.Fragment> (`blumint/prefer-fragment-shorthand`)
+
+🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+This rule prefers the use of fragment shorthand, `<>` over `<React.Fragment>`
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```jsx
+<React.Fragment>Hello World</React.Fragment>
+<React.Fragment><ChildComponent /></React.Fragment>
+```
+
+Examples of **correct** code for this rule:
+
+```jsx
+<>Hello World</>
+<><ChildComponent /></>
+```

package/docs/rules/prefer-type-over-interface.md

@@ -0,0 +1,21 @@
+# Prefer using type alias over interface (`blumint/prefer-type-over-interface`)
+
+<!-- end auto-generated rule header -->
+
+This rule prefers the use of `Type` over `Interface` in Typescript.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```typescript
+interface SomeInterface { field: string; };
+interface AnotherInterface extends SomeInterface { otherField: number; };
+```
+
+Examples of **correct** code for this rule:
+
+```typescript
+type SomeType = { field: string; };
+type AnotherType = SomeType & { otherField: number; };
+```

package/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const array_methods_this_context_1 = require("./rules/array-methods-this-context");
+const generic_starts_with_t_1 = require("./rules/generic-starts-with-t");
+const no_async_array_filter_1 = require("./rules/no-async-array-filter");
+const no_filter_without_return_1 = require("./rules/no-filter-without-return");
+const no_unpinned_dependencies_1 = require("./rules/no-unpinned-dependencies");
+const prefer_fragment_shorthand_1 = require("./rules/prefer-fragment-shorthand");
+const prefer_type_over_interface_1 = require("./rules/prefer-type-over-interface");
+module.exports = {
+    meta: {
+        name: 'eslint-plugin-blumint',
+        version: '0.0.1',
+    },
+    parseOptions: {
+        ecmaVersion: 2020,
+    },
+    rules: {
+        'array-methods-this-context': array_methods_this_context_1.arrayMethodsThisContext,
+        'generic-starts-with-t': generic_starts_with_t_1.genericStartsWithT,
+        'no-async-array-filter': no_async_array_filter_1.noAsyncArrayFilter,
+        'no-filter-without-return': no_filter_without_return_1.noFilterWithoutReturn,
+        'no-unpinned-dependencies': no_unpinned_dependencies_1.noUnpinnedDependencies,
+        'prefer-fragment-shorthand': prefer_fragment_shorthand_1.preferFragmentShorthand,
+        'prefer-type-over-interface': prefer_type_over_interface_1.preferTypeOverInterface,
+    },
+};
+//# sourceMappingURL=index.js.map

package/lib/rules/array-methods-this-context.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayMethodsThisContext = void 0;
+const createRule_1 = require("../utils/createRule");
+const arrayMethods = ['map', 'filter', 'forEach', 'reduce', 'some', 'every'];
+const arrayMethodsThisContext = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            CallExpression(node) {
+                // Array method called with a class method reference
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.property.type === 'Identifier' &&
+                    arrayMethods.includes(node.callee.property.name) &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0].type === 'MemberExpression' &&
+                    node.arguments[0].object.type === 'ThisExpression') {
+                    context.report({
+                        node: node.arguments[0],
+                        messageId: 'unexpected'
+                    });
+                }
+                // Function expression bound to `this` in array method
+                else if (node.callee.type === 'MemberExpression' &&
+                    node.callee.property.type === 'Identifier' &&
+                    arrayMethods.includes(node.callee.property.name) &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0].type === 'CallExpression' &&
+                    node.arguments[0].callee.type === 'MemberExpression' &&
+                    node.arguments[0].callee.object.type === 'FunctionExpression' &&
+                    node.arguments[0].callee.property.type === 'Identifier' &&
+                    node.arguments[0].callee.property.name === 'bind' &&
+                    node.arguments[0].arguments.length > 0 &&
+                    node.arguments[0].arguments[0].type === 'ThisExpression') {
+                    context.report({
+                        node: node.arguments[0],
+                        messageId: 'preferArrow'
+                    });
+                }
+            },
+        };
+    },
+    name: 'array-methods-this-context',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow async callbacks for Array.filter',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            unexpected: 'Use an arrow function to preserve "this" context.',
+            preferArrow: 'Use an arrow function instead of binding this.'
+        },
+    },
+    defaultOptions: [],
+});
+exports.arrayMethodsThisContext = arrayMethodsThisContext;
+//# sourceMappingURL=array-methods-this-context.js.map

package/lib/rules/generic-starts-with-t.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericStartsWithT = void 0;
+const createRule_1 = require("../utils/createRule");
+const genericStartsWithT = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            TSTypeParameterDeclaration(node) {
+                for (const param of node.params) {
+                    if (typeof param.name.name === 'string' && param.name.name[0] !== 'T') {
+                        context.report({
+                            node: param,
+                            messageId: 'genericStartsWithT',
+                        });
+                    }
+                }
+            },
+        };
+    },
+    name: 'generic-starts-with-t',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce TypeScript generic types to start with T',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            genericStartsWithT: 'Generic type parameter should start with T.',
+        },
+    },
+    defaultOptions: [],
+});
+exports.genericStartsWithT = genericStartsWithT;
+//# sourceMappingURL=generic-starts-with-t.js.map

package/lib/rules/no-async-array-filter.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noAsyncArrayFilter = void 0;
+const createRule_1 = require("../utils/createRule");
+const noAsyncArrayFilter = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'filter' &&
+                    node.arguments.length > 0) {
+                    const callback = node.arguments[0];
+                    if ((callback.type === 'FunctionExpression' ||
+                        callback.type === 'ArrowFunctionExpression') &&
+                        callback.async === true) {
+                        context.report({
+                            node: callback,
+                            messageId: 'unexpected',
+                        });
+                    }
+                }
+            },
+        };
+    },
+    name: 'no-async-array-filter',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow async callbacks for Array.filter',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            unexpected: 'Async array filter is dangerous as a Promise object will always be truthy. You should move the asynchronous logic elsewhere.',
+        },
+    },
+    defaultOptions: [],
+});
+exports.noAsyncArrayFilter = noAsyncArrayFilter;
+//# sourceMappingURL=no-async-array-filter.js.map

package/lib/rules/no-filter-without-return.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFilterWithoutReturn = void 0;
+const createRule_1 = require("../utils/createRule");
+const noFilterWithoutReturn = (0, createRule_1.createRule)({
+    create(context) {
+        function isNode(value) {
+            return typeof value === 'object'
+                && value !== null
+                && 'type' in value;
+        }
+        function hasReturnStatement(node) {
+            if (node.type === 'ReturnStatement') {
+                return true;
+            }
+            else if (node.type === 'IfStatement') {
+                // Check both branches of the if statement
+                const consequentHasReturn = hasReturnStatement(node.consequent);
+                const alternateHasReturn = !!node.alternate && hasReturnStatement(node.alternate);
+                return consequentHasReturn && alternateHasReturn;
+            }
+            else if (node.type === 'BlockStatement') {
+                // Check all statements in the block
+                for (const statement of node.body) {
+                    if (hasReturnStatement(statement)) {
+                        return true;
+                    }
+                }
+            }
+            for (const key in node) {
+                if (key === 'parent') {
+                    continue; // Ignore the parent property
+                }
+                const value = node[key];
+                if (isNode(value)) {
+                    if (hasReturnStatement(value)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        return {
+            'CallExpression[callee.property.name="filter"]'(node) {
+                const callback = node.arguments[0];
+                if (callback && callback.type === 'ArrowFunctionExpression') {
+                    const { body } = callback;
+                    if (body.type !== 'BlockStatement') {
+                        // If the body is not a block statement, it's a direct return
+                        return;
+                    }
+                    // Check if there's a ReturnStatement inside
+                    if (!hasReturnStatement(body)) {
+                        context.report({
+                            node,
+                            messageId: 'unexpected',
+                        });
+                    }
+                }
+            },
+        };
+    },
+    name: 'no-filter-without-return',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow Array.filter callbacks without an explicit return (if part of a block statement)',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            unexpected: 'An array filter callback with a block statement must contain a return statement',
+        },
+    },
+    defaultOptions: [],
+});
+exports.noFilterWithoutReturn = noFilterWithoutReturn;
+//# sourceMappingURL=no-filter-without-return.js.map

package/lib/rules/no-unpinned-dependencies.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnpinnedDependencies = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.noUnpinnedDependencies = (0, createRule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforces pinned dependencies',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            unexpected: "Dependency '{{ propertyName }}' should be pinned to a specific version, but '{{ version }}' was found.",
+        },
+    },
+    defaultOptions: [],
+    name: 'no-unpinned-dependencies',
+    create(context) {
+        return {
+            JSONLiteral(node) {
+                const property = node?.parent;
+                const configSection = node?.parent?.parent?.parent;
+                if (!property || !configSection) {
+                    return;
+                }
+                const configKey = configSection?.key;
+                if (!configKey) {
+                    return;
+                }
+                // Check if we're in the "dependencies" or "devDependencies" section of package.json
+                if (node.type === 'JSONLiteral' &&
+                    property?.type === 'JSONProperty' &&
+                    (configKey.name === 'devDependencies' || configKey.value === 'devDependencies' ||
+                        configKey.name === 'dependencies' || configKey.value === 'dependencies')) {
+                    // Get the version string
+                    const version = node.value;
+                    const propertyName = property.key.name ||
+                        property.key.value;
+                    // Check if the version string starts with a caret (^) or tilde (~), indicating a non-pinned version
+                    if (typeof version === 'string' &&
+                        (version.includes('^') || version.includes('~'))) {
+                        context.report({
+                            node: node,
+                            messageId: 'unexpected',
+                            data: {
+                                propertyName,
+                                version,
+                            },
+                            fix: function (fixer) {
+                                const fixed = version.replace('^', '').replace('~', '');
+                                return fixer.replaceTextRange(node.range, `"${fixed}"`);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-unpinned-dependencies.js.map

package/lib/rules/prefer-fragment-shorthand.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferFragmentShorthand = void 0;
+const preferFragmentShorthand = {
+    create(context) {
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                if (openingElement.name.type === 'JSXMemberExpression' &&
+                    openingElement.name.object.type === 'JSXIdentifier' &&
+                    openingElement.name.object.name === 'React' &&
+                    openingElement.name.property.type === 'JSXIdentifier' &&
+                    openingElement.name.property.name === 'Fragment') {
+                    context.report({
+                        node,
+                        messageId: 'preferShorthand',
+                        fix: (fixer) => [
+                            fixer.replaceTextRange(openingElement.range, '<>'),
+                            fixer.replaceTextRange(node.closingElement.range, '</>'),
+                        ],
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer <> shorthand for <React.Fragment>',
+            recommended: 'warn',
+        },
+        messages: {
+            preferShorthand: 'Use <> shorthand for <React.Fragment>',
+        },
+        schema: [],
+        fixable: 'code',
+    },
+    defaultOptions: [],
+};
+exports.preferFragmentShorthand = preferFragmentShorthand;
+//# sourceMappingURL=prefer-fragment-shorthand.js.map

package/lib/rules/prefer-type-over-interface.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferTypeOverInterface = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.preferTypeOverInterface = (0, createRule_1.createRule)({
+    name: 'prefer-type-over-interface',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer using type alias over interface',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            preferType: 'Prefer using type alias over interface.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            TSInterfaceDeclaration(node) {
+                context.report({
+                    node,
+                    messageId: 'preferType',
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-type-over-interface.js.map

package/lib/utils/createRule.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/BluMintInc/custom-eslint-rules/plugin/docs/rules/${name}.md`);
+exports.createRule = createRule;
+//# sourceMappingURL=createRule.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@blumintinc/eslint-plugin-blumint",
+  "version": "0.1.0",
+  "description": "Custom eslint rules for use at BluMint",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin"
+  ],
+  "author": "Brodie McGuire",
+  "main": "./lib/index.js",
+  "exports": "./lib/index.js",
+  "scripts": {
+    "lint": "npm-run-all \"lint:*\"",
+    "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
+    "lint:js": "eslint .",
+    "test": "jest",
+    "update:eslint-docs": "eslint-doc-generator"
+  },
+  "dependencies": {
+    "requireindex": "1.2.0"
+  },
+  "devDependencies": {
+    "@types/eslint": "^8.37.0",
+    "@typescript-eslint/utils": "5.59.6",
+    "eslint": "8.19.0",
+    "eslint-doc-generator": "1.0.0",
+    "eslint-import-resolver-typescript": "^3.5.5",
+    "eslint-plugin-eslint-plugin": "^5.0.0",
+    "eslint-plugin-node": "11.1.0",
+    "jest": "29.3.1",
+    "jsonc-eslint-parser": "2.3.0",
+    "npm-run-all": "4.1.5",
+    "ts-jest": "^29.0.5"
+  },
+  "engines": {
+    "node": "16.0.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=7"
+  },
+  "license": "ISC"
+}