@less-unsound/eslint-plugin 0.0.1

package/dist/cjs/rules/require-function-verb.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireFunctionVerbRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const string_case_js_1 = require("../utils/string-case.js");
+const allowedPrefixes = Object.freeze([
+    "add",
+    "advance",
+    "analyze",
+    "append",
+    "apply",
+    "assign",
+    "assert",
+    "attach",
+    "bind",
+    "build",
+    "calculate",
+    "call",
+    "capitalize",
+    "check",
+    "clear",
+    "close",
+    "collect",
+    "combine",
+    "compile",
+    "compare",
+    "compute",
+    "concat",
+    "conv",
+    "create",
+    "decode",
+    "dedupe",
+    "delete",
+    "derive",
+    "deserialize",
+    "diff",
+    "drain",
+    "elab",
+    "emit",
+    "encode",
+    "ensure",
+    "eq",
+    "erase",
+    "exec",
+    "expect",
+    "extend",
+    "fail",
+    "filter",
+    "find",
+    "flatMap",
+    "fold",
+    "format",
+    "get",
+    "guard",
+    "hash",
+    "handle",
+    "indent",
+    "inline",
+    "init",
+    "insert",
+    "intersect",
+    "join",
+    "lint",
+    "listen",
+    "list",
+    "load",
+    "lower",
+    "make",
+    "main",
+    "mark",
+    "map",
+    "match",
+    "measure",
+    "merge",
+    "neq",
+    "normalize",
+    "on",
+    "observe",
+    "open",
+    "parse",
+    "patch",
+    "pick",
+    "prepend",
+    "print",
+    "process",
+    "prune",
+    "qualify",
+    "read",
+    "receive",
+    "reduce",
+    "remove",
+    "render",
+    "repeat",
+    "require",
+    "replace",
+    "reset",
+    "resolve",
+    "rewrite",
+    "run",
+    "rank",
+    "save",
+    "search",
+    "select",
+    "send",
+    "serialize",
+    "set",
+    "show",
+    "simplify",
+    "skip",
+    "solve",
+    "sort",
+    "spawn",
+    "split",
+    "start",
+    "stop",
+    "strip",
+    "subscribe",
+    "to",
+    "transform",
+    "transpile",
+    "trim",
+    "unsubscribe",
+    "unify",
+    "unwrap",
+    "update",
+    "validate",
+    "verify",
+    "visit",
+    "walk",
+    "watch",
+    "with",
+    "wrap",
+    "write"
+]);
+const allowedPredicatePrefixes = Object.freeze(["check", "eq", "neq"]);
+const booleanLikePrefixes = Object.freeze([
+    "are",
+    "can",
+    "did",
+    "do",
+    "does",
+    "exists",
+    "has",
+    "have",
+    "includes",
+    "is",
+    "matches",
+    "may",
+    "must",
+    "need",
+    "needs",
+    "requires",
+    "should",
+    "supports",
+    "was",
+    "were",
+    "will",
+    "would"
+]);
+const messageIds = Object.freeze({
+    convertMustUseTo: "`convert` is not allowed for function variable names. Rename `{{name}}` to `{{suggestedName}}`.",
+    missingFunctionVerb: "CamelCase function variable names must start with an allowed verb prefix. `{{name}}` should start with one of: {{prefixes}}.",
+    predicateMustStartWithCheck: "Predicate function variable names must start with `check`. Rename `{{name}}` to `{{suggestedName}}`."
+});
+const isUppercaseLetter = (value) => value.toUpperCase() === value && value.toLowerCase() !== value;
+const getMatchedPrefix = (name, prefixes) => {
+    return prefixes.find((prefix) => {
+        if (!name.startsWith(prefix)) {
+            return false;
+        }
+        if (name.length === prefix.length) {
+            return true;
+        }
+        const next = name[prefix.length];
+        return next !== undefined && isUppercaseLetter(next);
+    });
+};
+const capitalize = (value) => {
+    const first = value[0];
+    if (first === undefined) {
+        return "";
+    }
+    return first.toUpperCase() + value.slice(1);
+};
+const getCheckName = (name) => {
+    const booleanLikePrefix = getMatchedPrefix(name, booleanLikePrefixes);
+    if (booleanLikePrefix !== undefined) {
+        const suffix = name.slice(booleanLikePrefix.length);
+        return "check" + suffix;
+    }
+    const allowedPrefix = getMatchedPrefix(name, allowedPrefixes.filter((prefix) => prefix !== "check" && prefix !== "on" && prefix !== "to"));
+    if (allowedPrefix !== undefined) {
+        const suffix = name.slice(allowedPrefix.length);
+        return suffix === "" ? "check" : "check" + suffix;
+    }
+    return "check" + capitalize(name);
+};
+const getToName = (name) => {
+    const suffix = name.slice("convert".length);
+    return suffix === "" ? "to" : "to" + suffix;
+};
+const isBooleanType = (checker, type) => {
+    const constrainedType = checker.getBaseConstraintOfType(type) ?? type;
+    if (constrainedType.isUnion()) {
+        return constrainedType.types.length > 0 && constrainedType.types.every((member) => isBooleanType(checker, member));
+    }
+    if (constrainedType.isIntersection()) {
+        return constrainedType.types.some((member) => isBooleanType(checker, member));
+    }
+    const baseType = checker.getBaseTypeOfLiteralType(constrainedType);
+    return checker.typeToString(baseType) === "boolean";
+};
+exports.requireFunctionVerbRule = (0, create_rule_js_1.createRule)({
+    name: "require-function-verb",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require camelCase function variable names to start with an allowed verb prefix."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const services = utils_1.ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            VariableDeclarator: (node) => {
+                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                if (node.init === null ||
+                    (node.init.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                        node.init.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    return;
+                }
+                const name = node.id.name;
+                if (!(0, string_case_js_1.isCamelCase)(name)) {
+                    return;
+                }
+                const booleanLikePrefix = getMatchedPrefix(name, booleanLikePrefixes);
+                if (booleanLikePrefix !== undefined) {
+                    context.report({
+                        node: node.id,
+                        messageId: "predicateMustStartWithCheck",
+                        data: {
+                            name,
+                            suggestedName: getCheckName(name)
+                        }
+                    });
+                    return;
+                }
+                const signature = checker.getSignatureFromDeclaration(services.esTreeNodeToTSNodeMap.get(node.init));
+                if (signature !== undefined && isBooleanType(checker, checker.getReturnTypeOfSignature(signature))) {
+                    if (getMatchedPrefix(name, allowedPredicatePrefixes) === undefined) {
+                        context.report({
+                            node: node.id,
+                            messageId: "predicateMustStartWithCheck",
+                            data: {
+                                name,
+                                suggestedName: getCheckName(name)
+                            }
+                        });
+                    }
+                    return;
+                }
+                if (getMatchedPrefix(name, ["convert"]) !== undefined) {
+                    context.report({
+                        node: node.id,
+                        messageId: "convertMustUseTo",
+                        data: {
+                            name,
+                            suggestedName: getToName(name)
+                        }
+                    });
+                    return;
+                }
+                if (getMatchedPrefix(name, allowedPrefixes) !== undefined) {
+                    return;
+                }
+                context.report({
+                    node: node.id,
+                    messageId: "missingFunctionVerb",
+                    data: {
+                        name,
+                        prefixes: allowedPrefixes.join(", ")
+                    }
+                });
+            }
+        };
+    }
+});

package/dist/cjs/rules/require-identifier-case.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireIdentifierCaseRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const string_case_js_1 = require("../utils/string-case.js");
+const messageIds = Object.freeze({
+    invalidIdentifierCase: "Identifiers must be in camelCase, PascalCase, `_camelCase`, or `$` followed by up to 2 letters. `{{name}}` is not allowed."
+});
+const isShortDollarName = (name) => /^\$[A-Za-z]{0,2}$/u.test(name);
+const isUnderscoreCamelCase = (name) => name.startsWith("_") && (0, string_case_js_1.isCamelCase)(name.slice(1));
+const isAllowedName = (name) => (0, string_case_js_1.isCamelCase)(name) ||
+    (0, string_case_js_1.isPascalCase)(name) ||
+    isUnderscoreCamelCase(name) ||
+    isShortDollarName(name);
+const reportIfNeeded = (context, node, name) => {
+    if (isAllowedName(name)) {
+        return;
+    }
+    context.report({
+        node,
+        messageId: "invalidIdentifierCase",
+        data: {
+            name
+        }
+    });
+};
+const reportNameNode = (context, node) => reportIfNeeded(context, node, node.name);
+const reportPattern = (context, node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        reportNameNode(context, node);
+        return;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.RestElement) {
+        reportPattern(context, node.argument);
+        return;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+        reportPattern(context, node.left);
+        return;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        for (const element of node.elements) {
+            if (element === null) {
+                continue;
+            }
+            reportPattern(context, element);
+        }
+        return;
+    }
+    if (node.type !== utils_1.AST_NODE_TYPES.ObjectPattern) {
+        return;
+    }
+    for (const property of node.properties) {
+        if (property.type === utils_1.AST_NODE_TYPES.RestElement) {
+            reportPattern(context, property.argument);
+            continue;
+        }
+        reportPattern(context, property.value);
+    }
+};
+const reportPropertyKey = (context, node) => {
+    if (node.type !== utils_1.AST_NODE_TYPES.Identifier &&
+        node.type !== utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+        return;
+    }
+    reportNameNode(context, node);
+};
+exports.requireIdentifierCaseRule = (0, create_rule_js_1.createRule)({
+    name: "require-identifier-case",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require identifiers to use camelCase, PascalCase, `_camelCase`, or short `$` names."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ArrowFunctionExpression: (node) => {
+            for (const param of node.params) {
+                reportPattern(context, param);
+            }
+        },
+        CatchClause: (node) => {
+            if (node.param === null) {
+                return;
+            }
+            reportPattern(context, node.param);
+        },
+        ClassDeclaration: (node) => {
+            if (node.id !== null) {
+                reportNameNode(context, node.id);
+            }
+        },
+        ClassExpression: (node) => {
+            if (node.id !== null) {
+                reportNameNode(context, node.id);
+            }
+        },
+        FunctionDeclaration: (node) => {
+            if (node.id !== null) {
+                reportNameNode(context, node.id);
+            }
+            for (const param of node.params) {
+                reportPattern(context, param);
+            }
+        },
+        FunctionExpression: (node) => {
+            if (node.id !== null) {
+                reportNameNode(context, node.id);
+            }
+            for (const param of node.params) {
+                reportPattern(context, param);
+            }
+        },
+        ImportDefaultSpecifier: (node) => {
+            reportNameNode(context, node.local);
+        },
+        ImportNamespaceSpecifier: (node) => {
+            reportNameNode(context, node.local);
+        },
+        ImportSpecifier: (node) => {
+            reportNameNode(context, node.local);
+        },
+        MethodDefinition: (node) => {
+            if (node.computed) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        Property: (node) => {
+            if (node.parent.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return;
+            }
+            if (node.computed || node.shorthand) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        PropertyDefinition: (node) => {
+            if (node.computed) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        TSEnumDeclaration: (node) => {
+            reportNameNode(context, node.id);
+        },
+        TSEnumMember: (node) => {
+            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            reportNameNode(context, node.id);
+        },
+        TSInterfaceDeclaration: (node) => {
+            reportNameNode(context, node.id);
+        },
+        TSMethodSignature: (node) => {
+            if (node.computed) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        TSModuleDeclaration: (node) => {
+            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            reportNameNode(context, node.id);
+        },
+        TSParameterProperty: (node) => {
+            if (node.parameter.type === utils_1.AST_NODE_TYPES.Identifier) {
+                reportNameNode(context, node.parameter);
+                return;
+            }
+            if (node.parameter.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                reportPattern(context, node.parameter);
+            }
+        },
+        TSPropertySignature: (node) => {
+            if (node.computed) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        TSTypeAliasDeclaration: (node) => {
+            reportNameNode(context, node.id);
+        },
+        TSTypeParameter: (node) => {
+            reportNameNode(context, node.name);
+        },
+        VariableDeclarator: (node) => {
+            reportPattern(context, node.id);
+        }
+    })
+});

package/dist/cjs/rules/require-kebab-case-filename.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireKebabCaseFilenameRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const string_case_js_1 = require("../utils/string-case.js");
+const messageIds = Object.freeze({
+    nonKebabCaseFilename: "Filenames must be in kebab-case. `{{filename}}` is not allowed."
+});
+const getFilename = (context) => context.filename;
+const getBaseFilename = (filename) => {
+    const parts = filename.split(/[/\\]/);
+    return parts.at(-1) ?? filename;
+};
+const isLintVirtualFilename = (filename) => filename.startsWith("<") && filename.endsWith(">");
+exports.requireKebabCaseFilenameRule = (0, create_rule_js_1.createRule)({
+    name: "require-kebab-case-filename",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require filenames to be in kebab-case."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Program: (node) => {
+            const filename = getFilename(context);
+            if (isLintVirtualFilename(filename)) {
+                return;
+            }
+            const baseFilename = getBaseFilename(filename);
+            if ((0, string_case_js_1.isKebabCase)(baseFilename)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "nonKebabCaseFilename",
+                data: {
+                    filename: baseFilename
+                }
+            });
+        }
+    })
+});

package/dist/cjs/rules/require-named-union-branch.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireNamedUnionBranchRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    requireNamedUnionBranch: "Object union branches must be named."
+});
+const isInlineObjectType = (node) => node.type === utils_1.AST_NODE_TYPES.TSTypeLiteral;
+exports.requireNamedUnionBranchRule = (0, create_rule_js_1.createRule)({
+    name: "require-named-union-branch",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require every object-shaped union branch to be defined through its own name."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSUnionType: (node) => {
+            for (const branch of node.types) {
+                if (!isInlineObjectType(branch)) {
+                    continue;
+                }
+                context.report({
+                    node: branch,
+                    messageId: "requireNamedUnionBranch"
+                });
+            }
+        }
+    })
+});

package/dist/cjs/rules/require-readonly-array.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireReadonlyArrayRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const readonly_js_1 = require("../utils/readonly.js");
+const messageIds = Object.freeze({
+    missingReadonlyArray: "Array types must use `readonly T[]`."
+});
+const isArrayReference = (node) => {
+    if (node.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return node.typeName.name === "Array" || node.typeName.name === "ReadonlyArray";
+};
+exports.requireReadonlyArrayRule = (0, create_rule_js_1.createRule)({
+    name: "require-readonly-array",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require array types to use `readonly T[]` unless mutability is required for performance."
+        },
+        fixable: "code",
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSArrayType: (node) => {
+            if ((0, readonly_js_1.isReadonlyType)(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyArray",
+                fix: (fixer) => fixer.insertTextBefore(node, "readonly ")
+            });
+        },
+        TSTypeReference: (node) => {
+            if (!isArrayReference(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyArray"
+            });
+        }
+    })
+});

package/dist/cjs/rules/require-readonly-collections.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireReadonlyCollectionsRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    missingReadonlyCollections: "Collection types must use `ReadonlySet` and `ReadonlyMap` unless mutability is required for performance."
+});
+const isMutableCollection = (node) => {
+    if (node.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return node.typeName.name === "Set" || node.typeName.name === "Map";
+};
+exports.requireReadonlyCollectionsRule = (0, create_rule_js_1.createRule)({
+    name: "require-readonly-collections",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require `ReadonlySet` and `ReadonlyMap` in types unless mutability is required for performance."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTypeReference: (node) => {
+            if (!isMutableCollection(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyCollections"
+            });
+        }
+    })
+});

package/dist/cjs/rules/require-readonly-object-fields.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireReadonlyObjectFieldsRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    missingReadonlyObjectField: "Object type fields must be marked `readonly`."
+});
+exports.requireReadonlyObjectFieldsRule = (0, create_rule_js_1.createRule)({
+    name: "require-readonly-object-fields",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require `readonly` on all object type fields unless mutability is required for performance."
+        },
+        fixable: "code",
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSPropertySignature: (node) => {
+            if (node.readonly) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyObjectField",
+                fix: (fixer) => fixer.insertTextBefore(node, "readonly ")
+            });
+        }
+    })
+});