@blumintinc/eslint-plugin-blumint 0.1.11 → 0.1.13

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) | 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-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,7 +1,5 @@
 # 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.
-
 <!-- 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.

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

@@ -1,7 +1,5 @@
 # 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.

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

@@ -1,4 +1,4 @@
-# Disallow Array.forEach with an async callback function (`@blumintinc/blumint/no-async-forEach`)
+# Disallow Array.forEach with an async callback function (`@blumintinc/blumint/no-async-foreach`)
 
 💼 This rule is enabled in the ✅ `recommended` config.
 

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

@@ -0,0 +1,25 @@
+# Disallow use of conditional literals in JSX code (`@blumintinc/blumint/no-conditional-literals-in-jsx`)
+
+<!-- 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-useless-fragment.md

@@ -1,6 +1,8 @@
 # Prevent unnecessary use of React fragments (`@blumintinc/blumint/no-useless-fragment`)
 
-💼 This rule is enabled in the ✅ `recommended` config.
+⚠️ 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).
 
 <!-- end auto-generated rule header -->
 

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

@@ -2,6 +2,8 @@
 
 ⚠️ 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).
+
 <!-- end auto-generated rule header -->
 
 This rule prefers the use of `Type` over `Interface` in Typescript.

package/lib/index.js

@@ -6,6 +6,7 @@ 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");
@@ -15,7 +16,7 @@ const prefer_type_over_interface_1 = require("./rules/prefer-type-over-interface
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '0.1.11',
+        version: '0.1.13',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -25,11 +26,12 @@ module.exports = {
             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/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-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',
@@ -46,6 +48,7 @@ module.exports = {
         '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,

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-useless-fragment.js

@@ -9,6 +9,21 @@ exports.noUselessFragment = {
                     context.report({
                         node,
                         messageId: 'noUselessFragment',
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+                            const openingFragment = sourceCode.getFirstToken(node);
+                            const closingFragment = sourceCode.getLastToken(node);
+                            return [
+                                fixer.removeRange([
+                                    openingFragment.range[0],
+                                    openingFragment.range[0] + 2,
+                                ]),
+                                fixer.removeRange([
+                                    closingFragment.range[0] - 3,
+                                    closingFragment.range[0],
+                                ]),
+                            ];
+                        },
                     });
                 }
             },
@@ -24,6 +39,7 @@ exports.noUselessFragment = {
             noUselessFragment: 'React fragment is unnecessary when wrapping a single child',
         },
         schema: [],
+        fixable: 'code',
     },
     defaultOptions: [],
 };

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

@@ -14,6 +14,7 @@ exports.preferTypeOverInterface = (0, createRule_1.createRule)({
         messages: {
             preferType: 'Prefer using type alias over interface.',
         },
+        fixable: 'code',
     },
     defaultOptions: [],
     create(context) {
@@ -22,6 +23,20 @@ exports.preferTypeOverInterface = (0, createRule_1.createRule)({
                 context.report({
                     node,
                     messageId: 'preferType',
+                    fix(fixer) {
+                        const sourceCode = context.getSourceCode();
+                        const openingBrace = sourceCode.getTokenAfter(node.id, {
+                            filter: (token) => token.value === '{',
+                        });
+                        const fixes = [
+                            fixer.replaceTextRange([node.range[0], node.id.range[1]], `type ${node.id.name} =`),
+                        ];
+                        if (node.extends && node.extends.length > 0 && openingBrace) {
+                            const extendsKeyword = sourceCode.getFirstTokenBetween(node.id, openingBrace, { filter: (token) => token.value === 'extends' });
+                            fixes.push(fixer.remove(extendsKeyword), fixer.insertTextBefore(openingBrace, '& '));
+                        }
+                        return fixes;
+                    },
                 });
             },
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Custom eslint rules for use at BluMint",
   "keywords": [
     "eslint",