@blumintinc/eslint-plugin-blumint 0.1.22 → 0.1.23

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

@@ -0,0 +1,44 @@
+# Try to keep classes reading top to bottom (`@blumintinc/blumint/class-methods-read-top-to-bottom`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
+
+<!-- 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/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/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 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

@@ -0,0 +1,99 @@
+"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/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/lib/utils/graph.js

@@ -0,0 +1,109 @@
+"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

@@ -0,0 +1,45 @@
+"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

package/package.json

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