@blumintinc/eslint-plugin-blumint 0.1.22 → 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

@@ -0,0 +1,46 @@
+# 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.
+
+## Rule Details
+
+This rule warns for classes that don't follow the 'top to bottom' ordering - such that properties appear at the top of the class, the constructor (if present) follows, and other methods follow in a top-to-bottom order.
+
+### Examples of incorrect code for this rule:
+
+```typescript
+class IncorrectlyOrdered {
+    field1: string;
+    field2: number;
+    methodA() {
+    this.methodB();
+    }
+    constructor() {
+    this.methodA();
+    this.methodC();
+    }
+    methodB() {}
+    methodC() {}
+}
+```
+
+### Examples of correct code for this rule:
+```typescript
+class CorrectlyOrdered {
+    field1: string;
+    field2: number;
+    constructor() {
+        this.methodA();
+    }
+    methodA() {
+        this.methodB();
+    }
+    methodB() {}
+}
+```

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/lib/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const array_methods_this_context_1 = require("./rules/array-methods-this-context");
+const class_methods_read_top_to_bottom_1 = require("./rules/class-methods-read-top-to-bottom");
 const dynamic_https_errors_1 = require("./rules/dynamic-https-errors");
 const export_if_in_doubt_1 = require("./rules/export-if-in-doubt");
 const extract_global_constants_1 = require("./rules/extract-global-constants");
@@ -18,7 +19,7 @@ const require_memo_1 = require("./rules/require-memo");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '0.1.22',
+        version: '0.1.23',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -28,6 +29,7 @@ module.exports = {
             plugins: ['@blumintinc/blumint'],
             rules: {
                 '@blumintinc/blumint/array-methods-this-context': 'warn',
+                '@blumintinc/blumint/class-methods-read-top-to-bottom': 'warn',
                 '@blumintinc/blumint/dynamic-https-errors': 'warn',
                 // '@blumintinc/blumint/export-if-in-doubt': 'warn',
                 // '@blumintinc/blumint/extract-global-constants': 'warn',
@@ -47,6 +49,7 @@ module.exports = {
     },
     rules: {
         'array-methods-this-context': array_methods_this_context_1.arrayMethodsThisContext,
+        'class-methods-read-top-to-bottom': class_methods_read_top_to_bottom_1.classMethodsReadTopToBottom,
         'dynamic-https-errors': dynamic_https_errors_1.dynamicHttpsErrors,
         'export-if-in-doubt': export_if_in_doubt_1.exportIfInDoubt,
         'extract-global-constants': extract_global_constants_1.extractGlobalConstants,

package/lib/rules/class-methods-read-top-to-bottom.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classMethodsReadTopToBottom = void 0;
+const createRule_1 = require("../utils/createRule");
+const ClassGraphBuilder_1 = require("../utils/graph/ClassGraphBuilder");
+function getMemberName(member) {
+    if (member.type === 'MethodDefinition' ||
+        member.type === 'PropertyDefinition') {
+        return member.key.type === 'Identifier' ? member.key.name : null;
+    }
+    return null;
+}
+exports.classMethodsReadTopToBottom = (0, createRule_1.createRule)({
+    name: 'class-methods-read-top-to-bottom',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures classes read linearly from top to bottom.',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            classMethodsReadTopToBottom: 'Methods should be ordered for top-down readability.',
+        },
+        fixable: 'code', // To allow ESLint to autofix issues.
+    },
+    defaultOptions: [],
+    create(context) {
+        let className;
+        return {
+            ClassDeclaration(node) {
+                className = node.id?.name || '';
+            },
+            'ClassBody:exit'(node) {
+                const graphBuilder = new ClassGraphBuilder_1.ClassGraphBuilder(className, node);
+                const sortedOrder = graphBuilder.memberNamesSorted;
+                const actualOrder = node.body
+                    .map((member) => member.type === 'MethodDefinition' ||
+                    member.type === 'PropertyDefinition'
+                    ? member.key.name
+                    : null)
+                    .filter(Boolean);
+                for (let i = 0; i < actualOrder.length; i++) {
+                    if (actualOrder[i] !== sortedOrder[i]) {
+                        const sourceCode = context.getSourceCode();
+                        const newClassBody = sortedOrder
+                            .map((n) => {
+                            // Fetch the actual AST node corresponding to the name
+                            const memberNode = node.body.find((member) => getMemberName(member) === n);
+                            const comments = sourceCode.getCommentsBefore(memberNode);
+                            memberNode.range = [
+                                Math.min(memberNode.range[0], Math.min(...comments.map((comment) => comment.range[0]))),
+                                Math.max(memberNode.range[1], Math.max(...comments.map((comment) => comment.range[1]))),
+                            ];
+                            return sourceCode.getText(memberNode);
+                        })
+                            .join('\n');
+                        return context.report({
+                            node,
+                            messageId: 'classMethodsReadTopToBottom',
+                            fix(fixer) {
+                                return fixer.replaceTextRange([node.range[0] + 1, node.range[1] - 1], // Exclude the curly braces
+                                newClassBody);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=class-methods-read-top-to-bottom.js.map

package/lib/utils/ASTHelpers.js

@@ -90,6 +90,164 @@ class ASTHelpers {
                 return false;
         }
     }
+    static classMethodDependenciesOf(node, graph, className) {
+        const dependencies = [];
+        if (!node) {
+            return dependencies;
+        }
+        switch (node.type) {
+            case 'MethodDefinition':
+                const functionBody = node.value.body;
+                return (functionBody?.body || [])
+                    .map((statement) => ASTHelpers.classMethodDependenciesOf(statement, graph, className))
+                    .flat();
+            case 'Identifier':
+                dependencies.push(node.name);
+                break;
+            case 'ExpressionStatement':
+                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
+            case 'MemberExpression':
+                if ((node.object.type === 'ThisExpression' &&
+                    node.property.type === 'Identifier') ||
+                    (node.object.type === 'Identifier' &&
+                        node.object.name === className &&
+                        node.property.type === 'Identifier')) {
+                    dependencies.push(node.property.name);
+                }
+                else {
+                    return [
+                        ...ASTHelpers.classMethodDependenciesOf(node.object, graph, className),
+                        ...ASTHelpers.classMethodDependenciesOf(node.property, graph, className),
+                    ];
+                }
+                break;
+            case 'TSNonNullExpression':
+                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
+            case 'ArrayPattern':
+                return node.elements
+                    .map((element) => ASTHelpers.classMethodDependenciesOf(element, graph, className))
+                    .flat();
+            case 'ObjectPattern':
+                return node.properties
+                    .map((property) => ASTHelpers.classMethodDependenciesOf(property.value || null, graph, className))
+                    .flat();
+            case 'AssignmentPattern':
+                return ASTHelpers.classMethodDependenciesOf(node.left, graph, className);
+            case 'RestElement':
+                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
+            case 'AwaitExpression':
+                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
+            case 'AssignmentExpression':
+                return [
+                    ...ASTHelpers.classMethodDependenciesOf(node.left, graph, className),
+                    ...ASTHelpers.classMethodDependenciesOf(node.right, graph, className),
+                ];
+            case 'BlockStatement':
+                return node.body
+                    .map((statement) => ASTHelpers.classMethodDependenciesOf(statement, graph, className))
+                    .flat()
+                    .filter(Boolean);
+            case 'IfStatement':
+                return [
+                    ...ASTHelpers.classMethodDependenciesOf(node.test, graph, className),
+                    ...ASTHelpers.classMethodDependenciesOf(node.consequent, graph, className),
+                    ...ASTHelpers.classMethodDependenciesOf(node.alternate, graph, className),
+                ];
+            case 'TSTypeAssertion':
+                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
+            case 'Identifier':
+                return dependencies;
+            case 'SpreadElement':
+                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
+            case 'ChainExpression':
+                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
+            case 'ArrayExpression':
+                return node.elements
+                    .map((element) => element &&
+                    (element.type === 'SpreadElement'
+                        ? ASTHelpers.classMethodDependenciesOf(element.argument, graph, className)
+                        : ASTHelpers.classMethodDependenciesOf(element, graph, className)))
+                    .flat()
+                    .filter(Boolean);
+            case 'ObjectExpression':
+                return node.properties
+                    .map((property) => {
+                    if (property.type === 'Property') {
+                        return ASTHelpers.classMethodDependenciesOf(property.value, graph, className);
+                    }
+                    else if (property.type === 'SpreadElement') {
+                        return ASTHelpers.classMethodDependenciesOf(property.argument, graph, className);
+                    }
+                    return false;
+                })
+                    .flat()
+                    .filter(Boolean);
+            case 'Property':
+                return ASTHelpers.classMethodDependenciesOf(node.value, graph, className);
+            case 'BinaryExpression':
+            case 'LogicalExpression':
+                return [
+                    ...ASTHelpers.classMethodDependenciesOf(node.left, graph, className),
+                    ...ASTHelpers.classMethodDependenciesOf(node.right, graph, className),
+                ];
+            case 'UnaryExpression':
+            case 'UpdateExpression':
+                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
+            case 'CallExpression':
+            case 'NewExpression':
+                // For function and constructor calls, we care about both the callee and the arguments.
+                return [
+                    ...ASTHelpers.classMethodDependenciesOf(node.callee, graph, className),
+                    ...node.arguments
+                        .map((arg) => ASTHelpers.classMethodDependenciesOf(arg, graph, className))
+                        .flat(),
+                ];
+            case 'ConditionalExpression':
+                return [
+                    ...ASTHelpers.classMethodDependenciesOf(node.test, graph, className),
+                    ...ASTHelpers.classMethodDependenciesOf(node.consequent, graph, className),
+                    ...ASTHelpers.classMethodDependenciesOf(node.alternate, graph, className),
+                ];
+            case 'TSAsExpression':
+                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
+            case 'VariableDeclaration':
+                return node.declarations
+                    .map((declaration) => ASTHelpers.classMethodDependenciesOf(declaration, graph, className))
+                    .flat()
+                    .filter(Boolean);
+            case 'VariableDeclarator':
+                return ASTHelpers.classMethodDependenciesOf(node.init, graph, className);
+            case 'ForOfStatement':
+                return [
+                    ...ASTHelpers.classMethodDependenciesOf(node.left, graph, className),
+                    ...ASTHelpers.classMethodDependenciesOf(node.body, graph, className),
+                    ...ASTHelpers.classMethodDependenciesOf(node.right, graph, className),
+                ];
+            case 'ForStatement':
+                return [node.body, node.init, node.test, node.update]
+                    .map((node) => ASTHelpers.classMethodDependenciesOf(node, graph, className))
+                    .flat();
+            case 'ThrowStatement':
+                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
+            case 'TemplateLiteral':
+                return node.expressions
+                    .map((expression) => ASTHelpers.classMethodDependenciesOf(expression, graph, className))
+                    .flat();
+            case 'ReturnStatement':
+                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
+            case 'ArrowFunctionExpression':
+                return [
+                    ...node.params.flatMap((param) => ASTHelpers.classMethodDependenciesOf(param, graph, className)),
+                    ...ASTHelpers.classMethodDependenciesOf(node.body, graph, className),
+                ];
+            default:
+                break;
+        }
+        // Removing duplicates
+        return [
+            ...new Set(dependencies.filter((dep) => graph?.[dep]?.type !== 'property')),
+        ];
+    }
     static isNode(value) {
         return typeof value === 'object' && value !== null && 'type' in value;
     }
@@ -165,7 +323,8 @@ class ASTHelpers {
             }
         }
         if (node.type === 'ConditionalExpression') {
-            return (this.returnsJSX(node.consequent) || this.returnsJSX(node.alternate));
+            return (ASTHelpers.returnsJSX(node.consequent) ||
+                ASTHelpers.returnsJSX(node.alternate));
         }
         return false;
     }

package/lib/utils/createRule.js

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

package/lib/utils/graph/ClassGraphBuilder.js

@@ -0,0 +1,80 @@
+"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 ClassGraphSorterReadability_1 = require("./ClassGraphSorterReadability");
+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 ClassGraphSorterReadability_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/graph/ClassGraphSorter.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassGraphSorter = void 0;
+class ClassGraphSorter {
+    constructor(graph) {
+        this.graph = graph;
+    }
+}
+exports.ClassGraphSorter = ClassGraphSorter;
+//# sourceMappingURL=ClassGraphSorter.js.map

package/lib/utils/graph/ClassGraphSorterReadability.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassGraphSorterReadability = void 0;
+const ClassGraphSorter_1 = require("./ClassGraphSorter");
+class ClassGraphSorterReadability extends ClassGraphSorter_1.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=ClassGraphSorterReadability.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "0.1.22",
+  "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"