@less-unsound/eslint-plugin 0.0.1

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

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

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

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

@@ -0,0 +1,30 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenEval: "`eval` is not allowed."
+});
+const isEvalIdentifier = (node) => node.type === AST_NODE_TYPES.Identifier &&
+    node.name === "eval";
+export const noEvalRule = 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/esm/rules/no-export-default.d.ts

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

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

@@ -0,0 +1,42 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenExportDefault: "Default exports are not allowed."
+});
+const isDefaultExportSpecifier = (node) => {
+    return node.exported.type === AST_NODE_TYPES.Identifier && node.exported.name === "default";
+};
+export const noExportDefaultRule = 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 !== AST_NODE_TYPES.ExportSpecifier) {
+                    continue;
+                }
+                if (!isDefaultExportSpecifier(specifier)) {
+                    continue;
+                }
+                context.report({
+                    node: specifier,
+                    messageId: "forbiddenExportDefault"
+                });
+            }
+        }
+    })
+});

package/dist/esm/rules/no-for-in.d.ts

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

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

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenForIn: "`for (... in ...)` is not allowed."
+});
+export const noForInRule = 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/esm/rules/no-for-let.d.ts

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

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

@@ -0,0 +1,36 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenForLet: "`for (let ...)` loops are not allowed."
+});
+export const noForLetRule = 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/esm/rules/no-function-constructor.d.ts

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

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

@@ -0,0 +1,81 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../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 === AST_NODE_TYPES.Identifier) {
+        return node.callee.name === "Function" && isGlobalReference(context, node.callee, "Function");
+    }
+    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 === "Function") {
+        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 === "Function";
+    }
+    if (node.callee.property.type === AST_NODE_TYPES.Literal) {
+        return node.callee.property.value === "Function";
+    }
+    return false;
+};
+export const noFunctionConstructorRule = 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/esm/rules/no-function-keyword.d.ts

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

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

@@ -0,0 +1,45 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenFunctionKeyword: "Non-generator `function` declarations and expressions are not allowed."
+});
+export const noFunctionKeywordRule = 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/esm/rules/no-generic-parameter-bounds.d.ts

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

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

@@ -0,0 +1,31 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenGenericParameterBounds: "Generic parameter bounds with `extends` are not allowed."
+});
+export const noGenericParameterBoundsRule = 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 === AST_NODE_TYPES.TSInferType) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenGenericParameterBounds"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-getter-setter.d.ts

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

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

@@ -0,0 +1,45 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenGetterSetter: "Getters and setters are not allowed."
+});
+export const noGetterSetterRule = 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"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-global-context.d.ts

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

package/dist/esm/rules/no-global-context.js

@@ -0,0 +1,131 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const forbiddenNames = new Set(["global", "globalThis", "self", "window"]);
+const messageIds = Object.freeze({
+    forbiddenGlobalContext: "`this` and explicit global objects 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;
+        }
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.MethodDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.PropertyDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.TSPropertySignature ||
+        parent.type === AST_NODE_TYPES.TSMethodSignature) {
+        return parent.key === node;
+    }
+    if (parent.type === AST_NODE_TYPES.LabeledStatement) {
+        return parent.label === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSQualifiedName) {
+        return parent.left === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSImportEqualsDeclaration) {
+        return parent.id === node;
+    }
+    return false;
+};
+const 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;
+};
+export const noGlobalContextRule = createRule({
+    name: "no-global-context",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `this` and explicit global-object identifiers."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ThisExpression: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenGlobalContext"
+            });
+        },
+        TSThisType: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenGlobalContext"
+            });
+        },
+        Identifier: (node) => {
+            if (!forbiddenNames.has(node.name)) {
+                return;
+            }
+            if (isBindingIdentifier(node)) {
+                return;
+            }
+            if (hasDeclaredBinding(context.sourceCode.getScope(node), node.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenGlobalContext"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-import-code-extension.d.ts

@@ -0,0 +1,4 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare const noImportCodeExtensionRule: TSESLint.RuleModule<"forbiddenImportCodeExtension", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-import-code-extension.js

@@ -0,0 +1,67 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const forbiddenExtensionPattern = /(\.tsx|\.ts|\.js)$/u;
+const messageIds = Object.freeze({
+    forbiddenImportCodeExtension: "Module specifier `{{specifier}}` must not end with `{{extension}}`. Remove the extension."
+});
+const getSpecifier = (node) => {
+    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 &&
+        node.quasis.length === 1) {
+        return node.quasis[0]?.value.cooked ?? undefined;
+    }
+    return undefined;
+};
+const getForbiddenExtension = (specifier) => {
+    return specifier.match(forbiddenExtensionPattern)?.[1];
+};
+const reportIfNeeded = (context, node, source) => {
+    const specifier = getSpecifier(source);
+    if (specifier === undefined) {
+        return;
+    }
+    const extension = getForbiddenExtension(specifier);
+    if (extension === undefined) {
+        return;
+    }
+    context.report({
+        node,
+        messageId: "forbiddenImportCodeExtension",
+        data: {
+            extension,
+            specifier
+        }
+    });
+};
+export const noImportCodeExtensionRule = createRule({
+    name: "no-import-code-extension",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `.ts`, `.tsx`, and `.js` file extensions in import specifiers."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ExportAllDeclaration: (node) => {
+            reportIfNeeded(context, node.source, node.source);
+        },
+        ExportNamedDeclaration: (node) => {
+            if (node.source === null) {
+                return;
+            }
+            reportIfNeeded(context, node.source, node.source);
+        },
+        ImportDeclaration: (node) => {
+            reportIfNeeded(context, node.source, node.source);
+        },
+        ImportExpression: (node) => {
+            reportIfNeeded(context, node.source, node.source);
+        }
+    })
+});

package/dist/esm/rules/no-import-rename.d.ts

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

package/dist/esm/rules/no-import-rename.js

@@ -0,0 +1,42 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenImportRename: "Renamed import `{{importedName}} as {{localName}}` is not allowed. Use the exported name directly or prefer `import * as ...` instead."
+});
+const getImportedName = (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;
+};
+export const noImportRenameRule = createRule({
+    name: "no-import-rename",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow renamed named imports."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ImportSpecifier: (node) => {
+            const importedName = getImportedName(node.imported);
+            if (importedName === undefined || importedName === node.local.name) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenImportRename",
+                data: {
+                    importedName,
+                    localName: node.local.name
+                }
+            });
+        }
+    })
+});

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

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