@less-unsound/eslint-plugin 0.0.1

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRequireRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const moduleSpecifiers = new Set(["module", "node:module"]);
+const messageIds = Object.freeze({
+    forbiddenCreateRequire: "`createRequire()` is not allowed. Use ES module imports instead.",
+    forbiddenRequire: "`require()` is not allowed. Use ES module imports instead."
+});
+const isBindingIdentifier = (node) => {
+    const parent = node.parent;
+    if (parent === null) {
+        return false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+        return parent.id === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+        parent.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        return parent.id === node || parent.params.includes(node);
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+        parent.type === utils_1.AST_NODE_TYPES.ClassExpression ||
+        parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+        parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
+        parent.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration) {
+        return parent.id === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSEnumMember) {
+        return parent.id === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.ImportSpecifier ||
+        parent.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        parent.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return parent.local === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.CatchClause) {
+        return parent.param === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+        return parent.parameter === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.Property && parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+        return parent.value === node || (parent.shorthand === true && parent.key === node);
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.RestElement) {
+        return parent.argument === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+        return parent.left === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        return true;
+    }
+    return false;
+};
+const hasDeclaredBinding = (scope, name) => {
+    const variable = scope.variables.find((value) => value.name === name);
+    if (variable !== undefined && (variable.defs.length > 0 || variable.identifiers.length > 0)) {
+        return true;
+    }
+    if (scope.upper === null) {
+        return false;
+    }
+    return hasDeclaredBinding(scope.upper, name);
+};
+const isGlobalReference = (context, node) => {
+    if (isBindingIdentifier(node)) {
+        return false;
+    }
+    return hasDeclaredBinding(context.sourceCode.getScope(node), node.name) === false;
+};
+const getPropertyName = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+        return node.value;
+    }
+    return undefined;
+};
+const getImportBindings = (program) => {
+    const createRequireNames = new Set();
+    const moduleNamespaces = new Set();
+    for (const statement of program.body) {
+        if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+            continue;
+        }
+        if (statement.source.type !== utils_1.AST_NODE_TYPES.Literal ||
+            typeof statement.source.value !== "string" ||
+            !moduleSpecifiers.has(statement.source.value)) {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                specifier.imported.name === "createRequire") {
+                createRequireNames.add(specifier.local.name);
+            }
+            if (specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                moduleNamespaces.add(specifier.local.name);
+            }
+        }
+    }
+    return {
+        createRequireNames,
+        moduleNamespaces
+    };
+};
+exports.noRequireRule = (0, create_rule_js_1.createRule)({
+    name: "no-require",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `require()` and Node `createRequire()`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const bindings = getImportBindings(context.sourceCode.ast);
+        return {
+            CallExpression: (node) => {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    if (node.callee.name === "require" && isGlobalReference(context, node.callee)) {
+                        context.report({
+                            node: node.callee,
+                            messageId: "forbiddenRequire"
+                        });
+                        return;
+                    }
+                    if (bindings.createRequireNames.has(node.callee.name)) {
+                        context.report({
+                            node: node.callee,
+                            messageId: "forbiddenCreateRequire"
+                        });
+                    }
+                    return;
+                }
+                if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                    return;
+                }
+                if (node.callee.object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                if (!bindings.moduleNamespaces.has(node.callee.object.name)) {
+                    return;
+                }
+                if (getPropertyName(node.callee.property) !== "createRequire") {
+                    return;
+                }
+                context.report({
+                    node: node.callee,
+                    messageId: "forbiddenCreateRequire"
+                });
+            }
+        };
+    }
+});

package/dist/cjs/rules/no-rest-parameter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRestParameterRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenRestParameter: "Using rest parameters is not allowed."
+});
+exports.noRestParameterRule = (0, create_rule_js_1.createRule)({
+    name: "no-rest-parameter",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow rest parameters."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const reportRestParameters = (params) => {
+            for (const param of params) {
+                if (param.type !== utils_1.AST_NODE_TYPES.RestElement) {
+                    continue;
+                }
+                context.report({
+                    node: param,
+                    messageId: "forbiddenRestParameter"
+                });
+            }
+        };
+        return {
+            ArrowFunctionExpression: (node) => reportRestParameters(node.params),
+            FunctionDeclaration: (node) => reportRestParameters(node.params),
+            FunctionExpression: (node) => reportRestParameters(node.params)
+        };
+    }
+});

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSwitchRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenSwitch: "`switch` statements are not allowed."
+});
+exports.noSwitchRule = (0, create_rule_js_1.createRule)({
+    name: "no-switch",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `switch` statements."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        SwitchStatement: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenSwitch"
+            });
+        }
+    })
+});

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

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

package/dist/cjs/rules/no-try-catch.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noTryCatchRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenTryCatch: "`try ... catch` is not allowed."
+});
+exports.noTryCatchRule = (0, create_rule_js_1.createRule)({
+    name: "no-try-catch",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `try ... catch`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TryStatement: (node) => {
+            if (node.handler === null) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenTryCatch"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-ts-comment-directive.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noTsCommentDirectiveRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const directives = Object.freeze([
+    "@ts-check",
+    "@ts-expect-error",
+    "@ts-ignore",
+    "@ts-nocheck"
+]);
+const messageIds = Object.freeze({
+    forbiddenTsCommentDirective: "TypeScript comment directives are not allowed."
+});
+const hasDirective = (value) => directives.some((directive) => value.includes(directive));
+exports.noTsCommentDirectiveRule = (0, create_rule_js_1.createRule)({
+    name: "no-ts-comment-directive",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow TypeScript comment directives."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Program: () => {
+            context.sourceCode.getAllComments().forEach((comment) => {
+                if (!hasDirective(comment.value)) {
+                    return;
+                }
+                context.report({
+                    loc: comment.loc,
+                    messageId: "forbiddenTsCommentDirective"
+                });
+            });
+        }
+    })
+});

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noTupleRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenTuple: "Tuple types are not allowed."
+});
+exports.noTupleRule = (0, create_rule_js_1.createRule)({
+    name: "no-tuple",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow tuple types."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTupleType: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenTuple"
+            });
+        }
+    })
+});

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noTypeGuardRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenTypeGuard: "Type guards are not allowed."
+});
+exports.noTypeGuardRule = (0, create_rule_js_1.createRule)({
+    name: "no-type-guard",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow TypeScript type guards."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTypePredicate: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenTypeGuard"
+            });
+        }
+    })
+});

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

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

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUndefinedTypeRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenUndefinedType: "The `undefined` type is not allowed. Use explicit options or tagged unions instead of `T | undefined`."
+});
+exports.noUndefinedTypeRule = (0, create_rule_js_1.createRule)({
+    name: "no-undefined-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the `undefined` type keyword in type positions."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSUndefinedKeyword: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenUndefinedType"
+            });
+        }
+    })
+});

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

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

package/dist/cjs/rules/no-untagged-object-union.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUntaggedObjectUnionRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenUntaggedObjectUnion: "Untagged object unions are not allowed."
+});
+const getPropertyName = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return `identifier:${node.name}`;
+    }
+    if (node.type !== utils_1.AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    const { value } = node;
+    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 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 getTaggedPropertyValue = (node, propertyName) => {
+    for (const member of node.members) {
+        if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+            continue;
+        }
+        if (member.optional) {
+            continue;
+        }
+        const name = getPropertyName(member.key);
+        if (name !== propertyName) {
+            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;
+};
+const isTaggedObjectUnion = (node) => {
+    if (node.types.length < 2) {
+        return false;
+    }
+    const first = node.types[0];
+    if (first.type !== utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+        return false;
+    }
+    const candidateNames = new Set();
+    for (const member of first.members) {
+        if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+            continue;
+        }
+        if (member.optional) {
+            continue;
+        }
+        if (member.typeAnnotation === undefined) {
+            continue;
+        }
+        if (member.typeAnnotation.typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSLiteralType) {
+            continue;
+        }
+        const name = getPropertyName(member.key);
+        if (name !== undefined) {
+            candidateNames.add(name);
+        }
+    }
+    for (const propertyName of candidateNames) {
+        const values = new Set();
+        let isValid = true;
+        for (const branch of node.types) {
+            if (branch.type !== utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                isValid = false;
+                break;
+            }
+            const value = getTaggedPropertyValue(branch, propertyName);
+            if (value === undefined) {
+                isValid = false;
+                break;
+            }
+            values.add(value);
+        }
+        if (isValid && values.size === node.types.length) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.noUntaggedObjectUnionRule = (0, create_rule_js_1.createRule)({
+    name: "no-untagged-object-union",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow unions of inline object types unless they share a literal tag field."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSUnionType: (node) => {
+            if (isTaggedObjectUnion(node)) {
+                return;
+            }
+            if (node.types.every((branch) => branch.type === utils_1.AST_NODE_TYPES.TSTypeLiteral)) {
+                context.report({
+                    node,
+                    messageId: "forbiddenUntaggedObjectUnion"
+                });
+            }
+        }
+    })
+});