@less-unsound/eslint-plugin 0.0.1

package/dist/esm/rules/require-identifier-case.js

@@ -0,0 +1,194 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+import { isCamelCase, isPascalCase } from "../utils/string-case.js";
+const messageIds = Object.freeze({
+    invalidIdentifierCase: "Identifiers must be in camelCase, PascalCase, `_camelCase`, or `$` followed by up to 2 letters. `{{name}}` is not allowed."
+});
+const isShortDollarName = (name) => /^\$[A-Za-z]{0,2}$/u.test(name);
+const isUnderscoreCamelCase = (name) => name.startsWith("_") && isCamelCase(name.slice(1));
+const isAllowedName = (name) => isCamelCase(name) ||
+    isPascalCase(name) ||
+    isUnderscoreCamelCase(name) ||
+    isShortDollarName(name);
+const reportIfNeeded = (context, node, name) => {
+    if (isAllowedName(name)) {
+        return;
+    }
+    context.report({
+        node,
+        messageId: "invalidIdentifierCase",
+        data: {
+            name
+        }
+    });
+};
+const reportNameNode = (context, node) => reportIfNeeded(context, node, node.name);
+const reportPattern = (context, node) => {
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        reportNameNode(context, node);
+        return;
+    }
+    if (node.type === AST_NODE_TYPES.RestElement) {
+        reportPattern(context, node.argument);
+        return;
+    }
+    if (node.type === AST_NODE_TYPES.AssignmentPattern) {
+        reportPattern(context, node.left);
+        return;
+    }
+    if (node.type === AST_NODE_TYPES.ArrayPattern) {
+        for (const element of node.elements) {
+            if (element === null) {
+                continue;
+            }
+            reportPattern(context, element);
+        }
+        return;
+    }
+    if (node.type !== AST_NODE_TYPES.ObjectPattern) {
+        return;
+    }
+    for (const property of node.properties) {
+        if (property.type === AST_NODE_TYPES.RestElement) {
+            reportPattern(context, property.argument);
+            continue;
+        }
+        reportPattern(context, property.value);
+    }
+};
+const reportPropertyKey = (context, node) => {
+    if (node.type !== AST_NODE_TYPES.Identifier &&
+        node.type !== AST_NODE_TYPES.PrivateIdentifier) {
+        return;
+    }
+    reportNameNode(context, node);
+};
+export const requireIdentifierCaseRule = createRule({
+    name: "require-identifier-case",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require identifiers to use camelCase, PascalCase, `_camelCase`, or short `$` names."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ArrowFunctionExpression: (node) => {
+            for (const param of node.params) {
+                reportPattern(context, param);
+            }
+        },
+        CatchClause: (node) => {
+            if (node.param === null) {
+                return;
+            }
+            reportPattern(context, node.param);
+        },
+        ClassDeclaration: (node) => {
+            if (node.id !== null) {
+                reportNameNode(context, node.id);
+            }
+        },
+        ClassExpression: (node) => {
+            if (node.id !== null) {
+                reportNameNode(context, node.id);
+            }
+        },
+        FunctionDeclaration: (node) => {
+            if (node.id !== null) {
+                reportNameNode(context, node.id);
+            }
+            for (const param of node.params) {
+                reportPattern(context, param);
+            }
+        },
+        FunctionExpression: (node) => {
+            if (node.id !== null) {
+                reportNameNode(context, node.id);
+            }
+            for (const param of node.params) {
+                reportPattern(context, param);
+            }
+        },
+        ImportDefaultSpecifier: (node) => {
+            reportNameNode(context, node.local);
+        },
+        ImportNamespaceSpecifier: (node) => {
+            reportNameNode(context, node.local);
+        },
+        ImportSpecifier: (node) => {
+            reportNameNode(context, node.local);
+        },
+        MethodDefinition: (node) => {
+            if (node.computed) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        Property: (node) => {
+            if (node.parent.type !== AST_NODE_TYPES.ObjectExpression) {
+                return;
+            }
+            if (node.computed || node.shorthand) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        PropertyDefinition: (node) => {
+            if (node.computed) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        TSEnumDeclaration: (node) => {
+            reportNameNode(context, node.id);
+        },
+        TSEnumMember: (node) => {
+            if (node.id.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            reportNameNode(context, node.id);
+        },
+        TSInterfaceDeclaration: (node) => {
+            reportNameNode(context, node.id);
+        },
+        TSMethodSignature: (node) => {
+            if (node.computed) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        TSModuleDeclaration: (node) => {
+            if (node.id.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            reportNameNode(context, node.id);
+        },
+        TSParameterProperty: (node) => {
+            if (node.parameter.type === AST_NODE_TYPES.Identifier) {
+                reportNameNode(context, node.parameter);
+                return;
+            }
+            if (node.parameter.type === AST_NODE_TYPES.AssignmentPattern) {
+                reportPattern(context, node.parameter);
+            }
+        },
+        TSPropertySignature: (node) => {
+            if (node.computed) {
+                return;
+            }
+            reportPropertyKey(context, node.key);
+        },
+        TSTypeAliasDeclaration: (node) => {
+            reportNameNode(context, node.id);
+        },
+        TSTypeParameter: (node) => {
+            reportNameNode(context, node.name);
+        },
+        VariableDeclarator: (node) => {
+            reportPattern(context, node.id);
+        }
+    })
+});

package/dist/esm/rules/require-kebab-case-filename.d.ts

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

package/dist/esm/rules/require-kebab-case-filename.js

@@ -0,0 +1,42 @@
+import { createRule } from "../utils/create-rule.js";
+import { isKebabCase } from "../utils/string-case.js";
+const messageIds = Object.freeze({
+    nonKebabCaseFilename: "Filenames must be in kebab-case. `{{filename}}` is not allowed."
+});
+const getFilename = (context) => context.filename;
+const getBaseFilename = (filename) => {
+    const parts = filename.split(/[/\\]/);
+    return parts.at(-1) ?? filename;
+};
+const isLintVirtualFilename = (filename) => filename.startsWith("<") && filename.endsWith(">");
+export const requireKebabCaseFilenameRule = createRule({
+    name: "require-kebab-case-filename",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require filenames to be in kebab-case."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Program: (node) => {
+            const filename = getFilename(context);
+            if (isLintVirtualFilename(filename)) {
+                return;
+            }
+            const baseFilename = getBaseFilename(filename);
+            if (isKebabCase(baseFilename)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "nonKebabCaseFilename",
+                data: {
+                    filename: baseFilename
+                }
+            });
+        }
+    })
+});

package/dist/esm/rules/require-named-union-branch.d.ts

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

package/dist/esm/rules/require-named-union-branch.js

@@ -0,0 +1,31 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    requireNamedUnionBranch: "Object union branches must be named."
+});
+const isInlineObjectType = (node) => node.type === AST_NODE_TYPES.TSTypeLiteral;
+export const requireNamedUnionBranchRule = createRule({
+    name: "require-named-union-branch",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require every object-shaped union branch to be defined through its own name."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSUnionType: (node) => {
+            for (const branch of node.types) {
+                if (!isInlineObjectType(branch)) {
+                    continue;
+                }
+                context.report({
+                    node: branch,
+                    messageId: "requireNamedUnionBranch"
+                });
+            }
+        }
+    })
+});

package/dist/esm/rules/require-readonly-array.d.ts

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

package/dist/esm/rules/require-readonly-array.js

@@ -0,0 +1,46 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+import { isReadonlyType } from "../utils/readonly.js";
+const messageIds = Object.freeze({
+    missingReadonlyArray: "Array types must use `readonly T[]`."
+});
+const isArrayReference = (node) => {
+    if (node.typeName.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return node.typeName.name === "Array" || node.typeName.name === "ReadonlyArray";
+};
+export const requireReadonlyArrayRule = createRule({
+    name: "require-readonly-array",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require array types to use `readonly T[]` unless mutability is required for performance."
+        },
+        fixable: "code",
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSArrayType: (node) => {
+            if (isReadonlyType(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyArray",
+                fix: (fixer) => fixer.insertTextBefore(node, "readonly ")
+            });
+        },
+        TSTypeReference: (node) => {
+            if (!isArrayReference(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyArray"
+            });
+        }
+    })
+});

package/dist/esm/rules/require-readonly-collections.d.ts

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

package/dist/esm/rules/require-readonly-collections.js

@@ -0,0 +1,34 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    missingReadonlyCollections: "Collection types must use `ReadonlySet` and `ReadonlyMap` unless mutability is required for performance."
+});
+const isMutableCollection = (node) => {
+    if (node.typeName.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return node.typeName.name === "Set" || node.typeName.name === "Map";
+};
+export const requireReadonlyCollectionsRule = createRule({
+    name: "require-readonly-collections",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require `ReadonlySet` and `ReadonlyMap` in types unless mutability is required for performance."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTypeReference: (node) => {
+            if (!isMutableCollection(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyCollections"
+            });
+        }
+    })
+});

package/dist/esm/rules/require-readonly-object-fields.d.ts

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

package/dist/esm/rules/require-readonly-object-fields.js

@@ -0,0 +1,29 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    missingReadonlyObjectField: "Object type fields must be marked `readonly`."
+});
+export const requireReadonlyObjectFieldsRule = createRule({
+    name: "require-readonly-object-fields",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require `readonly` on all object type fields unless mutability is required for performance."
+        },
+        fixable: "code",
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSPropertySignature: (node) => {
+            if (node.readonly) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyObjectField",
+                fix: (fixer) => fixer.insertTextBefore(node, "readonly ")
+            });
+        }
+    })
+});

package/dist/esm/rules/require-readonly-tuple.d.ts

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

package/dist/esm/rules/require-readonly-tuple.js

@@ -0,0 +1,30 @@
+import { createRule } from "../utils/create-rule.js";
+import { isReadonlyType } from "../utils/readonly.js";
+const messageIds = Object.freeze({
+    missingReadonlyTuple: "Tuple types must use `readonly [...]`."
+});
+export const requireReadonlyTupleRule = createRule({
+    name: "require-readonly-tuple",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require tuple types to use `readonly [...]` unless mutability is required for performance."
+        },
+        fixable: "code",
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTupleType: (node) => {
+            if (isReadonlyType(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyTuple",
+                fix: (fixer) => fixer.insertTextBefore(node, "readonly ")
+            });
+        }
+    })
+});

package/dist/esm/rules/require-return-type.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const requireReturnTypeRule: ESLintUtils.RuleModule<"forbiddenHigherOrderReturnType" | "missingReturnType", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/require-return-type.js

@@ -0,0 +1,79 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import ts from "typescript";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenHigherOrderReturnType: "Functions that return functions must not declare an outer return type.",
+    missingReturnType: "Functions must declare a return type unless they return a function."
+});
+const isCallableType = (checker, type) => {
+    const constrainedType = checker.getBaseConstraintOfType(type) ?? type;
+    if (constrainedType.isUnion()) {
+        return constrainedType.types.every((member) => isCallableType(checker, member));
+    }
+    return (checker.getSignaturesOfType(constrainedType, ts.SignatureKind.Call).length > 0 ||
+        checker.getSignaturesOfType(constrainedType, ts.SignatureKind.Construct).length > 0);
+};
+const hasNamedBinding = (node) => {
+    if (node.type === AST_NODE_TYPES.FunctionDeclaration) {
+        return node.id !== null;
+    }
+    if (node.type === AST_NODE_TYPES.TSDeclareFunction) {
+        return node.id !== null;
+    }
+    const parent = node.parent;
+    return parent !== undefined
+        && parent.type === AST_NODE_TYPES.VariableDeclarator
+        && parent.id.type === AST_NODE_TYPES.Identifier;
+};
+export const requireReturnTypeRule = createRule({
+    name: "require-return-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require functions to declare a return type unless they return a function."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        const checkFunction = (node) => {
+            if (!hasNamedBinding(node)) {
+                return;
+            }
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            const signature = checker.getSignatureFromDeclaration(tsNode);
+            if (signature === undefined) {
+                return;
+            }
+            const returnType = checker.getReturnTypeOfSignature(signature);
+            const isHigherOrder = isCallableType(checker, returnType);
+            if (node.returnType === undefined) {
+                if (isHigherOrder) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: "missingReturnType"
+                });
+                return;
+            }
+            if (!isHigherOrder) {
+                return;
+            }
+            context.report({
+                node: node.returnType,
+                messageId: "forbiddenHigherOrderReturnType"
+            });
+        };
+        return {
+            ArrowFunctionExpression: checkFunction,
+            FunctionDeclaration: checkFunction,
+            FunctionExpression: checkFunction,
+            TSDeclareFunction: checkFunction
+        };
+    }
+});

package/dist/esm/rules/require-string-template-expression.d.ts

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

package/dist/esm/rules/require-string-template-expression.js

@@ -0,0 +1,52 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    nonStringTemplateExpression: "Template literal expressions must have string type. Got `{{type}}`."
+});
+const isStringType = (checker, type) => {
+    const constrainedType = checker.getBaseConstraintOfType(type) ?? type;
+    if (constrainedType.isUnion()) {
+        return constrainedType.types.every((member) => isStringType(checker, member));
+    }
+    if (constrainedType.isIntersection()) {
+        return constrainedType.types.some((member) => isStringType(checker, member));
+    }
+    const baseType = checker.getBaseTypeOfLiteralType(constrainedType);
+    return checker.typeToString(baseType) === "string";
+};
+export const requireStringTemplateExpressionRule = createRule({
+    name: "require-string-template-expression",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require untagged template literal interpolations to have `string` type."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            TemplateLiteral: (node) => {
+                if (node.parent.type === AST_NODE_TYPES.TaggedTemplateExpression) {
+                    return;
+                }
+                for (const expression of node.expressions) {
+                    const expressionType = services.getTypeAtLocation(expression);
+                    if (isStringType(checker, expressionType)) {
+                        continue;
+                    }
+                    context.report({
+                        node: expression,
+                        messageId: "nonStringTemplateExpression",
+                        data: {
+                            type: checker.typeToString(expressionType)
+                        }
+                    });
+                }
+            }
+        };
+    }
+});

package/dist/esm/utils/create-rule.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/esm/utils/create-rule.js

@@ -0,0 +1,3 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+const buildRuleUrl = (name) => "docs/rules/" + name + ".md";
+export const createRule = ESLintUtils.RuleCreator(buildRuleUrl);

package/dist/esm/utils/package-entrypoint.d.ts

@@ -0,0 +1,2 @@
+export declare const findNearestPackageJsonPath: (filename: string) => string | undefined;
+export declare const isExplicitPackageEntrypoint: (filename: string) => boolean;

package/dist/esm/utils/package-entrypoint.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, parse, resolve } from "node:path";
+const packageEntrypointsCache = new Map();
+const isJsonObject = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const collectStringValues = (value) => {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap(collectStringValues);
+    }
+    if (!isJsonObject(value)) {
+        return [];
+    }
+    return Object.values(value).flatMap(collectStringValues);
+};
+const getExplicitEntrypointValues = (packageJson) => {
+    return [
+        ...collectStringValues(packageJson.bin ?? []),
+        ...collectStringValues(packageJson.browser ?? []),
+        ...collectStringValues(packageJson.exports ?? []),
+        ...collectStringValues(packageJson.main ?? []),
+        ...collectStringValues(packageJson.module ?? []),
+        ...collectStringValues(packageJson.types ?? []),
+        ...collectStringValues(packageJson.typings ?? [])
+    ];
+};
+const readPackageEntrypoints = (packageJsonPath) => {
+    const cached = packageEntrypointsCache.get(packageJsonPath);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const packageDir = dirname(packageJsonPath);
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const entrypoints = new Set(getExplicitEntrypointValues(packageJson).map((value) => resolve(packageDir, value)));
+    packageEntrypointsCache.set(packageJsonPath, entrypoints);
+    return entrypoints;
+};
+export const findNearestPackageJsonPath = (filename) => {
+    if (filename === "<input>" || filename === "<text>") {
+        return undefined;
+    }
+    let currentDir = dirname(filename);
+    const filesystemRoot = parse(currentDir).root;
+    while (true) {
+        const packageJsonPath = resolve(currentDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        if (currentDir === filesystemRoot) {
+            return undefined;
+        }
+        currentDir = dirname(currentDir);
+    }
+};
+export const isExplicitPackageEntrypoint = (filename) => {
+    const packageJsonPath = findNearestPackageJsonPath(filename);
+    if (packageJsonPath === undefined) {
+        return false;
+    }
+    return readPackageEntrypoints(packageJsonPath).has(resolve(filename));
+};

package/dist/esm/utils/readonly.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from "@typescript-eslint/utils";
+export declare const isReadonlyType: (node: TSESTree.TypeNode) => boolean;