wormajs 0.0.1

package/dist/core/loader/astLoader/generates/utils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+exports.getValue = getValue;
+exports.setComment = setComment;
+exports.normalizeCode = normalizeCode;
+exports.getTsStr = getTsStr;
+const helper_1 = require("../../../../helper");
+function generate(ast, ctx, generators) {
+    const generator = generators.find((generator) => {
+        const tyes = [generator.type].flat();
+        return tyes.includes(ast.type);
+    });
+    if (generator) {
+        return generator.generate(ast, ctx);
+    }
+    return null;
+}
+function getValue(result, options) {
+    if (options.shallowDeep) {
+        options.shallowDeep = false;
+        options.deep = false;
+        return result.code;
+    }
+    return options.deep || !result.name ? result.code : result.name;
+}
+function setComment(ast, options) {
+    let { comment } = ast;
+    if (ast.deepComment && options.deep) {
+        comment += ast.deepComment;
+    }
+    const commenter = helper_1.CommentHelper.load({
+        type: options.commentType,
+        comment,
+    });
+    if (ast.deprecated) {
+        commenter.add('[deprecated]');
+    }
+    ast.comment = commenter.end();
+    return ast.comment ?? '';
+}
+/** Generate normalized TS code body (prettier moved to file level per 9.5.1). Applies basic normalization for merged comments and indentation. */
+function normalizeCode(code, type) {
+    // Fix merged */ with next content: */id → */\nid, */{ → */\n{
+    const result = code.replace(/\*\/(\s*\S)/g, '*/\n$1');
+    const trimmed = result.trim();
+    // Normalize indentation for block structures
+    const blockTypes = ['interface', 'type', 'enum', 'group', 'array'];
+    if (!type || !blockTypes.includes(type))
+        return trimmed;
+    // Match { ... } blocks (interface/enum) or Array<{ ... }> blocks
+    const isBlock = trimmed.startsWith('{') || trimmed.startsWith('[') || trimmed.startsWith('Array<{');
+    if (!isBlock)
+        return trimmed;
+    const lines = trimmed.split('\n');
+    if (lines.length <= 2)
+        return trimmed;
+    return lines.map((line, i) => {
+        if (i === 0 || i === lines.length - 1)
+            return line.trim();
+        // Preserve nested indentation: lines already indented >= 2 spaces keep their depth
+        const trimmed = line.trimStart();
+        const leadingSpaces = line.length - trimmed.length;
+        return leadingSpaces >= 2 ? line : `  ${trimmed}`;
+    }).join('\n');
+}
+function getTsStr(genResult, options) {
+    let result = genResult.code;
+    switch (genResult.type) {
+        case 'interface':
+            result = `interface ${genResult.name}  ${genResult.code}`;
+            break;
+        case 'type':
+            result = `type ${genResult.name} = ${genResult.code}`;
+            break;
+        case 'enum':
+            result = `enum ${genResult.name} ${genResult.code}`;
+            break;
+        default:
+            break;
+    }
+    if (options?.export) {
+        result = `export ${result}`;
+    }
+    return result;
+}

package/dist/core/loader/astLoader/helper.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAST = transformAST;
+exports.transformSchema = transformSchema;
+const generates_1 = require("./generates");
+const normalize_1 = __importDefault(require("./normalize"));
+const parsers_1 = require("./parsers");
+async function transformAST(ast, options) {
+    const result = (0, generates_1.astGenerate)(ast, options);
+    if (options.format) {
+        result.code = await (0, generates_1.normalizeCode)(result.code, result.type);
+    }
+    return result;
+}
+async function transformSchema(schema, options) {
+    const normalized = normalize_1.default.normalize(schema);
+    return (0, parsers_1.astParse)(normalized, options);
+}

package/dist/core/loader/astLoader/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astLoader = exports.AstLoader = void 0;
+const generates_1 = require("./generates");
+const helper_1 = require("./helper");
+class AstLoader {
+    constructor() {
+        this.name = 'astLoader';
+    }
+    async transform(ast, options) {
+        return (0, helper_1.transformAST)(ast, options);
+    }
+    async transformSchema(schema, options) {
+        return (0, helper_1.transformSchema)(schema, options);
+    }
+    async transformTsStr(ast, options) {
+        const result = await this.transform(ast, options);
+        return (0, generates_1.getTsStr)(result, {
+            export: options.export,
+        });
+    }
+}
+exports.AstLoader = AstLoader;
+exports.astLoader = new AstLoader();

package/dist/core/loader/astLoader/normalize/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const normalizer_1 = require("./normalizer");
+const convertTypeArray_1 = __importDefault(require("./rules/convertTypeArray"));
+const handleEmptyType_1 = __importDefault(require("./rules/handleEmptyType"));
+const inferType_1 = __importDefault(require("./rules/inferType"));
+const mergeAnyOf_1 = __importDefault(require("./rules/mergeAnyOf"));
+const normalizeCombiningKeywords_1 = __importDefault(require("./rules/normalizeCombiningKeywords"));
+const normalizeEnum_1 = __importDefault(require("./rules/normalizeEnum"));
+const normalizeNullType_1 = __importDefault(require("./rules/normalizeNullType"));
+const removeRedundantKeywords_1 = __importDefault(require("./rules/removeRedundantKeywords"));
+const simplifySingleType_1 = __importDefault(require("./rules/simplifySingleType"));
+const validateSchema_1 = __importDefault(require("./rules/validateSchema"));
+const normalizer = new normalizer_1.SchemaNormalizer();
+// ================= 注册规则 =================
+normalizer
+    .addRule({
+    name: 'inferType',
+    description: '从关键字推断类型',
+    handler: inferType_1.default,
+})
+    .addRule({
+    name: 'normalizeNullType',
+    description: '规范化 null 类型',
+    handler: normalizeNullType_1.default,
+})
+    .addRule({
+    name: 'convertTypeArray',
+    description: '将 type 数组转换为 anyOf 结构',
+    handler: convertTypeArray_1.default,
+})
+    .addRule({
+    name: 'normalizeEnum',
+    description: '规范化枚举类型',
+    handler: normalizeEnum_1.default,
+})
+    .addRule({
+    name: 'normalizeCombiningKeywords',
+    description: '规范化anyOf/oneOf/allOf 关键字',
+    handler: normalizeCombiningKeywords_1.default,
+})
+    .addRule({
+    name: 'mergeAnyOf',
+    description: '合并anyOf中type相同的分支',
+    handler: mergeAnyOf_1.default,
+})
+    .addRule({
+    name: 'removeRedundantKeywords',
+    description: '移除多余关键字',
+    handler: removeRedundantKeywords_1.default,
+})
+    .addRule({
+    name: 'handleEmptyType',
+    description: '处理空类型定义',
+    handler: handleEmptyType_1.default,
+})
+    .addRule({
+    name: 'simplifySingleType',
+    description: '简化单元素类型数组',
+    handler: simplifySingleType_1.default,
+})
+    .addRule({
+    name: 'validateSchema',
+    description: '验证 schema 的有效性',
+    handler: validateSchema_1.default,
+});
+exports.default = normalizer;

package/dist/core/loader/astLoader/normalize/normalizer.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaNormalizer = void 0;
+const lodash_1 = require("lodash");
+const utils_1 = require("../../../../utils");
+class SchemaNormalizer {
+    constructor() {
+        this.rules = [];
+    }
+    /**
+     * 添加新规则
+     */
+    addRule(rule) {
+        this.rules.push(rule);
+        return this;
+    }
+    /**
+     * 规范化 JSON Schema
+     * M1-A3: 循环检测从 JSON.stringify 改为 WeakSet，消除每节点 O(s) 序列化开销
+     */
+    normalize(schema) {
+        // 深度优先遍历
+        const visited = new WeakSet();
+        const process = (s) => {
+            if (!s || (0, utils_1.isReferenceObject)(s) || visited.has(s)) {
+                return s;
+            }
+            visited.add(s);
+            // 处理组合模式
+            if (s.anyOf) {
+                s.anyOf = s.anyOf.map(item => process(item));
+            }
+            if (s.oneOf) {
+                s.oneOf = s.oneOf.map(item => process(item));
+            }
+            if (s.allOf) {
+                s.allOf = s.allOf.map(item => process(item));
+            }
+            // 处理数组类型
+            if ((0, utils_1.isMaybeArraySchemaObject)(s)) {
+                s.items = process(s.items);
+            }
+            // 处理对象属性
+            if (s.properties) {
+                const newProps = {};
+                for (const [key, value] of Object.entries(s.properties)) {
+                    newProps[key] = process(value);
+                }
+                s.properties = newProps;
+            }
+            let result = s;
+            // 应用规则
+            for (const rule of this.rules) {
+                const newResult = rule.handler(result);
+                if (newResult && !visited.has(newResult)) {
+                    result = newResult;
+                    visited.add(result);
+                }
+            }
+            if ((0, lodash_1.isEqual)(s, result)) {
+                return result;
+            }
+            visited.delete(result);
+            return process(result);
+        };
+        return process((0, lodash_1.cloneDeep)(schema));
+    }
+}
+exports.SchemaNormalizer = SchemaNormalizer;

package/dist/core/loader/astLoader/normalize/rules/convertTypeArray.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPE_REQUIRE_KEYWORDS = exports.TYPE_SPECIFIC_KEYWORDS = exports.GLOBAL_KEYWORDS = void 0;
+exports.assignTypeSpecificKeywords = assignTypeSpecificKeywords;
+exports.default = convertTypeArray;
+exports.GLOBAL_KEYWORDS = [
+    'title',
+    'description',
+    'default',
+    'examples',
+    'deprecated',
+    'readOnly',
+    'writeOnly',
+    'const',
+];
+exports.TYPE_SPECIFIC_KEYWORDS = {
+    string: ['minLength', 'maxLength', 'pattern', 'format', 'contentMediaType'],
+    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'],
+    integer: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'],
+    array: ['items', 'minItems', 'maxItems', 'uniqueItems'],
+    object: ['properties', 'additionalProperties', 'required', 'minProperties', 'maxProperties'],
+};
+exports.TYPE_REQUIRE_KEYWORDS = {
+    string: [],
+    number: [],
+    integer: [],
+    array: [['items', { type: 'any' }]],
+    object: [],
+};
+function assignTypeSpecificKeywords(branch, type, typeSpecificKeywords) {
+    const keywords = exports.TYPE_SPECIFIC_KEYWORDS[type];
+    const requireKeywords = exports.TYPE_REQUIRE_KEYWORDS[type];
+    if (!keywords) {
+        return;
+    }
+    keywords.forEach((key) => {
+        if (key in typeSpecificKeywords) {
+            branch[key] = typeSpecificKeywords[key];
+        }
+    });
+    requireKeywords.forEach(([key, value]) => {
+        if (!(key in typeSpecificKeywords)) {
+            branch[key] = value;
+        }
+    });
+}
+function convertTypeArray(schema) {
+    if (!Array.isArray(schema.type) || schema.type.length <= 1 || (schema.enum && Array.isArray(schema.enum))) {
+        return;
+    }
+    const { type: typeArray, ...restSchema } = schema;
+    const globalKeywords = {};
+    const typeSpecificKeywords = {};
+    for (const [key, value] of Object.entries(restSchema)) {
+        if (exports.GLOBAL_KEYWORDS.includes(key)) {
+            globalKeywords[key] = value;
+        }
+        else {
+            typeSpecificKeywords[key] = value;
+        }
+    }
+    const branches = typeArray.map((t) => {
+        const branch = { type: t };
+        assignTypeSpecificKeywords(branch, t, typeSpecificKeywords);
+        return branch;
+    });
+    return { ...globalKeywords, anyOf: branches };
+}

package/dist/core/loader/astLoader/normalize/rules/handleEmptyType.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = handleEmptyType;
+function handleEmptyType(schema) {
+    if (!schema.type && !schema.enum && !schema.oneOf && !schema.anyOf && !schema.allOf && schema.const === undefined) {
+        return { ...schema, type: 'null' };
+    }
+}

package/dist/core/loader/astLoader/normalize/rules/inferType.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = inferType;
+const utils_1 = require("../../../../../utils");
+function inferType(schema) {
+    if (Array.isArray(schema.type)
+        || typeof schema.type === 'string') {
+        return;
+    }
+    if (schema.enum || schema.oneOf || schema.anyOf || schema.allOf) {
+        return;
+    }
+    const type = [];
+    if (schema.properties
+        || schema.additionalProperties
+        || schema.required
+        || schema.minProperties !== undefined
+        || schema.maxProperties !== undefined) {
+        type.push('object');
+    }
+    if ((0, utils_1.isMaybeArraySchemaObject)(schema)
+        || schema.minItems !== undefined
+        || schema.maxItems !== undefined
+        || schema.uniqueItems !== undefined
+        || schema.contains) {
+        type.push('array');
+    }
+    if (schema.minLength !== undefined
+        || schema.maxLength !== undefined
+        || schema.pattern
+        || schema.format
+        || schema.contentMediaType) {
+        type.push('string');
+    }
+    if (schema.minimum !== undefined
+        || schema.maximum !== undefined
+        || schema.multipleOf !== undefined
+        || schema.exclusiveMinimum !== undefined
+        || schema.exclusiveMaximum !== undefined) {
+        type.push('number');
+    }
+    return { ...schema, type };
+}

package/dist/core/loader/astLoader/normalize/rules/mergeAnyOf.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = mergeAnyOf;
+function mergeAnyOf(schema) {
+    if (!schema.anyOf || schema.anyOf.length < 2) {
+        return;
+    }
+    const typeMap = new Map();
+    for (const sub of schema.anyOf) {
+        const t = sub.type;
+        const typeKey = Array.isArray(t) ? t.join(',') : String(t);
+        if (!typeMap.has(typeKey))
+            typeMap.set(typeKey, []);
+        typeMap.get(typeKey).push(sub);
+    }
+    const mergedAnyOf = [];
+    for (const group of typeMap.values()) {
+        if (group.length === 1) {
+            mergedAnyOf.push(group[0]);
+        }
+        else {
+            const merged = { type: group[0].type };
+            for (const sub of group) {
+                for (const [key, value] of Object.entries(sub)) {
+                    if (key === 'type')
+                        continue;
+                    if (merged[key] === undefined) {
+                        merged[key] = value;
+                    }
+                    else if (Array.isArray(merged[key]) && Array.isArray(value)) {
+                        merged[key] = Array.from(new Set([...merged[key], ...value]));
+                    }
+                    else if (typeof merged[key] === 'object' && typeof value === 'object') {
+                        merged[key] = { ...merged[key], ...value };
+                    }
+                }
+            }
+            mergedAnyOf.push(merged);
+        }
+    }
+    if (mergedAnyOf.length === schema.anyOf.length && mergedAnyOf.every((s, i) => s === schema.anyOf[i])) {
+        return;
+    }
+    return { ...schema, anyOf: mergedAnyOf };
+}

package/dist/core/loader/astLoader/normalize/rules/normalizeCombiningKeywords.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = normalizeCombiningKeywords;
+function normalizeCombiningKeywords(schema) {
+    const { allOf, anyOf, oneOf, ...baseSchema } = schema;
+    // 如果没有组合关键字，或只存在其中一个，则无需处理
+    if ([allOf, anyOf, oneOf].filter(Boolean).length <= 1) {
+        return;
+    }
+    // 用于存储最终转换后的 allOf 数组
+    const allOfArray = [];
+    // 2. 处理原始 allOf（展开到新 allOf 中）
+    if (Array.isArray(allOf)) {
+        allOfArray.push(...allOf);
+    }
+    // 3. 处理 anyOf（包装成 anyOf 对象）
+    if (Array.isArray(anyOf) && anyOf.length > 0) {
+        allOfArray.push({ anyOf });
+    }
+    // 4. 处理 oneOf（包装成 oneOf 对象）
+    if (Array.isArray(oneOf) && oneOf.length > 0) {
+        allOfArray.push({ oneOf });
+    }
+    // 构建最终模式
+    return allOfArray.length > 0 ? { allOf: allOfArray, ...baseSchema } : baseSchema;
+}

package/dist/core/loader/astLoader/normalize/rules/normalizeEnum.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = normalizeEnum;
+const lodash_1 = require("lodash");
+const utils_1 = require("../../../../../utils");
+const convertTypeArray_1 = require("./convertTypeArray");
+function normalizeEnum(schema) {
+    if (!schema.enum || !Array.isArray(schema.enum) || !schema.enum.length) {
+        return;
+    }
+    const enumArray = schema.enum ?? [];
+    const typeArray = [...new Set([schema.type ?? []].flat())];
+    const enumTypeArray = [];
+    enumArray.forEach((item) => {
+        const type = (0, utils_1.getType)(item);
+        if (!enumTypeArray.includes(type)) {
+            enumTypeArray.push(type);
+        }
+    });
+    const otherType = typeArray.filter(item => !enumTypeArray.includes(item));
+    const enumType = enumTypeArray.length > 1 ? enumTypeArray : (enumTypeArray[0] ?? 'null');
+    if (otherType.length > 0) {
+        return {
+            ...(0, lodash_1.pick)(schema, convertTypeArray_1.GLOBAL_KEYWORDS),
+            anyOf: [
+                {
+                    type: enumType,
+                    enum: enumArray,
+                },
+                {
+                    type: otherType,
+                    ...(0, lodash_1.omit)(schema, convertTypeArray_1.GLOBAL_KEYWORDS.concat(['type', 'enum'])),
+                },
+            ],
+        };
+    }
+    return { ...schema, type: enumType };
+}

package/dist/core/loader/astLoader/normalize/rules/normalizeNullType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = normalizeNullType;
+const NULL_TYPE = [null, 'null'];
+function normalizeNullType(schema) {
+    // 兼容openai3.0的nullable
+    if (schema.nullable) {
+        delete schema.nullable;
+        const currentType = schema.type || [];
+        const typeArray = Array.isArray(currentType) ? currentType : [currentType];
+        const filteredTypes = typeArray.filter(t => t !== null && t !== 'null');
+        schema.type = filteredTypes.length > 0 ? [...filteredTypes, 'null'] : 'null';
+    }
+    if (schema.type === null || (Array.isArray(schema.type) && !schema.type.length)) {
+        return { ...schema, type: 'null' };
+    }
+    if (Array.isArray(schema.type) && schema.type.some(t => NULL_TYPE.includes(t))) {
+        const filteredTypes = schema.type.filter(t => !NULL_TYPE.includes(t));
+        if (filteredTypes.length === 0) {
+            return { ...schema, type: 'null' };
+        }
+        return { ...schema, type: [...filteredTypes, 'null'] };
+    }
+}

package/dist/core/loader/astLoader/normalize/rules/removeRedundantKeywords.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = removeRedundantKeywords;
+const TYPE_SPECIFIC_KEYWORDS = {
+    string: ['minLength', 'maxLength', 'pattern', 'format', 'contentMediaType'],
+    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'],
+    integer: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'],
+    array: ['items', 'minItems', 'maxItems', 'uniqueItems'],
+    object: ['properties', 'additionalProperties', 'required', 'minProperties', 'maxProperties'],
+};
+function removeRedundantKeywords(schema) {
+    if (!schema.type || Array.isArray(schema.type))
+        return;
+    const { type } = schema;
+    const cleanSchema = { ...schema };
+    const typeKeywords = TYPE_SPECIFIC_KEYWORDS[type] ?? [];
+    Object.entries(TYPE_SPECIFIC_KEYWORDS).forEach(([typeName, keywords]) => {
+        if (type === typeName)
+            return;
+        keywords.forEach((keyword) => {
+            if (keyword in cleanSchema && !typeKeywords.includes(keyword)) {
+                delete cleanSchema[keyword];
+            }
+        });
+    });
+    return cleanSchema;
+}

package/dist/core/loader/astLoader/normalize/rules/simplifySingleType.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = simplifySingleType;
+function simplifySingleType(schema) {
+    if (Array.isArray(schema.type) && schema.type.length === 1) {
+        return { ...schema, type: schema.type[0] };
+    }
+}

package/dist/core/loader/astLoader/normalize/rules/validateSchema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = validateSchema;
+function validateSchema(schema) {
+    if (schema.type && typeof schema.type !== 'string' && !Array.isArray(schema.type)) {
+        return { ...schema, type: 'null' };
+    }
+    if (schema.enum && (!Array.isArray(schema.enum) || schema.enum.length === 0)) {
+        delete schema.enum;
+    }
+    if (schema.const !== undefined && schema.const === null) {
+        return { ...schema, type: 'null' };
+    }
+}

package/dist/core/loader/astLoader/parsers/array.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayTypeParser = arrayTypeParser;
+const helper_1 = require("../../../../helper");
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function arrayTypeParser(schema, ctx) {
+    ctx.pathKey = '[]';
+    const itemsAst = ctx.next(schema.items, ctx.options);
+    const result = {
+        ...(0, utils_1.initAST)(schema, ctx),
+        type: type_1.ASTType.ARRAY,
+        params: itemsAst,
+    };
+    result.deepComment = helper_1.CommentHelper.load({
+        type: ctx.options.commentType,
+    })
+        .add('[items] start')
+        .add(helper_1.CommentHelper.parse(itemsAst.comment ?? '').join('\n'))
+        .add(helper_1.CommentHelper.parse(itemsAst.deepComment ?? '').join('\n'))
+        .add('[items] end')
+        .end();
+    return result;
+}
+exports.default = {
+    type: 'array',
+    parse: arrayTypeParser,
+};

package/dist/core/loader/astLoader/parsers/enum.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumTypeParser = enumTypeParser;
+const standardLoader_1 = require("../../../../core/loader/standardLoader");
+const helper_1 = require("../../../../helper");
+const type_1 = require("../../../../type");
+const utils_1 = require("../../../../utils");
+const utils_2 = require("./utils");
+function enumTypeParser(schema, ctx) {
+    const result = {
+        ...(0, utils_2.initAST)(schema, ctx),
+        type: type_1.ASTType.ENUM,
+        params: [],
+    };
+    const enumArray = schema.enum ?? [];
+    let typeArray = [schema.type ?? []].flat();
+    // 如果没有指定type，从enum值中推断类型
+    if (typeArray.length === 0 && enumArray.length > 0) {
+        typeArray = [...new Set(enumArray.map(item => (0, utils_1.getType)(item)))];
+    }
+    // 类型兼容性检查函数
+    const isTypeCompatible = (itemType, allowedTypes) => {
+        return allowedTypes.includes(itemType)
+            || (allowedTypes.includes('number') && itemType === 'integer');
+    };
+    // 验证所有枚举值的类型
+    const hasInvalidType = enumArray.some(item => !isTypeCompatible((0, utils_1.getType)(item), typeArray));
+    if (hasInvalidType) {
+        throw helper_1.logger.throwError(`enum ${schema.title ?? 'undefined'} type error`, {
+            enum: enumArray,
+            type: typeArray,
+        });
+    }
+    enumArray.forEach((item) => {
+        const keyName = typeof item === 'string' && standardLoader_1.standardLoader.validate(item) ? item.toUpperCase() : '';
+        result.params.push({
+            keyName,
+            ast: {
+                type: type_1.ASTType.LITERAL,
+                params: item,
+            },
+        });
+    });
+    return result;
+}
+exports.default = {
+    type: 'enum',
+    parse: enumTypeParser,
+};