@less-unsound/eslint-plugin 0.0.1

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

@@ -0,0 +1,33 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenNull: "`null` is not allowed."
+});
+export const noNullRule = createRule({
+    name: "no-null",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow both runtime `null` literals and the `null` type."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Literal: (node) => {
+            if (node.value !== null) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenNull"
+            });
+        },
+        TSNullKeyword: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenNull"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-object-as-map.d.ts

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

package/dist/esm/rules/no-object-as-map.js

@@ -0,0 +1,135 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenObjectAsMap: "Plain objects are not allowed as dynamic maps."
+});
+const scopeObjects = new WeakMap();
+const getScopeNames = (scope) => {
+    const names = scopeObjects.get(scope);
+    if (names !== undefined) {
+        return names;
+    }
+    const created = new Map();
+    scopeObjects.set(scope, created);
+    return created;
+};
+const unwrapExpression = (node) => {
+    if (node.type === AST_NODE_TYPES.TSAsExpression) {
+        return unwrapExpression(node.expression);
+    }
+    if (node.type === AST_NODE_TYPES.TSSatisfiesExpression) {
+        return unwrapExpression(node.expression);
+    }
+    if (node.type === AST_NODE_TYPES.TSNonNullExpression) {
+        return unwrapExpression(node.expression);
+    }
+    return node;
+};
+const isNullLiteral = (node) => node.type === AST_NODE_TYPES.Literal && node.value === null;
+const isObjectCreateNullCall = (node) => {
+    if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    if (node.callee.computed) {
+        return false;
+    }
+    if (node.callee.object.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (node.callee.object.name !== "Object") {
+        return false;
+    }
+    if (node.callee.property.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (node.callee.property.name !== "create") {
+        return false;
+    }
+    if (node.arguments.length !== 1) {
+        return false;
+    }
+    const [argument] = node.arguments;
+    if (argument === undefined || argument.type === AST_NODE_TYPES.SpreadElement) {
+        return false;
+    }
+    return isNullLiteral(argument);
+};
+const isPlainObjectExpression = (node) => {
+    const expression = unwrapExpression(node);
+    if (expression.type === AST_NODE_TYPES.ObjectExpression) {
+        return true;
+    }
+    if (expression.type !== AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    return isObjectCreateNullCall(expression);
+};
+const isDynamicKey = (node) => {
+    if (!node.computed) {
+        return false;
+    }
+    return node.property.type !== AST_NODE_TYPES.Literal;
+};
+const markDeclaredVariable = (context, node, name, isPlainObject) => {
+    const scope = context.sourceCode.getScope(node);
+    const names = getScopeNames(scope);
+    const current = names.get(name) ?? false;
+    names.set(name, current || isPlainObject);
+};
+const isPlainObjectVariable = (context, node, name) => {
+    let scope = context.sourceCode.getScope(node);
+    while (scope !== null) {
+        const names = scopeObjects.get(scope);
+        if (names !== undefined && names.has(name)) {
+            return names.get(name) ?? false;
+        }
+        scope = scope.upper;
+    }
+    return false;
+};
+export const noObjectAsMapRule = createRule({
+    name: "no-object-as-map",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow using plain objects as dynamic maps."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        VariableDeclarator: (node) => {
+            if (node.id.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            const isPlainObject = node.init !== undefined &&
+                node.init !== null &&
+                isPlainObjectExpression(node.init);
+            markDeclaredVariable(context, node, node.id.name, isPlainObject);
+        },
+        MemberExpression: (node) => {
+            if (!isDynamicKey(node)) {
+                return;
+            }
+            const object = unwrapExpression(node.object);
+            if (object.type === AST_NODE_TYPES.ObjectExpression) {
+                context.report({
+                    node,
+                    messageId: "forbiddenObjectAsMap"
+                });
+                return;
+            }
+            if (object.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!isPlainObjectVariable(context, node, object.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenObjectAsMap"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-object-spread.d.ts

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

package/dist/esm/rules/no-object-spread.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenObjectSpread: "Object spread is not allowed."
+});
+export const noObjectSpreadRule = createRule({
+    name: "no-object-spread",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow object spread in object literals."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        "ObjectExpression > SpreadElement": (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenObjectSpread"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-object-stringification-hook.d.ts

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

package/dist/esm/rules/no-object-stringification-hook.js

@@ -0,0 +1,98 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const forbiddenNames = new Set(["toJSON", "toString"]);
+const messageIds = Object.freeze({
+    forbiddenObjectStringificationHook: "Runtime `.toString` and `.toJSON` are not allowed."
+});
+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;
+    }
+    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 isWriteTarget = (node) => {
+    const parent = node.parent;
+    if (parent === null) {
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.AssignmentExpression) {
+        return parent.left === node;
+    }
+    return false;
+};
+export const noObjectStringificationHookRule = createRule({
+    name: "no-object-stringification-hook",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow runtime `toString` and `toJSON` hooks on objects and classes."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const report = (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenObjectStringificationHook"
+            });
+        };
+        return {
+            AssignmentExpression: (node) => {
+                if (node.left.type !== AST_NODE_TYPES.MemberExpression) {
+                    return;
+                }
+                const name = getPropertyName(node.left.property);
+                if (name === undefined || !forbiddenNames.has(name)) {
+                    return;
+                }
+                report(node.left.property);
+            },
+            MethodDefinition: (node) => {
+                const name = getPropertyName(node.key);
+                if (name === undefined || !forbiddenNames.has(name)) {
+                    return;
+                }
+                report(node.key);
+            },
+            MemberExpression: (node) => {
+                if (isWriteTarget(node)) {
+                    return;
+                }
+                const name = getPropertyName(node.property);
+                if (name === undefined || !forbiddenNames.has(name)) {
+                    return;
+                }
+                report(node.property);
+            },
+            ObjectExpression: (node) => {
+                for (const property of node.properties) {
+                    if (property.type !== AST_NODE_TYPES.Property) {
+                        continue;
+                    }
+                    const name = getPropertyName(property.key);
+                    if (name === undefined || !forbiddenNames.has(name)) {
+                        continue;
+                    }
+                    report(property.key);
+                }
+            },
+            PropertyDefinition: (node) => {
+                const name = getPropertyName(node.key);
+                if (name === undefined || !forbiddenNames.has(name)) {
+                    return;
+                }
+                report(node.key);
+            }
+        };
+    }
+});

package/dist/esm/rules/no-optional-parameter.d.ts

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

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

@@ -0,0 +1,101 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenOptionalParameter: "Optional parameters are not allowed."
+});
+const isOptionalIdentifier = (node) => node.type === AST_NODE_TYPES.Identifier && node.optional;
+const reportOptionalParameters = (report, params) => {
+    params.forEach((param) => {
+        if (!isOptionalIdentifier(param)) {
+            return;
+        }
+        report(param);
+    });
+};
+export const noOptionalParameterRule = 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/esm/rules/no-optional-property.d.ts

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

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

@@ -0,0 +1,27 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenOptionalProperty: "Optional object fields are not allowed."
+});
+export const noOptionalPropertyRule = 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/esm/rules/no-overload.d.ts

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

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

@@ -0,0 +1,107 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../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 !== AST_NODE_TYPES.FunctionDeclaration &&
+            statement.type !== 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 !== 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 === AST_NODE_TYPES.TSMethodSignature) {
+            entries.push({
+                name: getText(sourceText, member.key.range),
+                node: member
+            });
+            return;
+        }
+        if (member.type === AST_NODE_TYPES.TSCallSignatureDeclaration) {
+            entries.push({
+                name: "(call)",
+                node: member
+            });
+            return;
+        }
+        if (member.type === AST_NODE_TYPES.TSConstructSignatureDeclaration) {
+            entries.push({
+                name: "(construct)",
+                node: member
+            });
+        }
+    });
+    return entries;
+};
+export const noOverloadRule = 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/esm/rules/no-param-assign.d.ts

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

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

@@ -0,0 +1,91 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenParamAssign: "Assigning to function parameters is not allowed."
+});
+const getPatternNames = (node) => {
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        return [node.name];
+    }
+    if (node.type === AST_NODE_TYPES.AssignmentPattern) {
+        return getPatternNames(node.left);
+    }
+    if (node.type === AST_NODE_TYPES.RestElement) {
+        return getPatternNames(node.argument);
+    }
+    if (node.type === AST_NODE_TYPES.ArrayPattern) {
+        return node.elements.flatMap((element) => {
+            if (element === null) {
+                return [];
+            }
+            return getPatternNames(element);
+        });
+    }
+    if (node.type === AST_NODE_TYPES.ObjectPattern) {
+        return node.properties.flatMap((property) => {
+            if (property.type === 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 === AST_NODE_TYPES.ArrowFunctionExpression ||
+            parent.type === AST_NODE_TYPES.FunctionDeclaration ||
+            parent.type === 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);
+};
+export const noParamAssignRule = 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 !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!isAssignedParam(node.left)) {
+                return;
+            }
+            context.report({
+                node: node.left,
+                messageId: "forbiddenParamAssign"
+            });
+        },
+        UpdateExpression: (node) => {
+            if (node.argument.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!isAssignedParam(node.argument)) {
+                return;
+            }
+            context.report({
+                node: node.argument,
+                messageId: "forbiddenParamAssign"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-prototype-access.d.ts

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