@less-unsound/eslint-plugin 0.0.1

package/dist/esm/rules/no-arguments-object.js

@@ -0,0 +1,119 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenArgumentsObject: "`arguments` is not allowed."
+});
+const isBindingIdentifier = (node) => {
+    const parent = node.parent;
+    if (parent === null) {
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.VariableDeclarator) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.FunctionDeclaration ||
+        parent.type === AST_NODE_TYPES.FunctionExpression) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ClassDeclaration ||
+        parent.type === AST_NODE_TYPES.ClassExpression ||
+        parent.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||
+        parent.type === AST_NODE_TYPES.TSInterfaceDeclaration ||
+        parent.type === AST_NODE_TYPES.TSEnumDeclaration) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSEnumMember) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ImportSpecifier ||
+        parent.type === AST_NODE_TYPES.ImportDefaultSpecifier ||
+        parent.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return parent.local === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ExportSpecifier) {
+        return parent.local === node || parent.exported === node;
+    }
+    if (parent.type === AST_NODE_TYPES.CatchClause) {
+        return parent.param === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSParameterProperty) {
+        return parent.parameter === node;
+    }
+    if (parent.type === AST_NODE_TYPES.MemberExpression) {
+        return parent.property === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.Property) {
+        if (parent.parent?.type === AST_NODE_TYPES.ObjectPattern) {
+            return parent.key === node && parent.computed === false;
+        }
+        if (parent.parent?.type === AST_NODE_TYPES.ObjectExpression) {
+            return parent.key === node && parent.computed === false && parent.shorthand === false;
+        }
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.MethodDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.PropertyDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.TSPropertySignature ||
+        parent.type === AST_NODE_TYPES.TSMethodSignature) {
+        return parent.key === node;
+    }
+    if (parent.type === AST_NODE_TYPES.LabeledStatement) {
+        return parent.label === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSQualifiedName) {
+        return parent.left === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSImportEqualsDeclaration) {
+        return parent.id === node;
+    }
+    return false;
+};
+const hasDeclaredArgumentsBinding = (scope, name) => {
+    let current = scope;
+    while (current !== null) {
+        for (const variable of current.variables) {
+            if (variable.name !== name) {
+                continue;
+            }
+            if (variable.defs.length > 0 || variable.identifiers.length > 0) {
+                return true;
+            }
+        }
+        current = current.upper;
+    }
+    return false;
+};
+export const noArgumentsObjectRule = createRule({
+    name: "no-arguments-object",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the `arguments` object."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Identifier: (node) => {
+            if (node.name !== "arguments") {
+                return;
+            }
+            if (isBindingIdentifier(node)) {
+                return;
+            }
+            const scope = context.sourceCode.getScope(node);
+            if (hasDeclaredArgumentsBinding(scope, node.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenArgumentsObject"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-as-type-assertion.d.ts

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

package/dist/esm/rules/no-as-type-assertion.js

@@ -0,0 +1,41 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenAsTypeAssertion: "`as` type assertions are not allowed except `as const`."
+});
+const isConstAssertion = (node) => {
+    if (node.typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) {
+        return false;
+    }
+    const typeName = node.typeAnnotation.typeName;
+    if (typeName === undefined) {
+        return false;
+    }
+    if (typeName.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return typeName.name === "const";
+};
+export const noAsTypeAssertionRule = createRule({
+    name: "no-as-type-assertion",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `as` type assertions except `as const`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSAsExpression: (node) => {
+            if (isConstAssertion(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenAsTypeAssertion"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-bigint.d.ts

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

package/dist/esm/rules/no-bigint.js

@@ -0,0 +1,71 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenBigInt: "`bigint` is not allowed."
+});
+const hasDeclaredBinding = (scope, name) => {
+    let current = scope;
+    while (current !== null) {
+        for (const variable of current.variables) {
+            if (variable.name !== name) {
+                continue;
+            }
+            if (variable.defs.length > 0 || variable.identifiers.length > 0) {
+                return true;
+            }
+        }
+        current = current.upper;
+    }
+    return false;
+};
+const isBigIntLiteral = (node) => node.type === AST_NODE_TYPES.Literal && "bigint" in node && typeof node.bigint === "string";
+export const noBigintRule = createRule({
+    name: "no-bigint",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `bigint` types and values."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Literal: (node) => {
+            if (!isBigIntLiteral(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenBigInt"
+            });
+        },
+        TSBigIntKeyword: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenBigInt"
+            });
+        },
+        Identifier: (node) => {
+            if (node.name !== "BigInt") {
+                return;
+            }
+            const parent = node.parent;
+            if (parent === null) {
+                return;
+            }
+            const isBigIntCall = parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node;
+            const isBigIntMember = parent.type === AST_NODE_TYPES.MemberExpression && parent.object === node;
+            if (!isBigIntCall && !isBigIntMember) {
+                return;
+            }
+            if (hasDeclaredBinding(context.sourceCode.getScope(node), node.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenBigInt"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-boolean-literal-compare.d.ts

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

package/dist/esm/rules/no-boolean-literal-compare.js

@@ -0,0 +1,34 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenBooleanLiteralCompare: "Comparisons to boolean literals are not allowed."
+});
+const equalityOperators = new Set(["==", "!=", "===", "!=="]);
+const isBooleanLiteral = (node) => node.type === AST_NODE_TYPES.Literal &&
+    typeof node.value === "boolean";
+export const noBooleanLiteralCompareRule = createRule({
+    name: "no-boolean-literal-compare",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow equality comparisons to boolean literals."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        BinaryExpression: (node) => {
+            if (!equalityOperators.has(node.operator)) {
+                return;
+            }
+            if (!isBooleanLiteral(node.left) && !isBooleanLiteral(node.right)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenBooleanLiteralCompare"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-broad-types.d.ts

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

package/dist/esm/rules/no-broad-types.js

@@ -0,0 +1,47 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const broadTypeNames = new Set(["Function", "Object"]);
+const messageIds = Object.freeze({
+    forbiddenBroadType: "`Object`, `object`, `{}`, and `Function` types are not allowed."
+});
+export const noBroadTypesRule = createRule({
+    name: "no-broad-types",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `Object`, `object`, `{}`, and `Function` types."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSObjectKeyword: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenBroadType"
+            });
+        },
+        TSTypeLiteral: (node) => {
+            if (node.members.length !== 0) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenBroadType"
+            });
+        },
+        TSTypeReference: (node) => {
+            if (node.typeName.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!broadTypeNames.has(node.typeName.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenBroadType"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-buffer.d.ts

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

package/dist/esm/rules/no-buffer.js

@@ -0,0 +1,143 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenBuffer: "`Buffer` is not allowed. Use `Uint8Array` instead."
+});
+const hasDeclaredBinding = (scope, name) => {
+    let current = scope;
+    while (current !== null) {
+        for (const variable of current.variables) {
+            if (variable.name !== name) {
+                continue;
+            }
+            if (variable.defs.length > 0 || variable.identifiers.length > 0) {
+                return true;
+            }
+        }
+        current = current.upper;
+    }
+    return false;
+};
+const isBindingIdentifier = (node) => {
+    const parent = node.parent;
+    if (parent === null) {
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.VariableDeclarator) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.FunctionDeclaration ||
+        parent.type === AST_NODE_TYPES.FunctionExpression) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ClassDeclaration ||
+        parent.type === AST_NODE_TYPES.ClassExpression ||
+        parent.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||
+        parent.type === AST_NODE_TYPES.TSInterfaceDeclaration ||
+        parent.type === AST_NODE_TYPES.TSEnumDeclaration) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSEnumMember) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ImportSpecifier ||
+        parent.type === AST_NODE_TYPES.ImportDefaultSpecifier ||
+        parent.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return parent.local === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ExportSpecifier) {
+        return parent.local === node || parent.exported === node;
+    }
+    if (parent.type === AST_NODE_TYPES.CatchClause) {
+        return parent.param === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSParameterProperty) {
+        return parent.parameter === node;
+    }
+    if (parent.type === AST_NODE_TYPES.MemberExpression) {
+        return parent.property === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.Property) {
+        if (parent.parent?.type === AST_NODE_TYPES.ObjectPattern) {
+            return parent.key === node && parent.computed === false;
+        }
+        if (parent.parent?.type === AST_NODE_TYPES.ObjectExpression) {
+            return parent.key === node && parent.computed === false;
+        }
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.MethodDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.PropertyDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.TSPropertySignature ||
+        parent.type === AST_NODE_TYPES.TSMethodSignature) {
+        return parent.key === node;
+    }
+    if (parent.type === AST_NODE_TYPES.LabeledStatement) {
+        return parent.label === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSQualifiedName) {
+        return parent.left === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSImportEqualsDeclaration) {
+        return parent.id === node;
+    }
+    return false;
+};
+const isGlobalBufferReference = (context, node) => {
+    if (node.name !== "Buffer") {
+        return false;
+    }
+    if (node.parent?.type === AST_NODE_TYPES.TSTypeReference &&
+        node.parent.typeName === node) {
+        return false;
+    }
+    if (isBindingIdentifier(node)) {
+        return false;
+    }
+    return !hasDeclaredBinding(context.sourceCode.getScope(node), node.name);
+};
+const isBufferTypeName = (context, node) => {
+    if (node.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (node.name !== "Buffer") {
+        return false;
+    }
+    return !hasDeclaredBinding(context.sourceCode.getScope(node), node.name);
+};
+export const noBufferRule = createRule({
+    name: "no-buffer",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow global `Buffer` types and values."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Identifier: (node) => {
+            if (!isGlobalBufferReference(context, node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenBuffer"
+            });
+        },
+        TSTypeReference: (node) => {
+            if (!isBufferTypeName(context, node.typeName)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenBuffer"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-class.d.ts

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

package/dist/esm/rules/no-class.js

@@ -0,0 +1,36 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenClass: "`class` is not allowed."
+});
+export const noClassRule = createRule({
+    name: "no-class",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `class` declarations and expressions when they are not already covered by `no-inheritance`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ClassDeclaration: (node) => {
+            if (node.superClass !== null) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenClass"
+            });
+        },
+        ClassExpression: (node) => {
+            if (node.superClass !== null) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenClass"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-comma-operator.d.ts

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

package/dist/esm/rules/no-comma-operator.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenCommaOperator: "The comma operator is not allowed."
+});
+export const noCommaOperatorRule = createRule({
+    name: "no-comma-operator",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the comma operator."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        SequenceExpression: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenCommaOperator"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-conditional-type.d.ts

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

package/dist/esm/rules/no-conditional-type.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenConditionalType: "Conditional types are not allowed."
+});
+export const noConditionalTypeRule = createRule({
+    name: "no-conditional-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow conditional types."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSConditionalType: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenConditionalType"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-default-parameter.d.ts

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

package/dist/esm/rules/no-default-parameter.js

@@ -0,0 +1,68 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenDefaultParameter: "Default parameters are not allowed."
+});
+export const noDefaultParameterRule = createRule({
+    name: "no-default-parameter",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow default parameters."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const reportDefaultParameters = (node) => {
+            if (node.type === AST_NODE_TYPES.AssignmentPattern) {
+                context.report({
+                    node,
+                    messageId: "forbiddenDefaultParameter"
+                });
+                reportDefaultParameters(node.left);
+                return;
+            }
+            if (node.type === AST_NODE_TYPES.TSParameterProperty) {
+                reportDefaultParameters(node.parameter);
+                return;
+            }
+            if (node.type === AST_NODE_TYPES.ArrayPattern) {
+                for (const element of node.elements) {
+                    if (element === null) {
+                        continue;
+                    }
+                    reportDefaultParameters(element);
+                }
+                return;
+            }
+            if (node.type === AST_NODE_TYPES.ObjectPattern) {
+                for (const property of node.properties) {
+                    if (property.type === AST_NODE_TYPES.RestElement) {
+                        reportDefaultParameters(property.argument);
+                        continue;
+                    }
+                    reportDefaultParameters(property.value);
+                }
+            }
+        };
+        return {
+            ArrowFunctionExpression: (node) => {
+                for (const param of node.params) {
+                    reportDefaultParameters(param);
+                }
+            },
+            FunctionDeclaration: (node) => {
+                for (const param of node.params) {
+                    reportDefaultParameters(param);
+                }
+            },
+            FunctionExpression: (node) => {
+                for (const param of node.params) {
+                    reportDefaultParameters(param);
+                }
+            }
+        };
+    }
+});

package/dist/esm/rules/no-enum.d.ts

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