@blumintinc/eslint-plugin-blumint 0.1.23 → 1.0.2

package/lib/utils/graph/ClassGraphSorterReadability.js

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

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

package/lib/utils/ruleTester.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ruleTesterJson = exports.ruleTesterJsx = exports.ruleTesterTs = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const eslint_1 = require("eslint");
-exports.ruleTesterTs = new utils_1.ESLintUtils.RuleTester({
-    parser: '@typescript-eslint/parser',
-});
-exports.ruleTesterJsx = new utils_1.ESLintUtils.RuleTester({
-    parser: '@typescript-eslint/parser',
-    parserOptions: {
-        ecmaFeatures: {
-            jsx: true,
-        },
-    },
-});
-exports.ruleTesterJson = new eslint_1.RuleTester({
-    parser: require.resolve('jsonc-eslint-parser'),
-    parserOptions: {
-        ecmaVersion: 2020,
-    },
-});
-//# sourceMappingURL=ruleTester.js.map

package/lib/utils/testClass.js

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