@less-unsound/eslint-plugin 0.0.1

package/dist/cjs/rules/no-utility-type.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUtilityTypeRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const utilityNames = new Set([
+    "Awaited",
+    "Capitalize",
+    "ConstructorParameters",
+    "Exclude",
+    "Extract",
+    "InstanceType",
+    "Lowercase",
+    "NonNullable",
+    "Omit",
+    "OmitThisParameter",
+    "Partial",
+    "Parameters",
+    "Pick",
+    "Readonly",
+    "Record",
+    "Required",
+    "ReturnType",
+    "ThisParameterType",
+    "ThisType",
+    "Uncapitalize",
+    "Uppercase"
+]);
+const messageIds = Object.freeze({
+    forbiddenUtilityType: "Built-in TypeScript utility types are not allowed."
+});
+exports.noUtilityTypeRule = (0, create_rule_js_1.createRule)({
+    name: "no-utility-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow built-in TypeScript utility types."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTypeReference: (node) => {
+            if (node.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!utilityNames.has(node.typeName.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenUtilityType"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-var.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noVarRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenVar: "`var` is not allowed."
+});
+exports.noVarRule = (0, create_rule_js_1.createRule)({
+    name: "no-var",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `var` declarations unless mutability is required for performance."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        "VariableDeclaration[kind='var']": (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenVar"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-void-operator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noVoidOperatorRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenVoidOperator: "The `void` operator is not allowed."
+});
+exports.noVoidOperatorRule = (0, create_rule_js_1.createRule)({
+    name: "no-void-operator",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the runtime `void` operator."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        "UnaryExpression[operator='void']": (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenVoidOperator"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-while.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noWhileRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenWhile: "`while` and `do ... while` loops are not allowed."
+});
+exports.noWhileRule = (0, create_rule_js_1.createRule)({
+    name: "no-while",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `while` loops and `do ... while` loops."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        DoWhileStatement: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenWhile"
+            });
+        },
+        WhileStatement: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenWhile"
+            });
+        }
+    })
+});

package/dist/cjs/rules/require-boolean-prefix.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireBooleanPrefixRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const allowedPrefixes = Object.freeze([
+    "is",
+    "are",
+    "was",
+    "were",
+    "has",
+    "have",
+    "can",
+    "may",
+    "should",
+    "must",
+    "will",
+    "would",
+    "did",
+    "does",
+    "do",
+    "needs",
+    "need",
+    "requires",
+    "supports",
+    "allows",
+    "contains",
+    "includes",
+    "matches",
+    "exists"
+]);
+const comparisonOperators = new Set([
+    "!=",
+    "!==",
+    "<",
+    "<=",
+    "==",
+    "===",
+    ">",
+    ">=",
+    "in",
+    "instanceof"
+]);
+const messageIds = Object.freeze({
+    missingBooleanPrefix: "Boolean variable and field names must start with an allowed boolean prefix. `{{name}}` should start with one of: {{prefixes}}."
+});
+const isUppercaseLetter = (value) => value.toUpperCase() === value && value.toLowerCase() !== value;
+const hasAllowedPrefix = (name) => allowedPrefixes.some((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 getName = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof node.value === "string") {
+        return node.value;
+    }
+    return undefined;
+};
+const isBooleanLiteralType = (node) => node.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+    node.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+    typeof node.literal.value === "boolean";
+const isBooleanType = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+        return true;
+    }
+    if (isBooleanLiteralType(node)) {
+        return true;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+        return node.types.length > 0 && node.types.every(isBooleanType);
+    }
+    return false;
+};
+const isBooleanAnnotation = (annotation) => annotation !== undefined && isBooleanType(annotation.typeAnnotation);
+const isBooleanExpression = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof node.value === "boolean") {
+        return true;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
+        return node.operator === "!";
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+        return comparisonOperators.has(node.operator);
+    }
+    return false;
+};
+const reportIfNeeded = (context, node, name) => {
+    if (hasAllowedPrefix(name)) {
+        return;
+    }
+    context.report({
+        node,
+        messageId: "missingBooleanPrefix",
+        data: {
+            name,
+            prefixes: allowedPrefixes.join(", ")
+        }
+    });
+};
+exports.requireBooleanPrefixRule = (0, create_rule_js_1.createRule)({
+    name: "require-boolean-prefix",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require boolean variables and fields to start with an allowed boolean prefix."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        VariableDeclarator: (node) => {
+            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            const isBoolean = isBooleanAnnotation(node.id.typeAnnotation) ||
+                (node.init !== null &&
+                    node.init !== undefined &&
+                    isBooleanExpression(node.init));
+            if (!isBoolean) {
+                return;
+            }
+            reportIfNeeded(context, node.id, node.id.name);
+        },
+        Property: (node) => {
+            if (node.computed || node.kind !== "init" || node.method) {
+                return;
+            }
+            const name = getName(node.key);
+            if (name === undefined) {
+                return;
+            }
+            if (!isBooleanExpression(node.value)) {
+                return;
+            }
+            reportIfNeeded(context, node.key, name);
+        },
+        PropertyDefinition: (node) => {
+            if (node.computed) {
+                return;
+            }
+            const name = getName(node.key);
+            if (name === undefined) {
+                return;
+            }
+            const isBoolean = isBooleanAnnotation(node.typeAnnotation) ||
+                (node.value !== null &&
+                    node.value !== undefined &&
+                    isBooleanExpression(node.value));
+            if (!isBoolean) {
+                return;
+            }
+            reportIfNeeded(context, node.key, name);
+        },
+        TSPropertySignature: (node) => {
+            if (node.computed || !isBooleanAnnotation(node.typeAnnotation)) {
+                return;
+            }
+            const name = getName(node.key);
+            if (name === undefined) {
+                return;
+            }
+            reportIfNeeded(context, node.key, name);
+        }
+    })
+});

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

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireDisjointUnionRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type !== utils_1.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 !== utils_1.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 === utils_1.AST_NODE_TYPES.TSLiteralType) {
+        return getLiteralValue(unwrapped) !== undefined;
+    }
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+        return (unwrapped.types.length > 0 &&
+            unwrapped.types.every((child) => isLiteralOnlyType(child)));
+    }
+    return false;
+};
+const getEntityName = (node) => {
+    if (node.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return undefined;
+    }
+    return node.name;
+};
+const getObjectMembers = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+        return node.body.body;
+    }
+    const unwrapped = unwrapType(node.typeAnnotation);
+    if (unwrapped.type !== utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+        return [];
+    }
+    return unwrapped.members;
+};
+const getLiteralTagValue = (members, tagName) => {
+    for (const member of members) {
+        if (member.type !== utils_1.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 !== utils_1.AST_NODE_TYPES.TSLiteralType) {
+            return undefined;
+        }
+        return getLiteralValue(member.typeAnnotation.typeAnnotation);
+    }
+    return undefined;
+};
+exports.requireDisjointUnionRule = (0, create_rule_js_1.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 === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                return getObjectMembers(declaration);
+            }
+            const unwrapped = unwrapType(declaration.typeAnnotation);
+            if (unwrapped.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                return unwrapped.members;
+            }
+            if (unwrapped.type !== utils_1.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 !== utils_1.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 === utils_1.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
+                            }
+                        });
+                    }
+                }
+            }
+        };
+    }
+});