@blumintinc/eslint-plugin-blumint 0.1.10 → 0.1.12

package/README.md

@@ -56,18 +56,21 @@ Or use the recommended config:
 ✅ 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                                                 |    | ✅  |    |
-| [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                                                    |    | ✅  |    |
+| Name                                                                           | Description                                                                               | 💼 | ⚠️ | 🔧 |
+| :----------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------- | :- | :- | :- |
+| [array-methods-this-context](docs/rules/array-methods-this-context.md)         | Prevent misuse of Array methods in OOP                                                    |    | ✅  |    |
+| [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 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-async-foreach](docs/rules/no-async-foreach.md)                             | Disallow Array.forEach with an async callback function                                    | ✅  |    |    |
+| [no-conditional-literals-in-jsx](docs/rules/no-conditional-literals-in-jsx.md) | Disallow use of conditional literals in JSX code                                          | ✅  |    |    |
+| [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                                                              | ✅  |    | 🔧 |
+| [no-useless-fragment](docs/rules/no-useless-fragment.md)                       | Prevent unnecessary use of React fragments                                                |    | ✅  |    |
+| [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/export-if-in-doubt.md

@@ -1,4 +1,4 @@
-# Always Export Top-level Const Definitions, Type Definitions, and Functions (`@blumintinc/blumint/export-if-in-doubt`)
+# All top-level const definitions, type definitions, and functions should be exported (`@blumintinc/blumint/export-if-in-doubt`)
 
 ⚠️ This rule _warns_ in the ✅ `recommended` config.
 

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

@@ -1,4 +1,4 @@
-# Extract Constants/Functions to the Global Scope When Possible (`@blumintinc/blumint/extract-global-constants`)
+# Extract constants/functions to the global scope when possible (`@blumintinc/blumint/extract-global-constants`)
 
 ⚠️ This rule _warns_ in the ✅ `recommended` config.
 

package/docs/rules/no-async-foreach.md

@@ -0,0 +1,41 @@
+# Disallow Array.forEach with an async callback function (`@blumintinc/blumint/no-async-foreach`)
+
+💼 This rule is enabled in the ✅ `recommended` config.
+
+<!-- end auto-generated rule header -->
+
+This rule disallows the use of `Array.forEach` callbacks with the async keyword. These are typically found when sequential promise execution is desired, but in fact these will execute almost concurrently. The use of a standard `for` loop is suggested instead, which will execute sequentially. If concurrent execution is required, `Promise.all` or `Promise.allSettled` should be used.
+
+## Rule Details
+
+This rule is aimed at ensuring that the async keyword is not used in an `Array.forEach` callback.
+
+Examples of **incorrect** code for this rule:
+
+```typescript
+['a','b','c'].forEach(async (letter) => {
+    await someAsyncFunction(letter)
+    console.log(letter)
+    })
+['foo','bar'].forEach(async function (letter) {
+    await someAsyncFunction(letter)
+    console.log(letter)
+})
+```
+
+Examples of **correct** code for this rule:
+
+```typescript
+['a','b','c'].forEach(letter) => {
+    someSyncFunction(letter)
+    console.log(letter)
+    })
+['foo','bar'].forEach(function (letter) {
+    someSyncFunction(letter)
+    console.log(letter)
+})
+for (const letter of ['a', 'b', 'c']) {             
+    someSyncFunction(letter);
+    console.log(letter); 
+ }
+```

package/docs/rules/no-conditional-literals-in-jsx.md

@@ -0,0 +1,27 @@
+# Disallow use of conditional literals in JSX code (`@blumintinc/blumint/no-conditional-literals-in-jsx`)
+
+💼 This rule is enabled in the ✅ `recommended` config.
+
+<!-- end auto-generated rule header -->
+
+This rule disallows the use of conditional literals in JSX.
+
+## Rule Details
+
+Browser auto-translation will break if pieces of text nodes are be rendered conditionally.
+
+Examples of **incorrect** code for this rule:
+
+```jsx
+<div>This will cause {conditional && 'errors'}</div>
+<div><span>This will {conditional && 'also'} cause errors </span></div>
+```
+
+Examples of **correct** code for this rule:
+
+```jsx
+      <div>Foo</div>
+      <div>
+        Bar {conditional && <span>Baz</span>}
+      </div>
+```

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

@@ -1,14 +1,14 @@
-# Prevent Misuse of Logical OR in Switch Case Statements (`@blumintinc/blumint/no-misused-switch-case`)
+# 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.
+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.
+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:
 

package/docs/rules/no-useless-fragment.md

@@ -0,0 +1,23 @@
+# Prevent unnecessary use of React fragments (`@blumintinc/blumint/no-useless-fragment`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
+
+<!-- end auto-generated rule header -->
+
+This rule enforces that React fragments (`<>...</>`) are only used when necessary. A fragment is deemed unnecessary if it wraps only a single child.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```jsx
+<><ChildComponent /></>
+```
+
+Examples of **correct** code for this rule:
+
+```jsx
+<><ChildComponent /><AnotherChild /></>
+<><ChildComponent />Some Text<AnotherChild /></>
+```
+

package/lib/index.js

@@ -5,15 +5,18 @@ 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_async_foreach_1 = require("./rules/no-async-foreach");
+const no_conditional_literals_in_jsx_1 = require("./rules/no-conditional-literals-in-jsx");
 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 no_useless_fragment_1 = require("./rules/no-useless-fragment");
 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: '@blumintinc/eslint-plugin-blumint',
-        version: '0.1.10',
+        version: '0.1.12',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -27,9 +30,12 @@ module.exports = {
                 '@blumintinc/blumint/extract-global-constants': 'warn',
                 '@blumintinc/blumint/generic-starts-with-t': 'warn',
                 '@blumintinc/blumint/no-async-array-filter': 'error',
+                '@blumintinc/blumint/no-async-foreach': 'error',
+                '@blumincinc/blumint/no-conditional-literals-in-jsx': 'error',
                 '@blumintinc/blumint/no-filter-without-return': 'error',
                 '@blumintinc/blumint/no-misused-switch-case': 'error',
                 '@blumintinc/blumint/no-unpinned-dependencies': 'error',
+                '@blumintinc/blumint/no-useless-fragment': 'warn',
                 '@blumintinc/blumint/prefer-fragment-shorthand': 'warn',
                 '@blumintinc/blumint/prefer-type-over-interface': 'warn',
             },
@@ -41,9 +47,12 @@ module.exports = {
         '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-async-foreach': no_async_foreach_1.noAsyncForEach,
+        'no-conditional-literals-in-jsx': no_conditional_literals_in_jsx_1.noConditionalLiteralsInJsx,
         '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,
+        'no-useless-fragment': no_useless_fragment_1.noUselessFragment,
         'prefer-fragment-shorthand': prefer_fragment_shorthand_1.preferFragmentShorthand,
         'prefer-type-over-interface': prefer_type_over_interface_1.preferTypeOverInterface,
     },

package/lib/rules/no-async-foreach.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noAsyncForEach = void 0;
+exports.noAsyncForEach = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const callee = node.callee;
+                if (callee.type === 'MemberExpression' &&
+                    callee.property.type === 'Identifier' &&
+                    callee.property.name === 'forEach' &&
+                    node.arguments[0] &&
+                    (node.arguments[0].type === 'ArrowFunctionExpression' ||
+                        node.arguments[0].type === 'FunctionExpression') &&
+                    node.arguments[0].async) {
+                    context.report({
+                        node,
+                        messageId: 'noAsyncForEach',
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow Array.forEach with an async callback function',
+            recommended: 'error',
+        },
+        messages: {
+            noAsyncForEach: 'Do not use async function as callback in Array.forEach. Use a standard for loop for sequential execution or Promise.all for concurrent execution.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+};
+//# sourceMappingURL=no-async-foreach.js.map

package/lib/rules/no-conditional-literals-in-jsx.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noConditionalLiteralsInJsx = void 0;
+/* eslint-disable @blumintinc/blumint/extract-global-constants */
+// import { ASTHelpers } from '../utils/ASTHelpers';
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+exports.noConditionalLiteralsInJsx = (0, createRule_1.createRule)({
+    name: 'no-conditional-literals-in-jsx',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow use of conditional literals in JSX code',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            unexpected: 'Conditional expression is a sibling of raw text and must be wrapped in <div> or <span>',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            // Imagine evaluating <div>text {conditional && 'string'}</div>
+            JSXExpressionContainer(node) {
+                // We start at the expression {conditional && 'string'}
+                if (node.expression.type !== 'LogicalExpression') {
+                    return;
+                }
+                const parentChildren = node.parent && 'children' in node.parent ? node.parent.children : [];
+                // "text" is one of the siblingTextNodes.
+                const siblingTextNodes = parentChildren.filter((n) => {
+                    if (n.type === utils_1.TSESTree.AST_NODE_TYPES.Literal ||
+                        n.type === utils_1.TSESTree.AST_NODE_TYPES.JSXText) {
+                        return !!('value' in n && !!n.value ? `${n.value}`.trim() : false);
+                    }
+                    return false;
+                });
+                // If we were evaluating
+                //   <div>{property} {conditional && 'string'}</div>
+                // Then {property} would be one of the siblingExpressionNodes
+                const siblingExpressionNodes = parentChildren.filter((n) => n.type === 'JSXExpressionContainer' &&
+                    'expression' in n &&
+                    (n.expression.type === 'Identifier' ||
+                        n.expression.type === 'MemberExpression'));
+                // Operands of {conditional && 'string'} -- the conditional and the
+                // literal. We want to make sure we have a text literal, otherwise we'd
+                // trigger this rule on the (safe) {conditional && <div>string</div>}.
+                const expressionOperandTypes = [
+                    node.expression.left.type,
+                    node.expression.right.type,
+                ];
+                if (siblingTextNodes.concat(siblingExpressionNodes).length > 0 &&
+                    expressionOperandTypes.includes(utils_1.TSESTree.AST_NODE_TYPES.Literal)) {
+                    context.report({ node, messageId: 'unexpected' });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-conditional-literals-in-jsx.js.map

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

@@ -7,12 +7,12 @@ exports.noMisusedSwitchCase = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Prevent misuse of logical OR (||) in switch case statements',
+            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.',
+            noMisusedSwitchCase: 'Avoid using logical OR  in switch case. Use cascading cases instead.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-useless-fragment.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUselessFragment = void 0;
+exports.noUselessFragment = {
+    create(context) {
+        return {
+            JSXFragment(node) {
+                if (node.children.length === 1) {
+                    context.report({
+                        node,
+                        messageId: 'noUselessFragment',
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prevent unnecessary use of React fragments',
+            recommended: 'warn',
+        },
+        messages: {
+            noUselessFragment: 'React fragment is unnecessary when wrapping a single child',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+};
+//# sourceMappingURL=no-useless-fragment.js.map

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

@@ -30,7 +30,7 @@ exports.preferFragmentShorthand = {
             recommended: 'warn',
         },
         messages: {
-            preferShorthand: 'Use <> shorthand for <React.Fragment>',
+            preferShorthand: 'Use <> shorthand for <React.Fragment>, unless a key is required for an iterator',
         },
         schema: [],
         fixable: 'code',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Custom eslint rules for use at BluMint",
   "keywords": [
     "eslint",
@@ -36,7 +36,7 @@
     "ts-jest": "29.0.5"
   },
   "engines": {
-    "node": "16.0.0"
+    "node": "^16.0.0"
   },
   "peerDependencies": {
     "eslint": ">=7"