@less-unsound/eslint-plugin 0.0.1

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noGlobalContextRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === 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;
+        }
+        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) => {
+    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;
+};
+exports.noGlobalContextRule = (0, create_rule_js_1.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/cjs/rules/no-import-code-extension.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noImportCodeExtensionRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === utils_1.AST_NODE_TYPES.Literal) {
+        return typeof node.value === "string" ? node.value : undefined;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        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
+        }
+    });
+};
+exports.noImportCodeExtensionRule = (0, create_rule_js_1.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/cjs/rules/no-import-rename.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noImportRenameRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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 === 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;
+};
+exports.noImportRenameRule = (0, create_rule_js_1.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/cjs/rules/no-import-type.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noImportTypeRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenImportType: "`import()` types are not allowed. Put type imports in the file header instead."
+});
+exports.noImportTypeRule = (0, create_rule_js_1.createRule)({
+    name: "no-import-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `import()` types."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSImportType: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenImportType"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-in-operator.js

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

package/dist/cjs/rules/no-indexed-access-type.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noIndexedAccessTypeRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const messageIds = Object.freeze({
+    forbiddenIndexedAccessType: "Indexed access types are not allowed."
+});
+exports.noIndexedAccessTypeRule = (0, create_rule_js_1.createRule)({
+    name: "no-indexed-access-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow indexed access types such as Foo[\"bar\"]."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSIndexedAccessType: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenIndexedAccessType"
+            });
+        }
+    })
+});

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noIndexedObjectTypeRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const type_reference_js_1 = require("../utils/type-reference.js");
+const messageIds = Object.freeze({
+    forbiddenIndexedObjectType: "Indexed object types are not allowed."
+});
+const getContainingTypeName = (node) => {
+    let current = node.parent;
+    while (current !== undefined) {
+        if (current.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+            return current.id.name;
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+const isAllowedRecursiveIndexSignature = (node) => {
+    if (node.typeAnnotation === undefined) {
+        return false;
+    }
+    const typeName = getContainingTypeName(node);
+    if (typeName === undefined) {
+        return false;
+    }
+    return (0, type_reference_js_1.containsTypeReference)(node.typeAnnotation.typeAnnotation, typeName);
+};
+exports.noIndexedObjectTypeRule = (0, create_rule_js_1.createRule)({
+    name: "no-indexed-object-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow indexed object types such as `{ [key: string]: T }`, except for explicit self-recursive cases."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSIndexSignature: (node) => {
+            if (isAllowedRecursiveIndexSignature(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenIndexedObjectType"
+            });
+        }
+    })
+});

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noInheritanceRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const type_reference_js_1 = require("../utils/type-reference.js");
+const messageIds = Object.freeze({
+    forbiddenInheritance: "Inheritance is not allowed."
+});
+const isAllowedRecursiveInterface = (node) => {
+    if (node.extends.length !== 1) {
+        return false;
+    }
+    if (node.body.body.length !== 0) {
+        return false;
+    }
+    const heritage = node.extends[0];
+    if (heritage.typeArguments === undefined) {
+        return false;
+    }
+    return heritage.typeArguments.params.some((parameter) => (0, type_reference_js_1.containsTypeReference)(parameter, node.id.name));
+};
+exports.noInheritanceRule = (0, create_rule_js_1.createRule)({
+    name: "no-inheritance",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `extends` on classes and interfaces, except for the documented recursive-interface workaround."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ClassDeclaration: (node) => {
+            if (node.superClass === null) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenInheritance"
+            });
+        },
+        ClassExpression: (node) => {
+            if (node.superClass === null) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenInheritance"
+            });
+        },
+        TSInterfaceDeclaration: (node) => {
+            if (node.extends.length === 0) {
+                return;
+            }
+            if (isAllowedRecursiveInterface(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenInheritance"
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-inline-tagged-object.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noInlineTaggedObjectRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const defaultTagName = "$";
+const messageIds = Object.freeze({
+    useConstructor: "Do not create tagged objects by supplying `{{tagName}}` directly. Use `{{constructorName}}()` instead.",
+    useConstructorGeneric: "Do not create tagged objects by supplying `{{tagName}}` directly. Use a constructor instead."
+});
+const getPropertyName = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type !== utils_1.AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    return typeof node.value === "string" ? node.value : undefined;
+};
+const buildConstructorName = (tagValue) => {
+    const parts = tagValue.match(/[A-Za-z0-9]+/g);
+    if (parts === null || parts.length === 0) {
+        return undefined;
+    }
+    const name = parts
+        .map((part) => part[0] === undefined
+        ? ""
+        : part[0].toUpperCase() + part.slice(1))
+        .join("");
+    return /^[A-Z][A-Za-z0-9]*$/u.test(name) ? name : undefined;
+};
+const getTaggedProperty = (node, tagName) => node.properties.find((property) => property.type === utils_1.AST_NODE_TYPES.Property &&
+    property.kind === "init" &&
+    property.computed === false &&
+    getPropertyName(property.key) === tagName);
+exports.noInlineTaggedObjectRule = (0, create_rule_js_1.createRule)({
+    name: "no-inline-tagged-object",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Ban creating tagged objects by supplying the configured tag field directly."
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    tagName: {
+                        type: "string"
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        messages: messageIds
+    },
+    defaultOptions: [{ tagName: defaultTagName }],
+    create: (context, [{ tagName }]) => ({
+        ObjectExpression: (node) => {
+            const property = getTaggedProperty(node, tagName);
+            if (property === undefined) {
+                return;
+            }
+            if (property.value.type !== utils_1.AST_NODE_TYPES.Literal ||
+                typeof property.value.value !== "string") {
+                context.report({
+                    node: property,
+                    messageId: "useConstructorGeneric",
+                    data: {
+                        tagName
+                    }
+                });
+                return;
+            }
+            const constructorName = buildConstructorName(property.value.value);
+            if (constructorName === undefined) {
+                context.report({
+                    node: property,
+                    messageId: "useConstructorGeneric",
+                    data: {
+                        tagName
+                    }
+                });
+                return;
+            }
+            context.report({
+                node: property,
+                messageId: "useConstructor",
+                data: {
+                    constructorName,
+                    tagName
+                }
+            });
+        }
+    })
+});

package/dist/cjs/rules/no-intersection-type.js

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