@vkontakte/api-schema-typescript-generator/dist/generators/enums.js

VK API TypeScript generator

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateInlineEnum = exports.generateEnumAsUnionType = exports.generateEnumConstantObject = exports.getEnumNamesIdentifier = exports.isNumericEnum = void 0;
const constants_1 = require("../constants");
const helpers_1 = require("../helpers");
const utils_1 = require("../utils");
const TypeCodeBlock_1 = require("./TypeCodeBlock");
function isNumericEnum(object) {
    return object.enum.some((value) => !!+value);
}
exports.isNumericEnum = isNumericEnum;
function getEnumNamesIdentifier(name) {
    if (!name) {
        throw new Error('[getEnumNamesIdentifier] empty name');
    }
    return `${name} enumNames`.trim();
}
exports.getEnumNamesIdentifier = getEnumNamesIdentifier;
function generateEnumConstantObject(object, objectName, enumNames) {
    const enumInterfaceName = (0, helpers_1.getInterfaceName)(objectName);
    const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
        type: TypeCodeBlock_1.TypeScriptCodeTypes.ConstantObject,
        refName: objectName,
        interfaceName: enumInterfaceName,
        needExport: true,
        properties: [],
    });
    enumNames.forEach((name, index) => {
        codeBlock.addProperty({
            name: (0, helpers_1.getEnumPropertyName)(name.toString()),
            value: object.enum[index],
            wrapValue: true,
        });
    });
    return codeBlock;
}
exports.generateEnumConstantObject = generateEnumConstantObject;
/**
 * Generates enum as union type with constant object if necessary
 */
function generateEnumAsUnionType(object) {
    const { codeBlocks, value, description } = generateInlineEnum(object, {
        refName: getEnumNamesIdentifier(object.name),
    });
    const unionType = new TypeCodeBlock_1.TypeCodeBlock({
        type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
        refName: object.name,
        interfaceName: (0, helpers_1.getInterfaceName)(object.name),
        description: [object.description, description].join(constants_1.newLineChar),
        needExport: true,
        properties: [],
        value,
    });
    codeBlocks.push(unionType);
    return {
        codeBlocks,
        imports: {},
        value: '',
    };
}
exports.generateEnumAsUnionType = generateEnumAsUnionType;
function getEnumNames(object) {
    let { enumNames } = object;
    const isNumeric = isNumericEnum(object);
    const needEnumNamesDescription = !!enumNames;
    if (!enumNames) {
        const canUseEnumNames = !isNumeric;
        if (canUseEnumNames) {
            enumNames = [...object.enum];
        }
    }
    return {
        isNumericEnum: isNumeric,
        needEnumNamesDescription,
        enumNames: Array.isArray(enumNames) && enumNames.length ? enumNames : undefined,
    };
}
function generateInlineEnum(object, options = {}) {
    const { isNumericEnum, enumNames, needEnumNamesDescription } = getEnumNames(object);
    options = {
        needEnumNamesConstant: isNumericEnum,
        ...options,
    };
    const codeBlocks = [];
    let descriptionLines = [];
    if (enumNames) {
        if (needEnumNamesDescription) {
            if (isNumericEnum && options.refName) {
                descriptionLines.push('');
                descriptionLines.push('@note This enum have auto-generated constant with keys and values');
                descriptionLines.push(`@see ${(0, helpers_1.getInterfaceName)(options.refName)}`);
            }
            descriptionLines.push('');
            enumNames.forEach((name, index) => {
                const value = object.enum[index];
                if (needEnumNamesDescription) {
                    descriptionLines.push(`\`${value}\` — ${name}`);
                }
            });
        }
        if (isNumericEnum && options.needEnumNamesConstant) {
            const enumName = getEnumNamesIdentifier(`${options.objectParentName || ''} ${object.name}`);
            const codeBlock = generateEnumConstantObject(object, enumName, enumNames);
            codeBlocks.push(codeBlock);
        }
    }
    const values = object.enum.map((value) => (0, utils_1.quoteJavaScriptValue)(value));
    return {
        codeBlocks,
        imports: {},
        value: (0, helpers_1.joinOneOfValues)(values, true),
        description: descriptionLines.join(constants_1.newLineChar),
    };
}
exports.generateInlineEnum = generateInlineEnum;