@arabasta/eslint-plugin-tsoa/dist/rules/require-jsdoc-example-for-enum-property-type.js

ESLint plugin for tsoa rules

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("@typescript-eslint/utils");
const utils_2 = require("../utils");
exports.default = (0, utils_2.createRule)({
    name: 'require-jsdoc-example-for-enum-property-type',
    meta: {
        messages: {
            exampleIsMissing: "Missing JSDoc '@example' declaration",
            exampleDescriptionIsMissing: "Missing JSDoc '@example' description",
            exampleValueIsNotValid: "JSDoc '@example' contains invalid enum value",
        },
        type: 'problem',
        docs: {
            description: "require JSDoc's `@example` declaration for enum properties",
            recommended: true,
            requiresTypeChecking: true,
        },
        schema: [],
    },
    defaultOptions: [],
    create: (context) => {
        const services = utils_1.ESLintUtils.getParserServices(context);
        const sourceCode = context.sourceCode || context.getSourceCode();
        return {
            TSPropertySignature(node) {
                if (!node.typeAnnotation ||
                    node.typeAnnotation.typeAnnotation.type !== 'TSTypeReference') {
                    return;
                }
                const propertyType = services.getTypeAtLocation(node);
                const { jsdoc } = (0, utils_2.parseJSDoc)(sourceCode, node);
                if (!jsdoc) {
                    return;
                }
                const targetTagName = 'example';
                const propertyExamples = jsdoc.tags.filter(({ tag }) => {
                    return tag === targetTagName;
                });
                if (!(0, utils_2.isTypeEnum)(propertyType)) {
                    return;
                }
                if (propertyExamples.length === 0) {
                    context.report({
                        node,
                        messageId: 'exampleIsMissing',
                    });
                    return;
                }
                const enumValues = propertyType.symbol.exports;
                for (const example of propertyExamples) {
                    const description = example.description.trim();
                    if (description.length === 0) {
                        context.report({
                            node,
                            messageId: 'exampleDescriptionIsMissing',
                        });
                        continue;
                    }
                    if (!description.startsWith('"') || !description.endsWith('"')) {
                        continue;
                    }
                    const exampleEnumValue = description.substring(1, description.length - 1);
                    if (enumValues && !enumValues.has(exampleEnumValue)) {
                        context.report({
                            node,
                            messageId: 'exampleValueIsNotValid',
                        });
                    }
                }
            },
        };
    },
});