@less-unsound/eslint-plugin 0.0.1

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireReadonlyTupleRule = void 0;
+const create_rule_js_1 = require("../utils/create-rule.js");
+const readonly_js_1 = require("../utils/readonly.js");
+const messageIds = Object.freeze({
+    missingReadonlyTuple: "Tuple types must use `readonly [...]`."
+});
+exports.requireReadonlyTupleRule = (0, create_rule_js_1.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 ((0, readonly_js_1.isReadonlyType)(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingReadonlyTuple",
+                fix: (fixer) => fixer.insertTextBefore(node, "readonly ")
+            });
+        }
+    })
+});

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

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireReturnTypeRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const utils_2 = require("@typescript-eslint/utils");
+const typescript_1 = __importDefault(require("typescript"));
+const create_rule_js_1 = require("../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, typescript_1.default.SignatureKind.Call).length > 0 ||
+        checker.getSignaturesOfType(constrainedType, typescript_1.default.SignatureKind.Construct).length > 0);
+};
+const hasNamedBinding = (node) => {
+    if (node.type === utils_2.AST_NODE_TYPES.FunctionDeclaration) {
+        return node.id !== null;
+    }
+    if (node.type === utils_2.AST_NODE_TYPES.TSDeclareFunction) {
+        return node.id !== null;
+    }
+    const parent = node.parent;
+    return parent !== undefined
+        && parent.type === utils_2.AST_NODE_TYPES.VariableDeclarator
+        && parent.id.type === utils_2.AST_NODE_TYPES.Identifier;
+};
+exports.requireReturnTypeRule = (0, create_rule_js_1.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 = utils_1.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/cjs/rules/require-string-template-expression.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireStringTemplateExpressionRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../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";
+};
+exports.requireStringTemplateExpressionRule = (0, create_rule_js_1.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 = utils_1.ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            TemplateLiteral: (node) => {
+                if (node.parent.type === utils_1.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/cjs/utils/create-rule.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const buildRuleUrl = (name) => "docs/rules/" + name + ".md";
+exports.createRule = utils_1.ESLintUtils.RuleCreator(buildRuleUrl);

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExplicitPackageEntrypoint = exports.findNearestPackageJsonPath = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("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 = (0, node_path_1.dirname)(packageJsonPath);
+    const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+    const entrypoints = new Set(getExplicitEntrypointValues(packageJson).map((value) => (0, node_path_1.resolve)(packageDir, value)));
+    packageEntrypointsCache.set(packageJsonPath, entrypoints);
+    return entrypoints;
+};
+const findNearestPackageJsonPath = (filename) => {
+    if (filename === "<input>" || filename === "<text>") {
+        return undefined;
+    }
+    let currentDir = (0, node_path_1.dirname)(filename);
+    const filesystemRoot = (0, node_path_1.parse)(currentDir).root;
+    while (true) {
+        const packageJsonPath = (0, node_path_1.resolve)(currentDir, "package.json");
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        if (currentDir === filesystemRoot) {
+            return undefined;
+        }
+        currentDir = (0, node_path_1.dirname)(currentDir);
+    }
+};
+exports.findNearestPackageJsonPath = findNearestPackageJsonPath;
+const isExplicitPackageEntrypoint = (filename) => {
+    const packageJsonPath = (0, exports.findNearestPackageJsonPath)(filename);
+    if (packageJsonPath === undefined) {
+        return false;
+    }
+    return readPackageEntrypoints(packageJsonPath).has((0, node_path_1.resolve)(filename));
+};
+exports.isExplicitPackageEntrypoint = isExplicitPackageEntrypoint;

package/dist/cjs/utils/readonly.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReadonlyType = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const isReadonlyType = (node) => {
+    const parent = node.parent;
+    if (parent === undefined) {
+        return false;
+    }
+    if (parent.type !== utils_1.AST_NODE_TYPES.TSTypeOperator) {
+        return false;
+    }
+    if (parent.operator !== "readonly") {
+        return false;
+    }
+    return parent.typeAnnotation === node;
+};
+exports.isReadonlyType = isReadonlyType;

package/dist/cjs/utils/string-case.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPascalCase = exports.isCamelCase = exports.isKebabCase = void 0;
+const kebabCasePattern = /^[a-z0-9][a-z0-9.-]*$/u;
+const camelCasePattern = /^[a-z][A-Za-z0-9]*$/u;
+const pascalCasePattern = /^[A-Z][A-Za-z0-9]*$/u;
+const isKebabCase = (value) => value === "" || kebabCasePattern.test(value);
+exports.isKebabCase = isKebabCase;
+const isCamelCase = (value) => camelCasePattern.test(value);
+exports.isCamelCase = isCamelCase;
+const isPascalCase = (value) => pascalCasePattern.test(value);
+exports.isPascalCase = isPascalCase;

package/dist/cjs/utils/type-reference.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsTypeReference = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const isIdentifierTypeName = (typeName, name) => {
+    if (typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return typeName.name === name;
+};
+const containsTypeReferenceValue = (value, name, seen) => {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const objectValue = value;
+    if (seen.has(objectValue)) {
+        return false;
+    }
+    seen.add(objectValue);
+    const typedValue = value;
+    if (typedValue.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        const node = value;
+        if (isIdentifierTypeName(node.typeName, name)) {
+            return true;
+        }
+    }
+    return Object.entries(value).some(([key, child]) => {
+        if (key === "parent") {
+            return false;
+        }
+        return containsTypeReferenceValue(child, name, seen);
+    });
+};
+const containsTypeReference = (node, name) => containsTypeReferenceValue(node, name, new WeakSet());
+exports.containsTypeReference = containsTypeReference;