@less-unsound/eslint-plugin 0.0.1

package/dist/esm/rules/require-disjoint-union.js

@@ -0,0 +1,225 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const defaultTagName = "$";
+const messageIds = Object.freeze({
+    forbiddenDisjointUnion: "Union members must be literal types or disjoint object types tagged by `{{tagName}}`."
+});
+const getPropertyName = (node) => {
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type !== AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    const { value } = node;
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    if (typeof value === "boolean") {
+        return String(value);
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (value === null) {
+        return "null";
+    }
+    return undefined;
+};
+const getLiteralValue = (node) => {
+    if (node.literal.type !== AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    const { value } = node.literal;
+    if (typeof value === "string") {
+        return `string:${value}`;
+    }
+    if (typeof value === "number") {
+        return `number:${value}`;
+    }
+    if (typeof value === "boolean") {
+        return `boolean:${value}`;
+    }
+    if (typeof value === "bigint") {
+        return `bigint:${value.toString()}`;
+    }
+    if (value === null) {
+        return "null";
+    }
+    return undefined;
+};
+const unwrapType = (node) => node;
+const isLiteralOnlyType = (node) => {
+    const unwrapped = unwrapType(node);
+    if (unwrapped.type === AST_NODE_TYPES.TSLiteralType) {
+        return getLiteralValue(unwrapped) !== undefined;
+    }
+    if (unwrapped.type === AST_NODE_TYPES.TSUnionType) {
+        return (unwrapped.types.length > 0 &&
+            unwrapped.types.every((child) => isLiteralOnlyType(child)));
+    }
+    return false;
+};
+const getEntityName = (node) => {
+    if (node.type !== AST_NODE_TYPES.Identifier) {
+        return undefined;
+    }
+    return node.name;
+};
+const getObjectMembers = (node) => {
+    if (node.type === AST_NODE_TYPES.TSInterfaceDeclaration) {
+        return node.body.body;
+    }
+    const unwrapped = unwrapType(node.typeAnnotation);
+    if (unwrapped.type !== AST_NODE_TYPES.TSTypeLiteral) {
+        return [];
+    }
+    return unwrapped.members;
+};
+const getLiteralTagValue = (members, tagName) => {
+    for (const member of members) {
+        if (member.type !== AST_NODE_TYPES.TSPropertySignature) {
+            continue;
+        }
+        if (member.computed || member.optional) {
+            continue;
+        }
+        const propertyName = getPropertyName(member.key);
+        if (propertyName !== tagName) {
+            continue;
+        }
+        if (member.typeAnnotation === undefined) {
+            return undefined;
+        }
+        if (member.typeAnnotation.typeAnnotation.type !== AST_NODE_TYPES.TSLiteralType) {
+            return undefined;
+        }
+        return getLiteralValue(member.typeAnnotation.typeAnnotation);
+    }
+    return undefined;
+};
+export const requireDisjointUnionRule = createRule({
+    name: "require-disjoint-union",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require unions to stay literal-only or to use a shared literal tag field on each local object branch."
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    tagName: {
+                        type: "string"
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        messages: messageIds
+    },
+    defaultOptions: [{ tagName: defaultTagName }],
+    create: (context) => {
+        const declarations = new Map();
+        const unions = [];
+        const resolveObjectMembers = (name, seen) => {
+            if (seen.has(name)) {
+                return undefined;
+            }
+            seen.add(name);
+            const declaration = declarations.get(name);
+            if (declaration === undefined) {
+                return undefined;
+            }
+            if (declaration.type === AST_NODE_TYPES.TSInterfaceDeclaration) {
+                return getObjectMembers(declaration);
+            }
+            const unwrapped = unwrapType(declaration.typeAnnotation);
+            if (unwrapped.type === AST_NODE_TYPES.TSTypeLiteral) {
+                return unwrapped.members;
+            }
+            if (unwrapped.type !== AST_NODE_TYPES.TSTypeReference) {
+                return undefined;
+            }
+            const referencedName = getEntityName(unwrapped.typeName);
+            if (referencedName === undefined) {
+                return undefined;
+            }
+            return resolveObjectMembers(referencedName, seen);
+        };
+        const getNamedObjectMembers = (node) => {
+            const unwrapped = unwrapType(node);
+            if (unwrapped.type !== AST_NODE_TYPES.TSTypeReference) {
+                return undefined;
+            }
+            const name = getEntityName(unwrapped.typeName);
+            if (name === undefined) {
+                return undefined;
+            }
+            return resolveObjectMembers(name, new Set());
+        };
+        const isInlineObjectBranch = (node) => {
+            const unwrapped = unwrapType(node);
+            return unwrapped.type === AST_NODE_TYPES.TSTypeLiteral;
+        };
+        const isDisjointObjectUnion = (node, tagName) => {
+            const values = new Set();
+            for (const branch of node.types) {
+                const members = getNamedObjectMembers(branch);
+                if (members === undefined) {
+                    return false;
+                }
+                const tagValue = getLiteralTagValue(members, tagName);
+                if (tagValue === undefined) {
+                    return false;
+                }
+                values.add(tagValue);
+            }
+            return values.size === node.types.length;
+        };
+        const shouldReportUnion = (node, tagName) => {
+            if (node.types.length < 2) {
+                return false;
+            }
+            if (node.types.every((branch) => isLiteralOnlyType(branch))) {
+                return false;
+            }
+            if (node.types.some((branch) => isInlineObjectBranch(branch))) {
+                return false;
+            }
+            if (node.types.every((branch) => getNamedObjectMembers(branch) !== undefined)) {
+                return isDisjointObjectUnion(node, tagName) === false;
+            }
+            return true;
+        };
+        return {
+            TSInterfaceDeclaration: (node) => {
+                declarations.set(node.id.name, node);
+            },
+            TSTypeAliasDeclaration: (node) => {
+                declarations.set(node.id.name, node);
+            },
+            TSUnionType: (node) => {
+                unions.push(node);
+            },
+            "Program:exit": () => {
+                const option = context.options[0] ?? { tagName: defaultTagName };
+                const tagName = option.tagName;
+                for (const node of unions) {
+                    if (shouldReportUnion(node, tagName)) {
+                        context.report({
+                            node,
+                            messageId: "forbiddenDisjointUnion",
+                            data: {
+                                tagName
+                            }
+                        });
+                    }
+                }
+            }
+        };
+    }
+});

package/dist/esm/rules/require-function-verb.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const requireFunctionVerbRule: ESLintUtils.RuleModule<"convertMustUseTo" | "missingFunctionVerb" | "predicateMustStartWithCheck", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

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

@@ -0,0 +1,290 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+import { isCamelCase } from "../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";
+};
+export const requireFunctionVerbRule = 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 = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            VariableDeclarator: (node) => {
+                if (node.id.type !== AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                if (node.init === null ||
+                    (node.init.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+                        node.init.type !== AST_NODE_TYPES.FunctionExpression)) {
+                    return;
+                }
+                const name = node.id.name;
+                if (!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/esm/rules/require-identifier-case.d.ts

@@ -0,0 +1,4 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare const requireIdentifierCaseRule: TSESLint.RuleModule<"invalidIdentifierCase", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};