@tianjos/eslint-plugin-elegant 0.3.2 → 0.5.0

package/dist/rules/max-class-dependencies.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_MAX = 4;
+/**
+ * Ambient types every codebase reaches for. Instantiating a `Date` or a `Map` is
+ * not a design decision worth budgeting, so they never count as collaborators.
+ */
+const BUILT_INS = [
+    'Array',
+    'Date',
+    'Error',
+    'Map',
+    'Promise',
+    'RegExp',
+    'Set',
+    'URL',
+    'WeakMap',
+    'WeakSet',
+];
+const injected = (body, sourceCode) => {
+    const constructor = body.body.find((member) => member.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+        member.kind === 'constructor');
+    return (constructor?.value.params ?? []).flatMap((param) => {
+        const target = param.type === utils_1.AST_NODE_TYPES.TSParameterProperty
+            ? param.parameter
+            : param;
+        const annotation = target.typeAnnotation?.typeAnnotation;
+        return annotation?.type === utils_1.AST_NODE_TYPES.TSTypeReference
+            ? [
+                {
+                    key: sourceCode.getText(annotation),
+                    root: sourceCode.getText(annotation.typeName),
+                },
+            ]
+            : [];
+    });
+};
+const instantiated = (node, sourceCode) => {
+    const root = sourceCode.getText(node.callee);
+    return {
+        key: `${root}${node.typeArguments === undefined
+            ? ''
+            : sourceCode.getText(node.typeArguments)}`,
+        root,
+    };
+};
+exports.default = (0, createRule_1.createRule)({
+    name: 'max-class-dependencies',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce a maximum number of distinct collaborators a class depends on.',
+        },
+        messages: {
+            tooManyDependencies: "Class '{{name}}' depends on {{count}} types (max {{max}}): {{names}}. Consider extracting a collaborator.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    max: { type: 'integer', minimum: 1 },
+                    ignore: { type: 'array', items: { type: 'string' } },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ max: DEFAULT_MAX, ignore: [] }],
+    create(context, [{ max, ignore }]) {
+        const sourceCode = context.sourceCode;
+        const ignored = new Set([...BUILT_INS, ...ignore]);
+        const scopes = [];
+        const record = (scope, dependency) => {
+            if (scope !== undefined && !ignored.has(dependency.root)) {
+                scope.add(dependency.key);
+            }
+        };
+        return {
+            ClassBody(node) {
+                const scope = new Set();
+                scopes.push(scope);
+                for (const dependency of injected(node, sourceCode)) {
+                    record(scope, dependency);
+                }
+            },
+            NewExpression(node) {
+                if (node.parent.type === utils_1.AST_NODE_TYPES.ThrowStatement) {
+                    return;
+                }
+                record(scopes[scopes.length - 1], instantiated(node, sourceCode));
+            },
+            'ClassBody:exit'(node) {
+                const dependencies = scopes.pop() ?? new Set();
+                if (dependencies.size <= max) {
+                    return;
+                }
+                context.report({
+                    node: node.parent.id ?? node,
+                    messageId: 'tooManyDependencies',
+                    data: {
+                        name: node.parent.id?.name ?? '(anonymous)',
+                        count: dependencies.size,
+                        max,
+                        names: [...dependencies].join(', '),
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/max-class-fields.d.ts

@@ -0,0 +1,9 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type Options = [{
+    max: number;
+    ignoreDecorated: boolean;
+}];
+declare const _default: TSESLint.RuleModule<"tooManyFields", Options, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/max-class-fields.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_MAX = 5;
+const isField = (member) => member.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+    member.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition ||
+    member.type === utils_1.AST_NODE_TYPES.AccessorProperty;
+const named = (key, sourceCode) => key.type === utils_1.AST_NODE_TYPES.Identifier ? key.name : sourceCode.getText(key);
+/** Every property declared in the class body. */
+const declared = (member, sourceCode) => isField(member) && !member.static ? [named(member.key, sourceCode)] : [];
+/**
+ * The same, minus the decorated ones: `@Column`, `@IsString` and friends map a
+ * field to a table or a payload, which is framework shape rather than state the
+ * class chose to carry.
+ */
+const declaredUndecorated = (member, sourceCode) => isField(member) && member.decorators.length > 0
+    ? []
+    : declared(member, sourceCode);
+/**
+ * Constructor parameter properties. `ignoreDecorated` deliberately does not
+ * reach them: a decorator on a parameter is injection (`@Inject(TOKEN)`), so the
+ * field is a genuine collaborator and has to stay inside the budget.
+ */
+const promoted = (member, sourceCode) => {
+    if (member.type !== utils_1.AST_NODE_TYPES.MethodDefinition ||
+        member.kind !== 'constructor') {
+        return [];
+    }
+    return member.value.params.flatMap((param) => param.type === utils_1.AST_NODE_TYPES.TSParameterProperty
+        ? [named(param.parameter, sourceCode)]
+        : []);
+};
+exports.default = (0, createRule_1.createRule)({
+    name: 'max-class-fields',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce a maximum number of instance fields per class to keep objects from becoming data bags.',
+        },
+        messages: {
+            tooManyFields: "Class '{{name}}' holds {{count}} fields (max {{max}}): {{names}}. Consider grouping related fields into a value object.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    max: { type: 'integer', minimum: 1 },
+                    ignoreDecorated: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ max: DEFAULT_MAX, ignoreDecorated: true }],
+    create(context, [{ max, ignoreDecorated }]) {
+        const sourceCode = context.sourceCode;
+        const fieldsOf = ignoreDecorated ? declaredUndecorated : declared;
+        return {
+            ClassBody(node) {
+                const fields = node.body.flatMap((member) => [
+                    ...fieldsOf(member, sourceCode),
+                    ...promoted(member, sourceCode),
+                ]);
+                if (fields.length <= max) {
+                    return;
+                }
+                context.report({
+                    node: node.parent.id ?? node,
+                    messageId: 'tooManyFields',
+                    data: {
+                        name: node.parent.id?.name ?? '(anonymous)',
+                        count: fields.length,
+                        max,
+                        names: fields.join(', '),
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/max-class-methods.js

@@ -32,10 +32,9 @@ exports.default = (0, createRule_1.createRule)({
                 if (methods.length <= max) {
                     return;
                 }
-                const classNode = node.parent;
-                const name = classNode.id?.name ?? '(anonymous)';
+                const name = node.parent.id?.name ?? '(anonymous)';
                 context.report({
-                    node: classNode.id ?? node,
+                    node: node.parent.id ?? node,
                     messageId: 'tooManyMethods',
                     data: { name, count: methods.length, max },
                 });

package/dist/rules/max-returns.d.ts

@@ -0,0 +1,7 @@
+type Options = [{
+    max: number;
+}];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooManyReturns", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/max-returns.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_MAX = 3;
+/**
+ * The name to report a function by. Declarations carry their own; the rest
+ * borrow it from whatever binds them, so a method and an arrow assigned to a
+ * const are named rather than reported as anonymous.
+ */
+const nameOf = (node) => {
+    if (node.id !== null) {
+        return node.id.name;
+    }
+    if ((node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+        node.parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+        node.parent.type === utils_1.AST_NODE_TYPES.Property) &&
+        !node.parent.computed &&
+        node.parent.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.parent.key.name;
+    }
+    if (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+        node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.parent.id.name;
+    }
+    return '(anonymous)';
+};
+exports.default = (0, createRule_1.createRule)({
+    name: 'max-returns',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce a maximum number of return statements per function.',
+        },
+        messages: {
+            tooManyReturns: "Function '{{name}}' returns from {{count}} places (max {{max}}). Consider collapsing the branches or extracting them into named functions.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    max: { type: 'integer', minimum: 1 },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ max: DEFAULT_MAX }],
+    create(context, [{ max }]) {
+        const sourceCode = context.sourceCode;
+        const scopes = [];
+        const enter = (node) => {
+            scopes.push({ node, count: 0 });
+        };
+        const leave = () => {
+            const scope = scopes.pop();
+            if (scope === undefined || scope.count <= max) {
+                return;
+            }
+            const signature = scope.node.id ?? sourceCode.getFirstToken(scope.node);
+            context.report({
+                loc: (signature ?? scope.node).loc,
+                messageId: 'tooManyReturns',
+                data: {
+                    name: nameOf(scope.node),
+                    count: scope.count,
+                    max,
+                },
+            });
+        };
+        return {
+            ArrowFunctionExpression: enter,
+            'ArrowFunctionExpression:exit': leave,
+            FunctionDeclaration: enter,
+            'FunctionDeclaration:exit': leave,
+            FunctionExpression: enter,
+            'FunctionExpression:exit': leave,
+            ReturnStatement() {
+                const scope = scopes[scopes.length - 1];
+                if (scope !== undefined) {
+                    scope.count += 1;
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-anonymous-param-type.d.ts

@@ -0,0 +1,7 @@
+type Options = [{
+    minMembers: number;
+}];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"anonymousParamType", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-anonymous-param-type.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_MIN_MEMBERS = 2;
+const bindingOf = (param) => {
+    if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+        return bindingOf(param.parameter);
+    }
+    const target = param.type === utils_1.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
+    switch (target.type) {
+        case utils_1.AST_NODE_TYPES.ArrayPattern:
+        case utils_1.AST_NODE_TYPES.Identifier:
+        case utils_1.AST_NODE_TYPES.ObjectPattern:
+        case utils_1.AST_NODE_TYPES.RestElement:
+            return target;
+        default:
+            return undefined;
+    }
+};
+const nameOf = (binding) => binding.type === utils_1.AST_NODE_TYPES.Identifier ? binding.name : '(destructured)';
+/** The type nodes a shape can hide inside, one level down. */
+const reachableFrom = (node) => {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeReference:
+            return node.typeArguments?.params ?? [];
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+            return node.types;
+        case utils_1.AST_NODE_TYPES.TSArrayType:
+            return [node.elementType];
+        default:
+            return [];
+    }
+};
+/**
+ * The first anonymous shape of at least `minMembers` properties reachable from
+ * a type annotation. Shapes hide behind generic arguments as readily as they
+ * sit in the open — `Array<{ day; count }>` is as unnamed as `{ day; count }`.
+ */
+const shapeIn = (node, minMembers) => {
+    if (node.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+        return node.members.length >= minMembers ? node : undefined;
+    }
+    for (const inner of reachableFrom(node)) {
+        const shape = shapeIn(inner, minMembers);
+        if (shape !== undefined) {
+            return shape;
+        }
+    }
+    return undefined;
+};
+/**
+ * Whether the signature is a function handed straight to a call. Such a
+ * parameter annotates whatever the callee yields — often an untyped response
+ * body — so an inline shape is the only way to type it at all.
+ */
+const isInlineCallback = (node) => (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+    node.parent.type === utils_1.AST_NODE_TYPES.CallExpression;
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-anonymous-param-type',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow parameters typed as an anonymous shape. Name the shape so it can carry behaviour instead of being a bag.',
+        },
+        messages: {
+            anonymousParamType: "Parameter '{{name}}' is typed as an anonymous shape of {{count}} properties. Name the shape so it can carry behaviour instead of being a bag.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    minMembers: { type: 'integer', minimum: 1 },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ minMembers: DEFAULT_MIN_MEMBERS }],
+    create(context, [{ minMembers }]) {
+        const check = (node) => {
+            if (isInlineCallback(node)) {
+                return;
+            }
+            for (const param of node.params) {
+                const binding = bindingOf(param);
+                if (binding === undefined) {
+                    continue;
+                }
+                const annotation = binding.typeAnnotation?.typeAnnotation;
+                if (annotation === undefined) {
+                    continue;
+                }
+                const shape = shapeIn(annotation, minMembers);
+                if (shape === undefined) {
+                    continue;
+                }
+                context.report({
+                    node: param,
+                    messageId: 'anonymousParamType',
+                    data: {
+                        name: nameOf(binding),
+                        count: shape.members.length,
+                    },
+                });
+            }
+        };
+        return {
+            ArrowFunctionExpression: check,
+            FunctionDeclaration: check,
+            FunctionExpression: check,
+            TSDeclareFunction: check,
+            TSEmptyBodyFunctionExpression: check,
+            TSFunctionType: check,
+            TSMethodSignature: check,
+        };
+    },
+});

package/dist/rules/no-comments-in-function-body.d.ts

@@ -0,0 +1,7 @@
+type Options = [{
+    allow: string[];
+}];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentInBody", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-comments-in-function-body.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * Comments the toolchain reads rather than humans. Suppressing another rule or
+ * a type error inside a body is routine and says nothing about the code's shape,
+ * so these never count — the counterpart of qulice's `@checkstyle` exemption.
+ */
+const DIRECTIVES = [
+    '@ts-',
+    '@vite-ignore',
+    'c8 ignore',
+    'eslint',
+    'istanbul ignore',
+    'prettier-ignore',
+    'v8 ignore',
+    'webpackChunkName',
+];
+const directs = (comment, allow) => {
+    const text = comment.value.trim();
+    return [...DIRECTIVES, ...allow].some((prefix) => text.startsWith(prefix));
+};
+const encloses = (block, comment) => block.range[0] < comment.range[0] && comment.range[1] < block.range[1];
+const span = (block) => block.range[1] - block.range[0];
+/**
+ * The tightest block wrapping the comment, which is what decides whether it is
+ * merely annotating an empty one. An empty `catch` inside a busy function still
+ * earns its explanation, so the lookup cannot stop at the function body.
+ */
+const innermost = (blocks, comment) => blocks
+    .filter((block) => encloses(block, comment))
+    .reduce((tightest, block) => tightest === undefined || span(block) < span(tightest)
+    ? block
+    : tightest, undefined);
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-comments-in-function-body',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow comments inside function bodies, where they stand in for a name the code should carry itself.',
+        },
+        messages: {
+            commentInBody: 'A comment inside a function body signals code that needs a better name. Move it to a docblock above the function, or extract what it explains into a named function.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allow: { type: 'array', items: { type: 'string' } },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ allow: [] }],
+    create(context, [{ allow }]) {
+        const sourceCode = context.sourceCode;
+        const bodies = [];
+        const blocks = [];
+        const collect = (node) => {
+            if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                bodies.push(node.body);
+            }
+        };
+        return {
+            BlockStatement(node) {
+                blocks.push(node);
+            },
+            ArrowFunctionExpression: collect,
+            FunctionDeclaration: collect,
+            FunctionExpression: collect,
+            'Program:exit'() {
+                for (const comment of sourceCode.getAllComments()) {
+                    const inside = bodies.some((body) => encloses(body, comment));
+                    const block = innermost(blocks, comment);
+                    const explains = block === undefined || block.body.length === 0;
+                    if (inside && !explains && !directs(comment, allow)) {
+                        context.report({ loc: comment.loc, messageId: 'commentInBody' });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-else-after-throw.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"elseAfterThrow", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-else-after-throw.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * Whether the branch leaves through a `throw` no matter what. A bare `throw`
+ * qualifies, as does a block whose last statement is one. The check does not
+ * recurse: a block ending in a nested `if` may or may not throw, and `else`
+ * still carries information there.
+ */
+const alwaysThrows = (branch) => {
+    if (branch.type === utils_1.AST_NODE_TYPES.ThrowStatement) {
+        return true;
+    }
+    if (branch.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return false;
+    }
+    return branch.body.at(-1)?.type === utils_1.AST_NODE_TYPES.ThrowStatement;
+};
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-else-after-throw',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow an else branch when the then branch always throws.',
+        },
+        messages: {
+            elseAfterThrow: "The 'then' branch always throws, so 'else' adds nothing but nesting. Drop it and let the alternative sit at the outer level.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            IfStatement(node) {
+                if (node.alternate === null || !alwaysThrows(node.consequent)) {
+                    return;
+                }
+                const keyword = sourceCode.getTokenBefore(node.alternate);
+                context.report({
+                    node: keyword ?? node.alternate,
+                    messageId: 'elseAfterThrow',
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-interpolated-log-message.d.ts

@@ -0,0 +1,8 @@
+type Options = [{
+    objects: string[];
+    methods: string[];
+}];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"interpolatedMessage", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;