@less-unsound/eslint-plugin 0.0.1

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noClassRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenClass: "`class` is not allowed."
+});
+exports.noClassRule = (0, create_rule_js_1.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/cjs/rules/no-comma-operator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noCommaOperatorRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenCommaOperator: "The comma operator is not allowed."
+});
+exports.noCommaOperatorRule = (0, create_rule_js_1.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/cjs/rules/no-conditional-type.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noConditionalTypeRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenConditionalType: "Conditional types are not allowed."
+});
+exports.noConditionalTypeRule = (0, create_rule_js_1.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/cjs/rules/no-default-parameter.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noDefaultParameterRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenDefaultParameter: "Default parameters are not allowed."
+});
+exports.noDefaultParameterRule = (0, create_rule_js_1.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 === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                context.report({
+                    node,
+                    messageId: "forbiddenDefaultParameter"
+                });
+                reportDefaultParameters(node.left);
+                return;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                reportDefaultParameters(node.parameter);
+                return;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                for (const element of node.elements) {
+                    if (element === null) {
+                        continue;
+                    }
+                    reportDefaultParameters(element);
+                }
+                return;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                for (const property of node.properties) {
+                    if (property.type === utils_1.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/cjs/rules/no-enum.js

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

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noEvalRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenEval: "`eval` is not allowed."
+});
+const isEvalIdentifier = (node) => node.type === utils_1.AST_NODE_TYPES.Identifier &&
+    node.name === "eval";
+exports.noEvalRule = (0, create_rule_js_1.createRule)({
+    name: "no-eval",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `eval`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        CallExpression: (node) => {
+            if (!isEvalIdentifier(node.callee)) {
+                return;
+            }
+            context.report({
+                node: node.callee,
+                messageId: "forbiddenEval"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-export-default.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noExportDefaultRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenExportDefault: "Default exports are not allowed."
+});
+const isDefaultExportSpecifier = (node) => {
+    return node.exported.type === utils_1.AST_NODE_TYPES.Identifier && node.exported.name === "default";
+};
+exports.noExportDefaultRule = (0, create_rule_js_1.createRule)({
+    name: "no-export-default",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow default exports."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ExportDefaultDeclaration: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenExportDefault"
+            });
+        },
+        ExportNamedDeclaration: (node) => {
+            for (const specifier of node.specifiers) {
+                if (specifier.type !== utils_1.AST_NODE_TYPES.ExportSpecifier) {
+                    continue;
+                }
+                if (!isDefaultExportSpecifier(specifier)) {
+                    continue;
+                }
+                context.report({
+                    node: specifier,
+                    messageId: "forbiddenExportDefault"
+                });
+            }
+        }
+    })
+});

package/dist/cjs/rules/no-for-in.js

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

package/dist/cjs/rules/no-for-let.js

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

package/dist/cjs/rules/no-function-constructor.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFunctionConstructorRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const globalNames = new Set(["Function", "globalThis", "window", "self", "global"]);
+const messageIds = Object.freeze({
+    forbiddenFunctionConstructor: "`Function()` 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 isGlobalReference = (context, node, name) => {
+    const scope = context.sourceCode.getScope(node);
+    return !hasDeclaredBinding(scope, name);
+};
+const isFunctionConstructorCall = (context, node) => {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.callee.name === "Function" && isGlobalReference(context, node.callee, "Function");
+    }
+    if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    if (node.callee.object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (!globalNames.has(node.callee.object.name) || node.callee.object.name === "Function") {
+        return false;
+    }
+    if (!isGlobalReference(context, node.callee.object, node.callee.object.name)) {
+        return false;
+    }
+    if (node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.callee.property.name === "Function";
+    }
+    if (node.callee.property.type === utils_1.AST_NODE_TYPES.Literal) {
+        return node.callee.property.value === "Function";
+    }
+    return false;
+};
+exports.noFunctionConstructorRule = (0, create_rule_js_1.createRule)({
+    name: "no-function-constructor",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow global `Function` constructor usage."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        CallExpression: (node) => {
+            if (!isFunctionConstructorCall(context, node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenFunctionConstructor"
+            });
+        },
+        NewExpression: (node) => {
+            if (!isFunctionConstructorCall(context, node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenFunctionConstructor"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-function-keyword.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFunctionKeywordRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenFunctionKeyword: "Non-generator `function` declarations and expressions are not allowed."
+});
+exports.noFunctionKeywordRule = (0, create_rule_js_1.createRule)({
+    name: "no-function-keyword",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow non-generator `function` declarations and expressions."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        FunctionDeclaration: (node) => {
+            if (node.generator) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenFunctionKeyword"
+            });
+        },
+        FunctionExpression: (node) => {
+            if (node.generator) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenFunctionKeyword"
+            });
+        },
+        TSDeclareFunction: (node) => {
+            if (node.generator) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenFunctionKeyword"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-generic-parameter-bounds.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noGenericParameterBoundsRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenGenericParameterBounds: "Generic parameter bounds with `extends` are not allowed."
+});
+exports.noGenericParameterBoundsRule = (0, create_rule_js_1.createRule)({
+    name: "no-generic-parameter-bounds",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow generic parameter bounds with `extends`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTypeParameter: (node) => {
+            if (node.constraint === undefined) {
+                return;
+            }
+            if (node.parent.type === utils_1.AST_NODE_TYPES.TSInferType) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenGenericParameterBounds"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-getter-setter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noGetterSetterRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenGetterSetter: "Getters and setters are not allowed."
+});
+exports.noGetterSetterRule = (0, create_rule_js_1.createRule)({
+    name: "no-getter-setter",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow getters and setters in objects, classes, and interfaces."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        MethodDefinition: (node) => {
+            if (node.kind !== "get" && node.kind !== "set") {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenGetterSetter"
+            });
+        },
+        Property: (node) => {
+            if (node.kind !== "get" && node.kind !== "set") {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenGetterSetter"
+            });
+        },
+        TSMethodSignature: (node) => {
+            if (node.kind !== "get" && node.kind !== "set") {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenGetterSetter"
+            });
+        }
+    })
+});