@blumintinc/eslint-plugin-blumint 1.0.2 → 1.0.3

package/lib/rules/require-memo.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireMemo = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const isComponentExplicitlyUnmemoized = (componentName) => componentName.toLowerCase().includes('unmemoized');
+function isFunction(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+}
+function isHigherOrderFunctionReturningJSX(node) {
+    if (isFunction(node)) {
+        // Check if function takes another function as an argument
+        const hasFunctionParam = 'params' in node && node.params.some(isFunction);
+        if (node.body && node.body.type === 'BlockStatement') {
+            for (const statement of node.body.body) {
+                if (statement.type === 'ReturnStatement' && statement.argument) {
+                    const returnsJSX = ASTHelpers_1.ASTHelpers.returnsJSX(statement.argument);
+                    const returnsFunction = isFunction(statement.argument);
+                    return (hasFunctionParam || returnsFunction) && returnsJSX;
+                }
+            }
+        }
+    }
+    return false;
+}
+const isUnmemoizedArrowFunction = (parentNode) => {
+    return (parentNode.type === 'VariableDeclarator' &&
+        parentNode.id.type === 'Identifier' &&
+        !isComponentExplicitlyUnmemoized(parentNode.id.name));
+};
+const isUnmemoizedFunctionComponent = (parentNode, node) => {
+    return (node.type === 'FunctionDeclaration' &&
+        parentNode.type === 'Program' &&
+        node.id &&
+        !isComponentExplicitlyUnmemoized(node.id.name));
+};
+const isUnmemoizedExportedFunctionComponent = (parentNode, node) => {
+    return (node.type === 'FunctionDeclaration' &&
+        parentNode.type === 'ExportNamedDeclaration' &&
+        node.id &&
+        !isComponentExplicitlyUnmemoized(node.id.name));
+};
+function isMemoImport(importPath) {
+    // Match both absolute and relative paths ending with util/memo
+    return /(?:^|\/)util\/memo$/.test(importPath);
+}
+function checkFunction(context, node) {
+    const fileName = context.getFilename();
+    if (!fileName.endsWith('.tsx')) {
+        return;
+    }
+    if (isHigherOrderFunctionReturningJSX(node)) {
+        return;
+    }
+    const parentNode = node.parent;
+    if (node.parent.type === 'CallExpression') {
+        return;
+    }
+    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body) && ASTHelpers_1.ASTHelpers.hasParameters(node)) {
+        const results = [
+            isUnmemoizedArrowFunction,
+            isUnmemoizedFunctionComponent,
+            isUnmemoizedExportedFunctionComponent,
+        ].map((fn) => fn(parentNode, node));
+        if (results.some((result) => !!result)) {
+            context.report({
+                node,
+                messageId: 'requireMemo',
+                fix: results[2] || results[1]
+                    ? function fix(fixer) {
+                        const sourceCode = context.getSourceCode();
+                        let importFix = null;
+                        // Search for memo import statement
+                        const importDeclarations = sourceCode.ast.body.filter((node) => node.type === 'ImportDeclaration');
+                        const memoImport = importDeclarations.find((importDeclaration) => isMemoImport(importDeclaration.source.value));
+                        if (memoImport) {
+                            // Check if memo is already imported
+                            if (!memoImport.specifiers.some((specifier) => specifier.local.name === 'memo')) {
+                                // Add memo to existing import statement
+                                const lastSpecifier = memoImport.specifiers[memoImport.specifiers.length - 1];
+                                importFix = fixer.insertTextAfter(lastSpecifier, ', memo');
+                            }
+                        }
+                        else {
+                            // Calculate relative path based on current file location
+                            const currentFilePath = context.getFilename();
+                            const importPath = calculateImportPath(currentFilePath);
+                            // Find the first import statement to insert after
+                            const firstImport = importDeclarations[0];
+                            // Add new import statement for memo
+                            const importStatement = `import { memo } from '${importPath}';\n`;
+                            if (firstImport) {
+                                // Insert after the first import with a single newline
+                                importFix = fixer.insertTextAfter(firstImport, '\n' + importStatement.trim());
+                            }
+                            else {
+                                // Insert at the start of the file
+                                importFix = fixer.insertTextBeforeRange([sourceCode.ast.range[0], sourceCode.ast.range[0]], importStatement.trim() + '\n');
+                            }
+                        }
+                        const functionKeywordRange = [
+                            node.range[0],
+                            node.range[0] + 'function'.length,
+                        ];
+                        const functionKeywordReplacement = `const ${node.id.name} = memo(`;
+                        // Step 3: Rename function
+                        const functionNameReplacement = `function ${node.id.name}Unmemoized`;
+                        const fixes = [
+                            fixer.replaceTextRange(functionKeywordRange, functionKeywordReplacement),
+                            fixer.insertTextAfterRange([node.range[1], node.range[1]], ')'),
+                            fixer.replaceTextRange([node.id.range[0] - 1, node.id.range[1]], functionNameReplacement),
+                        ];
+                        if (importFix) {
+                            fixes.push(importFix);
+                        }
+                        return fixes;
+                    }
+                    : undefined,
+            });
+        }
+    }
+}
+function calculateImportPath(currentFilePath) {
+    // Default to absolute path if we can't calculate relative path
+    if (!currentFilePath)
+        return 'src/util/memo';
+    // Split the current file path into parts and normalize
+    const parts = currentFilePath.split(/[\\/]/); // Handle both Unix and Windows paths
+    const srcIndex = parts.indexOf('src');
+    if (srcIndex === -1) {
+        // If we're not in a src directory, use absolute path
+        return 'src/util/memo';
+    }
+    // Calculate relative path based on current file depth from src
+    // Subtract 1 from depth to exclude the filename itself
+    const depth = parts.length - (srcIndex + 1) - 1;
+    return '../'.repeat(depth) + 'util/memo';
+}
+exports.requireMemo = {
+    create: (context) => ({
+        ArrowFunctionExpression(node) {
+            checkFunction(context, node);
+        },
+        FunctionDeclaration(node) {
+            checkFunction(context, node);
+        },
+        FunctionExpression(node) {
+            checkFunction(context, node);
+        },
+    }),
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'React components must be memoized',
+            recommended: 'error',
+        },
+        messages: {
+            requireMemo: 'Component definition not wrapped in React.memo()',
+        },
+        schema: [],
+        fixable: 'code',
+    },
+    defaultOptions: [],
+};
+//# sourceMappingURL=require-memo.js.map

package/lib/utils/ASTHelpers.d.ts

@@ -0,0 +1,12 @@
+import { TSESTree } from '@typescript-eslint/utils';
+import { Graph } from './graph/ClassGraphBuilder';
+export declare class ASTHelpers {
+    static blockIncludesIdentifier(block: TSESTree.BlockStatement): boolean;
+    static declarationIncludesIdentifier(node: TSESTree.Node | null): boolean;
+    static classMethodDependenciesOf(node: TSESTree.Node | null, graph: Graph, className: string): string[];
+    static isNode(value: unknown): value is TSESTree.Node;
+    static hasReturnStatement(node: TSESTree.Node): boolean;
+    static isNodeExported(node: TSESTree.Node): boolean;
+    static returnsJSX(node: TSESTree.Node): boolean;
+    static hasParameters(node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration): boolean;
+}

package/lib/utils/ASTHelpers.js

@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASTHelpers = void 0;
+class ASTHelpers {
+    static blockIncludesIdentifier(block) {
+        for (const statement of block.body) {
+            if (ASTHelpers.declarationIncludesIdentifier(statement)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static declarationIncludesIdentifier(node) {
+        if (!node) {
+            return false;
+        }
+        switch (node.type) {
+            case 'TSNonNullExpression':
+                return this.declarationIncludesIdentifier(node.expression);
+            case 'ArrayPattern':
+                return node.elements.some((element) => ASTHelpers.declarationIncludesIdentifier(element));
+            case 'ObjectPattern':
+                return node.properties.some((property) => this.declarationIncludesIdentifier(property.value || null));
+            case 'AssignmentPattern':
+                return this.declarationIncludesIdentifier(node.left);
+            case 'RestElement':
+                return this.declarationIncludesIdentifier(node.argument);
+            case 'AwaitExpression':
+                return this.declarationIncludesIdentifier(node.argument);
+            case 'AssignmentExpression':
+                return (this.declarationIncludesIdentifier(node.left) ||
+                    this.declarationIncludesIdentifier(node.right));
+            case 'BlockStatement':
+                return node.body.some((statement) => statement.type === 'BlockStatement' &&
+                    ASTHelpers.blockIncludesIdentifier(statement));
+            case 'IfStatement':
+                return (this.declarationIncludesIdentifier(node.test) ||
+                    this.declarationIncludesIdentifier(node.consequent) ||
+                    this.declarationIncludesIdentifier(node.alternate));
+            case 'TSTypeAssertion':
+                return this.declarationIncludesIdentifier(node.expression);
+            case 'Identifier':
+                return true;
+            case 'SpreadElement':
+                return ASTHelpers.declarationIncludesIdentifier(node.argument);
+            case 'ChainExpression':
+                return ASTHelpers.declarationIncludesIdentifier(node.expression);
+            case 'ArrayExpression':
+                return node.elements.some((element) => element &&
+                    (element.type === 'SpreadElement'
+                        ? ASTHelpers.declarationIncludesIdentifier(element.argument)
+                        : ASTHelpers.declarationIncludesIdentifier(element)));
+            case 'ObjectExpression':
+                return node.properties.some((property) => {
+                    if (property.type === 'Property') {
+                        return ASTHelpers.declarationIncludesIdentifier(property.value);
+                    }
+                    else if (property.type === 'SpreadElement') {
+                        return ASTHelpers.declarationIncludesIdentifier(property.argument);
+                    }
+                    return false;
+                });
+            case 'Property':
+                return this.declarationIncludesIdentifier(node.value);
+            case 'BinaryExpression':
+            case 'LogicalExpression':
+                return (this.declarationIncludesIdentifier(node.left) ||
+                    this.declarationIncludesIdentifier(node.right));
+            case 'UnaryExpression':
+            case 'UpdateExpression':
+                return this.declarationIncludesIdentifier(node.argument);
+            case 'MemberExpression':
+                if (node.object.type === 'ThisExpression') {
+                    return true;
+                }
+                return (this.declarationIncludesIdentifier(node.object) ||
+                    this.declarationIncludesIdentifier(node.property));
+            case 'CallExpression':
+            case 'NewExpression':
+                // For function and constructor calls, we care about both the callee and the arguments.
+                return (this.declarationIncludesIdentifier(node.callee) ||
+                    node.arguments.some((arg) => this.declarationIncludesIdentifier(arg)));
+            case 'ConditionalExpression':
+                return (this.declarationIncludesIdentifier(node.test) ||
+                    this.declarationIncludesIdentifier(node.consequent) ||
+                    this.declarationIncludesIdentifier(node.alternate));
+            case 'TSAsExpression':
+                return this.declarationIncludesIdentifier(node.expression);
+            default:
+                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;
+    }
+    static hasReturnStatement(node) {
+        if (node.type === 'ReturnStatement') {
+            return true;
+        }
+        if (node.type === 'IfStatement') {
+            const consequentHasReturn = ASTHelpers.hasReturnStatement(node.consequent);
+            const alternateHasReturn = !!node.alternate && ASTHelpers.hasReturnStatement(node.alternate);
+            return consequentHasReturn && alternateHasReturn;
+        }
+        if (node.type === 'BlockStatement') {
+            for (const statement of node.body) {
+                if (ASTHelpers.hasReturnStatement(statement)) {
+                    return true;
+                }
+            }
+        }
+        for (const key in node) {
+            if (key === 'parent') {
+                continue; // Ignore the parent property
+            }
+            const value = node[key];
+            if (ASTHelpers.isNode(value)) {
+                if (ASTHelpers.hasReturnStatement(value)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    static isNodeExported(node) {
+        // Checking if the node is exported as a named export.
+        if (node.parent && node.parent.type === 'ExportNamedDeclaration') {
+            return true;
+        }
+        // Checking if the node is exported as default.
+        if (node.parent &&
+            node.parent.parent &&
+            node.parent.parent.type === 'ExportDefaultDeclaration') {
+            return true;
+        }
+        // Checking if the node is exported in a list of exports.
+        if (node.parent &&
+            node.parent.parent &&
+            node.parent.parent.type === 'ExportSpecifier' &&
+            node.parent.parent.exported.name === node.name) {
+            return true;
+        }
+        return false;
+    }
+    static returnsJSX(node) {
+        if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
+            return true;
+        }
+        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;
+    }
+    static hasParameters(node) {
+        return node.params && node.params.length > 0;
+    }
+}
+exports.ASTHelpers = ASTHelpers;
+//# sourceMappingURL=ASTHelpers.js.map

package/lib/utils/createRule.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const createRule: <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener = import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<TOptions, TMessageIds, TRuleListener>>) => import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<TMessageIds, TOptions, TRuleListener>;

package/lib/utils/createRule.js

@@ -0,0 +1,6 @@
+"use strict";
+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/eslint-custom-rules/plugin/docs/rules/${name}.md`);
+//# sourceMappingURL=createRule.js.map

package/lib/utils/graph/ClassGraphBuilder.d.ts

@@ -0,0 +1,29 @@
+import { TSESTree } from '@typescript-eslint/utils';
+export type GraphNode = {
+    name: string;
+    type: 'method' | 'property' | 'constructor';
+    accessibility?: TSESTree.Accessibility;
+    isStatic: boolean;
+    dependencies: string[];
+};
+export type Graph = Record<string, GraphNode>;
+/**
+ * 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.
+ */
+export declare class ClassGraphBuilder {
+    private className;
+    private classBody;
+    graph: Graph;
+    private sorter;
+    constructor(className: string, classBody: TSESTree.ClassBody);
+    private buildGraph;
+    private static isClassMember;
+    private addMemberToGraph;
+    private static nodeTypeOf;
+    private static createGraphNode;
+    private static isNamedClassMethod;
+    private addDependencies;
+    get graphSorted(): GraphNode[];
+    get memberNamesSorted(): string[];
+}

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.d.ts

@@ -0,0 +1,7 @@
+import { Graph, GraphNode } from './ClassGraphBuilder';
+export declare abstract class ClassGraphSorter {
+    graph: Graph;
+    constructor(graph: Graph);
+    abstract nodesSorted: GraphNode[];
+    abstract nodeNamesSorted: GraphNode['name'][];
+}

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.d.ts

@@ -0,0 +1,16 @@
+import { Graph, GraphNode } from './ClassGraphBuilder';
+import { ClassGraphSorter } from './ClassGraphSorter';
+type GraphNodeModifier = 'isStatic' | 'accessibility';
+export declare class ClassGraphSorterReadability extends ClassGraphSorter {
+    graph: Graph;
+    static readonly MODIFIER_PRIORITY_MAP: Record<GraphNodeModifier, any[]>;
+    private static readonly SEARCH_NODE_PRIORITY_FUNCTIONS;
+    constructor(graph: Graph);
+    get nodeNamesSorted(): string[];
+    get nodesSorted(): GraphNode[];
+    sortNodes(): GraphNode[];
+    private groupNodesByType;
+    private static sortMembersForReadability;
+    private dependencyDfs;
+}
+export {};