devextreme-internal-tools 10.0.0-beta.9 → 12.0.0-beta.10

package/ts/angular-components-generator/import-helper.d.ts

@@ -0,0 +1,6 @@
+import { Option } from './metadata-model';
+export interface FileImport {
+    path: string;
+    importString: string;
+}
+export declare function buildImports(options: Option[], widgetPackageName: string): FileImport[];

package/ts/angular-components-generator/import-helper.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildImports = void 0;
+var helpers_1 = require("./helpers");
+function buildImports(options, widgetPackageName) {
+    var importsByPath = extractImportsMeta(options).reduce(function (paths, _a) {
+        var Path = _a.Path, Name = _a.Name, Alias = _a.Alias;
+        if (!paths[Path]) {
+            paths[Path] = {};
+        }
+        paths[Path]["".concat(Name, "+").concat(Alias)] = { Name: Name, Alias: Alias };
+        return paths;
+    }, {});
+    return Object.keys(importsByPath)
+        .map(function (path) {
+        var _a = extractDefaultImport((0, helpers_1.getValues)(importsByPath[path])), defaultImport = _a.defaultImport, namedImports = _a.namedImports;
+        var parts = [];
+        if (defaultImport) {
+            parts.push(defaultImport);
+        }
+        if (namedImports.length) {
+            var namedImportsString = namedImports
+                .sort((0, helpers_1.byKeyComparer)(function (i) { return i.Name; }))
+                .map(function (_a) {
+                var Name = _a.Name, Alias = _a.Alias;
+                return (Alias ? "".concat(Name, " as ").concat(Alias) : Name);
+            })
+                .join(', ');
+            parts.push("{ ".concat(namedImportsString, " }"));
+        }
+        return {
+            path: "".concat(widgetPackageName, "/").concat(path),
+            importString: parts.join(', '),
+        };
+    })
+        .sort((0, helpers_1.byKeyComparer)(function (i) { return i.path; }));
+}
+exports.buildImports = buildImports;
+function extractImportsMeta(options) {
+    if (!options || !options.length) {
+        return [];
+    }
+    return options.reduce(function (r, option) {
+        if (option) {
+            r.push.apply(r, option.TypeImports);
+            r.push.apply(r, extractImportsMeta((0, helpers_1.getValues)(option.Options)));
+        }
+        return r;
+    }, []);
+}
+function extractDefaultImport(imports) {
+    var result = {
+        defaultImport: undefined,
+        namedImports: [],
+    };
+    for (var _i = 0, imports_1 = imports; _i < imports_1.length; _i++) {
+        var entry = imports_1[_i];
+        if (isDefaultImport(entry)) {
+            if (!entry.Alias) {
+                throw new Error("default export must have an alias: ".concat(JSON.stringify(entry)));
+            }
+            result.defaultImport = entry.Alias;
+        }
+        else {
+            result.namedImports.push(entry);
+        }
+    }
+    return result;
+}
+function isDefaultImport(importName) {
+    return importName.Name.toLowerCase() === 'default';
+}
+//# sourceMappingURL=import-helper.js.map

package/ts/angular-components-generator/import-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-helper.js","sourceRoot":"","sources":["../../../ts/angular-components-generator/import-helper.ts"],"names":[],"mappings":";;;AACA,qCAAqD;AAOrD,SAAgB,YAAY,CAAC,OAAiB,EAAE,iBAAyB;IACvE,IAAM,aAAa,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC,MAAM,CACtD,UAAC,KAAK,EAAE,EAAqB;YAAnB,IAAI,UAAA,EAAE,IAAI,UAAA,EAAE,KAAK,WAAA;QACzB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;YAChB,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;SAClB;QAED,KAAK,CAAC,IAAI,CAAC,CAAC,UAAG,IAAI,cAAI,KAAK,CAAE,CAAC,GAAG,EAAE,IAAI,MAAA,EAAE,KAAK,OAAA,EAAE,CAAC;QAElD,OAAO,KAAK,CAAC;IACf,CAAC,EAAE,EAAgD,CACpD,CAAC;IAEF,OAAO,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC;SAC9B,GAAG,CAAC,UAAC,IAAI;QACF,IAAA,KAAkC,oBAAoB,CAAC,IAAA,mBAAS,EAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAApF,aAAa,mBAAA,EAAE,YAAY,kBAAyD,CAAC;QAC7F,IAAM,KAAK,GAAG,EAAE,CAAC;QAEjB,IAAI,aAAa,EAAE;YACjB,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SAC3B;QAED,IAAI,YAAY,CAAC,MAAM,EAAE;YACvB,IAAM,kBAAkB,GAAG,YAAY;iBACpC,IAAI,CAAC,IAAA,uBAAa,EAAC,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,IAAI,EAAN,CAAM,CAAC,CAAC;iBAClC,GAAG,CAAC,UAAC,EAAe;oBAAb,IAAI,UAAA,EAAE,KAAK,WAAA;gBAAO,OAAA,CAAC,KAAK,CAAC,CAAC,CAAC,UAAG,IAAI,iBAAO,KAAK,CAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YAAtC,CAAsC,CAAC;iBAChE,IAAI,CAAC,IAAI,CAAC,CAAC;YAEd,KAAK,CAAC,IAAI,CAAC,YAAK,kBAAkB,OAAI,CAAC,CAAC;SACzC;QAED,OAAO;YACL,IAAI,EAAE,UAAG,iBAAiB,cAAI,IAAI,CAAE;YACpC,YAAY,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;SACjB,CAAC;IAClB,CAAC,CAAC;SACD,IAAI,CAAC,IAAA,uBAAa,EAAC,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,IAAI,EAAN,CAAM,CAAC,CAAC,CAAC;AACxC,CAAC;AArCD,oCAqCC;AAED,SAAS,kBAAkB,CAAC,OAAiB;IAC3C,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;QAC/B,OAAO,EAAE,CAAC;KACX;IAED,OAAO,OAAO,CAAC,MAAM,CACnB,UAAC,CAAC,EAAE,MAAM;QACR,IAAI,MAAM,EAAE;YACV,CAAC,CAAC,IAAI,OAAN,CAAC,EAAS,MAAM,CAAC,WAAW,EAAE;YAC9B,CAAC,CAAC,IAAI,OAAN,CAAC,EAAS,kBAAkB,CAAC,IAAA,mBAAS,EAAC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE;SAC1D;QACD,OAAO,CAAC,CAAC;IACX,CAAC,EAAE,EAAc,CAClB,CAAC;AACJ,CAAC;AAED,SAAS,oBAAoB,CAC3B,OAAqB;IAErB,IAAM,MAAM,GAA4C;QACtD,aAAa,EAAE,SAAS;QACxB,YAAY,EAAE,EAAE;KACjB,CAAC;IAEF,KAAoB,UAAO,EAAP,mBAAO,EAAP,qBAAO,EAAP,IAAO,EAAE;QAAxB,IAAM,KAAK,gBAAA;QACd,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE;YAC1B,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE;gBAChB,MAAM,IAAI,KAAK,CAAC,6CAAsC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAE,CAAC,CAAC;aAChF;YACD,MAAM,CAAC,aAAa,GAAG,KAAK,CAAC,KAAK,CAAC;SACpC;aAAM;YACL,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACjC;KACF;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,eAAe,CAAC,UAAsB;IAC7C,OAAO,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,SAAS,CAAC;AACrD,CAAC"}

package/ts/angular-components-generator/logger.d.ts

@@ -0,0 +1 @@
+export default function (...args: any[]): void;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var yargs = require("yargs");
+var argv = yargs
+    .default('verbose', false).parseSync();
+function default_1() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (argv.verbose) {
+        console.log.apply(console, args);
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=logger.js.map

package/ts/angular-components-generator/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../../ts/angular-components-generator/logger.ts"],"names":[],"mappings":";;AAAA,6BAA+B;AAE/B,IAAM,IAAI,GAAG,KAAK;KACf,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,SAAS,EAAE,CAAC;AAEzC;IAAyB,cAAO;SAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;QAAP,yBAAO;;IAC9B,IAAI,IAAI,CAAC,OAAO,EAAE;QAChB,OAAO,CAAC,GAAG,OAAX,OAAO,EAAQ,IAAI,EAAE;KACtB;AACH,CAAC;AAJD,4BAIC"}

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

@@ -0,0 +1,27 @@
+import { Metadata } from './metadata-model';
+export interface IObjectStore {
+    read(name: string): Metadata;
+    write(name: string, data: Record<string, any>): void;
+}
+export declare class FSObjectStore implements IObjectStore {
+    private encoding;
+    read(filePath: any): any;
+    write(filePath: any, data: any): void;
+}
+export declare class ComponentMetadataGenerator {
+    private store?;
+    constructor(store?: IObjectStore);
+    generate(config: any): void;
+    private createEvent;
+    private getTypesDescription;
+    private getTypeParts;
+    private getObjectType;
+    private getEventType;
+    private getType;
+    private mergeArrayTypes;
+    private getExternalObjectInfo;
+    private generateComplexOptionByType;
+    private generateComplexOption;
+    private getBaseComponentPath;
+    private generateNestedOptions;
+}

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

@@ -0,0 +1,490 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentMetadataGenerator = exports.FSObjectStore = void 0;
+var fs = require("fs");
+var path = require("path");
+var mkdirp = require("mkdirp");
+var merge = require("deepmerge");
+var inflector = require("inflector-js");
+var logger_1 = require("./logger");
+var import_helper_1 = require("./import-helper");
+var helpers_1 = require("./helpers");
+var OPTION_COMPONENT_PREFIX = 'Dxo';
+var ITEM_COMPONENT_PREFIX = 'Dxi';
+var TYPES_SEPORATOR = ' | ';
+function trimDx(value) {
+    return trimPrefix('dx-', value);
+}
+function trimPrefix(prefix, value) {
+    if (value.indexOf(prefix) === 0) {
+        return value.substr(prefix.length);
+    }
+    return value;
+}
+var FSObjectStore = (function () {
+    function FSObjectStore() {
+        this.encoding = 'utf8';
+    }
+    FSObjectStore.prototype.read = function (filePath) {
+        (0, logger_1.default)("Read from file: ".concat(filePath));
+        var dataString = fs.readFileSync(filePath, { encoding: this.encoding });
+        (0, logger_1.default)('Parse data');
+        return JSON.parse(dataString);
+    };
+    FSObjectStore.prototype.write = function (filePath, data) {
+        (0, logger_1.default)("Write data to file ".concat(filePath));
+        var dataString = JSON.stringify(data, null, 4);
+        fs.writeFileSync(filePath, dataString, { encoding: this.encoding });
+    };
+    return FSObjectStore;
+}());
+exports.FSObjectStore = FSObjectStore;
+var ComponentMetadataGenerator = (function () {
+    function ComponentMetadataGenerator(store) {
+        this.store = store;
+        if (!this.store) {
+            this.store = new FSObjectStore();
+        }
+    }
+    ComponentMetadataGenerator.prototype.generate = function (config) {
+        var _a, _b;
+        var sourceMetadata = this.store.read(config.sourceMetadataFilePath);
+        var deprecatedMetadata = this.store.read(config.deprecatedMetadataFilePath);
+        var metadata = merge(sourceMetadata, deprecatedMetadata);
+        var widgetsMetadata = metadata.Widgets;
+        var allNestedComponents = [];
+        mkdirp.sync(config.outputFolderPath);
+        mkdirp.sync(path.join(config.outputFolderPath, config.nestedPathPart));
+        mkdirp.sync(path.join(config.outputFolderPath, config.nestedPathPart, config.basePathPart));
+        var _loop_1 = function (widgetName) {
+            var widget = widgetsMetadata[widgetName];
+            var nestedComponents = [];
+            if (!widget.Module) {
+                (0, logger_1.default)("Skipping metadata for ".concat(widgetName));
+                return "continue";
+            }
+            (0, logger_1.default)("Generate metadata for ".concat(widgetName));
+            var isTranscludedContent = widget.IsTranscludedContent;
+            var isViz = widget.Module.indexOf('viz') === 0;
+            var isExtension = widget.IsExtensionComponent || false;
+            var className = inflector.camelize(widgetName);
+            var dasherizedWidgetName = inflector.dasherize(inflector.underscore(widgetName));
+            var outputFilePath = path.join(config.outputFolderPath, "".concat(trimDx(dasherizedWidgetName), ".json"));
+            var events = [];
+            var changeEvents = [];
+            var properties = [];
+            var isEditor = Object.keys(widget.Options).indexOf('onValueChanged') !== -1;
+            for (var optionName in widget.Options) {
+                var option = widget.Options[optionName];
+                if (option.IsEvent) {
+                    var eventName = inflector.camelize(optionName.substr('on'.length), true);
+                    var eventType = ((_a = option.TypeImports) === null || _a === void 0 ? void 0 : _a.length) ? option.TypeImports[0].Name : 'any';
+                    events.push({
+                        docID: option.DocID,
+                        isDeprecated: option.IsDeprecated,
+                        emit: optionName,
+                        subscribe: eventName,
+                        type: "EventEmitter<".concat(eventType, ">"),
+                    });
+                }
+                else {
+                    var typesDescription = this_1.getTypesDescription(option);
+                    var finalizedType = this_1.getType(typesDescription);
+                    var property = {
+                        docID: option.DocID,
+                        isDeprecated: option.IsDeprecated,
+                        name: optionName,
+                        type: finalizedType,
+                        typesDescription: typesDescription,
+                        option: option,
+                    };
+                    if (!!option.IsCollection || !!option.IsDataSource) {
+                        property.isCollection = true;
+                    }
+                    properties.push(property);
+                    changeEvents.push(this_1.createEvent(optionName, finalizedType, option));
+                    var components = this_1.generateComplexOptionByType(metadata, option, optionName, [], config);
+                    nestedComponents = nestedComponents.concat.apply(nestedComponents, components);
+                }
+            }
+            var allEvents = events.concat(changeEvents);
+            if (isEditor) {
+                allEvents.push({ emit: 'onBlur', type: 'EventEmitter<any>' });
+            }
+            var widgetNestedComponents = nestedComponents
+                .reduce(function (result, component) {
+                if (result.filter(function (c) { return c.className === component.className; }).length === 0) {
+                    result.push({
+                        path: component.path,
+                        propertyName: component.propertyName,
+                        className: component.className,
+                        events: component.events,
+                        isCollection: component.isCollection,
+                        hasTemplate: component.hasTemplate,
+                        root: properties.filter(function (p) { return p.name === component.propertyName; }).length === 1 ? true : undefined,
+                    });
+                }
+                return result;
+            }, []);
+            var containsReexports = !!((_b = widget.Reexports) === null || _b === void 0 ? void 0 : _b.filter(function (r) { return r !== 'default'; }).length);
+            var widgetMetadata = {
+                docID: widget.DocID,
+                isDeprecated: widget.IsDeprecated,
+                className: className,
+                widgetName: widgetName,
+                isTranscludedContent: isTranscludedContent,
+                isViz: isViz,
+                isExtension: isExtension,
+                selector: dasherizedWidgetName,
+                events: allEvents,
+                properties: properties,
+                isEditor: isEditor,
+                module: "".concat(config.widgetPackageName, "/").concat(widget.Module),
+                packageName: config.wrapperPackageName,
+                imports: (0, import_helper_1.buildImports)((0, helpers_1.getValues)(widget.Options), config.widgetPackageName),
+                nestedComponents: widgetNestedComponents,
+                optionsTypeParams: widget.OptionsTypeParams,
+                renderReexports: config.generateReexports && containsReexports,
+            };
+            (0, logger_1.default)("Write metadata to file ".concat(outputFilePath));
+            this_1.store.write(outputFilePath, normalizeMeta(widgetMetadata));
+            allNestedComponents = allNestedComponents.concat.apply(allNestedComponents, nestedComponents);
+        };
+        var this_1 = this;
+        for (var widgetName in widgetsMetadata) {
+            _loop_1(widgetName);
+        }
+        this.generateNestedOptions(config, allNestedComponents);
+    };
+    ComponentMetadataGenerator.prototype.createEvent = function (name, type, option) {
+        return {
+            isInternal: true,
+            emit: "".concat(name, "Change"),
+            type: "EventEmitter<".concat(type, ">"),
+            option: option,
+        };
+    };
+    ComponentMetadataGenerator.prototype.getTypesDescription = function (optionMetadata) {
+        var typeParts = this.getTypeParts(optionMetadata);
+        return {
+            primitiveTypes: typeParts.primitiveTypes,
+            arrayTypes: typeParts.arrayTypes,
+        };
+    };
+    ComponentMetadataGenerator.prototype.getTypeParts = function (optionMetadata) {
+        var primitiveTypes = optionMetadata.PrimitiveTypes ? optionMetadata.PrimitiveTypes.slice(0) : [];
+        var arrayTypes = [];
+        if (optionMetadata.ItemPrimitiveTypes) {
+            if (optionMetadata.IsPromise) {
+                var promiseType = optionMetadata.ItemPrimitiveTypes.join(TYPES_SEPORATOR);
+                primitiveTypes.push("Promise<".concat(promiseType, "> & JQueryPromise<").concat(promiseType, ">"));
+            }
+            else {
+                arrayTypes = arrayTypes.concat(optionMetadata.ItemPrimitiveTypes);
+            }
+        }
+        if (optionMetadata.Options) {
+            var optionType = this.getObjectType(optionMetadata.Options);
+            if (optionType.length) {
+                (optionMetadata.IsCollection ? arrayTypes : primitiveTypes).push(optionType);
+            }
+        }
+        return ({ primitiveTypes: primitiveTypes, arrayTypes: arrayTypes });
+    };
+    ComponentMetadataGenerator.prototype.getObjectType = function (optionMetadata) {
+        var objectType = [];
+        for (var option in optionMetadata) {
+            var typeParts = this.getTypeParts(optionMetadata[option]);
+            var type = this.getType(typeParts);
+            objectType.push("".concat(option, "?: ").concat(type));
+        }
+        if (objectType.length) {
+            return "{ ".concat(objectType.join(', '), " }");
+        }
+        return '';
+    };
+    ComponentMetadataGenerator.prototype.getEventType = function (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: ".concat(option.TypeImports[0].Name, ") => void)");
+    };
+    ComponentMetadataGenerator.prototype.getType = function (typesDescription) {
+        var primitiveTypes = typesDescription.primitiveTypes.slice(0);
+        var result = 'any';
+        if (typesDescription.arrayTypes.length) {
+            primitiveTypes.push("Array<".concat(typesDescription.arrayTypes.join(TYPES_SEPORATOR), ">"));
+        }
+        if (primitiveTypes.length) {
+            result = primitiveTypes.join(TYPES_SEPORATOR);
+        }
+        return result;
+    };
+    ComponentMetadataGenerator.prototype.mergeArrayTypes = function (array1, array2) {
+        var newTypes = array2.filter(function (type) { return array1.indexOf(type) === -1; });
+        return [].concat(array1, newTypes);
+    };
+    ComponentMetadataGenerator.prototype.getExternalObjectInfo = function (metadata, typeName) {
+        var externalObject = metadata.ExtraObjects[typeName];
+        if (!externalObject) {
+            var postfix = 'Options';
+            if (typeName.endsWith(postfix)) {
+                var widgetName = typeName.substr(0, typeName.length - postfix.length);
+                externalObject = metadata.Widgets[widgetName];
+                typeName = trimPrefix('dx', typeName);
+            }
+        }
+        if (!externalObject) {
+            console.warn("WARN: missed complex type: ".concat(typeName));
+        }
+        else {
+            return {
+                Options: externalObject.Options,
+                typeName: typeName,
+            };
+        }
+        return undefined;
+    };
+    ComponentMetadataGenerator.prototype.generateComplexOptionByType = function (metadata, option, optionName, complexTypes, config) {
+        var _this = this;
+        var 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 undefined;
+            }
+            var result_1 = [];
+            optionComplexTypes.forEach(function (complexType) {
+                var externalObjectInfo = _this.getExternalObjectInfo(metadata, complexType);
+                if (externalObjectInfo) {
+                    var nestedOptions = externalObjectInfo.Options;
+                    var nestedComplexTypes = complexTypes.concat(externalObjectInfo.typeName);
+                    result_1.push.apply(result_1, _this.generateComplexOption(metadata, nestedOptions, optionName, nestedComplexTypes, option, config));
+                }
+            });
+            if (optionComplexTypes.length === 1) {
+                var externalObjectInfo = this.getExternalObjectInfo(metadata, optionComplexTypes[0]);
+                if (externalObjectInfo) {
+                    result_1[0].baseClass = (option.IsCollection ? ITEM_COMPONENT_PREFIX : OPTION_COMPONENT_PREFIX) + externalObjectInfo.typeName;
+                    result_1[0].basePath = inflector.dasherize(inflector.underscore(externalObjectInfo.typeName));
+                }
+            }
+            return result_1;
+        }
+        return undefined;
+    };
+    ComponentMetadataGenerator.prototype.generateComplexOption = function (metadata, nestedOptions, optionName, complexTypes, option, config) {
+        var _a;
+        var _b;
+        if (!nestedOptions || !Object.keys(nestedOptions).length) {
+            return undefined;
+        }
+        var pluralName = optionName;
+        if (option.IsCollection) {
+            pluralName = "".concat(option.SingularName, "Dxi");
+        }
+        var singularName = option.SingularName || pluralName;
+        var underscoreSingular = inflector.underscore(singularName).split('.').join('_');
+        var underscorePlural = inflector.underscore(pluralName).split('.').join('_');
+        var prefix = "".concat((option.IsCollection ? ITEM_COMPONENT_PREFIX : OPTION_COMPONENT_PREFIX).toLocaleLowerCase(), "_");
+        var underscoreSelector = prefix + (option.IsCollection ? underscoreSingular : underscorePlural);
+        var selector = inflector.dasherize(underscoreSelector);
+        var complexOptionMetadata = {
+            docID: option.DocID,
+            isDeprecated: option.IsDeprecated,
+            className: inflector.camelize(underscoreSelector),
+            selector: selector,
+            optionName: optionName,
+            properties: [],
+            events: [],
+            path: inflector.dasherize(underscorePlural),
+            propertyName: optionName,
+            isCollection: option.IsCollection,
+            hasTemplate: option.Options && option.Options.template && option.Options.template.IsTemplate,
+            collectionNestedComponents: [],
+            imports: [],
+        };
+        var nestedComponents = [complexOptionMetadata];
+        for (var optName in nestedOptions) {
+            var nestedOption = nestedOptions[optName];
+            var typesDescription = this.getTypesDescription(nestedOption);
+            var propertyType = this.getType(typesDescription);
+            if (nestedOption.IsEvent && nestedOption.IsEvent && ((_b = nestedOption.TypeImports) === null || _b === void 0 ? void 0 : _b.length)) {
+                propertyType = "((e: ".concat(nestedOption.TypeImports[0].Name, ") => void)");
+            }
+            var property = {
+                docID: nestedOption.DocID,
+                isDeprecated: nestedOption.IsDeprecated,
+                name: optName,
+                type: propertyType,
+                typesDescription: 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));
+            }
+            var components = this.generateComplexOptionByType(metadata, nestedOptions[optName], optName, complexTypes, config) || [];
+            nestedComponents = nestedComponents.concat.apply(nestedComponents, components);
+            var ownCollectionNestedComponents = components
+                .filter(function (c) { return complexOptionMetadata
+                .properties
+                .filter(function (p) { return p.name === c.propertyName && p.isCollection; }).length === 1; })
+                .map(function (c) { return ({
+                className: c.className,
+                path: c.path,
+                propertyName: c.propertyName,
+            }); });
+            (_a = complexOptionMetadata.collectionNestedComponents).push.apply(_a, ownCollectionNestedComponents);
+        }
+        complexOptionMetadata.imports = (0, import_helper_1.buildImports)((0, helpers_1.getValues)(nestedOptions), config.widgetPackageName);
+        return nestedComponents;
+    };
+    ComponentMetadataGenerator.prototype.getBaseComponentPath = function (component) {
+        return component.basePath + (component.isCollection ? '-dxi' : '');
+    };
+    ComponentMetadataGenerator.prototype.generateNestedOptions = function (config, metadata) {
+        var _this = this;
+        var normalizedMetadata = metadata
+            .reduce(function (result, component) {
+            var _a, _b, _c, _d;
+            var existingComponent = result.filter(function (c) { return c.className === component.className; })[0];
+            if (!existingComponent) {
+                component.options = component.properties.map(function (p) { return p.option; });
+                result.push(component);
+            }
+            else {
+                existingComponent.properties = (_a = existingComponent.properties)
+                    .concat.apply(_a, component.properties).reduce(function (properties, property) {
+                    var _a;
+                    if (properties.filter(function (p) { return p.name === property.name; }).length === 0) {
+                        properties.push(property);
+                    }
+                    else {
+                        var existingProperty = properties.filter(function (p) { return p.name === property.name; })[0];
+                        var typesDescription = existingProperty.typesDescription;
+                        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;
+                }, []);
+                existingComponent.events = (_b = existingComponent.events)
+                    .concat.apply(_b, component.events).reduce(function (events, event) {
+                    if (events.filter(function (e) { return e.emit === event.emit; }).length === 0) {
+                        events.push(event);
+                    }
+                    return events;
+                }, []);
+                existingComponent.baseClass = existingComponent.baseClass || component.baseClass;
+                existingComponent.basePath = existingComponent.basePath || component.basePath;
+                (_c = existingComponent.collectionNestedComponents).push.apply(_c, component.collectionNestedComponents);
+                (_d = existingComponent.options).push.apply(_d, component.properties.map(function (p) { return p.option; }));
+            }
+            return result;
+        }, []);
+        normalizedMetadata.forEach(function (component) {
+            component.collectionNestedComponents = component.collectionNestedComponents
+                .reduce(function (result, nestedComponent) {
+                if (result.filter(function (c) { return nestedComponent.className === c.className; }).length === 0) {
+                    result.push(nestedComponent);
+                }
+                return result;
+            }, []);
+        });
+        normalizedMetadata
+            .reduce(function (result, component) {
+            var existingComponent = result.filter(function (c) { return c.className === component.baseClass; })[0];
+            if (!existingComponent && component.baseClass) {
+                var 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;
+        }, [])
+            .forEach(function (component) {
+            var outputFilePath = path.join(config.outputFolderPath, config.nestedPathPart, config.basePathPart, "".concat(component.path, ".json"));
+            _this.store.write(outputFilePath, normalizeMeta(component));
+        });
+        normalizedMetadata
+            .map(function (component) {
+            if (component.events && !component.events.length) {
+                delete component.events;
+            }
+            if (component.baseClass) {
+                component.inputs = component.properties;
+                delete component.properties;
+                component.basePath = "./base/".concat(_this.getBaseComponentPath(component));
+                component.imports = component.events
+                    ? component.imports = (0, import_helper_1.buildImports)(component.events.map(function (e) { return 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;
+        })
+            .forEach(function (component) {
+            var outputFilePath = path.join(config.outputFolderPath, config.nestedPathPart, "".concat(component.path, ".json"));
+            _this.store.write(outputFilePath, normalizeMeta(component));
+        });
+    };
+    return ComponentMetadataGenerator;
+}());
+exports.ComponentMetadataGenerator = ComponentMetadataGenerator;
+function normalizeMeta(meta) {
+    var result = __assign(__assign({}, meta), { properties: meta.properties && meta.properties.map(function (_a) {
+            var option = _a.option, rest = __rest(_a, ["option"]);
+            return (__assign({}, rest));
+        }), events: meta.events && meta.events.map(function (_a) {
+            var option = _a.option, rest = __rest(_a, ["option"]);
+            return (__assign({}, rest));
+        }) });
+    if (!result.imports || !result.imports.length) {
+        result.imports = undefined;
+        delete result.imports;
+    }
+    (0, logger_1.default)(result);
+    return result;
+}
+//# sourceMappingURL=metadata-generator.js.map