@less-unsound/eslint-plugin 0.0.1

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

@@ -0,0 +1,76 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../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 === AST_NODE_TYPES.Identifier) {
+        return isComputed ? undefined : node.name;
+    }
+    if (node.type === AST_NODE_TYPES.Literal) {
+        return typeof node.value === "string" ? node.value : undefined;
+    }
+    if (node.type === AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0) {
+        return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
+    }
+    return undefined;
+};
+export const noPrototypeAccessRule = 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 !== 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/esm/rules/no-proxy-reflect.d.ts

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

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

@@ -0,0 +1,109 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../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 === 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;
+};
+export const noProxyReflectRule = 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/esm/rules/no-reexport-outside-entrypoint.d.ts

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

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

@@ -0,0 +1,43 @@
+import { createRule } from "../utils/create-rule.js";
+import { findNearestPackageJsonPath } from "../utils/package-entrypoint.js";
+import { isExplicitPackageEntrypoint } from "../utils/package-entrypoint.js";
+const messageIds = Object.freeze({
+    forbiddenReexportOutsideEntrypoint: "Reexports are only allowed in files explicitly mentioned in package.json as entrypoints."
+});
+export const noReexportOutsideEntrypointRule = 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 = findNearestPackageJsonPath(context.physicalFilename);
+        const isRuleEnabledForFile = packageJsonPath !== undefined;
+        const isEntrypoint = isRuleEnabledForFile && 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/esm/rules/no-regular-expression.d.ts

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

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

@@ -0,0 +1,90 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../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 === AST_NODE_TYPES.Identifier) {
+        return node.callee.name === "RegExp" && isGlobalReference(context, node.callee, "RegExp");
+    }
+    if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    if (node.callee.object.type !== 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 === AST_NODE_TYPES.Identifier) {
+        return node.callee.property.name === "RegExp";
+    }
+    if (node.callee.property.type === AST_NODE_TYPES.Literal) {
+        return node.callee.property.value === "RegExp";
+    }
+    return false;
+};
+export const noRegularExpressionRule = 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"
+            });
+        }
+    })
+});

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

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

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

@@ -0,0 +1,159 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../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 === AST_NODE_TYPES.VariableDeclarator) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.FunctionDeclaration ||
+        parent.type === AST_NODE_TYPES.FunctionExpression ||
+        parent.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+        return parent.id === node || parent.params.includes(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.CatchClause) {
+        return parent.param === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSParameterProperty) {
+        return parent.parameter === node;
+    }
+    if (parent.type === AST_NODE_TYPES.Property && parent.parent?.type === AST_NODE_TYPES.ObjectPattern) {
+        return parent.value === node || (parent.shorthand === true && parent.key === node);
+    }
+    if (parent.type === AST_NODE_TYPES.RestElement) {
+        return parent.argument === node;
+    }
+    if (parent.type === AST_NODE_TYPES.AssignmentPattern) {
+        return parent.left === node;
+    }
+    if (parent.type === 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 === AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === 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 !== AST_NODE_TYPES.ImportDeclaration) {
+            continue;
+        }
+        if (statement.source.type !== AST_NODE_TYPES.Literal ||
+            typeof statement.source.value !== "string" ||
+            !moduleSpecifiers.has(statement.source.value)) {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+                specifier.imported.type === AST_NODE_TYPES.Identifier &&
+                specifier.imported.name === "createRequire") {
+                createRequireNames.add(specifier.local.name);
+            }
+            if (specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                moduleNamespaces.add(specifier.local.name);
+            }
+        }
+    }
+    return {
+        createRequireNames,
+        moduleNamespaces
+    };
+};
+export const noRequireRule = 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 === 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 !== AST_NODE_TYPES.MemberExpression) {
+                    return;
+                }
+                if (node.callee.object.type !== 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/esm/rules/no-rest-parameter.d.ts

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

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

@@ -0,0 +1,35 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenRestParameter: "Using rest parameters is not allowed."
+});
+export const noRestParameterRule = 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 !== 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/esm/rules/no-switch.d.ts

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

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

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenSwitch: "`switch` statements are not allowed."
+});
+export const noSwitchRule = 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/esm/rules/no-symbol.d.ts

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

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

@@ -0,0 +1,30 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenSymbolType: "`symbol` and `unique symbol` types are not allowed."
+});
+export const noSymbolRule = 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/esm/rules/no-try-catch.d.ts

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

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

@@ -0,0 +1,27 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenTryCatch: "`try ... catch` is not allowed."
+});
+export const noTryCatchRule = 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/esm/rules/no-ts-comment-directive.d.ts

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

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

@@ -0,0 +1,36 @@
+import { createRule } from "../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));
+export const noTsCommentDirectiveRule = 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"
+                });
+            });
+        }
+    })
+});