@blumintinc/eslint-plugin-blumint 0.1.23 → 0.1.24

package/README.md

@@ -56,21 +56,24 @@ 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-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                                                    |    | ✅  | 🔧 |
+| Name                                                                               | Description                                                                                                                                     | 💼 | ⚠️ | 🔧 |
+| :--------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- |
+| [array-methods-this-context](docs/rules/array-methods-this-context.md)             | Prevent misuse of Array methods in OOP                                                                                                          |    | ✅  |    |
+| [class-methods-read-top-to-bottom](docs/rules/class-methods-read-top-to-bottom.md) | Ensures classes read linearly from top to bottom.                                                                                               |    | ✅  | 🔧 |
+| [dynamic-https-errors](docs/rules/dynamic-https-errors.md)                         | Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id. |    | ✅  |    |
+| [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                                                                                                          |    | ✅  | 🔧 |
+| [require-memo](docs/rules/require-memo.md)                                         | React components must be memoized                                                                                                               | ✅  |    | 🔧 |
 
 <!-- end auto-generated rules list -->
 

package/docs/rules/class-methods-read-top-to-bottom.md

@@ -1,7 +1,9 @@
-# Try to keep classes reading top to bottom (`@blumintinc/blumint/class-methods-read-top-to-bottom`)
+# Ensures classes read linearly from top to bottom (`@blumintinc/blumint/class-methods-read-top-to-bottom`)
 
 ⚠️ 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 enforces an ordering of class methods according to BluMint's code style.

package/docs/rules/dynamic-https-errors.md

@@ -1,4 +1,4 @@
-# Dynamic elements of errors should be in the 'details' field (`@blumintinc/blumint/dynamic-https-errors`)
+# Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id (`@blumintinc/blumint/dynamic-https-errors`)
 
 ⚠️ This rule _warns_ in the ✅ `recommended` config.
 

package/docs/rules/require-memo.md

@@ -1,4 +1,8 @@
-# Requires memoization of react components (`@blumintinc/blumint/require-memo`)
+# React components must be memoized (`@blumintinc/blumint/require-memo`)
+
+💼 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).
 
 <!-- end auto-generated rule header -->
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "Custom eslint rules for use at BluMint",
   "keywords": [
     "eslint",
@@ -13,7 +13,7 @@
   "scripts": {
     "lint": "npm-run-all \"lint:*\"",
     "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
-    "lint:js": "eslint .",
+    "lint:js": "eslint ./src",
     "test": "jest",
     "docs": "./scripts/make-docs.sh && npm run update:eslint-docs",
     "update:eslint-docs": "eslint-doc-generator"
@@ -36,7 +36,7 @@
     "ts-jest": "29.0.5"
   },
   "engines": {
-    "node": "^16.0.0"
+    "node": "^20.0.0"
   },
   "peerDependencies": {
     "eslint": ">=7"

package/lib/utils/ClassGraphBuilder.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClassGraphBuilder = void 0;
-/* eslint-disable security/detect-object-injection */
-const utils_1 = require("@typescript-eslint/utils");
-const ClassGraphSorter_1 = require("./ClassGraphSorter");
-const ASTHelpers_1 = require("./ASTHelpers");
-/**
- * Builds a graph of class methods and properties with their dependencies from a class declaration.
- * A dependency in this case is the name of another class method.
- */
-class ClassGraphBuilder {
-    constructor(className, classBody) {
-        this.className = className;
-        this.classBody = classBody;
-        this.graph = {};
-        this.buildGraph();
-        // Note: extension requires injection of other sorters
-        this.sorter = new ClassGraphSorter_1.ClassGraphSorterReadability(this.graph);
-    }
-    buildGraph() {
-        // NOTE: these need to be run sequentially for each member,
-        // since we need to know the class members before we can search
-        // methods for dependencies
-        this.classBody.body.forEach((member) => {
-            if (ClassGraphBuilder.isClassMember(member)) {
-                this.addMemberToGraph(member);
-            }
-        });
-        this.classBody.body.forEach((member) => {
-            if (ClassGraphBuilder.isNamedClassMethod(member)) {
-                const { key } = member;
-                if (utils_1.ASTUtils.isIdentifier(key)) {
-                    this.addDependencies(member, key.name);
-                }
-            }
-        });
-    }
-    static isClassMember(node) {
-        return (node.type === 'MethodDefinition' || node.type === 'PropertyDefinition');
-    }
-    addMemberToGraph(member) {
-        const name = member.key.name;
-        const type = ClassGraphBuilder.nodeTypeOf(member);
-        const node = ClassGraphBuilder.createGraphNode(name, type, member.accessibility, member.static);
-        this.graph[name] = node;
-    }
-    static nodeTypeOf(member) {
-        if (member.type === 'MethodDefinition') {
-            return member.kind === 'constructor' ? 'constructor' : 'method';
-        }
-        return 'property';
-    }
-    static createGraphNode(name, type, accessibility, isStatic = false) {
-        return {
-            name,
-            type,
-            accessibility,
-            isStatic,
-            dependencies: [],
-        };
-    }
-    static isNamedClassMethod(node) {
-        return node.type === 'MethodDefinition';
-    }
-    addDependencies(node, methodName) {
-        const newDependencies = ASTHelpers_1.ASTHelpers.classMethodDependenciesOf(node, this.graph, this.className).filter((name) => !!this.graph[name] && name !== methodName);
-        if (this.graph[methodName]) {
-            this.graph[methodName].dependencies.push(...newDependencies);
-        }
-    }
-    get graphSorted() {
-        return this.sorter.nodesSorted;
-    }
-    get memberNamesSorted() {
-        return this.sorter.nodeNamesSorted;
-    }
-}
-exports.ClassGraphBuilder = ClassGraphBuilder;
-//# sourceMappingURL=ClassGraphBuilder.js.map

package/lib/utils/ClassGraphSorter.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClassGraphSorterReadability = exports.ClassGraphSorter = void 0;
-class ClassGraphSorter {
-    constructor(graph) {
-        this.graph = graph;
-    }
-}
-exports.ClassGraphSorter = ClassGraphSorter;
-class ClassGraphSorterReadability extends ClassGraphSorter {
-    constructor(graph) {
-        super(graph);
-        this.graph = graph;
-    }
-    get nodeNamesSorted() {
-        return this.nodesSorted.map((node) => node.name);
-    }
-    get nodesSorted() {
-        return this.sortNodes();
-    }
-    sortNodes() {
-        const { methods, properties, classConstructor } = this.groupNodesByType();
-        const [propertiesSorted, methodsSorted] = [properties, methods].map((nodeGroup) => nodeGroup.sort(ClassGraphSorterReadability.sortMembersForReadability));
-        const searchNodeCandidates = [classConstructor, ...methodsSorted].filter((node) => !!node);
-        const searchNodeCandidatesValidated = searchNodeCandidates.filter((method, _index, arr) => ClassGraphSorterReadability.SEARCH_NODE_PRIORITY_FUNCTIONS.some((fn) => !!fn(method, arr)));
-        const searchNodesSorted = searchNodeCandidatesValidated.sort((a, b) => {
-            const getPriority = (method) => {
-                const priority = ClassGraphSorterReadability.SEARCH_NODE_PRIORITY_FUNCTIONS.findIndex((fn) => !!fn(method, methodsSorted));
-                return priority === -1
-                    ? ClassGraphSorterReadability.SEARCH_NODE_PRIORITY_FUNCTIONS.length
-                    : priority;
-            };
-            return getPriority(a) - getPriority(b);
-        });
-        const dfsSortedNodes = this.dependencyDfs(searchNodesSorted);
-        return [...propertiesSorted, ...dfsSortedNodes];
-    }
-    groupNodesByType() {
-        const nodes = Object.values(this.graph);
-        return nodes.reduce((acc, node) => {
-            switch (node.type) {
-                case 'property':
-                    acc.properties.push(node);
-                    break;
-                case 'constructor':
-                    acc.classConstructor = node;
-                    break;
-                case 'method':
-                    acc.methods.push(node);
-                    break;
-            }
-            return acc;
-        }, {
-            properties: [],
-            methods: [],
-            classConstructor: null,
-        });
-    }
-    static sortMembersForReadability(a, b) {
-        // NOTE: the ordering from Object.entries is safe here since it is readonly
-        for (const [key, priorities] of Object.entries(ClassGraphSorterReadability.MODIFIER_PRIORITY_MAP)) {
-            const indexA = priorities.indexOf(a[key]);
-            const indexB = priorities.indexOf(b[key]);
-            if (indexA !== indexB) {
-                return indexA - indexB;
-            }
-        }
-        return 0;
-    }
-    dependencyDfs(searchNodes) {
-        const visited = new Set();
-        const dfsSortedNodes = [];
-        const dfs = (node) => {
-            if (visited.has(node.name) || !node) {
-                return;
-            }
-            visited.add(node.name);
-            dfsSortedNodes.push(node);
-            for (const dep of node.dependencies) {
-                dfs(this.graph[String(dep)]);
-            }
-        };
-        searchNodes.forEach((node) => dfs(node));
-        return dfsSortedNodes;
-    }
-}
-exports.ClassGraphSorterReadability = ClassGraphSorterReadability;
-ClassGraphSorterReadability.MODIFIER_PRIORITY_MAP = {
-    isStatic: [true, false],
-    accessibility: ['public', undefined, 'private'],
-};
-ClassGraphSorterReadability.SEARCH_NODE_PRIORITY_FUNCTIONS = [
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    (method, _methods) => method.type === 'constructor',
-    (method, _methods) => !_methods.some((node) => node.dependencies.includes(method.name)),
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    (method, _methods) => method.dependencies.length === 0,
-];
-//# sourceMappingURL=ClassGraphSorter.js.map

package/lib/utils/graph.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.classNodesDfs = exports.ClassGraphSorter = void 0;
-class ClassGraphSorter {
-    constructor(graph, sortFunction) {
-        this.graph = graph;
-        this.sortFunction = sortFunction;
-    }
-    sort() {
-        const nodesGrouped = this.sortFunction(Object.values(this.graph));
-        // Additional logic for DFS and sorting will be implemented here
-        // Placeholder for the sorted result
-        const sortedResult = [];
-        // Logic to populate sortedResult
-        return sortedResult;
-    }
-    defaultEnhancedSort(nodes) {
-        // Implementation of the default enhanced sort logic
-        // This will include sorting by type, static status, and accessibility
-        // Placeholder for return value
-        return { properties: [], notProperties: [] };
-    }
-    // Additional private helper methods will be implemented here
-    // Placeholder for depth-first search (DFS) logic
-    dfs(node, visited, sortedNodes) {
-        // Implementation of the DFS logic
-    }
-}
-exports.ClassGraphSorter = ClassGraphSorter;
-function classNodesDfs(graph) {
-    const { properties, notProperties } = sortClassMembersForReadability(Object.values(graph));
-    //now we have nodes in properties -> constructor -> methods order
-    //we need to sort constructor & methods such that
-    //if a node has dependencies, then the dependencies are moved after that node in a dfs manner
-    const visited = new Set();
-    const dfsSortedNodes = [];
-    const dfs = (node) => {
-        if (visited.has(node.name)) {
-            return;
-        }
-        visited.add(node.name);
-        dfsSortedNodes.push(node);
-        for (const dep of node.dependencies) {
-            dfs(graph[dep]);
-        }
-    };
-    const searchNodes = notProperties
-        .filter((method) => method.type === 'constructor' ||
-        !notProperties.some((node) => node.dependencies.includes(method.name)) ||
-        method.dependencies.length === 0)
-        .sort((a, b) => {
-        const getPriority = (method) => {
-            if (method.type === 'constructor')
-                return 1;
-            if (!notProperties.some((node) => node.dependencies.includes(method.name)))
-                return 2;
-            if (method.dependencies.length === 0)
-                return 3;
-            return 4; // In case none of the conditions match
-        };
-        return getPriority(a) - getPriority(b);
-    });
-    for (const searchNode of searchNodes) {
-        dfs(searchNode);
-    }
-    return [...properties, ...dfsSortedNodes].map((node) => node.name);
-}
-exports.classNodesDfs = classNodesDfs;
-function sortClassMembersForReadability(nodes) {
-    // 1. Group nodes by type
-    const properties = [];
-    const methods = [];
-    let constructor = null;
-    for (const node of nodes) {
-        switch (node.type) {
-            case 'property':
-                properties.push(node);
-                break;
-            case 'constructor':
-                constructor = node;
-                break;
-            case 'method':
-                methods.push(node);
-                break;
-        }
-    }
-    // 2. Fine-tune ordering within each group
-    // For properties and methods
-    const comparator = (a, b) => {
-        // Static methods/properties come first
-        if (a.isStatic && !b.isStatic)
-            return -1;
-        if (!a.isStatic && b.isStatic)
-            return 1;
-        const accessibilityA = a.accessibility ?? 'public';
-        const accessibilityB = b.accessibility ?? 'public';
-        if (accessibilityA === 'public' && accessibilityB === 'private')
-            return -1;
-        if (accessibilityA === 'private' && accessibilityB === 'public')
-            return 1;
-        // Maintain original order otherwise
-        return 0;
-    };
-    properties.sort(comparator);
-    methods.sort(comparator);
-    // Return the nodes in the desired order
-    return { properties, notProperties: [constructor, ...methods] };
-}
-//# sourceMappingURL=graph.js.map

package/lib/utils/testClass.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASTHelpers = void 0;
-class ASTHelpers {
-    constructor() {
-        ASTHelpers.returnsJSX;
-    }
-    static returnsJSX(node) {
-        if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
-            return true;
-        }
-        this.bar();
-        if (node.type === 'BlockStatement') {
-            for (const statement of node.body) {
-                if (statement.type === 'ReturnStatement' &&
-                    (statement.argument?.type === 'JSXElement' ||
-                        statement.argument?.type === 'JSXFragment')) {
-                    return true;
-                }
-                // Handle conditional returns
-                if (statement.type === 'ReturnStatement' &&
-                    statement.argument?.type === 'ConditionalExpression') {
-                    const conditionalExpr = statement.argument;
-                    if (ASTHelpers.returnsJSX(conditionalExpr.consequent) ||
-                        ASTHelpers.returnsJSX(conditionalExpr.alternate)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        if (node.type === 'ConditionalExpression') {
-            return (ASTHelpers.returnsJSX(node.consequent) ||
-                ASTHelpers.returnsJSX(node.alternate));
-        }
-        return false;
-    }
-    bar() {
-        this.foo();
-    }
-    foo() {
-        return ASTHelpers.returnsJSX(node);
-    }
-}
-exports.ASTHelpers = ASTHelpers;
-//# sourceMappingURL=testClass.js.map