@less-unsound/eslint-plugin 0.0.1

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noOptionalParameterRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenOptionalParameter: "Optional parameters are not allowed."
+});
+const isOptionalIdentifier = (node) => node.type === utils_1.AST_NODE_TYPES.Identifier && node.optional;
+const reportOptionalParameters = (report, params) => {
+    params.forEach((param) => {
+        if (!isOptionalIdentifier(param)) {
+            return;
+        }
+        report(param);
+    });
+};
+exports.noOptionalParameterRule = (0, create_rule_js_1.createRule)({
+    name: "no-optional-parameter",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow optional parameters marked with `?` in functions and constructor parameter properties."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ArrowFunctionExpression: (node) => {
+            reportOptionalParameters((param) => {
+                context.report({
+                    node: param,
+                    messageId: "forbiddenOptionalParameter"
+                });
+            }, node.params);
+        },
+        FunctionDeclaration: (node) => {
+            reportOptionalParameters((param) => {
+                context.report({
+                    node: param,
+                    messageId: "forbiddenOptionalParameter"
+                });
+            }, node.params);
+        },
+        FunctionExpression: (node) => {
+            reportOptionalParameters((param) => {
+                context.report({
+                    node: param,
+                    messageId: "forbiddenOptionalParameter"
+                });
+            }, node.params);
+        },
+        TSCallSignatureDeclaration: (node) => {
+            reportOptionalParameters((param) => {
+                context.report({
+                    node: param,
+                    messageId: "forbiddenOptionalParameter"
+                });
+            }, node.params);
+        },
+        TSConstructSignatureDeclaration: (node) => {
+            reportOptionalParameters((param) => {
+                context.report({
+                    node: param,
+                    messageId: "forbiddenOptionalParameter"
+                });
+            }, node.params);
+        },
+        TSDeclareFunction: (node) => {
+            reportOptionalParameters((param) => {
+                context.report({
+                    node: param,
+                    messageId: "forbiddenOptionalParameter"
+                });
+            }, node.params);
+        },
+        TSFunctionType: (node) => {
+            reportOptionalParameters((param) => {
+                context.report({
+                    node: param,
+                    messageId: "forbiddenOptionalParameter"
+                });
+            }, node.params);
+        },
+        TSMethodSignature: (node) => {
+            reportOptionalParameters((param) => {
+                context.report({
+                    node: param,
+                    messageId: "forbiddenOptionalParameter"
+                });
+            }, node.params);
+        },
+        TSParameterProperty: (node) => {
+            if (!isOptionalIdentifier(node.parameter)) {
+                return;
+            }
+            context.report({
+                node: node.parameter,
+                messageId: "forbiddenOptionalParameter"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-optional-property.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noOptionalPropertyRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenOptionalProperty: "Optional object fields are not allowed."
+});
+exports.noOptionalPropertyRule = (0, create_rule_js_1.createRule)({
+    name: "no-optional-property",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow optional object fields marked with `?`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSPropertySignature: (node) => {
+            if (!node.optional) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenOptionalProperty"
+            });
+        }
+    })
+});

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noOverloadRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenOverload: "Overloads are not allowed."
+});
+const getText = (sourceText, range) => sourceText.slice(range[0], range[1]);
+const getTopLevelEntries = (body) => {
+    const entries = [];
+    body.forEach((statement) => {
+        if (statement.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+            statement.type !== utils_1.AST_NODE_TYPES.TSDeclareFunction) {
+            return;
+        }
+        if (statement.id === null) {
+            return;
+        }
+        entries.push({
+            name: statement.id.name,
+            node: statement
+        });
+    });
+    return entries;
+};
+const getClassEntries = (sourceText, body) => {
+    const entries = [];
+    body.forEach((member) => {
+        if (member.type !== utils_1.AST_NODE_TYPES.MethodDefinition) {
+            return;
+        }
+        if (member.kind === "get" || member.kind === "set") {
+            return;
+        }
+        entries.push({
+            name: getText(sourceText, member.key.range),
+            node: member
+        });
+    });
+    return entries;
+};
+const getTypeEntries = (sourceText, body) => {
+    const entries = [];
+    body.forEach((member) => {
+        if (member.type === utils_1.AST_NODE_TYPES.TSMethodSignature) {
+            entries.push({
+                name: getText(sourceText, member.key.range),
+                node: member
+            });
+            return;
+        }
+        if (member.type === utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration) {
+            entries.push({
+                name: "(call)",
+                node: member
+            });
+            return;
+        }
+        if (member.type === utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration) {
+            entries.push({
+                name: "(construct)",
+                node: member
+            });
+        }
+    });
+    return entries;
+};
+exports.noOverloadRule = (0, create_rule_js_1.createRule)({
+    name: "no-overload",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow function and method overloads."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const sourceText = context.sourceCode.getText();
+        const reportDuplicates = (entries) => {
+            const seen = new Set();
+            entries.forEach((entry) => {
+                if (seen.has(entry.name)) {
+                    context.report({
+                        node: entry.node,
+                        messageId: "forbiddenOverload"
+                    });
+                    return;
+                }
+                seen.add(entry.name);
+            });
+        };
+        return {
+            Program: (node) => {
+                reportDuplicates(getTopLevelEntries(node.body));
+            },
+            ClassBody: (node) => {
+                reportDuplicates(getClassEntries(sourceText, node.body));
+            },
+            TSInterfaceBody: (node) => {
+                reportDuplicates(getTypeEntries(sourceText, node.body));
+            },
+            TSTypeLiteral: (node) => {
+                reportDuplicates(getTypeEntries(sourceText, node.members));
+            }
+        };
+    }
+});

package/dist/cjs/rules/no-param-assign.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noParamAssignRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenParamAssign: "Assigning to function parameters is not allowed."
+});
+const getPatternNames = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return [node.name];
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+        return getPatternNames(node.left);
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.RestElement) {
+        return getPatternNames(node.argument);
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        return node.elements.flatMap((element) => {
+            if (element === null) {
+                return [];
+            }
+            return getPatternNames(element);
+        });
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+        return node.properties.flatMap((property) => {
+            if (property.type === utils_1.AST_NODE_TYPES.RestElement) {
+                return getPatternNames(property.argument);
+            }
+            return getPatternNames(property.value);
+        });
+    }
+    return [];
+};
+const getParamNames = (params) => new Set(params.flatMap((param) => getPatternNames(param)));
+const getEnclosingFunction = (node) => {
+    let parent = node.parent;
+    while (parent !== undefined) {
+        if (parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            parent.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            return parent;
+        }
+        parent = parent.parent;
+    }
+    return undefined;
+};
+const isAssignedParam = (node) => {
+    const fn = getEnclosingFunction(node);
+    if (fn === undefined) {
+        return false;
+    }
+    return getParamNames(fn.params).has(node.name);
+};
+exports.noParamAssignRule = (0, create_rule_js_1.createRule)({
+    name: "no-param-assign",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow assigning to function parameters unless mutability is required for performance."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        AssignmentExpression: (node) => {
+            if (node.left.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!isAssignedParam(node.left)) {
+                return;
+            }
+            context.report({
+                node: node.left,
+                messageId: "forbiddenParamAssign"
+            });
+        },
+        UpdateExpression: (node) => {
+            if (node.argument.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!isAssignedParam(node.argument)) {
+                return;
+            }
+            context.report({
+                node: node.argument,
+                messageId: "forbiddenParamAssign"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-prototype-access.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noPrototypeAccessRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const forbiddenNames = new Set(["prototype", "__proto__"]);
+const messageIds = Object.freeze({
+    forbiddenPrototypeAccess: "Runtime use of `prototype` and `__proto__` is not allowed."
+});
+const getStaticPropertyName = (node, isComputed) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return isComputed ? undefined : node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+        return typeof node.value === "string" ? node.value : undefined;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0) {
+        return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
+    }
+    return undefined;
+};
+exports.noPrototypeAccessRule = (0, create_rule_js_1.createRule)({
+    name: "no-prototype-access",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow runtime access to `prototype` and `__proto__`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        MemberExpression: (node) => {
+            const name = getStaticPropertyName(node.property, node.computed);
+            if (name === undefined || !forbiddenNames.has(name)) {
+                return;
+            }
+            context.report({
+                node: node.property,
+                messageId: "forbiddenPrototypeAccess"
+            });
+        },
+        MethodDefinition: (node) => {
+            const name = getStaticPropertyName(node.key, node.computed);
+            if (name === undefined || !forbiddenNames.has(name)) {
+                return;
+            }
+            context.report({
+                node: node.key,
+                messageId: "forbiddenPrototypeAccess"
+            });
+        },
+        Property: (node) => {
+            if (node.parent.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return;
+            }
+            const name = getStaticPropertyName(node.key, node.computed);
+            if (name === undefined || !forbiddenNames.has(name)) {
+                return;
+            }
+            context.report({
+                node: node.key,
+                messageId: "forbiddenPrototypeAccess"
+            });
+        },
+        PropertyDefinition: (node) => {
+            const name = getStaticPropertyName(node.key, node.computed);
+            if (name === undefined || !forbiddenNames.has(name)) {
+                return;
+            }
+            context.report({
+                node: node.key,
+                messageId: "forbiddenPrototypeAccess"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-proxy-reflect.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noProxyReflectRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const forbiddenNames = new Set(["Proxy", "Reflect"]);
+const messageIds = Object.freeze({
+    forbiddenProxyReflect: "Proxy and Reflect 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 && 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;
+};
+exports.noProxyReflectRule = (0, create_rule_js_1.createRule)({
+    name: "no-proxy-reflect",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the `Proxy` and `Reflect` global objects."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const reported = new Set();
+        return {
+            Identifier: (node) => {
+                if (!forbiddenNames.has(node.name)) {
+                    return;
+                }
+                if (isBindingIdentifier(node)) {
+                    return;
+                }
+                const key = node.range.join(":");
+                if (reported.has(key)) {
+                    return;
+                }
+                reported.add(key);
+                context.report({
+                    node,
+                    messageId: "forbiddenProxyReflect"
+                });
+            }
+        };
+    }
+});

package/dist/cjs/rules/no-reexport-outside-entrypoint.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noReexportOutsideEntrypointRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const package_entrypoint_js_1 = require("../utils/package-entrypoint.js");
+const package_entrypoint_js_2 = require("../utils/package-entrypoint.js");
+const messageIds = Object.freeze({
+    forbiddenReexportOutsideEntrypoint: "Reexports are only allowed in files explicitly mentioned in package.json as entrypoints."
+});
+exports.noReexportOutsideEntrypointRule = (0, create_rule_js_1.createRule)({
+    name: "no-reexport-outside-entrypoint",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow reexports outside files explicitly mentioned in package.json as entrypoints."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const packageJsonPath = (0, package_entrypoint_js_1.findNearestPackageJsonPath)(context.physicalFilename);
+        const isRuleEnabledForFile = packageJsonPath !== undefined;
+        const isEntrypoint = isRuleEnabledForFile && (0, package_entrypoint_js_2.isExplicitPackageEntrypoint)(context.physicalFilename);
+        return {
+            ExportAllDeclaration: (node) => {
+                if (!isRuleEnabledForFile || isEntrypoint) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: "forbiddenReexportOutsideEntrypoint"
+                });
+            },
+            ExportNamedDeclaration: (node) => {
+                if (node.source === null || !isRuleEnabledForFile || isEntrypoint) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: "forbiddenReexportOutsideEntrypoint"
+                });
+            }
+        };
+    }
+});

package/dist/cjs/rules/no-regular-expression.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRegularExpressionRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const globalNames = new Set(["RegExp", "globalThis", "window", "self", "global"]);
+const messageIds = Object.freeze({
+    forbiddenRegularExpression: "Regular expressions are 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 isGlobalConstructorCall = (context, node) => {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.callee.name === "RegExp" && isGlobalReference(context, node.callee, "RegExp");
+    }
+    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 === "RegExp") {
+        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 === "RegExp";
+    }
+    if (node.callee.property.type === utils_1.AST_NODE_TYPES.Literal) {
+        return node.callee.property.value === "RegExp";
+    }
+    return false;
+};
+exports.noRegularExpressionRule = (0, create_rule_js_1.createRule)({
+    name: "no-regular-expression",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow regular-expression literals and global `RegExp()` constructor usage."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Literal: (node) => {
+            if (!("regex" in node) || node.regex === undefined) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenRegularExpression"
+            });
+        },
+        CallExpression: (node) => {
+            if (!isGlobalConstructorCall(context, node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenRegularExpression"
+            });
+        },
+        NewExpression: (node) => {
+            if (!isGlobalConstructorCall(context, node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenRegularExpression"
+            });
+        }
+    })
+});