devextreme-internal-tools 19.2.15 → 20.0.0

package/ts/angular-components-generator/metadata-generator.js

@@ -0,0 +1,753 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentMetadataGenerator = exports.FSObjectStore = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const mkdirp_1 = require("mkdirp");
+const helpers_1 = require("./helpers");
+const import_helper_1 = require("./import-helper");
+const utils_1 = require("../common/utils");
+const helpers_2 = require("../components-generation/helpers");
+const metadata_augmentation_1 = require("../components-generation/metadata-augmentation");
+const type_resolving_1 = require("../components-generation/type-resolving");
+const logging_1 = require("../logging");
+const OPTION_COMPONENT_PREFIX = 'Dxo';
+const ITEM_COMPONENT_PREFIX = 'Dxi';
+const TYPES_SEPARATOR = ' | ';
+const NON_EXPORTED_NESTED_COMPONENTS = [
+    'DxiToolbarItem',
+];
+function trimDx(value) {
+    return trimPrefix('dx-', value);
+}
+function trimPrefix(prefix, value) {
+    if (value.startsWith(prefix)) {
+        return value.substr(prefix.length);
+    }
+    return value;
+}
+function trimComponentPrefix(className) {
+    const pattern = new RegExp(`^(${OPTION_COMPONENT_PREFIX}|${ITEM_COMPONENT_PREFIX})`);
+    return className.replace(pattern, '');
+}
+class FSObjectStore {
+    constructor() {
+        this.encoding = 'utf8';
+    }
+    read(filePath) {
+        (0, logging_1.log)(`Read from file: ${filePath}`);
+        const dataString = node_fs_1.default.readFileSync(filePath, { encoding: this.encoding });
+        (0, logging_1.log)('Parse data');
+        return JSON.parse(dataString);
+    }
+    write(filePath, data) {
+        (0, logging_1.log)(`Write data to file ${filePath}`);
+        const dataString = JSON.stringify(data, null, 4);
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+        node_fs_1.default.writeFileSync(filePath, dataString, { encoding: this.encoding });
+    }
+}
+exports.FSObjectStore = FSObjectStore;
+const TYPE_ALIASES = {
+    Component: 'CoreComponent',
+};
+function createImports(customTypeModules, metadataAugmentation, aliases) {
+    const customTypeImports = {};
+    const defaultTypeImports = {};
+    const wildcardTypeImports = {};
+    Object.keys(customTypeModules).forEach((t) => {
+        if (metadataAugmentation.defaultImports[t]) {
+            defaultTypeImports[metadataAugmentation.defaultImports[t]] = t;
+            return;
+        }
+        const modules = customTypeModules[t].map((m) => { var _a; return (_a = metadataAugmentation.importOverrides[t]) !== null && _a !== void 0 ? _a : m; });
+        if (modules.length) {
+            modules.forEach((module) => {
+                const importNamespace = metadataAugmentation.nameConflictsResolutionNamespaces[t];
+                if (importNamespace) {
+                    wildcardTypeImports[module] = `* as ${importNamespace}`;
+                }
+                else {
+                    const moduleImports = new Set(customTypeImports[module]);
+                    const hasAlias = aliases && aliases[t];
+                    moduleImports.add(hasAlias ? aliases[t] : t);
+                    customTypeImports[module] = Array.from(moduleImports);
+                }
+            });
+        }
+    });
+    return [].concat(Object.keys(defaultTypeImports).map((key) => ({
+        path: key,
+        importString: defaultTypeImports[key],
+    })), Object.keys(wildcardTypeImports).map((key) => ({
+        path: key,
+        importString: wildcardTypeImports[key],
+    })), Object.keys(customTypeImports).map((key) => ({
+        path: key,
+        importString: `{ ${customTypeImports[key].join(', ')} }`,
+    })));
+}
+function replaceEmptyFunction(optionType) {
+    const emptyFunction = /\(\(\) => (void|any)\)/;
+    const typeFunction = 'Function';
+    if (emptyFunction.exec(optionType)) {
+        return optionType
+            .split(TYPES_SEPARATOR)
+            .map((typeName) => typeName.replace(emptyFunction, typeFunction))
+            .join(TYPES_SEPARATOR);
+    }
+    return optionType;
+}
+function mapProp(option, typeResolver) {
+    if (option.name.toLowerCase().includes('template')) {
+        return {
+            name: option.name,
+            type: type_resolving_1.BaseTypes.Any,
+            isSubscribable: option.isSubscribable,
+        };
+    }
+    let optionType = (0, type_resolving_1.getComplexOptionType)(option.types, typeResolver, {
+        trimTypeParams: true,
+    });
+    if (option.props && option.props.length) {
+        const nested = option.props.map((o) => mapProp(o, typeResolver));
+        const nestedTypes = nested.map((n) => `${n.name}?: ${n.type}`);
+        optionType = optionType
+            .split(TYPES_SEPARATOR)
+            .filter((typeName) => typeName !== type_resolving_1.BaseTypes.Object &&
+            typeName !== `Array<${type_resolving_1.BaseTypes.Object}>`)
+            .concat(`{ ${nestedTypes.join(', ')} }${(0, type_resolving_1.isNestedOptionArray)(option) ? '[]' : ''}`)
+            .join(TYPES_SEPARATOR);
+    }
+    optionType = replaceEmptyFunction(optionType);
+    return {
+        name: option.name,
+        type: optionType,
+        isSubscribable: option.isSubscribable,
+    };
+}
+function getComponentInfo(component, parentName) {
+    const prefix = component.isCollectionItem
+        ? ITEM_COMPONENT_PREFIX
+        : OPTION_COMPONENT_PREFIX;
+    const name = 'name' in component ? component.name : component.componentName;
+    return {
+        selector: `${prefix.toLowerCase()}-${parentName}-${(0, helpers_2.toKebabCase)(name)}`,
+        className: `${prefix}${(0, helpers_2.toUpperCamelCase)(parentName)}${(0, helpers_2.uppercaseFirst)(name)}`,
+        filename: `${(0, helpers_2.toKebabCase)(name)}${component.isCollectionItem ? `-${prefix.toLowerCase()}` : ''}`,
+    };
+}
+function getCollectionNestedComponents(nesteds, parentName) {
+    if (nesteds && nesteds.length) {
+        return nesteds
+            .filter((n) => n.isCollectionItem)
+            .map((n) => {
+            const { className, filename } = getComponentInfo(n, parentName);
+            return {
+                className,
+                path: filename,
+                propertyName: n.optionName,
+                methodName: (0, helpers_2.pluralize)((0, helpers_2.lowercaseFirst)((0, helpers_2.camelize)((0, helpers_2.dasherize)(n.componentName)))),
+            };
+        });
+    }
+    return [];
+}
+function getMissingCollectionItems(nestedComponents) {
+    const nestedComponentsHash = {};
+    let nestedCollectionOptions = [];
+    nestedComponents.forEach((c) => {
+        var _a;
+        nestedComponentsHash[c.optionName] = c;
+        const collectionNesteds = (_a = c.nesteds) === null || _a === void 0 ? void 0 : _a.filter((n) => n.isCollectionItem).reduce((acc, nestedOption) => {
+            acc[nestedOption.optionName] = nestedOption.componentName;
+            return acc;
+        }, {});
+        if (collectionNesteds) {
+            nestedCollectionOptions = nestedCollectionOptions.concat(c.props
+                .filter((prop) => collectionNesteds[prop.name])
+                .map((prop) => ({
+                ...prop,
+                name: collectionNesteds[prop.name],
+                optionName: prop.name,
+                isCollectionItem: true,
+                nesteds: [],
+                owners: [],
+                predefinedProps: null,
+                templates: null,
+            })));
+        }
+    });
+    const result = [];
+    nestedCollectionOptions.forEach((option) => {
+        if (!nestedComponentsHash[option.optionName]) {
+            result.push(option);
+        }
+    });
+    return result;
+}
+function appendMissingRecursiveNestedComponents(component, siblings) {
+    const collectionItems = siblings.filter((c) => c.isCollectionItem);
+    const siblingsByOptionName = (0, helpers_2.groupBy)(collectionItems, (c) => c.optionName);
+    const missingNesteds = [];
+    component.props.forEach((prop) => {
+        var _a;
+        const recursiveNesteds = siblingsByOptionName[prop.name];
+        if ((0, type_resolving_1.isNestedOptionArray)(prop) && recursiveNesteds) {
+            const isMergedNested = component.owners.length > 1 && prop.name === component.optionName;
+            if (isMergedNested) {
+                missingNesteds.push({
+                    componentName: component.name,
+                    optionName: prop.name,
+                    isCollectionItem: true,
+                });
+            }
+            else {
+                recursiveNesteds.forEach((r) => {
+                    const haveCommonOwner = r.owners.some((o) => component.owners.includes(o));
+                    if (haveCommonOwner) {
+                        missingNesteds.push({
+                            componentName: r.name,
+                            optionName: r.optionName,
+                            isCollectionItem: true,
+                        });
+                    }
+                });
+                if (!((_a = component.nesteds) === null || _a === void 0 ? void 0 : _a.some((n) => n.optionName === prop.name))) {
+                    const nestedsAreOwners = recursiveNesteds
+                        .filter((r) => component.owners.includes(r.name))
+                        .map((r) => r.owners)
+                        .flat();
+                    recursiveNesteds
+                        .filter((r) => r.owners.some((o) => nestedsAreOwners.includes(o)))
+                        .forEach((r) => {
+                        missingNesteds.push({
+                            componentName: r.name,
+                            optionName: r.optionName,
+                            isCollectionItem: true,
+                        });
+                    });
+                }
+            }
+        }
+    });
+    const allNesteds = component.nesteds
+        ? component.nesteds.concat(missingNesteds)
+        : missingNesteds;
+    return (0, utils_1.distinctByProperty)(allNesteds, 'componentName');
+}
+class ComponentMetadataGenerator {
+    constructor(store) {
+        this.store = store;
+        if (!this.store) {
+            this.store = new FSObjectStore();
+        }
+    }
+    generate(config) {
+        var _a, _b, _c;
+        const ngMetadata = this.store.read(config.sourceMetadataFilePath);
+        const imdMetadata = this.store.read(config.imdMetadataFilePath);
+        const customTypeHash = (0, type_resolving_1.createCustomTypeHash)(imdMetadata.customTypes);
+        const widgetsMetadata = ngMetadata.Widgets;
+        let allNestedComponents = [];
+        (0, mkdirp_1.sync)(config.outputFolderPath);
+        (0, mkdirp_1.sync)(node_path_1.default.join(config.outputFolderPath, config.nestedPathPart));
+        (0, mkdirp_1.sync)(node_path_1.default.join(config.outputFolderPath, config.nestedPathPart, config.basePathPart));
+        for (const widget of imdMetadata.widgets) {
+            const widgetName = (0, helpers_2.lowercaseFirst)(widget.name);
+            const legacyWidget = widgetsMetadata[widgetName];
+            if (!widget.exportPath) {
+                (0, logging_1.log)(`Skipping metadata for ${widgetName}`);
+                continue;
+            }
+            (0, logging_1.log)(`Generate metadata for ${widgetName}`);
+            const isTranscludedContent = widget.hasTranscludedContent;
+            const isViz = widget.exportPath.startsWith('viz');
+            const isExtension = widget.isExtension || false;
+            const dasherizedWidgetName = (0, helpers_2.dasherize)((0, helpers_2.underscore)(widgetName));
+            const outputFilePath = node_path_1.default.join(config.outputFolderPath, trimDx(dasherizedWidgetName), `${trimDx(dasherizedWidgetName)}.json`);
+            const events = [];
+            const changeEvents = [];
+            const properties = [];
+            const metadataAugmentation = (0, metadata_augmentation_1.readFromConfig)(config.unifiedConfig);
+            const [typeResolver, customTypeModules] = (0, type_resolving_1.createCustomTypeResolver)(customTypeHash, metadataAugmentation);
+            for (const option of widget.options) {
+                const legacyOption = legacyWidget === null || legacyWidget === void 0 ? void 0 : legacyWidget.Options[option.name];
+                const isEvent = option.types.filter((type) => type.type === 'Function').length ===
+                    1 &&
+                    (!option.firedEvents || option.firedEvents.length === 0) &&
+                    option.name.startsWith('on');
+                if (isEvent) {
+                    const eventName = (0, helpers_2.lowercaseFirst)((0, helpers_2.camelize)(option.name.slice('on'.length)));
+                    const eventTypeDescr = option.types[0]
+                        .params[0].types[0];
+                    let eventType = eventTypeDescr.type;
+                    const { importPath } = eventTypeDescr;
+                    if (importPath) {
+                        customTypeModules[eventType] = [
+                            `${config.widgetPackageName}/${importPath}`,
+                        ];
+                    }
+                    else if (customTypeHash[eventType]) {
+                        customTypeModules[eventType] = [
+                            `${config.widgetPackageName}/${customTypeHash[eventType].module}`,
+                        ];
+                    }
+                    if (metadataAugmentation.genericTypes[eventType]) {
+                        eventType += `<${type_resolving_1.BaseTypes.Any}>`;
+                    }
+                    events.push({
+                        docID: legacyOption === null || legacyOption === void 0 ? void 0 : legacyOption.DocID,
+                        isDeprecated: option.isDeprecated,
+                        emit: option.name,
+                        subscribe: eventName,
+                        type: `EventEmitter<${eventType}>`,
+                    });
+                }
+                else {
+                    const { type: finalizedType } = mapProp(option, typeResolver);
+                    const property = {
+                        docID: legacyOption === null || legacyOption === void 0 ? void 0 : legacyOption.DocID,
+                        isDeprecated: option.isDeprecated,
+                        name: option.name,
+                        type: finalizedType,
+                    };
+                    const isDataSource = option.name.toLowerCase() === 'datasource';
+                    const isCollection = option.types.length && option.types[0].type === 'Array';
+                    if (isCollection || isDataSource) {
+                        property.isCollection = true;
+                    }
+                    properties.push(property);
+                    changeEvents.push(this.createEvent(option.name, finalizedType));
+                }
+            }
+            const allEvents = events.concat(changeEvents);
+            const isEditor = widget.options.some((o) => o.name === 'onValueChanged');
+            if (isEditor) {
+                allEvents.push({ emit: 'onBlur', type: 'EventEmitter<any>' });
+            }
+            const parentName = trimDx(dasherizedWidgetName);
+            const componentNestedOptions = this.generateIMDComponentNestedOptions((_a = widget.complexOptions) !== null && _a !== void 0 ? _a : [], trimDx(dasherizedWidgetName), customTypeHash, metadataAugmentation);
+            const widgetNestedComponents = this.filterWidgetNestedComponents(componentNestedOptions, properties);
+            let nestedComponents = [];
+            if (legacyWidget) {
+                for (const optionName of Object.keys(legacyWidget.Options)) {
+                    const option = legacyWidget.Options[optionName];
+                    if (!option.IsEvent) {
+                        const components = (_b = this.generateComplexOptionByType(ngMetadata, option, optionName, [], config)) !== null && _b !== void 0 ? _b : [];
+                        nestedComponents = nestedComponents.concat(...components);
+                    }
+                }
+            }
+            const widgetLegacyNestedComponents = this.filterWidgetNestedComponents(nestedComponents, properties).filter((component) => !NON_EXPORTED_NESTED_COMPONENTS.includes(component.className));
+            const containsReexports = (_c = widget.reexports) === null || _c === void 0 ? void 0 : _c.some((r) => r !== 'default');
+            const widgetMetadata = {
+                docID: legacyWidget === null || legacyWidget === void 0 ? void 0 : legacyWidget.DocID,
+                className: widget.name,
+                widgetName,
+                isTranscludedContent,
+                isViz,
+                isExtension,
+                selector: dasherizedWidgetName,
+                path: trimDx(dasherizedWidgetName),
+                events: allEvents,
+                properties,
+                isEditor,
+                module: `${config.widgetPackageName}/${widget.exportPath}`,
+                packageName: config.wrapperPackageName,
+                imports: createImports(customTypeModules, metadataAugmentation),
+                collectionNestedComponents: getCollectionNestedComponents(widget.nesteds, parentName),
+                nestedComponents: widgetNestedComponents,
+                legacyNestedComponents: widgetLegacyNestedComponents,
+                optionsTypeParams: widget.optionsTypeParams,
+                renderReexports: config.generateReexports && containsReexports,
+            };
+            (0, logging_1.log)(`Write metadata to file ${outputFilePath}`);
+            this.store.write(outputFilePath, normalizeMeta(widgetMetadata));
+            this.writeNestedOptionsMetadata(componentNestedOptions, node_path_1.default.join(config.outputFolderPath, parentName, config.nestedPathPart));
+            allNestedComponents = allNestedComponents.concat(...nestedComponents);
+        }
+        const commonNestedOptions = this.prepareCommonNestedOptionsMetadata(config, allNestedComponents);
+        this.writeNestedOptionsMetadata(commonNestedOptions, node_path_1.default.join(config.outputFolderPath, config.nestedPathPart));
+    }
+    createEvent(name, type, option) {
+        return {
+            isInternal: true,
+            emit: `${name}Change`,
+            type: `EventEmitter<${type}>`,
+            option,
+        };
+    }
+    filterWidgetNestedComponents(nestedComponents, widgetProperties) {
+        return (0, utils_1.distinctByProperty)(nestedComponents, 'className').map((component) => ({
+            path: component.path,
+            propertyName: component.propertyName,
+            className: component.className,
+            events: component.events,
+            isCollection: component.isCollection,
+            hasTemplate: component.hasTemplate,
+            root: widgetProperties.filter((p) => p.name === component.propertyName)
+                .length === 1
+                ? true
+                : undefined,
+        }));
+    }
+    getTypesDescription(optionMetadata) {
+        const typeParts = this.getTypeParts(optionMetadata);
+        return {
+            primitiveTypes: typeParts.primitiveTypes,
+            arrayTypes: typeParts.arrayTypes,
+        };
+    }
+    getTypeParts(optionMetadata) {
+        const primitiveTypes = optionMetadata.PrimitiveTypes
+            ? optionMetadata.PrimitiveTypes.slice(0)
+            : [];
+        let arrayTypes = [];
+        if (optionMetadata.ItemPrimitiveTypes) {
+            if (optionMetadata.IsPromise) {
+                const promiseType = optionMetadata.ItemPrimitiveTypes.join(TYPES_SEPARATOR);
+                primitiveTypes.push(`Promise<${promiseType}> & JQueryPromise<${promiseType}>`);
+            }
+            else {
+                arrayTypes = arrayTypes.concat(optionMetadata.ItemPrimitiveTypes);
+            }
+        }
+        if (optionMetadata.Options) {
+            const optionType = this.getObjectType(optionMetadata.Options);
+            if (optionType.length) {
+                (optionMetadata.IsCollection ? arrayTypes : primitiveTypes).push(optionType);
+            }
+        }
+        return { primitiveTypes, arrayTypes };
+    }
+    getObjectType(optionMetadata) {
+        const objectType = [];
+        for (const option of Object.keys(optionMetadata)) {
+            const typeParts = this.getTypeParts(optionMetadata[option]);
+            const type = this.getType(typeParts);
+            objectType.push(`${option}?: ${type}`);
+        }
+        if (objectType.length) {
+            return `{ ${objectType.join(', ')} }`;
+        }
+        return '';
+    }
+    getEventType(typesDescription, option) {
+        var _a;
+        if (!((option === null || option === void 0 ? void 0 : option.IsEvent) && ((_a = option.TypeImports) === null || _a === void 0 ? void 0 : _a.length))) {
+            return this.getType(typesDescription);
+        }
+        return `((e: ${option.TypeImports[0].Name}) => void)`;
+    }
+    getType(typesDescription) {
+        const primitiveTypes = typesDescription.primitiveTypes.slice(0);
+        let result = 'any';
+        if (typesDescription.arrayTypes.length) {
+            primitiveTypes.push(`Array<${typesDescription.arrayTypes.join(TYPES_SEPARATOR)}>`);
+        }
+        if (primitiveTypes.length) {
+            result = primitiveTypes.join(TYPES_SEPARATOR);
+        }
+        return result;
+    }
+    mergeArrayTypes(array1, array2) {
+        const newTypes = array2.filter((type) => !array1.includes(type));
+        return [].concat(array1, newTypes);
+    }
+    getExternalObjectInfo(metadata, typeName) {
+        let externalObject = metadata.ExtraObjects[typeName];
+        if (!externalObject) {
+            const postfix = 'Options';
+            if (typeName.endsWith(postfix)) {
+                const widgetName = typeName.substr(0, typeName.length - postfix.length);
+                externalObject = metadata.Widgets[widgetName];
+                typeName = trimPrefix('dx', typeName);
+            }
+        }
+        if (!externalObject) {
+            console.warn(`WARN: missed complex type: ${typeName}`);
+        }
+        else {
+            return {
+                Options: externalObject.Options,
+                typeName,
+            };
+        }
+        return undefined;
+    }
+    generateComplexOptionByType(metadata, option, optionName, complexTypes, config) {
+        const optionComplexTypes = option[option.IsCollection ? 'ItemComplexTypes' : 'ComplexTypes'];
+        if (option.Options) {
+            return this.generateComplexOption(metadata, option.Options, optionName, complexTypes, option, config);
+        }
+        if (optionComplexTypes && optionComplexTypes.length > 0) {
+            if (complexTypes.indexOf(complexTypes[complexTypes.length - 1]) !==
+                complexTypes.length - 1) {
+                return [];
+            }
+            const result = [];
+            optionComplexTypes.forEach((complexType) => {
+                const externalObjectInfo = this.getExternalObjectInfo(metadata, complexType);
+                if (externalObjectInfo) {
+                    const nestedOptions = externalObjectInfo.Options;
+                    const nestedComplexTypes = complexTypes.concat(externalObjectInfo.typeName);
+                    result.push(...this.generateComplexOption(metadata, nestedOptions, optionName, nestedComplexTypes, option, config));
+                }
+            });
+            if (optionComplexTypes.length === 1) {
+                const externalObjectInfo = this.getExternalObjectInfo(metadata, optionComplexTypes[0]);
+                if (externalObjectInfo) {
+                    if (result.length === 0) {
+                        console.warn(`External object has empty complex options DocID: ${option.DocID}, typeName: ${externalObjectInfo.typeName}`);
+                        return [];
+                    }
+                    result[0].baseClass =
+                        (option.IsCollection
+                            ? ITEM_COMPONENT_PREFIX
+                            : OPTION_COMPONENT_PREFIX) + externalObjectInfo.typeName;
+                    result[0].basePath = (0, helpers_2.dasherize)((0, helpers_2.underscore)(externalObjectInfo.typeName));
+                }
+            }
+            return result;
+        }
+        return [];
+    }
+    generateComplexOption(metadata, nestedOptions, optionName, complexTypes, option, config) {
+        var _a;
+        if (!nestedOptions || !Object.keys(nestedOptions).length) {
+            return [];
+        }
+        let pluralName = optionName;
+        if (option.IsCollection) {
+            pluralName = `${option.SingularName}Dxi`;
+        }
+        const singularName = option.SingularName || pluralName;
+        const underscoreSingular = (0, helpers_2.underscore)(singularName).split('.').join('_');
+        const underscorePlural = (0, helpers_2.underscore)(pluralName).split('.').join('_');
+        const prefix = `${(option.IsCollection ? ITEM_COMPONENT_PREFIX : OPTION_COMPONENT_PREFIX).toLocaleLowerCase()}_`;
+        const underscoreSelector = prefix + (option.IsCollection ? underscoreSingular : underscorePlural);
+        const selector = (0, helpers_2.dasherize)(underscoreSelector);
+        const complexOptionMetadata = {
+            docID: option.DocID,
+            isDeprecated: option.IsDeprecated,
+            className: (0, helpers_2.camelize)(underscoreSelector),
+            selector,
+            optionName,
+            properties: [],
+            events: [],
+            path: (0, helpers_2.dasherize)(underscorePlural),
+            propertyName: optionName,
+            isCollection: option.IsCollection,
+            hasTemplate: option.Options &&
+                option.Options.template &&
+                option.Options.template.IsTemplate,
+            collectionNestedComponents: [],
+            imports: [],
+        };
+        let nestedComponents = [complexOptionMetadata];
+        for (const optName of Object.keys(nestedOptions)) {
+            const nestedOption = nestedOptions[optName];
+            const typesDescription = this.getTypesDescription(nestedOption);
+            let propertyType = this.getType(typesDescription);
+            if (nestedOption.IsEvent && ((_a = nestedOption.TypeImports) === null || _a === void 0 ? void 0 : _a.length)) {
+                propertyType = `((e: ${nestedOption.TypeImports[0].Name}) => void)`;
+            }
+            const property = {
+                docID: nestedOption.DocID,
+                isDeprecated: nestedOption.IsDeprecated,
+                name: optName,
+                type: propertyType,
+                typesDescription,
+                option: nestedOption,
+            };
+            if (nestedOption.IsCollection) {
+                property.isCollection = true;
+            }
+            complexOptionMetadata.properties.push(property);
+            if (nestedOption.IsChangeable || nestedOption.IsReadonly) {
+                complexOptionMetadata.events.push(this.createEvent(optName, propertyType, nestedOption));
+            }
+            const components = this.generateComplexOptionByType(metadata, nestedOptions[optName], optName, complexTypes, config);
+            nestedComponents = nestedComponents.concat(...components);
+            const ownCollectionNestedComponents = components
+                .filter((c) => complexOptionMetadata.properties.filter((p) => p.name === c.propertyName && p.isCollection).length === 1)
+                .map((c) => ({
+                className: c.className,
+                path: c.path,
+                propertyName: c.propertyName,
+            }));
+            complexOptionMetadata.collectionNestedComponents.push(...ownCollectionNestedComponents);
+        }
+        complexOptionMetadata.imports = (0, import_helper_1.buildImports)((0, helpers_1.getValues)(nestedOptions), config.widgetPackageName);
+        return nestedComponents;
+    }
+    getBaseComponentPath(component) {
+        return component.basePath + (component.isCollection ? '-dxi' : '');
+    }
+    mergeNestedComponents(components) {
+        const mergedNestedComponents = {};
+        components.forEach((component) => {
+            if (!mergedNestedComponents[component.className]) {
+                mergedNestedComponents[component.className] = {
+                    ...component,
+                    options: component.properties.map((p) => p.option),
+                };
+            }
+            else {
+                const mergedComponent = mergedNestedComponents[component.className];
+                mergedComponent.properties = mergedComponent.properties
+                    .concat(...component.properties)
+                    .reduce((properties, property) => {
+                    var _a;
+                    if (!properties.some(({ name }) => name === property.name)) {
+                        properties.push(property);
+                    }
+                    else {
+                        const existingProperty = properties.find(({ name }) => name === property.name);
+                        const { typesDescription } = existingProperty;
+                        typesDescription.primitiveTypes = this.mergeArrayTypes(typesDescription.primitiveTypes, property.typesDescription.primitiveTypes);
+                        typesDescription.arrayTypes = this.mergeArrayTypes(typesDescription.arrayTypes, property.typesDescription.arrayTypes);
+                        existingProperty.type = ((_a = existingProperty.option) === null || _a === void 0 ? void 0 : _a.IsEvent)
+                            ? this.getEventType(typesDescription, existingProperty.option)
+                            : this.getType(typesDescription);
+                    }
+                    return properties;
+                }, []);
+                if (mergedComponent.events != null) {
+                    mergedComponent.events = (0, utils_1.distinctByProperty)(mergedComponent.events.concat(...component.events), 'emit');
+                }
+                mergedComponent.baseClass =
+                    mergedComponent.baseClass || component.baseClass;
+                mergedComponent.basePath =
+                    mergedComponent.basePath || component.basePath;
+                mergedComponent.hasTemplate =
+                    mergedComponent.hasTemplate || component.hasTemplate;
+                mergedComponent.collectionNestedComponents.push(...component.collectionNestedComponents);
+                mergedComponent.options.push(...component.properties.map((p) => p.option));
+            }
+        });
+        return Object.values(mergedNestedComponents);
+    }
+    generateIMDComponentNestedOptions(nestedComponents, parentName, customTypeHash, metadataAugmentation) {
+        nestedComponents = nestedComponents.concat(getMissingCollectionItems(nestedComponents));
+        return nestedComponents.map((component) => {
+            const { selector, className, filename } = getComponentInfo(component, parentName);
+            const aliases = {};
+            const resolveCustomTypeConflicts = (typeName) => {
+                if (TYPE_ALIASES[typeName]) {
+                    aliases[typeName] = `${typeName} as ${TYPE_ALIASES[typeName]}`;
+                    return TYPE_ALIASES[typeName];
+                }
+                return typeName;
+            };
+            const [typeResolver, customTypeModules] = (0, type_resolving_1.createCustomTypeResolver)(customTypeHash, metadataAugmentation, resolveCustomTypeConflicts);
+            const properties = component.props.map((prop) => mapProp(prop, typeResolver));
+            const events = properties
+                .filter((p) => p.isSubscribable)
+                .map((p) => this.createEvent(p.name, p.type, null));
+            const nesteds = appendMissingRecursiveNestedComponents(component, nestedComponents);
+            const collectionNestedComponents = getCollectionNestedComponents(nesteds, parentName);
+            return {
+                ...component,
+                nesteds,
+                path: filename,
+                selector,
+                className,
+                propertyName: component.optionName,
+                baseClass: component.isCollectionItem
+                    ? 'CollectionNestedOption'
+                    : 'NestedOption',
+                basePath: 'devextreme-angular/core',
+                isCollection: component.isCollectionItem,
+                hasTemplate: component.templates && component.templates.includes('template'),
+                properties,
+                events: events.length ? events : undefined,
+                imports: createImports(customTypeModules, metadataAugmentation, aliases),
+                collectionNestedComponents,
+            };
+        });
+    }
+    prepareCommonNestedOptionsMetadata(config, metadata) {
+        const commonNestedOptions = this.mergeNestedComponents(metadata);
+        commonNestedOptions.forEach((component) => {
+            component.collectionNestedComponents = (0, utils_1.distinctByProperty)(component.collectionNestedComponents, 'className');
+        });
+        const baseComponents = commonNestedOptions.reduce((result, component) => {
+            const existingComponent = result.find((c) => c.className === component.baseClass);
+            if (!existingComponent && component.baseClass) {
+                const nestedComponent = {
+                    properties: component.properties,
+                    events: component.events,
+                    className: component.baseClass,
+                    path: this.getBaseComponentPath(component),
+                    baseClass: component.isCollection
+                        ? 'CollectionNestedOption'
+                        : 'NestedOption',
+                    basePath: 'devextreme-angular/core',
+                    imports: (0, import_helper_1.buildImports)(component.options, config.widgetPackageName),
+                };
+                result.push(nestedComponent);
+            }
+            return result;
+        }, []);
+        Object.values((0, helpers_2.groupBy)(baseComponents, (c) => trimComponentPrefix(c.className)))
+            .filter((g) => g.length > 1)
+            .forEach((g) => g.forEach((c) => {
+            if (c.className.startsWith(ITEM_COMPONENT_PREFIX)) {
+                c.selector = `base-${(0, helpers_2.toKebabCase)(c.className)}`;
+            }
+        }));
+        baseComponents.forEach((component) => {
+            const outputFilePath = node_path_1.default.join(config.outputFolderPath, config.nestedPathPart, config.basePathPart, `${component.path}.json`);
+            this.store.write(outputFilePath, normalizeMeta(component));
+        });
+        return commonNestedOptions.map((component) => {
+            if (component.events && !component.events.length) {
+                delete component.events;
+            }
+            if (component.baseClass) {
+                component.inputs = component.properties;
+                delete component.properties;
+                component.basePath = `./base/${this.getBaseComponentPath(component)}`;
+                component.imports = component.events
+                    ? (component.imports = (0, import_helper_1.buildImports)(component.events.map((e) => e.option), config.widgetPackageName))
+                    : undefined;
+            }
+            else {
+                component.baseClass = component.isCollection
+                    ? 'CollectionNestedOption'
+                    : 'NestedOption';
+                component.basePath = 'devextreme-angular/core';
+                component.hasSimpleBaseClass = true;
+                component.imports = (0, import_helper_1.buildImports)(component.options, config.widgetPackageName);
+            }
+            return component;
+        });
+    }
+    writeNestedOptionsMetadata(components, outputDir) {
+        components.forEach((component) => {
+            const outputFilePath = node_path_1.default.join(outputDir, `${component.path}.json`);
+            this.store.write(outputFilePath, normalizeMeta(component));
+        });
+    }
+}
+exports.ComponentMetadataGenerator = ComponentMetadataGenerator;
+function normalizeMeta(meta) {
+    const result = {
+        ...meta,
+        properties: meta.properties &&
+            meta.properties.map(({ option, ...rest }) => ({ ...rest })),
+        events: meta.events && meta.events.map(({ option, ...rest }) => ({ ...rest })),
+    };
+    if (!result.imports || !result.imports.length) {
+        result.imports = undefined;
+        delete result.imports;
+    }
+    (0, logging_1.log)(result);
+    return result;
+}
+//# sourceMappingURL=metadata-generator.js.map