@less-unsound/eslint-plugin 0.0.1

package/dist/cjs/rules/no-json-static-method.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noJsonStaticMethodRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenJsonStaticMethod: "`JSON.parse` and `JSON.stringify` 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;
+};
+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;
+    }
+    const scope = context.sourceCode.getScope(node);
+    return hasDeclaredBinding(scope, node.name) === false;
+};
+const getPropertyName = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+        return node.value;
+    }
+    return undefined;
+};
+const isStaticJsonNamespace = (context, node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        return isStaticJsonNamespace(context, node.expression);
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        if (node.name !== "JSON") {
+            return false;
+        }
+        return isGlobalReference(context, node);
+    }
+    if (node.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const propertyName = getPropertyName(node.property);
+    if (propertyName !== "JSON") {
+        return false;
+    }
+    if (node.object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (!isGlobalReference(context, node.object)) {
+        return false;
+    }
+    return node.object.name === "globalThis" || node.object.name === "window";
+};
+const isForbiddenMethod = (node) => {
+    const propertyName = getPropertyName(node.property);
+    return propertyName === "parse" || propertyName === "stringify";
+};
+exports.noJsonStaticMethodRule = (0, create_rule_js_1.createRule)({
+    name: "no-json-static-method",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `JSON.parse` and `JSON.stringify`, including access through `globalThis.JSON` and `window.JSON`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        MemberExpression: (node) => {
+            if (!isForbiddenMethod(node)) {
+                return;
+            }
+            if (!isStaticJsonNamespace(context, node.object)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenJsonStaticMethod"
+            });
+        }
+    })
+});

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

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noLetRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenLet: "`let` is not allowed."
+});
+const isForLoopDeclaration = (parent) => {
+    if (parent === undefined) {
+        return false;
+    }
+    if (parent.type === "ForStatement") {
+        return parent.init !== null && parent.init.type === "VariableDeclaration";
+    }
+    if (parent.type === "ForInStatement" || parent.type === "ForOfStatement") {
+        return parent.left.type === "VariableDeclaration";
+    }
+    return false;
+};
+exports.noLetRule = (0, create_rule_js_1.createRule)({
+    name: "no-let",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `let` declarations unless mutability is required for performance."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        VariableDeclaration: (node) => {
+            if (node.kind !== "let") {
+                return;
+            }
+            if (isForLoopDeclaration(node.parent)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenLet"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-mapped-object-type.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMappedObjectTypeRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenMappedObjectType: "Mapped object types are not allowed."
+});
+exports.noMappedObjectTypeRule = (0, create_rule_js_1.createRule)({
+    name: "no-mapped-object-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow mapped object types."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSMappedType: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenMappedObjectType"
+            });
+        }
+    })
+});

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

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

package/dist/cjs/rules/no-non-null-assertion.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noNonNullAssertionRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenNonNullAssertion: "Non-null assertions are not allowed."
+});
+exports.noNonNullAssertionRule = (0, create_rule_js_1.createRule)({
+    name: "no-non-null-assertion",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow non-null assertions."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSNonNullExpression: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenNonNullAssertion"
+            });
+        }
+    })
+});

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noNullRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenNull: "`null` is not allowed."
+});
+exports.noNullRule = (0, create_rule_js_1.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/cjs/rules/no-object-as-map.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noObjectAsMapRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === utils_1.AST_NODE_TYPES.TSAsExpression) {
+        return unwrapExpression(node.expression);
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression) {
+        return unwrapExpression(node.expression);
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+        return unwrapExpression(node.expression);
+    }
+    return node;
+};
+const isNullLiteral = (node) => node.type === utils_1.AST_NODE_TYPES.Literal && node.value === null;
+const isObjectCreateNullCall = (node) => {
+    if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    if (node.callee.computed) {
+        return false;
+    }
+    if (node.callee.object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (node.callee.object.name !== "Object") {
+        return false;
+    }
+    if (node.callee.property.type !== utils_1.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 === utils_1.AST_NODE_TYPES.SpreadElement) {
+        return false;
+    }
+    return isNullLiteral(argument);
+};
+const isPlainObjectExpression = (node) => {
+    const expression = unwrapExpression(node);
+    if (expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+        return true;
+    }
+    if (expression.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    return isObjectCreateNullCall(expression);
+};
+const isDynamicKey = (node) => {
+    if (!node.computed) {
+        return false;
+    }
+    return node.property.type !== utils_1.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;
+};
+exports.noObjectAsMapRule = (0, create_rule_js_1.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 !== utils_1.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 === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                context.report({
+                    node,
+                    messageId: "forbiddenObjectAsMap"
+                });
+                return;
+            }
+            if (object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!isPlainObjectVariable(context, node, object.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenObjectAsMap"
+            });
+        }
+    })
+});

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noObjectSpreadRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenObjectSpread: "Object spread is not allowed."
+});
+exports.noObjectSpreadRule = (0, create_rule_js_1.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/cjs/rules/no-object-stringification-hook.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noObjectStringificationHookRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+        return node.value;
+    }
+    if (node.type === utils_1.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 === utils_1.AST_NODE_TYPES.AssignmentExpression) {
+        return parent.left === node;
+    }
+    return false;
+};
+exports.noObjectStringificationHookRule = (0, create_rule_js_1.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 !== utils_1.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 !== utils_1.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);
+            }
+        };
+    }
+});