@cnbcool/cnb-api-generate 1.0.0

package/built/codegen/enum/generate-enum-ast-node.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnumASTNode = generateEnumASTNode;
+const ts = __importStar(require("typescript"));
+const format_interface_name_1 = require("../../utils/format-interface-name");
+const generate_enum_content_ast_node_1 = require("./generate-enum-content-ast-node");
+const comment_line_break_1 = require("../../utils/comment-line-break");
+function generateEnumASTNode(name, defintion) {
+    const enumName = (0, format_interface_name_1.formatInterfaceName)(name);
+    const propertieDesc = {};
+    const { enum: enumValues, 'x-enum-varnames': enumKeys, 'x-enum-descriptions': enumDesc, type, } = defintion;
+    const jsonData = {
+        type: type === 'integer' ? 'number' : type,
+        enum: enumValues,
+        'x-enum-descriptions': enumDesc,
+    };
+    const nodes = [];
+    const { enumContent } = (0, generate_enum_content_ast_node_1.generateEnumContentASTNode)(name, type, enumKeys, enumValues, enumDesc, propertieDesc);
+    nodes.push(ts.factory.createEnumDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(enumName), enumContent));
+    const enumFileContent = [];
+    const { description, example, default: _default, format } = defintion;
+    if (description || example || _default) {
+        const startFlag = `<$desc-flag-start$>`;
+        propertieDesc[startFlag] = '/**';
+        enumFileContent.push(ts.factory.createExpressionStatement(ts.factory.createStringLiteral(startFlag)));
+        if (description) {
+            const flag = `<$desc-flag-desc$>`;
+            propertieDesc[flag] = `* ${description}`;
+            propertieDesc[flag] = (0, comment_line_break_1.commentLineBreak)(propertieDesc[flag]);
+            enumFileContent.push(ts.factory.createExpressionStatement(ts.factory.createStringLiteral(flag)));
+        }
+        if (format) {
+            const flag = `<$desc-flag-format$>`;
+            propertieDesc[flag] = `* @format ${format}`;
+            propertieDesc[flag] = (0, comment_line_break_1.commentLineBreak)(propertieDesc[flag]);
+            enumFileContent.push(ts.factory.createExpressionStatement(ts.factory.createStringLiteral(flag)));
+        }
+        if (example) {
+            const flag = `<$desc-flag-example$>`;
+            propertieDesc[flag] = `* @example ${example}`;
+            propertieDesc[flag] = (0, comment_line_break_1.commentLineBreak)(propertieDesc[flag]);
+            enumFileContent.push(ts.factory.createExpressionStatement(ts.factory.createStringLiteral(flag)));
+        }
+        if (_default) {
+            const flag = `<$desc-flag-default$>`;
+            propertieDesc[flag] = `* @default ${_default}`;
+            propertieDesc[flag] = (0, comment_line_break_1.commentLineBreak)(propertieDesc[flag]);
+            enumFileContent.push(ts.factory.createExpressionStatement(ts.factory.createStringLiteral(flag)));
+        }
+        const endFlag = `<$desc-flag-end$>`;
+        propertieDesc[endFlag] = '*/';
+        enumFileContent.push(ts.factory.createExpressionStatement(ts.factory.createStringLiteral(endFlag)));
+    }
+    enumFileContent.push(...nodes);
+    return {
+        exportName: enumName,
+        nodes: enumFileContent,
+        importList: [],
+        descriptions: propertieDesc,
+        jsonData
+    };
+}

package/built/codegen/enum/generate-enum-content-ast-node.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnumContentASTNode = generateEnumContentASTNode;
+const ts = __importStar(require("typescript"));
+const constants_1 = require("../../constants");
+const debug_1 = __importDefault(require("debug"));
+const logger = (0, debug_1.default)('cag:enum');
+function generateEnumContentASTNode(name, type, enumkeys, enumValues, enumDesc, propertieDesc) {
+    if (type !== constants_1.DefinitionsType.STRING &&
+        type !== constants_1.DefinitionsType.INTEGER &&
+        type !== constants_1.DefinitionsType.NUMBER) {
+        throw new Error(`[${name}] type: ${type}, defintion other than string、integer or nunber is not supported!`);
+    }
+    const enumContent = [];
+    for (let i = 0; i < enumValues.length; i++) {
+        const enumValue = enumValues[i];
+        const enumKey = enumkeys ? enumkeys[i] : `Value${enumValue}`;
+        logger(`[${name}] Enum: ${enumKey} = ${enumValue}`);
+        if (enumDesc && enumDesc[i]) {
+            const flag = `<$enum-${enumKey}-flag$>`;
+            enumContent.push(ts.factory.createEnumMember(ts.factory.createStringLiteral(flag), undefined));
+            propertieDesc[flag] = `/* ${enumDesc[i]} */`;
+        }
+        if (type === constants_1.DefinitionsType.STRING) {
+            enumContent.push(ts.factory.createEnumMember(ts.factory.createIdentifier(enumKey), ts.factory.createStringLiteral(enumValue)));
+        }
+        else {
+            // 数字是否为负数
+            if (enumValue >= 0) {
+                enumContent.push(ts.factory.createEnumMember(ts.factory.createIdentifier(enumKey), ts.factory.createNumericLiteral(enumValue)));
+            }
+            else {
+                enumContent.push(ts.factory.createEnumMember(ts.factory.createIdentifier(enumKey), ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(Math.abs(enumValue)))));
+            }
+        }
+    }
+    return { enumContent };
+}

package/built/codegen/interface/generate-import-interface-ast-node.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportInterfaceAstNode = generateImportInterfaceAstNode;
+const ts = __importStar(require("typescript"));
+const constants_1 = require("../../constants");
+const get_printer_file_prefix_1 = require("../../utils/get-printer-file-prefix");
+function generateImportInterfaceAstNode(type, importName, importPath) {
+    const prefix = type === constants_1.PrinterFilterType.INTERFACE
+        ? './'
+        : `../${(0, get_printer_file_prefix_1.getPrinterFilePrefix)(type)}/`;
+    return ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(importName)),
+    ])), ts.factory.createStringLiteral(`${prefix}${importPath}`), undefined);
+}

package/built/codegen/interface/generate-interface-anchor-ast-node.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterfaceAnchorASTNode = generateInterfaceAnchorASTNode;
+const debug_1 = __importDefault(require("debug"));
+const get_defintion_name_1 = require("../../utils/get-defintion-name");
+const swagger_definitions_to_ast_node_1 = require("../swagger-definitions-to-ast-node");
+const logger = (0, debug_1.default)('cag:interface');
+function generateInterfaceAnchorASTNode(name, key, ref, definitions, defintionsMap, interfaceDependency) {
+    const refKey = (0, get_defintion_name_1.getDefinitionName)(ref);
+    const refTarget = definitions[refKey];
+    logger(`[${name}] <${key}> is anchor point, $ref -> ${refKey}`);
+    (0, swagger_definitions_to_ast_node_1.swaggerDefinitionsToASTNode)(refKey, refTarget, definitions, defintionsMap);
+    // 检查锚点是否正确解析AST
+    if (!defintionsMap[refKey]) {
+        throw new Error(`[${name}] ${refKey} Object anchor point is not found!`);
+    }
+    // 添加依赖记录
+    interfaceDependency.add(refKey);
+    // 获取锚点对应的AST
+    const anchorPointItem = defintionsMap[refKey];
+    return anchorPointItem;
+}

package/built/codegen/interface/generate-interface-ast-node.js

@@ -0,0 +1,322 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterfaceASTNode = generateInterfaceASTNode;
+const ts = __importStar(require("typescript"));
+const constants_1 = require("../../constants");
+const get_keyword_type_node_1 = require("../../utils/get-keyword-type-node");
+const debug_1 = __importDefault(require("debug"));
+const is_english_only_1 = require("../../utils/is-english-only");
+const generate_record_ast_node_1 = require("../record/generate-record-ast-node");
+const generate_interface_anchor_ast_node_1 = require("./generate-interface-anchor-ast-node");
+const comment_line_break_1 = require("../../utils/comment-line-break");
+const logger = (0, debug_1.default)('cag:interface');
+function generateInterfaceASTNode(name, definitionsType, currProperties, definitions, defintionsMap, parentKey) {
+    const currLoggerName = parentKey ? `${name}.${parentKey}` : name;
+    logger(`[${currLoggerName}] generate start...`);
+    if (definitionsType !== constants_1.DefinitionsType.OBJECT &&
+        definitionsType !== constants_1.DefinitionsType.ARRAY) {
+        throw new Error(`[${name}] type: ${definitionsType}, defintion other than object or array is not supported!`);
+    }
+    let keywordTypeNode;
+    let interfaceDependency = new Set();
+    const propertieDesc = {};
+    const interfaceContent = [];
+    const interfaceJSONData = {};
+    // eslint-disable-next-line no-restricted-syntax
+    for (const key in currProperties) {
+        interfaceJSONData[key] = {};
+        const property = currProperties[key];
+        const { type, $ref, properties, additionalProperties, items, enum: _enum, oneOf, allOf, anyOf, example, description, default: _default, } = property;
+        type && logger(`[${currLoggerName}] <${key}> is ${type}`);
+        // 当存在oneOf、allOf、anyOf时，需要特殊处理
+        if (oneOf || allOf || anyOf) {
+            const someOfList = oneOf || allOf || anyOf || [];
+            const someOfDataTypeFlag = [];
+            const someOfJSONData = [];
+            const unionIntersectionTypeNodes = [];
+            // eslint-disable-next-line @typescript-eslint/prefer-for-of
+            for (let i = 0; i < someOfList.length; i++) {
+                const someOfItem = someOfList[i];
+                // 普通对象类型
+                if (someOfItem.properties) {
+                    const { interfaceContent: subInterfaceContent, interfaceDependency: subInterfaceDependency, descriptionMap: subDescriptionMap, jsonData: subJsonData, } = generateInterfaceASTNode(name, someOfItem.type, someOfItem.properties, definitions, defintionsMap, `${parentKey ? `${parentKey}.` : ''}${key}`);
+                    someOfDataTypeFlag.push(constants_1.PrinterFilterType.INTERFACE);
+                    someOfJSONData.push(subJsonData);
+                    unionIntersectionTypeNodes.push(ts.factory.createTypeLiteralNode(subInterfaceContent));
+                    // 合并依赖
+                    interfaceDependency = new Set([
+                        ...interfaceDependency,
+                        ...subInterfaceDependency,
+                    ]);
+                    Object.assign(propertieDesc, subDescriptionMap);
+                    continue;
+                }
+                // 引用类型
+                if (someOfItem.$ref) {
+                    const anchorPointItem = (0, generate_interface_anchor_ast_node_1.generateInterfaceAnchorASTNode)(name, key, someOfItem.$ref, definitions, defintionsMap, interfaceDependency);
+                    someOfDataTypeFlag.push(anchorPointItem.type === constants_1.PrinterFilterType.ENUM ? constants_1.PrinterFilterType.ENUM : constants_1.PrinterFilterType.INTERFACE);
+                    someOfJSONData.push(anchorPointItem.jsonData);
+                    unionIntersectionTypeNodes.push(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(anchorPointItem.exportName), undefined));
+                    continue;
+                }
+            }
+            // 交叉类型 &
+            if (allOf) {
+                keywordTypeNode = ts.factory.createIntersectionTypeNode(unionIntersectionTypeNodes);
+                // 对于交叉类型，合并所有JSON数据
+                if (someOfDataTypeFlag[0] === constants_1.PrinterFilterType.INTERFACE) {
+                    interfaceJSONData[key] = { type: 'object', properties: Object.assign({}, ...someOfJSONData) };
+                }
+                else {
+                    interfaceJSONData[key] = { type: someOfJSONData[0].type };
+                }
+                // 联合类型 |
+            }
+            else {
+                keywordTypeNode = ts.factory.createUnionTypeNode(unionIntersectionTypeNodes);
+                // 对于联合类型，使用第一个JSON数据作为代表，并标记为联合类型
+                if (someOfDataTypeFlag[0] === constants_1.PrinterFilterType.INTERFACE) {
+                    interfaceJSONData[key] = { type: 'object', properties: someOfJSONData[0] };
+                }
+                else {
+                    interfaceJSONData[key] = { type: someOfJSONData[0].type };
+                }
+                interfaceJSONData[key] = {
+                    type: 'object',
+                    properties: someOfJSONData.length > 0 ? someOfJSONData[0] : undefined,
+                };
+            }
+        }
+        else {
+            const keywordTypeSyntaxKind = (0, get_keyword_type_node_1.getKeywordTypeNode)(type);
+            // 遇到锚点，优先处理锚点
+            if (keywordTypeSyntaxKind === ts.SyntaxKind.UnknownKeyword && $ref) {
+                const anchorPointItem = (0, generate_interface_anchor_ast_node_1.generateInterfaceAnchorASTNode)(name, key, $ref, definitions, defintionsMap, interfaceDependency);
+                if (anchorPointItem.type === constants_1.PrinterFilterType.ENUM) {
+                    interfaceJSONData[key] = anchorPointItem.jsonData;
+                }
+                else {
+                    interfaceJSONData[key] = { type: 'object', properties: anchorPointItem.jsonData };
+                }
+                keywordTypeNode = ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(anchorPointItem.exportName), undefined);
+                // 定义Record
+            }
+            else if (additionalProperties) {
+                const { recordContent, recordDependency, descriptionMap, recordJSON } = (0, generate_record_ast_node_1.generateRecordASTNode)(name, definitionsType, additionalProperties, definitions, defintionsMap);
+                keywordTypeNode = recordContent;
+                interfaceJSONData[key] = { type: 'object', properties: recordJSON };
+                // 合并依赖
+                interfaceDependency = new Set([
+                    ...interfaceDependency,
+                    ...recordDependency,
+                ]);
+                Object.assign(propertieDesc, descriptionMap);
+            }
+            else {
+                // 处理object
+                if (keywordTypeSyntaxKind === ts.SyntaxKind.ObjectKeyword &&
+                    properties) {
+                    const { interfaceContent: subInterfaceContent, interfaceDependency: subInterfaceDependency, descriptionMap: subDescriptionMap, jsonData: subJsonData, } = generateInterfaceASTNode(name, type, properties, definitions, defintionsMap, `${parentKey ? `${parentKey}.` : ''}${key}`);
+                    interfaceJSONData[key] = { type: 'object', properties: subJsonData };
+                    keywordTypeNode =
+                        ts.factory.createTypeLiteralNode(subInterfaceContent);
+                    // 合并依赖
+                    interfaceDependency = new Set([
+                        ...interfaceDependency,
+                        ...subInterfaceDependency,
+                    ]);
+                    Object.assign(propertieDesc, subDescriptionMap);
+                    // 处理数组
+                }
+                else if (keywordTypeSyntaxKind === ts.SyntaxKind.ArrayType) {
+                    if (!items) {
+                        throw new Error(`items is null.`);
+                    }
+                    const { $ref, type: subType } = items;
+                    // 判断是直接类型还是锚点
+                    if ($ref) {
+                        const anchorPointItem = (0, generate_interface_anchor_ast_node_1.generateInterfaceAnchorASTNode)(name, key, $ref, definitions, defintionsMap, interfaceDependency);
+                        interfaceJSONData[key] = { type: 'array', items: { properties: anchorPointItem.jsonData } };
+                        keywordTypeNode = ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(anchorPointItem.exportName), undefined));
+                    }
+                    else {
+                        logger(`[${currLoggerName}] <${key}> is multidimensional array`);
+                        const arrayItemKeywordTypeSyntaxKind = (0, get_keyword_type_node_1.getKeywordTypeNode)(subType);
+                        // 判断是否为一个对象, 如果是对象，则需要递归处理
+                        if (arrayItemKeywordTypeSyntaxKind === ts.SyntaxKind.ObjectKeyword &&
+                            items.properties) {
+                            const { interfaceContent: subObjectContent, interfaceDependency: subObjectDependency, descriptionMap: subObjectDescriptionMap, jsonData: subObjectJSON, } = generateInterfaceASTNode(name, subType, items.properties, definitions, defintionsMap, `${parentKey ? `${parentKey}.` : ''}${key}`);
+                            interfaceJSONData[key] = { type: 'array', items: subObjectJSON };
+                            keywordTypeNode =
+                                type === constants_1.DefinitionsKeywordTypeNodeKey.array
+                                    ? ts.factory.createArrayTypeNode(ts.factory.createTypeLiteralNode(subObjectContent))
+                                    : ts.factory.createTypeLiteralNode(subObjectContent);
+                            // 合并依赖
+                            interfaceDependency = new Set([
+                                ...interfaceDependency,
+                                ...subObjectDependency,
+                            ]);
+                            Object.assign(propertieDesc, subObjectDescriptionMap);
+                        }
+                        else {
+                            // 默认是any
+                            let arrayItemKeywordTypeNode = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword);
+                            // 多维数组的值只能是锚点或者直接类型
+                            if (arrayItemKeywordTypeSyntaxKind === ts.SyntaxKind.ArrayType) {
+                                // 查找对内层的具体类型
+                                let theEnd = false;
+                                let target = items;
+                                let layer = 0;
+                                while (!theEnd) {
+                                    if (!target.items) {
+                                        theEnd = true;
+                                        if (target.$ref) {
+                                            const anchorPointItem = (0, generate_interface_anchor_ast_node_1.generateInterfaceAnchorASTNode)(name, key, target.$ref, definitions, defintionsMap, interfaceDependency);
+                                            keywordTypeNode = ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(anchorPointItem.exportName), undefined));
+                                            let content = ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(anchorPointItem.exportName), undefined);
+                                            let _json = anchorPointItem.jsonData;
+                                            for (let i = 0; i < layer; i++) {
+                                                _json = [_json];
+                                                content = ts.factory.createArrayTypeNode(content);
+                                            }
+                                            interfaceJSONData[key] = { type: 'array', items: _json };
+                                            arrayItemKeywordTypeNode = content;
+                                        }
+                                        else {
+                                            const keywordTypeSyntaxKind = (0, get_keyword_type_node_1.getKeywordTypeNode)(target.type || undefined);
+                                            let content = ts.factory.createKeywordTypeNode(keywordTypeSyntaxKind);
+                                            let _json = undefined;
+                                            for (let i = 0; i < layer; i++) {
+                                                _json = [_json];
+                                                content = ts.factory.createArrayTypeNode(content);
+                                            }
+                                            interfaceJSONData[key] = { type: 'array', items: _json };
+                                            arrayItemKeywordTypeNode = content;
+                                        }
+                                    }
+                                    else {
+                                        layer += 1;
+                                        target = target.items;
+                                    }
+                                }
+                            }
+                            else {
+                                // 默认是string
+                                interfaceJSONData[key] = { type: 'array', items: { type: 'string' } };
+                                arrayItemKeywordTypeNode = ts.factory.createKeywordTypeNode(arrayItemKeywordTypeSyntaxKind);
+                            }
+                            keywordTypeNode = ts.factory.createArrayTypeNode(arrayItemKeywordTypeNode);
+                        }
+                    }
+                    // 其他类型
+                }
+                else {
+                    // 可能是枚举
+                    if (_enum) {
+                        if (type !== constants_1.DefinitionsKeywordTypeNodeKey.string &&
+                            type !== constants_1.DefinitionsKeywordTypeNodeKey.number &&
+                            type !== constants_1.DefinitionsKeywordTypeNodeKey.integer) {
+                            throw new Error(`type: ${type}, enum is not supported!`);
+                        }
+                        interfaceJSONData[key] = {
+                            type: type === 'integer' ? 'number' : type,
+                            enum: _enum,
+                        };
+                        const enumNodes = _enum.map((item) => {
+                            return ts.factory.createLiteralTypeNode(type === constants_1.DefinitionsKeywordTypeNodeKey.string
+                                ? ts.factory.createStringLiteral(item)
+                                : ts.factory.createNumericLiteral(`${item}`));
+                        });
+                        keywordTypeNode = ts.factory.createUnionTypeNode(enumNodes);
+                    }
+                    else {
+                        if (keywordTypeSyntaxKind) {
+                            keywordTypeNode = ts.factory.createKeywordTypeNode(keywordTypeSyntaxKind);
+                            interfaceJSONData[key] = {
+                                type: type === 'integer' ? 'number' : type,
+                            };
+                        }
+                        else {
+                            logger(`[${currLoggerName}] <${key}> type: ${type}, keywordTypeSyntaxKind is null!`);
+                        }
+                    }
+                }
+            }
+        }
+        if (description || example || _default) {
+            const startFlag = `<$desc-flag-start@${parentKey ? `${parentKey}.` : ''}${key}$>`;
+            propertieDesc[startFlag] = '/**';
+            interfaceContent.push(ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral(startFlag), undefined, undefined));
+            if (description) {
+                const flag = `<$desc-flag-desc@${parentKey ? `${parentKey}.` : ''}${key}$>`;
+                interfaceJSONData[key].description = description;
+                propertieDesc[flag] = `* ${description}`;
+                propertieDesc[flag] = (0, comment_line_break_1.commentLineBreak)(propertieDesc[flag]);
+                interfaceContent.push(ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral(flag), undefined, undefined));
+            }
+            if (example) {
+                const flag = `<$desc-flag-example@${parentKey ? `${parentKey}.` : ''}${key}$>`;
+                interfaceJSONData[key].example = example;
+                propertieDesc[flag] = `* @example ${example}`;
+                propertieDesc[flag] = (0, comment_line_break_1.commentLineBreak)(propertieDesc[flag]);
+                interfaceContent.push(ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral(flag), undefined, undefined));
+            }
+            if (_default) {
+                const flag = `<$desc-flag-default@${parentKey ? `${parentKey}.` : ''}${key}$>`;
+                interfaceJSONData[key].default = _default;
+                propertieDesc[flag] = `* @default ${_default}`;
+                propertieDesc[flag] = (0, comment_line_break_1.commentLineBreak)(propertieDesc[flag]);
+                interfaceContent.push(ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral(flag), undefined, undefined));
+            }
+            const endFlag = `<$desc-flag-end@${parentKey ? `${parentKey}>` : ''}${key}$>`;
+            propertieDesc[endFlag] = '*/';
+            interfaceContent.push(ts.factory.createPropertySignature(undefined, ts.factory.createStringLiteral(endFlag), undefined, undefined));
+        }
+        keywordTypeNode &&
+            interfaceContent.push(ts.factory.createPropertySignature(undefined, (0, is_english_only_1.isEnglishOnly)(key)
+                ? ts.factory.createIdentifier(key)
+                : ts.factory.createStringLiteral(key), ts.factory.createToken(ts.SyntaxKind.QuestionToken), keywordTypeNode));
+    }
+    return {
+        interfaceContent,
+        interfaceDependency,
+        descriptionMap: propertieDesc,
+        jsonData: interfaceJSONData,
+    };
+}

package/built/codegen/interface/generate-interface-desc-ast-node.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterfaceDescAstNode = generateInterfaceDescAstNode;
+const ts = __importStar(require("typescript"));
+function generateInterfaceDescAstNode(interfaceName, description, descriptions) {
+    const descNodes = [];
+    // 添加注释
+    if (description) {
+        const flagStart = `<$desc-flag-start@${interfaceName}$>`;
+        const flagEnd = `<$desc-flag-end@${interfaceName}$>`;
+        const flag = `<$desc-flag@${interfaceName}$>`;
+        descNodes.push(ts.factory.createExpressionStatement(ts.factory.createStringLiteral(flagStart)), ts.factory.createExpressionStatement(ts.factory.createStringLiteral(flag)), ts.factory.createExpressionStatement(ts.factory.createStringLiteral(flagEnd)));
+        descriptions[flagStart] = '/**';
+        descriptions[flag] = `* ${description}`;
+        descriptions[flagEnd] = '*/';
+    }
+    return descNodes;
+}