@less-unsound/eslint-plugin 0.0.1

package/dist/cjs/rules/no-ambient-dom-globals.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noAmbientDomGlobalsRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const browserGlobals = new Set([
+    "addEventListener",
+    "blur",
+    "close",
+    "closed",
+    "confirm",
+    "defaultStatus",
+    "defaultstatus",
+    "event",
+    "external",
+    "find",
+    "focus",
+    "frameElement",
+    "frames",
+    "history",
+    "innerHeight",
+    "innerWidth",
+    "length",
+    "location",
+    "locationbar",
+    "menubar",
+    "moveBy",
+    "moveTo",
+    "name",
+    "onblur",
+    "onerror",
+    "onfocus",
+    "onload",
+    "onresize",
+    "onunload",
+    "open",
+    "opener",
+    "opera",
+    "outerHeight",
+    "outerWidth",
+    "pageXOffset",
+    "pageYOffset",
+    "parent",
+    "print",
+    "removeEventListener",
+    "resizeBy",
+    "resizeTo",
+    "screen",
+    "screenLeft",
+    "screenTop",
+    "screenX",
+    "screenY",
+    "scroll",
+    "scrollBy",
+    "scrollTo",
+    "scrollX",
+    "scrollY",
+    "scrollbars",
+    "status",
+    "statusbar",
+    "stop",
+    "toolbar",
+    "top"
+]);
+const messageIds = Object.freeze({
+    forbiddenAmbientDomGlobal: "Ambient DOM globals are not allowed."
+});
+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) {
+        return parent.id === 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.ExportSpecifier) {
+        return parent.local === node || parent.exported === 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.MemberExpression) {
+        return parent.property === node && parent.computed === false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.Property) {
+        if (parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+            return parent.key === node && parent.computed === false;
+        }
+        if (parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+            return parent.key === node && parent.computed === false;
+        }
+        return false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSPropertySignature ||
+        parent.type === utils_1.AST_NODE_TYPES.TSMethodSignature) {
+        return parent.key === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.LabeledStatement) {
+        return parent.label === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+        return parent.left === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration) {
+        return parent.id === node;
+    }
+    return false;
+};
+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;
+};
+exports.noAmbientDomGlobalsRule = (0, create_rule_js_1.createRule)({
+    name: "no-ambient-dom-globals",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the confusing ambient browser-global surface."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Identifier: (node) => {
+            if (!browserGlobals.has(node.name)) {
+                return;
+            }
+            if (isBindingIdentifier(node)) {
+                return;
+            }
+            const scope = context.sourceCode.getScope(node);
+            if (hasDeclaredBinding(scope, node.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenAmbientDomGlobal"
+            });
+        }
+    })
+});

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

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

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noArgumentsObjectRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === 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) {
+        return parent.id === 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.ExportSpecifier) {
+        return parent.local === node || parent.exported === 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.MemberExpression) {
+        return parent.property === node && parent.computed === false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.Property) {
+        if (parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+            return parent.key === node && parent.computed === false;
+        }
+        if (parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+            return parent.key === node && parent.computed === false && parent.shorthand === false;
+        }
+        return false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSPropertySignature ||
+        parent.type === utils_1.AST_NODE_TYPES.TSMethodSignature) {
+        return parent.key === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.LabeledStatement) {
+        return parent.label === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+        return parent.left === node;
+    }
+    if (parent.type === utils_1.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;
+};
+exports.noArgumentsObjectRule = (0, create_rule_js_1.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/cjs/rules/no-as-type-assertion.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noAsTypeAssertionRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+        return false;
+    }
+    const typeName = node.typeAnnotation.typeName;
+    if (typeName === undefined) {
+        return false;
+    }
+    if (typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return typeName.name === "const";
+};
+exports.noAsTypeAssertionRule = (0, create_rule_js_1.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/cjs/rules/no-bigint.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noBigintRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === utils_1.AST_NODE_TYPES.Literal && "bigint" in node && typeof node.bigint === "string";
+exports.noBigintRule = (0, create_rule_js_1.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 === utils_1.AST_NODE_TYPES.CallExpression && parent.callee === node;
+            const isBigIntMember = parent.type === utils_1.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/cjs/rules/no-boolean-literal-compare.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noBooleanLiteralCompareRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === utils_1.AST_NODE_TYPES.Literal &&
+    typeof node.value === "boolean";
+exports.noBooleanLiteralCompareRule = (0, create_rule_js_1.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/cjs/rules/no-broad-types.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noBroadTypesRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const broadTypeNames = new Set(["Function", "Object"]);
+const messageIds = Object.freeze({
+    forbiddenBroadType: "`Object`, `object`, `{}`, and `Function` types are not allowed."
+});
+exports.noBroadTypesRule = (0, create_rule_js_1.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 !== utils_1.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!broadTypeNames.has(node.typeName.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenBroadType"
+            });
+        }
+    })
+});

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noBufferRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === 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) {
+        return parent.id === 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.ExportSpecifier) {
+        return parent.local === node || parent.exported === 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.MemberExpression) {
+        return parent.property === node && parent.computed === false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.Property) {
+        if (parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+            return parent.key === node && parent.computed === false;
+        }
+        if (parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+            return parent.key === node && parent.computed === false;
+        }
+        return false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSPropertySignature ||
+        parent.type === utils_1.AST_NODE_TYPES.TSMethodSignature) {
+        return parent.key === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.LabeledStatement) {
+        return parent.label === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+        return parent.left === node;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration) {
+        return parent.id === node;
+    }
+    return false;
+};
+const isGlobalBufferReference = (context, node) => {
+    if (node.name !== "Buffer") {
+        return false;
+    }
+    if (node.parent?.type === utils_1.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 !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (node.name !== "Buffer") {
+        return false;
+    }
+    return !hasDeclaredBinding(context.sourceCode.getScope(node), node.name);
+};
+exports.noBufferRule = (0, create_rule_js_1.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"
+            });
+        }
+    })
+});