@blumintinc/eslint-plugin-blumint 0.1.0 → 0.1.2

package/README.md

@@ -1,4 +1,4 @@
-# eslint-plugin-blumint
+# @blumintinc/eslint-plugin-blumint
 
 Custom eslint rules for use at BluMint
 
@@ -10,20 +10,20 @@ You'll first need to install [ESLint](https://eslint.org/):
 npm i eslint --save-dev
 ```
 
-Next, install `eslint-plugin-blumint`:
+Next, install `@blumintinc/eslint-plugin-blumint`:
 
 ```sh
-npm install eslint-plugin-blumint --save-dev
+npm install @blumintinc/eslint-plugin-blumint --save-dev
 ```
 
 ## Usage
 
-Add `blumint` to the plugins section of your `.eslintrc` configuration file. You can omit the `eslint-plugin-` prefix:
+Add `@blumintinc/blumint` to the plugins section of your `.eslintrc` configuration file. You can omit the `eslint-plugin-` prefix:
 
 ```json
 {
     "plugins": [
-        "blumint"
+        "@blumintinc/blumint"
     ]
 }
 ```
@@ -39,21 +39,35 @@ Then configure the rules you want to use under the rules section.
 }
 ```
 
+Or use the recommended config:
+
+```json
+{
+    "extends": ["some-other-plugin", "plugin:@blumintinc/blumint/recommended"]
+}
+```
+
 ## Rules
 
 <!-- begin auto-generated rules list -->
 
+💼 Configurations enabled in.\
+⚠️ Configurations set to warn in.\
+✅ Set in the `recommended` configuration.\
 🔧 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                                                    | 🔧 |
+| Name                                                                   | Description                                                                               | 💼 | ⚠️ | 🔧 |
+| :--------------------------------------------------------------------- | :---------------------------------------------------------------------------------------- | :- | :- | :- |
+| [array-methods-this-context](docs/rules/array-methods-this-context.md) | Disallow async callbacks for Array.filter                                                 |    | ✅  |    |
+| [export-if-in-doubt](docs/rules/export-if-in-doubt.md)                 | All top-level const definitions, type definitions, and functions should be exported       |    | ✅  |    |
+| [extract-global-constants](docs/rules/extract-global-constants.md)     | Extract constants/functions from React components to the global scope when possible       |    | ✅  |    |
+| [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-misused-switch-case](docs/rules/no-misused-switch-case.md)         | Prevent misuse of logical OR (||) in switch case statements                               | ✅  |    |    |
+| [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

@@ -1,4 +1,8 @@
-# Disallow 'this' context in array methods (`blumint/array-methods-this-context`)
+# Prevent misuse of Array methods in OOP (`@blumintinc/blumint/array-methods-this-context`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
+
+<!-- end auto-generated rule header -->
 
 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.
 

package/docs/rules/export-if-in-doubt.md

@@ -0,0 +1,28 @@
+# Always Export Top-level Const Definitions, Type Definitions, and Functions (`@blumintinc/blumint/export-if-in-doubt`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
+
+<!-- end auto-generated rule header -->
+
+This rule enforces that all top-level const definitions, type definitions, and functions should always be exported. If not done, this rule will trigger a warning message suggesting to export the declaration.
+
+## Rule Details
+
+This rule targets `VariableDeclaration`, `FunctionDeclaration`, and `TSTypeAliasDeclaration` at the top-level of the file. It will issue a warning if these are not part of an `ExportNamedDeclaration`.
+
+### Examples of incorrect code for this rule:
+
+```typescript
+const someVar = "Hello, world!";
+function someFunc() { return someVar; }
+type SomeType = { val: number };
+```
+
+### Examples of correct code for this rule:
+
+```typescript
+export const someVar = "Hello, world!";
+export function someFunc() { return someVar; }
+export type SomeType = { val: number };
+```
+

package/docs/rules/extract-global-constants.md

@@ -0,0 +1,35 @@
+# Extract Constants/Functions to the Global Scope When Possible (`@blumintinc/blumint/extract-global-constants`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
+
+<!-- end auto-generated rule header -->
+
+This rule suggests that if a constant or a function within a function or block scope doesn't depend on any other identifiers in that scope, it should be moved to the global scope. This aims to improve the readability of the code and the possibility of reuse.
+
+## Rule Details
+
+This rule enforces that all `const` declarations and `FunctionDeclaration` at a non-global scope, which have no dependencies on other identifiers within the scope, should be extracted to the global scope.
+
+### Examples of incorrect code for this rule:
+
+```typescript
+function someFunc() {
+  const SOME_CONST = "Hello, world!";
+}
+
+function parentFunc() {
+  function childFunc() { return "Hello, world!"; }
+}
+```
+
+### Examples of correct code for this rule:
+
+```typescript
+const SOME_CONST = "Hello, world!";
+function someFunc() { /* ... */ }
+
+function childFunc() { return "Hello, world!"; }
+function parentFunc() { /* ... */ }
+```
+
+In the correct examples, each declaration is moved to the global scope since they don't depend on any identifier in their previous block or function scope. This aligns with the rule and promotes potential reuse of these declarations.

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

@@ -1,4 +1,6 @@
-# Enforce TypeScript generic types to start with T (`blumint/generic-starts-with-t`)
+# Enforce TypeScript generic types to start with T (`@blumintinc/blumint/generic-starts-with-t`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
 
 <!-- end auto-generated rule header -->
 

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

@@ -1,4 +1,6 @@
-# Disallow async callbacks for Array.filter (`blumint/no-async-array-filter`)
+# Disallow async callbacks for Array.filter (`@blumintinc/blumint/no-async-array-filter`)
+
+💼 This rule is enabled in the ✅ `recommended` config.
 
 <!-- end auto-generated rule header -->
 

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

@@ -1,4 +1,6 @@
-# Disallow Array.filter callbacks without an explicit return (if part of a block statement) (`blumint/no-filter-without-return`)
+# Disallow Array.filter callbacks without an explicit return (if part of a block statement) (`@blumintinc/blumint/no-filter-without-return`)
+
+💼 This rule is enabled in the ✅ `recommended` config.
 
 <!-- end auto-generated rule header -->
 

package/docs/rules/no-misused-switch-case.md

@@ -0,0 +1,38 @@
+# Prevent Misuse of Logical OR in Switch Case Statements (`@blumintinc/blumint/no-misused-switch-case`)
+
+💼 This rule is enabled in the ✅ `recommended` config.
+
+<!-- end auto-generated rule header -->
+
+This rule prevents the misuse of logical OR (`||`) in switch case statements. Instead, cascading cases should be used. This improves code readability and understanding.
+
+## Rule Details
+
+This rule specifically targets `SwitchStatement` and issues a warning if a case uses a logical OR (`||`) in its test.
+
+### Examples of incorrect code for this rule:
+
+```typescript
+switch (value) {
+  case 'a' || 'b':
+    console.log('It is a or b');
+    break;
+  default:
+    console.log('Unknown value');
+}
+```
+
+### Examples of correct code for this rule:
+
+```typescript
+switch (value) {
+  case 'a':
+  case 'b':
+    console.log('It is a or b');
+    break;
+  default:
+    console.log('Unknown value');
+}
+```
+
+In the correct example, instead of using a logical OR in the case test, cascading cases are used to capture the multiple possibilities. This is the standard way to handle multiple possibilities in a switch case and adheres to the rule.

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

@@ -1,4 +1,6 @@
-# Enforces pinned dependencies (`blumint/no-unpinned-dependencies`)
+# Enforces pinned dependencies (`@blumintinc/blumint/no-unpinned-dependencies`)
+
+💼 This rule is enabled in the ✅ `recommended` config.
 
 🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
 

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

@@ -1,4 +1,6 @@
-# Prefer <> shorthand for <React.Fragment> (`blumint/prefer-fragment-shorthand`)
+# Prefer <> shorthand for <React.Fragment> (`@blumintinc/blumint/prefer-fragment-shorthand`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
 
 🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
 

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

@@ -1,4 +1,6 @@
-# Prefer using type alias over interface (`blumint/prefer-type-over-interface`)
+# Prefer using type alias over interface (`@blumintinc/blumint/prefer-type-over-interface`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
 
 <!-- end auto-generated rule header -->
 

package/lib/index.js

@@ -1,28 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.testingAFunction = void 0;
 const array_methods_this_context_1 = require("./rules/array-methods-this-context");
+const export_if_in_doubt_1 = require("./rules/export-if-in-doubt");
+const extract_global_constants_1 = require("./rules/extract-global-constants");
 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_misused_switch_case_1 = require("./rules/no-misused-switch-case");
 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',
+        name: '@blumintinc/eslint-plugin-blumint',
+        version: '0.1.2',
     },
     parseOptions: {
         ecmaVersion: 2020,
     },
+    configs: {
+        recommended: {
+            plugins: ['@blumintinc/blumint'],
+            rules: {
+                '@blumintinc/blumint/array-methods-this-context': 'warn',
+                '@blumintinc/blumint/export-if-in-doubt': 'warn',
+                '@blumintinc/blumint/extract-global-constants': 'warn',
+                '@blumintinc/blumint/generic-starts-with-t': 'warn',
+                '@blumintinc/blumint/no-async-array-filter': 'error',
+                '@blumintinc/blumint/no-filter-without-return': 'error',
+                '@blumintinc/blumint/no-misused-switch-case': 'error',
+                '@blumintinc/blumint/no-unpinned-dependencies': 'error',
+                '@blumintinc/blumint/prefer-fragment-shorthand': 'warn',
+                '@blumintinc/blumint/prefer-type-over-interface': 'warn',
+            },
+        },
+    },
     rules: {
         'array-methods-this-context': array_methods_this_context_1.arrayMethodsThisContext,
+        'export-if-in-doubt': export_if_in_doubt_1.exportIfInDoubt,
+        'extract-global-constants': extract_global_constants_1.extractGlobalConstants,
         '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-misused-switch-case': no_misused_switch_case_1.noMisusedSwitchCase,
         '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,
     },
 };
+const testingAFunction = (input) => {
+    const a = input?.A;
+    return a;
+};
+exports.testingAFunction = testingAFunction;
 //# sourceMappingURL=index.js.map

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

@@ -1,28 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayMethodsThisContext = void 0;
+exports.arrayMethodsThisContext = exports.ARRAY_METHODS = void 0;
 const createRule_1 = require("../utils/createRule");
-const arrayMethods = ['map', 'filter', 'forEach', 'reduce', 'some', 'every'];
-const arrayMethodsThisContext = (0, createRule_1.createRule)({
+exports.ARRAY_METHODS = [
+    'map',
+    'filter',
+    'forEach',
+    'reduce',
+    'some',
+    'every',
+];
+exports.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) &&
+                    exports.ARRAY_METHODS.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'
+                        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) &&
+                    exports.ARRAY_METHODS.includes(node.callee.property.name) &&
                     node.arguments.length > 0 &&
                     node.arguments[0].type === 'CallExpression' &&
                     node.arguments[0].callee.type === 'MemberExpression' &&
@@ -33,7 +40,7 @@ const arrayMethodsThisContext = (0, createRule_1.createRule)({
                     node.arguments[0].arguments[0].type === 'ThisExpression') {
                     context.report({
                         node: node.arguments[0],
-                        messageId: 'preferArrow'
+                        messageId: 'preferArrow',
                     });
                 }
             },
@@ -49,10 +56,9 @@ const arrayMethodsThisContext = (0, createRule_1.createRule)({
         schema: [],
         messages: {
             unexpected: 'Use an arrow function to preserve "this" context.',
-            preferArrow: 'Use an arrow function instead of binding this.'
+            preferArrow: 'Use an arrow function instead of binding this.',
         },
     },
     defaultOptions: [],
 });
-exports.arrayMethodsThisContext = arrayMethodsThisContext;
 //# sourceMappingURL=array-methods-this-context.js.map

package/lib/rules/export-if-in-doubt.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportIfInDoubt = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.exportIfInDoubt = (0, createRule_1.createRule)({
+    name: 'always-export',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'All top-level const definitions, type definitions, and functions should be exported',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            exportIfInDoubt: 'Top-level const definitions, type definitions, and functions should be exported.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            'Program > VariableDeclaration > VariableDeclarator, Program > FunctionDeclaration, Program > TSTypeAliasDeclaration'(node) {
+                if ((node.parent && node.parent.type !== 'ExportNamedDeclaration') ||
+                    (node.parent &&
+                        node.parent.parent &&
+                        node.parent.parent.type !== 'ExportNamedDeclaration')) {
+                    context.report({
+                        node,
+                        messageId: 'exportIfInDoubt',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=export-if-in-doubt.js.map

package/lib/rules/extract-global-constants.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractGlobalConstants = void 0;
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const createRule_1 = require("../utils/createRule");
+exports.extractGlobalConstants = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            VariableDeclaration(node) {
+                if (node.kind !== 'const') {
+                    return;
+                }
+                const scope = context.getScope();
+                const hasDependencies = node.declarations.some((declaration) => declaration.init &&
+                    ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(declaration.init));
+                if (!hasDependencies && scope.type === 'function') {
+                    const constName = node.declarations[0].id.name;
+                    context.report({
+                        node,
+                        messageId: 'extractGlobalConstants',
+                        data: {
+                            declarationName: constName,
+                        },
+                    });
+                }
+            },
+            FunctionDeclaration(node) {
+                if (node.parent &&
+                    (node.parent.type === 'FunctionDeclaration' ||
+                        node.parent.type === 'FunctionExpression' ||
+                        node.parent.type === 'ArrowFunctionExpression')) {
+                    const scope = context.getScope();
+                    const hasDependencies = ASTHelpers_1.ASTHelpers.blockIncludesIdentifier(node.body);
+                    if (!hasDependencies && scope.type === 'function') {
+                        const funcName = node.id.name;
+                        context.report({
+                            node,
+                            messageId: 'extractGlobalConstants',
+                            data: {
+                                declarationName: funcName,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+    name: 'extract-global-constants',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Extract constants/functions from React components to the global scope when possible',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            extractGlobalConstants: 'Move this declaration {{ declarationName }} to the global scope and rename it to UPPER_SNAKE_CASE if necessary.',
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=extract-global-constants.js.map

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

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.genericStartsWithT = void 0;
 const createRule_1 = require("../utils/createRule");
-const genericStartsWithT = (0, createRule_1.createRule)({
+exports.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') {
+                    if (typeof param.name.name === 'string' &&
+                        param.name.name[0] !== 'T') {
                         context.report({
                             node: param,
                             messageId: 'genericStartsWithT',
@@ -31,5 +32,4 @@ const genericStartsWithT = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
 });
-exports.genericStartsWithT = genericStartsWithT;
 //# sourceMappingURL=generic-starts-with-t.js.map

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noAsyncArrayFilter = void 0;
 const createRule_1 = require("../utils/createRule");
-const noAsyncArrayFilter = (0, createRule_1.createRule)({
+exports.noAsyncArrayFilter = (0, createRule_1.createRule)({
     create(context) {
         return {
             CallExpression(node) {
@@ -37,5 +37,4 @@ const noAsyncArrayFilter = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
 });
-exports.noAsyncArrayFilter = noAsyncArrayFilter;
 //# sourceMappingURL=no-async-array-filter.js.map

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

@@ -1,45 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noFilterWithoutReturn = void 0;
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
-const noFilterWithoutReturn = (0, createRule_1.createRule)({
+exports.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];
@@ -49,8 +14,7 @@ const noFilterWithoutReturn = (0, createRule_1.createRule)({
                         // If the body is not a block statement, it's a direct return
                         return;
                     }
-                    // Check if there's a ReturnStatement inside
-                    if (!hasReturnStatement(body)) {
+                    if (!ASTHelpers_1.ASTHelpers.hasReturnStatement(body)) {
                         context.report({
                             node,
                             messageId: 'unexpected',
@@ -74,5 +38,4 @@ const noFilterWithoutReturn = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
 });
-exports.noFilterWithoutReturn = noFilterWithoutReturn;
 //# sourceMappingURL=no-filter-without-return.js.map

package/lib/rules/no-misused-switch-case.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMisusedSwitchCase = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.noMisusedSwitchCase = (0, createRule_1.createRule)({
+    name: 'no-misused-switch-case',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent misuse of logical OR (||) in switch case statements',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMisusedSwitchCase: 'Avoid using logical OR (||) in switch case. Use cascading cases instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            SwitchStatement(node) {
+                for (const switchCase of node.cases) {
+                    if (switchCase.test?.type === 'LogicalExpression' &&
+                        switchCase.test.operator === '||') {
+                        context.report({
+                            node: switchCase,
+                            messageId: 'noMisusedSwitchCase',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-misused-switch-case.js.map

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

@@ -21,6 +21,7 @@ exports.noUnpinnedDependencies = (0, createRule_1.createRule)({
         return {
             JSONLiteral(node) {
                 const property = node?.parent;
+                // const property = node.parent;
                 const configSection = node?.parent?.parent?.parent;
                 if (!property || !configSection) {
                     return;
@@ -32,8 +33,10 @@ exports.noUnpinnedDependencies = (0, createRule_1.createRule)({
                 // 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')) {
+                    (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 ||

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferFragmentShorthand = void 0;
-const preferFragmentShorthand = {
+exports.preferFragmentShorthand = {
     create(context) {
         return {
             JSXElement(node) {
@@ -37,5 +37,4 @@ const preferFragmentShorthand = {
     },
     defaultOptions: [],
 };
-exports.preferFragmentShorthand = preferFragmentShorthand;
 //# sourceMappingURL=prefer-fragment-shorthand.js.map

package/lib/utils/ASTHelpers.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASTHelpers = void 0;
+// import { RuleContext } from '@typescript-eslint/utils/dist/ts-eslint';
+class ASTHelpers {
+    static blockIncludesIdentifier(block) {
+        for (const statement of block.body) {
+            if (ASTHelpers.declarationIncludesIdentifier(statement)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static declarationIncludesIdentifier(node) {
+        if (!node) {
+            return false;
+        }
+        console.log('visting node of type', node.type);
+        switch (node.type) {
+            case 'BlockStatement':
+                return ASTHelpers.blockIncludesIdentifier(node);
+            case 'Identifier':
+                return true;
+            case 'SpreadElement':
+                return ASTHelpers.declarationIncludesIdentifier(node.argument);
+            case 'ChainExpression':
+                return ASTHelpers.declarationIncludesIdentifier(node.expression);
+            case 'ArrayExpression':
+                return node.elements.some((element) => element &&
+                    (element.type === 'SpreadElement'
+                        ? ASTHelpers.declarationIncludesIdentifier(element.argument)
+                        : ASTHelpers.declarationIncludesIdentifier(element)));
+            case 'ObjectExpression':
+                return node.properties.some((property) => {
+                    if (property.type === 'Property') {
+                        return ASTHelpers.declarationIncludesIdentifier(property.value);
+                    }
+                    else if (property.type === 'SpreadElement') {
+                        return ASTHelpers.declarationIncludesIdentifier(property.argument);
+                    }
+                    return false;
+                });
+            case 'Property':
+                return this.declarationIncludesIdentifier(node.value);
+            case 'BinaryExpression':
+            case 'LogicalExpression':
+                return (this.declarationIncludesIdentifier(node.left) ||
+                    this.declarationIncludesIdentifier(node.right));
+            case 'UnaryExpression':
+            case 'UpdateExpression':
+                return this.declarationIncludesIdentifier(node.argument);
+            case 'MemberExpression':
+                return this.declarationIncludesIdentifier(node.object);
+            case 'CallExpression':
+            case 'NewExpression':
+                // For function and constructor calls, we care about both the callee and the arguments.
+                return (this.declarationIncludesIdentifier(node.callee) ||
+                    node.arguments.some((arg) => this.declarationIncludesIdentifier(arg)));
+            case 'ConditionalExpression':
+                return (this.declarationIncludesIdentifier(node.test) ||
+                    this.declarationIncludesIdentifier(node.consequent) ||
+                    this.declarationIncludesIdentifier(node.alternate));
+            default:
+                return false;
+        }
+    }
+    // public static declarationIncludesIdentifier(
+    //   node: TSESTree.Expression | null,
+    // ): boolean {
+    //   if (!node) {
+    //     return false;
+    //   }
+    //   switch (node.type) {
+    //     case 'Identifier':
+    //       return true;
+    //     case 'ArrayExpression':
+    //       return node.elements.some(
+    //         (element) =>
+    //           element &&
+    //           (element.type === 'SpreadElement'
+    //             ? ASTHelpers.declarationIncludesIdentifier(element.argument)
+    //             : ASTHelpers.declarationIncludesIdentifier(element)),
+    //       );
+    //     case 'ObjectExpression':
+    //       return node.properties.some((property) => {
+    //         if (property.type === 'Property') {
+    //           return ASTHelpers.declarationIncludesIdentifier(property.key);
+    //         } else if (property.type === 'SpreadElement') {
+    //           return ASTHelpers.declarationIncludesIdentifier(property.argument);
+    //         }
+    //         return false;
+    //       });
+    //     default:
+    //       return (
+    //         ASTHelpers.declarationIncludesIdentifier((node as any).left) ||
+    //         ASTHelpers.declarationIncludesIdentifier((node as any).right)
+    //       );
+    //   }
+    // }
+    static isNode(value) {
+        return typeof value === 'object' && value !== null && 'type' in value;
+    }
+    static hasReturnStatement(node) {
+        if (node.type === 'ReturnStatement') {
+            return true;
+        }
+        else if (node.type === 'IfStatement') {
+            // Check both branches of the if statement
+            const consequentHasReturn = ASTHelpers.hasReturnStatement(node.consequent);
+            const alternateHasReturn = !!node.alternate && ASTHelpers.hasReturnStatement(node.alternate);
+            return consequentHasReturn && alternateHasReturn;
+        }
+        else if (node.type === 'BlockStatement') {
+            // Check all statements in the block
+            for (const statement of node.body) {
+                if (ASTHelpers.hasReturnStatement(statement)) {
+                    return true;
+                }
+            }
+        }
+        for (const key in node) {
+            if (key === 'parent') {
+                continue; // Ignore the parent property
+            }
+            const value = node[key];
+            if (ASTHelpers.isNode(value)) {
+                if (ASTHelpers.hasReturnStatement(value)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+exports.ASTHelpers = ASTHelpers;
+//# sourceMappingURL=ASTHelpers.js.map

package/lib/utils/createRule.js

@@ -2,6 +2,5 @@
 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;
+exports.createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/BluMintInc/custom-eslint-rules/plugin/docs/rules/${name}.md`);
 //# sourceMappingURL=createRule.js.map

package/lib/utils/ruleTester.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleTesterJson = exports.ruleTesterJsx = exports.ruleTesterTs = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const eslint_1 = require("eslint");
+exports.ruleTesterTs = new utils_1.ESLintUtils.RuleTester({
+    parser: '@typescript-eslint/parser',
+});
+exports.ruleTesterJsx = new utils_1.ESLintUtils.RuleTester({
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+        ecmaFeatures: {
+            jsx: true,
+        },
+    },
+});
+exports.ruleTesterJson = new eslint_1.RuleTester({
+    parser: require.resolve('jsonc-eslint-parser'),
+    parserOptions: {
+        ecmaVersion: 2020,
+    },
+});
+//# sourceMappingURL=ruleTester.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Custom eslint rules for use at BluMint",
   "keywords": [
     "eslint",
@@ -15,23 +15,25 @@
     "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
     "lint:js": "eslint .",
     "test": "jest",
+    "docs": "./scripts/make-docs.sh && npm run update:eslint-docs",
     "update:eslint-docs": "eslint-doc-generator"
   },
   "dependencies": {
     "requireindex": "1.2.0"
   },
   "devDependencies": {
-    "@types/eslint": "^8.37.0",
+    "@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-import-resolver-typescript": "3.5.5",
+    "eslint-plugin-eslint-plugin": "5.0.0",
+    "@blumintinc/eslint-plugin-blumint": "file:./",
     "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"
+    "ts-jest": "29.0.5"
   },
   "engines": {
     "node": "16.0.0"

package/scripts/make-docs.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+# Set the directories relative to the script location
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+SRC_DIR="$SCRIPT_DIR/../src/rules"
+DOCS_DIR="$SCRIPT_DIR/../docs/rules"
+
+# Create docs/rules directory if it doesn't exist
+mkdir -p "$DOCS_DIR"
+
+# Iterate over every file in src/rules
+for SRC_FILE in $SRC_DIR/*; do
+    # Extract the filename without the extension
+    FILENAME=$(basename -- "$SRC_FILE")
+    FILENAME="${FILENAME%.*}"
+    
+    # Create a corresponding .md file in docs/rules
+    touch "$DOCS_DIR/$FILENAME.md"
+done
+
+echo "Markdown files have been created in $DOCS_DIR."