@zspk/ts-esm-generator/dist/astGenerationHelper.js

Генератор определений типов TypeScript для пользовательских элементов управления UI5, реализованных в TypeScript.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createTypeNode = exports.createMethodSignature = exports.createMethodDeclaration = exports.createConstructorBlock = exports.addLineBreakBefore = exports.generateEventTypeAliases = exports.generateEventParameterInterfaces = exports.generateSettingsInterface = exports.generateEventWithGenericsCompatibilityModule = exports.collectMetadataClass = exports.expandDefaultKey = void 0;
const typescript_1 = __importDefault(require("typescript"));
const astToString_1 = __importDefault(require("./astToString"));
const loglevel_1 = __importDefault(require("loglevel"));
const jsdocGenerator_1 = require("./jsdocGenerator");
const factory = typescript_1.default.factory;
const PropertyBindingInfoType = "sap.ui.base.ManagedObject.PropertyBindingInfo";
const AggregationBindingInfoType = "sap.ui.base.ManagedObject.AggregationBindingInfo";
function createParameterDeclaration(name, type, questionToken) {
    return factory.createParameterDeclaration(undefined, undefined, name, questionToken, type);
}
function generateSettingsInterface(classInfo, managedObject, requiredImports, knownGlobals) {
    if (!managedObject.settingsTypeName)
        return;
    const typeElements = [];
    // properties
    for (const n in classInfo.properties) {
        const property = classInfo.properties[n];
        if (property.visibility === "hidden")
            continue;
        const actualType = createTypeNode(property.type, requiredImports, knownGlobals);
        const bindingType = createTypeNode(PropertyBindingInfoType, requiredImports, knownGlobals);
        const propertyTypes = [actualType, bindingType];
        if (property.type !== "string") {
            propertyTypes.push(createBindingStringTypeNode());
        }
        const propertySignature = factory.createPropertySignature(undefined, property.name, factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), factory.createUnionTypeNode(propertyTypes));
        (0, jsdocGenerator_1.createJSDoc)(propertySignature, property);
        typeElements.push(propertySignature);
    }
    // aggregations
    for (const n in classInfo.aggregations) {
        const aggregation = classInfo.aggregations[n];
        if (aggregation.visibility !== "hidden") {
            let aggregationInitializationTypeNode;
            const aggregationSingleTypeNode = createTypeNode(aggregation.type, requiredImports, knownGlobals);
            if (aggregation.cardinality === "0..1") {
                if (Array.isArray(aggregation.altTypes) && aggregation.altTypes.length > 0) {
                    const typesToUse = [
                        aggregationSingleTypeNode,
                        createTypeNode(
                        // add first altType as alternative - only ONE is supported by UI5
                        aggregation.altTypes[0], requiredImports, knownGlobals)
                    ];
                    typesToUse.push(createTypeNode(
                    // altType can be bound via property binding
                    PropertyBindingInfoType, requiredImports, knownGlobals));
                    if (aggregation.altTypes[0] !== "string") {
                        // if "string" is not anyway allowed, also allow binding strings
                        typesToUse.push(createBindingStringTypeNode());
                    }
                    aggregationInitializationTypeNode = factory.createUnionTypeNode(typesToUse);
                }
                else {
                    // no altTypes
                    aggregationInitializationTypeNode = aggregationSingleTypeNode;
                }
            }
            else {
                // 0..n
                aggregationInitializationTypeNode = factory.createUnionTypeNode([
                    factory.createArrayTypeNode(aggregationSingleTypeNode),
                    aggregationSingleTypeNode,
                    createTypeNode(
                    // 3. an aggregation binding info object
                    AggregationBindingInfoType, requiredImports, knownGlobals),
                    createBindingStringTypeNode() // 4. a binding string
                ]);
            }
            const propertySignature = factory.createPropertySignature(undefined, aggregation.name, factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), aggregationInitializationTypeNode);
            (0, jsdocGenerator_1.createJSDoc)(propertySignature, aggregation);
            typeElements.push(propertySignature);
        }
    }
    // associations
    for (const n in classInfo.associations) {
        const association = classInfo.associations[n];
        if (association.visibility !== "hidden") {
            let associationInitializationTypeNode;
            const associationSingleTypeNode = createTypeNode(association.type, requiredImports, knownGlobals);
            // allow object and string (=ID) and in case of multiple associations also arrays
            if (association.cardinality === "0..1") {
                associationInitializationTypeNode = factory.createUnionTypeNode([associationSingleTypeNode, factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword)]);
            }
            else {
                // 0..n
                associationInitializationTypeNode = factory.createUnionTypeNode([
                    associationSingleTypeNode,
                    factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword),
                    factory.createArrayTypeNode(factory.createUnionTypeNode([associationSingleTypeNode, factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword)]))
                ]);
            }
            const propertySignature = factory.createPropertySignature(undefined, association.name, factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), associationInitializationTypeNode);
            (0, jsdocGenerator_1.createJSDoc)(propertySignature, association);
            factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword), typeElements.push(propertySignature);
        }
    }
    // events
    for (const n in classInfo.events) {
        const event = classInfo.events[n];
        if (event.visibility !== "hidden") {
            const propertySignature = factory.createPropertySignature(undefined, event.name, factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), factory.createFunctionTypeNode([], [createParameterDeclaration("event", factory.createTypeReferenceNode(managedObject.eventTypeAliases[event.name].statement.name))], factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.VoidKeyword)));
            (0, jsdocGenerator_1.createJSDoc)(propertySignature, event);
            typeElements.push(propertySignature);
        }
    }
    let ownSettingsTypeName = "T" + managedObject.className + "Settings";
    if (managedObject.settingsTypeName.endsWith(ownSettingsTypeName)) {
        // name clash
        ownSettingsTypeName += "_1"; // append suffix to make the name unique
    }
    const localName = uniqueImport(managedObject.settingsTypeName, requiredImports, knownGlobals);
    if (!managedObject.isConstructorDecorated) {
        printConstructorBlockWarning(ownSettingsTypeName, managedObject.className);
    }
    const settingsSuperclass = factory.createIdentifier(localName);
    const settingsSuperclassAsExpression = factory.createExpressionWithTypeArguments(settingsSuperclass, undefined);
    const heritageClauses = [factory.createHeritageClause(typescript_1.default.SyntaxKind.ExtendsKeyword, [settingsSuperclassAsExpression])];
    return factory.createInterfaceDeclaration([factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword)], ownSettingsTypeName, undefined, heritageClauses, typeElements);
}
exports.generateSettingsInterface = generateSettingsInterface;
// creates a template string that matches all binding strings
function createBindingStringTypeNode() {
    return factory.createTemplateLiteralType(factory.createTemplateHead("{", "{"), [
        factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword), factory.createTemplateTail("}", "}"))
    ]);
}
function printConstructorBlockWarning(settingsTypeName, className) {
    const constructorBlock = createConstructorBlock(settingsTypeName);
    loglevel_1.default.warn(`NOTE: Для класса ${className} нужно добавить конструктор:\n===== BEGIN =====\n${(0, astToString_1.default)(constructorBlock)}====== END ======`);
}
function createMethodDeclaration(modifiers, name, typeParameters, parameters, type) {
    return factory.createMethodDeclaration(modifiers, undefined, name, undefined, typeParameters, parameters, type, undefined);
}
exports.createMethodDeclaration = createMethodDeclaration;
function createMethodSignature(modifiers, name, typeParameters, parameters, type) {
    return factory.createMethodSignature(modifiers, name, undefined, typeParameters, parameters, type);
}
exports.createMethodSignature = createMethodSignature;
function createTypeNode(typeName, requiredImports, knownGlobals, typeArguments = []) {
    if (!typeName || typeof typeName !== "string")
        return factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword);
    switch (typeName) {
        case "this":
            return factory.createThisTypeNode();
        case "void":
            return factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.VoidKeyword);
        case "string":
            return factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword);
        case "string[]":
            return factory.createArrayTypeNode(factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword));
        case "int":
        case "float":
        case "number":
            return factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword);
        case "int[]":
        case "float[]":
        case "number[]":
            return factory.createArrayTypeNode(factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword));
        case "boolean":
            return factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.BooleanKeyword);
        case "boolean[]":
            return factory.createArrayTypeNode(factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.BooleanKeyword));
        case "object":
            return factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.ObjectKeyword);
        case "object[]":
            return factory.createArrayTypeNode(factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.ObjectKeyword));
        case "function":
            return factory.createTypeReferenceNode(factory.createIdentifier("Function"));
        case "function[]":
            return factory.createArrayTypeNode(factory.createTypeReferenceNode(factory.createIdentifier("Function")));
        case "any":
            return factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.AnyKeyword);
        case "any[]": // a kinda strange type, but to be complete, let's cover it
            return factory.createArrayTypeNode(factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.AnyKeyword));
        default:
            // UI5 type
            if (typeName.endsWith("[]")) {
                // rare case: an array thereof, something like "sap.ui.core.CSSSize[]"
                return factory.createArrayTypeNode(factory.createTypeReferenceNode(uniqueImport(typeName.slice(0, -2).trim(), requiredImports, knownGlobals), typeArguments));
            }
            else {
                // common case: something like "sap.ui.core.CSSSize"
                return factory.createTypeReferenceNode(uniqueImport(typeName, requiredImports, knownGlobals), typeArguments);
            }
    }
}
exports.createTypeNode = createTypeNode;
function uniqueImport(typeName, requiredImports, knownGlobals) {
    if (typeName === requiredImports.currentClassName) {
        return typeName;
    }
    // нужен обработчик на стандатрные типы
    if (typeName.match(/^(Record|Map)(<.+,.+>)$/) || typeName === "Date") {
        return typeName;
    }
    let moduleName;
    let localName;
    const matches = typeName.match(/"([^"]+)"\.(.*)/);
    if (matches) {
        moduleName = matches[1];
        localName = matches[2];
    }
    else {
        const parts = typeName.split(".");
        if (parts.length === 1) {
            if (typeName.startsWith('"') && typeName.endsWith('"')) {
                // Литерал
                return typeName;
            }
        }
        localName = parts[parts.length - 1];
        moduleName = parts.join("/");
    }
    let moduleInfo = knownGlobals[typeName];
    if (!moduleInfo) {
        moduleInfo = {
            exportName: localName,
            moduleName: moduleName
        };
    }
    else {
        moduleName = moduleInfo.moduleName;
        if (!moduleInfo.exportName) {
            moduleInfo.localName = localName;
        }
    }
    if (moduleInfo.exportName) {
        localName = moduleInfo.exportName;
    }
    const imports = requiredImports[localName];
    if (!imports) {
        requiredImports[localName] = {
            isDefault: !moduleInfo.exportName,
            globalModule: moduleInfo.moduleName
        };
    }
    return localName;
}
function addLineBreakBefore(node, count = 1) {
    for (let i = 0; i < count; i++) {
        typescript_1.default.addSyntheticLeadingComment(node, typescript_1.default.SyntaxKind.SingleLineCommentTrivia, "");
    }
}
exports.addLineBreakBefore = addLineBreakBefore;
function createConstructorBlock(settingsTypeName) {
    const nodes = [];
    // This creates:
    //   constructor(id?: string | $SampleControlSettings);
    nodes.push(factory.createConstructorDeclaration(undefined, [
        createParameterDeclaration("idOrSettings", factory.createUnionTypeNode([factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword), factory.createTypeReferenceNode(settingsTypeName)]), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken))
    ], undefined));
    // This creates:
    //   constructor(id?: string, settings?: $SampleControlSettings);
    nodes.push(factory.createConstructorDeclaration(undefined, [
        createParameterDeclaration("id", factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken)),
        createParameterDeclaration("settings", factory.createTypeReferenceNode(settingsTypeName), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken))
    ], undefined));
    // This creates:
    //   constructor(id?: string, settings?: $SampleControlSettings) {
    //      super(id, settings);
    //   }
    nodes.push(factory.createConstructorDeclaration(undefined, [
        createParameterDeclaration("id", factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken)),
        createParameterDeclaration("settings", factory.createTypeReferenceNode(settingsTypeName), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken))
    ], factory.createBlock([
        factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), undefined, [factory.createIdentifier("id"), factory.createIdentifier("settings")]))
    ])));
    return nodes;
}
exports.createConstructorBlock = createConstructorBlock;
function makeEventParametersName(className, eventName) {
    const capitalizedEventName = eventName.charAt(0).toUpperCase() + eventName.slice(1);
    return {
        eventParametersName: `${className}${capitalizedEventName}EventParameters`,
        eventTypealiasName: `${className}${capitalizedEventName}EventType`
    };
}
function generateEventWithGenericsCompatibilityModule(className, requiredImports, knownGlobals) {
    const typeParameters = [
        factory.createTypeParameterDeclaration(undefined, factory.createIdentifier("T"), factory.createTypeReferenceNode(factory.createIdentifier("Record"), [
            factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword),
            factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.AnyKeyword)
        ]), factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.ObjectKeyword))
    ];
    const methods = [
        factory.createMethodSignature(undefined, factory.createIdentifier("constructor"), undefined, undefined, [
            createParameterDeclaration(factory.createIdentifier("id"), factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword)),
            createParameterDeclaration(factory.createIdentifier("source"), createTypeNode("sap.ui.base.EventProvider", requiredImports, knownGlobals)),
            createParameterDeclaration(factory.createIdentifier("parameters"), factory.createTypeReferenceNode(factory.createIdentifier("T"), undefined))
        ], undefined),
        factory.createMethodSignature(undefined, factory.createIdentifier("getParameters"), undefined, undefined, [], factory.createTypeReferenceNode(factory.createIdentifier("T"), undefined)),
        factory.createMethodSignature(undefined, factory.createIdentifier("getParameter"), undefined, [
            factory.createTypeParameterDeclaration(undefined, factory.createIdentifier("ParamName"), factory.createTypeOperatorNode(typescript_1.default.SyntaxKind.KeyOfKeyword, factory.createTypeReferenceNode(factory.createIdentifier("T"), undefined)), undefined)
        ], [createParameterDeclaration(factory.createIdentifier("name"), factory.createTypeReferenceNode(factory.createIdentifier("ParamName"), undefined))], factory.createIndexedAccessTypeNode(factory.createTypeReferenceNode(factory.createIdentifier("T"), undefined), factory.createTypeReferenceNode(factory.createIdentifier("ParamName"), undefined)))
    ];
    uniqueImport("sap.ui.base.Event", requiredImports, knownGlobals);
    return factory.createInterfaceDeclaration([factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(`${className}Event`), typeParameters, [factory.createHeritageClause(typescript_1.default.SyntaxKind.ExtendsKeyword, [factory.createExpressionWithTypeArguments(factory.createIdentifier("Event"), undefined)])], methods);
}
exports.generateEventWithGenericsCompatibilityModule = generateEventWithGenericsCompatibilityModule;
function generateEventParameterInterfaces(events, className, requiredImports, knownGlobals) {
    const eventParameterInterfaces = {};
    for (const eventName in events) {
        const event = events[eventName];
        if (event.visibility !== "hidden") {
            const properties = [];
            for (const parameterName in event.parameters) {
                const parameter = event.parameters[parameterName];
                if (parameter) {
                    const property = factory.createPropertySignature(undefined, factory.createIdentifier(parameterName), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), createTypeNode(parameter.type || "string", requiredImports, knownGlobals));
                    properties.push(property);
                }
            }
            // ESLint фикс
            if (properties.length === 0) {
                properties.push(factory.createPropertySignature(undefined, factory.createIdentifier("unused"), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.UndefinedKeyword)));
            }
            const interfc = factory.createInterfaceDeclaration([factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(makeEventParametersName(className, eventName).eventParametersName), undefined, undefined, properties);
            eventParameterInterfaces[eventName] = {
                jsDoc: event,
                statement: interfc
            };
        }
    }
    return eventParameterInterfaces;
}
exports.generateEventParameterInterfaces = generateEventParameterInterfaces;
function generateEventTypeAliases(events, managedObject) {
    const eventTypeAliases = {};
    for (const eventName in managedObject.eventParameterInterfaces) {
        const typeNode = factory.createTypeReferenceNode(managedObject.eventParameterInterfaces[eventName].statement.name.text);
        const typeAlias = factory.createTypeAliasDeclaration([factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(makeEventParametersName(managedObject.className, eventName).eventTypealiasName), undefined, factory.createTypeReferenceNode(`${managedObject.className}Event`, [typeNode]));
        eventTypeAliases[eventName] = {
            jsDoc: events[eventName],
            statement: typeAlias
        };
    }
    return eventTypeAliases;
}
exports.generateEventTypeAliases = generateEventTypeAliases;
const pluralRegEx = /(children|ies|ves|oes|ses|ches|shes|xes|s)$/i;
const mSingular = {
    children: -3,
    ies: "y",
    ves: "f",
    oes: -2,
    ses: -2,
    ches: -2,
    shes: -2,
    xes: -2,
    s: -1
};
function collectMetadataClass(metadata, managedObject, imports, knownGlobals, createMethod) {
    if (!metadata)
        return;
    function upper(n) {
        return n.slice(0, 1).toUpperCase() + n.slice(1);
    }
    function each(map, defaultKey, callback) {
        if (!map)
            return;
        for (const n in map) {
            if (Object.prototype.hasOwnProperty.call(map, n)) {
                const settings = expandDefaultKey(map[n], defaultKey);
                if (settings == null) {
                    loglevel_1.default.warn(`Некорректные метаданные для ${n} ('${map[n].name}')`);
                    continue;
                }
                callback(n, settings, map[n]);
            }
        }
    }
    const modifiers = [];
    if (managedObject.isIncludeMethodModifier === true) {
        modifiers.push(factory.createModifier(typescript_1.default.SyntaxKind.PublicKeyword));
    }
    each(metadata.properties, "type", (n, settings) => {
        if (settings.visibility === "hidden")
            return;
        const methodName = upper(n);
        const propertyType = settings.type || "string";
        const setterParameters = createParameterDeclaration(n, createTypeNode(propertyType, imports, knownGlobals));
        const setter = createMethod(modifiers, "set" + methodName, [], [setterParameters], factory.createThisTypeNode());
        const getter = createMethod(modifiers, "get" + methodName, [], [], createTypeNode(propertyType, imports, knownGlobals));
        managedObject.methods.push(getter, setter);
        (0, jsdocGenerator_1.createJSDoc)(getter, settings);
        (0, jsdocGenerator_1.createJSDoc)(setter, settings);
        if (!!settings.bindable) {
            const bindParameters = createParameterDeclaration("bindingInfo", createTypeNode(PropertyBindingInfoType, imports, knownGlobals));
            const bind = createMethod(modifiers, "bind" + methodName, [], [bindParameters], factory.createThisTypeNode());
            const unbind = createMethod(modifiers, "unbind" + methodName, [], [], factory.createThisTypeNode());
            managedObject.methods.push(bind, unbind);
            (0, jsdocGenerator_1.createJSDoc)(bind, settings);
            (0, jsdocGenerator_1.createJSDoc)(unbind, settings);
        }
    });
    each(metadata.aggregations, "type", (n, settings) => {
        if (settings.visibility === "hidden")
            return;
        const methodName = upper(n);
        const singularMethodName = upper(settings.singularName || guessSingularName(n));
        const aggregationType = settings.type || "sap.ui.core.Control";
        const typeNode = createTypeNode(aggregationType, imports, knownGlobals);
        const parameterType = createParameterDeclaration(n, typeNode);
        settings.multiple = !!settings.multiple;
        if (settings.multiple === true) {
            const getter = createMethod(modifiers, "get" + methodName, [], [], factory.createArrayTypeNode(typeNode));
            const add = createMethod(modifiers, "add" + singularMethodName, [], [parameterType], factory.createThisTypeNode());
            const insert = createMethod(modifiers, "insert" + singularMethodName, [], [parameterType, createParameterDeclaration("index", factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword))], factory.createThisTypeNode());
            const remove = createMethod(modifiers, "remove" + singularMethodName, [], [
                createParameterDeclaration(n, factory.createUnionTypeNode([
                    factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword),
                    factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword),
                    typeNode
                ]))
            ], factory.createThisTypeNode());
            const removeAll = createMethod(modifiers, "removeAll" + methodName, [], [], factory.createArrayTypeNode(typeNode));
            const indexOf = createMethod(modifiers, "indexOf" + singularMethodName, [], [createParameterDeclaration(n, typeNode)], factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword));
            const destroy = createMethod(modifiers, "destroy" + methodName, [], [], factory.createThisTypeNode());
            managedObject.methods.push(getter, add, insert, remove, removeAll, indexOf, destroy);
            (0, jsdocGenerator_1.createJSDoc)(getter, settings);
            (0, jsdocGenerator_1.createJSDoc)(add, settings);
            (0, jsdocGenerator_1.createJSDoc)(insert, settings);
            (0, jsdocGenerator_1.createJSDoc)(remove, settings);
            (0, jsdocGenerator_1.createJSDoc)(removeAll, settings);
            (0, jsdocGenerator_1.createJSDoc)(indexOf, settings);
            (0, jsdocGenerator_1.createJSDoc)(destroy, settings);
        }
        else {
            const getter = createMethod(modifiers, "get" + methodName, [], [], typeNode);
            const setter = createMethod(modifiers, "set" + methodName, [], [parameterType], factory.createThisTypeNode());
            managedObject.methods.push(getter, setter);
            (0, jsdocGenerator_1.createJSDoc)(getter, settings);
            (0, jsdocGenerator_1.createJSDoc)(setter, settings);
        }
        if (!!settings.bindable) {
            const bindParameters = createParameterDeclaration("bindingInfo", createTypeNode(AggregationBindingInfoType, imports, knownGlobals));
            const bind = createMethod(modifiers, "bind" + methodName, [], [bindParameters], factory.createThisTypeNode());
            const unbind = createMethod(modifiers, "unbind" + methodName, [], [], factory.createThisTypeNode());
            managedObject.methods.push(bind, unbind);
            (0, jsdocGenerator_1.createJSDoc)(bind, settings);
            (0, jsdocGenerator_1.createJSDoc)(unbind, settings);
        }
    });
    each(metadata.associations, "type", (n, settings) => {
        if (settings.visibility === "hidden")
            return;
        const methodName = upper(n);
        const singularMethodName = upper(settings.singularName || guessSingularName(n));
        const associationType = settings.type || "sap.ui.core.Control";
        const typeNode = createTypeNode(associationType, imports, knownGlobals);
        const stringTypeNode = factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword);
        const numberTypeNode = factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword);
        settings.multiple = !!settings.multiple;
        if (settings.multiple === true) {
            const getter = createMethod(modifiers, "get" + methodName, [], [], factory.createArrayTypeNode(stringTypeNode));
            const add = createMethod(modifiers, "add" + singularMethodName, [], [createParameterDeclaration(n, factory.createUnionTypeNode([stringTypeNode, typeNode]))], factory.createThisTypeNode());
            const remove = createMethod(modifiers, "remove" + singularMethodName, [], [createParameterDeclaration(n, factory.createUnionTypeNode([numberTypeNode, stringTypeNode, typeNode]))], stringTypeNode);
            const removeAll = createMethod(modifiers, "removeAll" + methodName, [], [], factory.createArrayTypeNode(stringTypeNode));
            managedObject.methods.push(getter, add, remove, removeAll);
            (0, jsdocGenerator_1.createJSDoc)(getter, settings);
            (0, jsdocGenerator_1.createJSDoc)(add, settings);
            (0, jsdocGenerator_1.createJSDoc)(remove, settings);
            (0, jsdocGenerator_1.createJSDoc)(removeAll, settings);
        }
        else {
            const getter = createMethod(modifiers, "get" + methodName, [], [], stringTypeNode);
            const setter = createMethod(modifiers, "set" + methodName, [], [createParameterDeclaration(n, factory.createUnionTypeNode([stringTypeNode, typeNode]), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken))], factory.createThisTypeNode());
            managedObject.methods.push(getter, setter);
            (0, jsdocGenerator_1.createJSDoc)(getter, settings);
            (0, jsdocGenerator_1.createJSDoc)(setter, settings);
        }
    });
    each(metadata.events, null, (n, settings) => {
        const methodName = upper(n);
        const callback = factory.createFunctionTypeNode([], [createParameterDeclaration("event", factory.createTypeReferenceNode(managedObject.eventTypeAliases[n].statement.name))], factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.VoidKeyword));
        const callbackWithData = factory.createFunctionTypeNode([], [
            createParameterDeclaration("event", factory.createTypeReferenceNode(managedObject.eventTypeAliases[n].statement.name)),
            createParameterDeclaration("data", factory.createTypeReferenceNode("CustomDataType"))
        ], factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.VoidKeyword));
        const returnValue = settings.allowPreventDefault ? factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.BooleanKeyword) : factory.createThisTypeNode();
        const attach = createMethod(modifiers, "attach" + methodName, [], [
            createParameterDeclaration("fn", callback),
            createParameterDeclaration("listener", factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.ObjectKeyword), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken))
        ], factory.createThisTypeNode());
        const attach2 = createMethod(modifiers, "attach" + methodName, [factory.createTypeParameterDeclaration(undefined, "CustomDataType", factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.ObjectKeyword))], [
            createParameterDeclaration("data", factory.createTypeReferenceNode("CustomDataType")),
            createParameterDeclaration("fn", callbackWithData),
            createParameterDeclaration("listener", factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.ObjectKeyword), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken))
        ], factory.createThisTypeNode());
        const detach = createMethod(modifiers, "detach" + methodName, [], [
            createParameterDeclaration("fn", callback),
            createParameterDeclaration("listener", factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.ObjectKeyword), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken))
        ], factory.createThisTypeNode());
        const fire = createMethod(modifiers, "fire" + methodName, [], [
            createParameterDeclaration("parameters", factory.createTypeReferenceNode(managedObject.eventParameterInterfaces[n].statement.name), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken))
        ], returnValue);
        managedObject.methods.push(attach, attach2, detach, fire);
        (0, jsdocGenerator_1.createJSDoc)(attach, settings);
        (0, jsdocGenerator_1.createJSDoc)(attach2, settings);
        (0, jsdocGenerator_1.createJSDoc)(detach, settings);
        (0, jsdocGenerator_1.createJSDoc)(fire, settings);
        // each<SpecialSetting>(settings.parameters, "type", (pName: string, pSettings) => {
        // 	info.parameters[pName] = {
        // 		name: pName,
        // 		doc: settings.doc,
        // 		since: settings.since,
        // 		deprecation: settings.deprecation,
        // 		experimental: settings.experimental,
        // 		type: pSettings && pSettings.type ? pSettings.type : ""
        // 	};
        // });
    });
}
exports.collectMetadataClass = collectMetadataClass;
function expandDefaultKey(node, defaultKey) {
    if (node != null) {
        // if, instead of an object literal only a string is given and there is a defaultKey, then wrap the literal
        if (typeof node === "string" && defaultKey != null) {
            const result = {};
            result[defaultKey] = node;
            return result;
        }
    }
    return node;
}
exports.expandDefaultKey = expandDefaultKey;
function guessSingularName(sPluralName) {
    return sPluralName.replace(pluralRegEx, ($, plural) => {
        const vRepl = mSingular[plural.toLowerCase()];
        return typeof vRepl === "string" ? vRepl : plural.slice(0, vRepl);
    });
}
//# sourceMappingURL=astGenerationHelper.js.map