wormajs 0.0.1

package/dist/constant.js

@@ -0,0 +1,162 @@
+"use strict";
+// ============================================================
+// 枚举常量定义 — 统一管理项目中所有硬编码的字符串/数字常量
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRAMEWORK_NAMES = exports.MODULE_TYPE_TO_KIND = exports.MODULE_TYPE_DIRS = exports.ModuleTypeDir = exports.PresetTemplateName = exports.TemplateSkipDir = exports.TemplatePlaceholder = exports.PluginName = exports.ModifierScope = exports.FilterScope = exports.RenameScope = exports.ParameterIn = exports.TEMPLATE_EXTENSIONS = exports.FileExtension = exports.FrameworkName = exports.ModuleKind = exports.PlatformTypeEnum = exports.ConfigTypeEnum = exports.TemplateTypeEnum = void 0;
+exports.getTypeFileExtension = getTypeFileExtension;
+/** 模板代码生成类型 */
+var TemplateTypeEnum;
+(function (TemplateTypeEnum) {
+    TemplateTypeEnum["TYPESCRIPT"] = "typescript";
+    TemplateTypeEnum["MODULE"] = "module";
+    TemplateTypeEnum["COMMONJS"] = "commonjs";
+})(TemplateTypeEnum || (exports.TemplateTypeEnum = TemplateTypeEnum = {}));
+/** 配置中的 type 字段值（比 TemplateTypeEnum 多了 auto/ts 选项） */
+var ConfigTypeEnum;
+(function (ConfigTypeEnum) {
+    ConfigTypeEnum["AUTO"] = "auto";
+    ConfigTypeEnum["TS"] = "ts";
+    ConfigTypeEnum["TYPESCRIPT"] = "typescript";
+    ConfigTypeEnum["MODULE"] = "module";
+    ConfigTypeEnum["COMMONJS"] = "commonjs";
+})(ConfigTypeEnum || (exports.ConfigTypeEnum = ConfigTypeEnum = {}));
+/** 支持的 OpenAPI 平台 */
+var PlatformTypeEnum;
+(function (PlatformTypeEnum) {
+    PlatformTypeEnum["SWAGGER"] = "swagger";
+    PlatformTypeEnum["KNIFE4J"] = "knife4j";
+    PlatformTypeEnum["YAPI"] = "yapi";
+})(PlatformTypeEnum || (exports.PlatformTypeEnum = PlatformTypeEnum = {}));
+/** 模块体系类型 */
+var ModuleKind;
+(function (ModuleKind) {
+    ModuleKind["ES_MODULE"] = "ESModule";
+    ModuleKind["COMMON_JS"] = "commonJs";
+})(ModuleKind || (exports.ModuleKind = ModuleKind = {}));
+/** 前端框架名称 */
+var FrameworkName;
+(function (FrameworkName) {
+    FrameworkName["VUE"] = "vue";
+    FrameworkName["REACT"] = "react";
+    FrameworkName["SVELTE"] = "svelte";
+    FrameworkName["SOLID_JS"] = "solid-js";
+    FrameworkName["NUXT"] = "nuxt";
+})(FrameworkName || (exports.FrameworkName = FrameworkName = {}));
+/** 模板文件扩展名 */
+var FileExtension;
+(function (FileExtension) {
+    FileExtension["HBS"] = ".hbs";
+    FileExtension["HANDLEBARS"] = ".handlebars";
+    FileExtension["TS"] = ".ts";
+    FileExtension["TSX"] = ".tsx";
+    FileExtension["JS"] = ".js";
+    FileExtension["JSX"] = ".jsx";
+    FileExtension["MJS"] = ".mjs";
+    FileExtension["CJS"] = ".cjs";
+    FileExtension["D_TS"] = ".d.ts";
+    FileExtension["D_CTS"] = ".d.cts";
+    FileExtension["D_MTS"] = ".d.mts";
+})(FileExtension || (exports.FileExtension = FileExtension = {}));
+/** Handlebars 模板文件扩展名列表（不含普通 ts/js 扩展） */
+exports.TEMPLATE_EXTENSIONS = Object.values(FileExtension);
+/** OpenAPI 参数位置 */
+var ParameterIn;
+(function (ParameterIn) {
+    ParameterIn["QUERY"] = "query";
+    ParameterIn["PATH"] = "path";
+    ParameterIn["HEADER"] = "header";
+    ParameterIn["COOKIE"] = "cookie";
+})(ParameterIn || (exports.ParameterIn = ParameterIn = {}));
+/** 重命名的 scope 类型 */
+var RenameScope;
+(function (RenameScope) {
+    RenameScope["URL"] = "url";
+    RenameScope["PARAMS"] = "params";
+    RenameScope["PATH_PARAMS"] = "pathParams";
+    RenameScope["DATA"] = "data";
+    RenameScope["RESPONSE"] = "response";
+    RenameScope["REF_NAME"] = "refName";
+})(RenameScope || (exports.RenameScope = RenameScope = {}));
+/** 过滤 scope 类型 */
+var FilterScope;
+(function (FilterScope) {
+    FilterScope["URL"] = "url";
+    FilterScope["TAG"] = "tag";
+})(FilterScope || (exports.FilterScope = FilterScope = {}));
+/** 参数修改 scope 类型 */
+var ModifierScope;
+(function (ModifierScope) {
+    ModifierScope["PARAMS"] = "params";
+    ModifierScope["PATH_PARAMS"] = "pathParams";
+    ModifierScope["DATA"] = "data";
+    ModifierScope["RESPONSE"] = "response";
+})(ModifierScope || (exports.ModifierScope = ModifierScope = {}));
+/** 内建插件名称 */
+var PluginName;
+(function (PluginName) {
+    PluginName["TAG_MODIFIER"] = "tagModifier";
+    PluginName["FILTER_API"] = "filterApi";
+    PluginName["RENAME"] = "rename";
+    PluginName["PAYLOAD_MODIFIER"] = "payloadModifier";
+    PluginName["IMPORT_TYPE"] = "importType";
+    PluginName["AI_DOC"] = "aiDoc";
+    PluginName["APIFOX"] = "apifox";
+    PluginName["PLATFORM"] = "platform";
+    PluginName["TEMPLATE_ALOVA"] = "templateAlova";
+    PluginName["TEMPLATE_ALOVA_GLOBALS"] = "templateAlovaGlobals";
+    PluginName["TEMPLATE_AXIOS"] = "templateAxios";
+    PluginName["TEMPLATE_FETCH"] = "templateFetch";
+    PluginName["TEMPLATE_KY"] = "templateKy";
+    PluginName["TEMPLATE_CONFIG"] = "templateConfig";
+})(PluginName || (exports.PluginName = PluginName = {}));
+/** 模板占位符 */
+var TemplatePlaceholder;
+(function (TemplatePlaceholder) {
+    TemplatePlaceholder["TAG"] = "{tag}";
+    TemplatePlaceholder["API"] = "{api}";
+})(TemplatePlaceholder || (exports.TemplatePlaceholder = TemplatePlaceholder = {}));
+/** 模板扫描时跳过的目录 */
+var TemplateSkipDir;
+(function (TemplateSkipDir) {
+    TemplateSkipDir["PARTIALS"] = "partials";
+    TemplateSkipDir["TAG_DIR"] = "{tag}";
+})(TemplateSkipDir || (exports.TemplateSkipDir = TemplateSkipDir = {}));
+/** 预设模板名称 */
+var PresetTemplateName;
+(function (PresetTemplateName) {
+    PresetTemplateName["ALOVA"] = "alova";
+    PresetTemplateName["AXIOS"] = "axios";
+    PresetTemplateName["FETCH"] = "fetch";
+    PresetTemplateName["KY"] = "ky";
+    PresetTemplateName["GLOBALS"] = "alova-globals";
+    PresetTemplateName["CONFIG"] = "config";
+    PresetTemplateName["AI_DOC"] = "ai-doc";
+})(PresetTemplateName || (exports.PresetTemplateName = PresetTemplateName = {}));
+/** 模板目录名（与 config.type 不同：commonjs -> common） */
+var ModuleTypeDir;
+(function (ModuleTypeDir) {
+    ModuleTypeDir["TYPESCRIPT"] = "typescript";
+    ModuleTypeDir["MODULE"] = "module";
+    ModuleTypeDir["COMMON"] = "common";
+})(ModuleTypeDir || (exports.ModuleTypeDir = ModuleTypeDir = {}));
+/** 模块类型目录名数组 */
+exports.MODULE_TYPE_DIRS = [ModuleTypeDir.TYPESCRIPT, ModuleTypeDir.MODULE, ModuleTypeDir.COMMON];
+/** 模块类型 -> ModuleKind 映射 */
+exports.MODULE_TYPE_TO_KIND = {
+    [TemplateTypeEnum.TYPESCRIPT]: ModuleKind.ES_MODULE,
+    [TemplateTypeEnum.MODULE]: ModuleKind.ES_MODULE,
+    [TemplateTypeEnum.COMMONJS]: ModuleKind.COMMON_JS,
+};
+/** 文件扩展名 -> 输出文件名映射 */
+function getTypeFileExtension(type) {
+    return type === TemplateTypeEnum.TYPESCRIPT ? FileExtension.TS : FileExtension.JS;
+}
+/** 框架名称列表 */
+exports.FRAMEWORK_NAMES = [
+    FrameworkName.VUE,
+    FrameworkName.REACT,
+    FrameworkName.SVELTE,
+    FrameworkName.SOLID_JS,
+    FrameworkName.NUXT,
+];

package/dist/core/WorkerPool.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerPool = void 0;
+exports.pickPoolSize = pickPoolSize;
+/**
+ * 9.3.1: Generic WorkerPool — pure thread pool for task/result patterns.
+ * Handles lifecycle, task distribution, and result collection.
+ */
+const node_os_1 = require("node:os");
+const node_worker_threads_1 = require("node:worker_threads");
+function pickPoolSize(apiCount) {
+    const cpu = Math.max(1, (0, node_os_1.cpus)().length);
+    // P2: Lowered threshold from 200→20 so moderate API counts benefit from workers
+    if (apiCount <= 20)
+        return 0;
+    if (apiCount <= 1000)
+        return Math.min(2, cpu);
+    if (apiCount <= 3000)
+        return Math.min(4, cpu);
+    if (apiCount <= 8000)
+        return Math.min(Math.ceil(cpu * 0.75), cpu);
+    return Math.max(2, cpu - 1);
+}
+class WorkerPool {
+    constructor(options) {
+        this.options = options;
+        this.workers = [];
+        this.idleTimer = null;
+        this.terminated = false;
+        this.idleTimeout = options.idleTimeout ?? 30000;
+    }
+    get size() {
+        return this.options.poolSize;
+    }
+    /** Spawn workers lazily on first batch */
+    ensureWorkers() {
+        if (this.workers.length > 0)
+            return;
+        for (let i = 0; i < this.options.poolSize; i++) {
+            const w = new node_worker_threads_1.Worker(this.options.workerScript, {
+                workerData: this.options.sharedContext,
+            });
+            this.workers.push(w);
+        }
+        this.resetIdleTimer();
+    }
+    /** Reset the idle timer — auto-terminate after idleTimeout ms of inactivity */
+    resetIdleTimer() {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = setTimeout(() => this.terminate(), this.idleTimeout);
+    }
+    /**
+     * Process a batch of tasks via the worker pool.
+     * Distributes tasks round-robin across workers for even load balancing.
+     */
+    async processBatch(tasks) {
+        if (this.terminated)
+            return [];
+        this.ensureWorkers();
+        // Round-robin distribution — even load across all workers
+        const batches = Array.from({ length: this.workers.length }, () => []);
+        tasks.forEach((task, i) => batches[i % this.workers.length].push(task));
+        const nonEmpty = batches.filter(b => b.length > 0);
+        const results = await Promise.all(nonEmpty.map((batch, i) => this.sendToWorker(i, batch)));
+        this.resetIdleTimer();
+        return results.flat();
+    }
+    /** Send a batch to a specific worker and wait for result */
+    sendToWorker(workerIdx, batch) {
+        return new Promise((resolve, reject) => {
+            const worker = this.workers[workerIdx];
+            const handler = (msg) => {
+                worker.off('message', handler);
+                if (msg.type === 'result') {
+                    resolve(msg.data);
+                }
+                else {
+                    reject(new Error(msg.message ?? 'Unknown worker error'));
+                }
+            };
+            worker.on('message', handler);
+            worker.on('error', (err) => {
+                worker.off('message', handler);
+                reject(err);
+            });
+            worker.postMessage(batch);
+        });
+    }
+    /** Terminate all workers and cleanup */
+    terminate() {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+        this.terminated = true;
+        for (const w of this.workers) {
+            w.terminate();
+        }
+        this.workers.length = 0;
+    }
+}
+exports.WorkerPool = WorkerPool;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayTypeGenerator = arrayTypeGenerator;
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function arrayTypeGenerator(ast, ctx) {
+    const result = {
+        name: ast.keyName ?? '',
+        comment: (0, utils_1.setComment)(ast, ctx.options),
+        type: 'type',
+        code: '',
+    };
+    ctx.pathKey = '[]';
+    const paramsResult = ctx.next(ast.params, ctx.options);
+    const tsStr = (0, utils_1.getValue)(paramsResult, ctx.options);
+    if (ast.params.type !== type_1.ASTType.INTERFACE || tsStr === paramsResult.name) {
+        // Only wrap in parentheses when needed for operator precedence:
+        // UNION / INTERSECTION / TUPLE elements need parens to prevent ambiguity
+        // ENUM can produce union-like output (via otherEnumTypeGenerator), so also needs parens
+        const needsParens = ast.params.type === type_1.ASTType.UNION
+            || ast.params.type === type_1.ASTType.INTERSECTION
+            || ast.params.type === type_1.ASTType.TUPLE
+            || ast.params.type === type_1.ASTType.ENUM;
+        result.code = needsParens ? `(${tsStr})[]` : `${tsStr}[]`;
+    }
+    else {
+        result.code = `Array<${tsStr}>`;
+    }
+    return result;
+}
+exports.default = {
+    type: type_1.ASTType.ARRAY,
+    generate: arrayTypeGenerator,
+};

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalEnumTypeGenerator = normalEnumTypeGenerator;
+exports.isNormalEnum = isNormalEnum;
+exports.enumTypeGenerator = enumTypeGenerator;
+const loader_1 = require("../../../../core/loader");
+const type_1 = require("../../../../type");
+const utils_1 = require("../../../../utils");
+const utils_2 = require("./utils");
+function normalEnumTypeGenerator(ast, ctx) {
+    const result = {
+        name: ast.keyName ?? '',
+        comment: (0, utils_2.setComment)(ast, ctx.options),
+        type: 'enum',
+        code: '',
+    };
+    const lines = [`{`];
+    ast.params.forEach((param, idx, arr) => {
+        ctx.pathKey = param.keyName;
+        const paramResult = ctx.next(param.ast, ctx.options);
+        const endText = idx === arr.length - 1 ? '' : ',';
+        const keyName = loader_1.standardLoader.validate(param.keyName) ? param.keyName : `"${param.keyName || paramResult.code}"`;
+        `${param.ast.comment ?? ''}${keyName} = ${paramResult.code}${endText}`
+            .split('\n')
+            .forEach(line => lines.push(` ${line}`));
+    });
+    lines.push(`}`);
+    result.code = lines.join('\n');
+    return result;
+}
+function otherEnumTypeGenerator(ast, ctx) {
+    const result = {
+        name: ast.keyName ?? '',
+        comment: (0, utils_2.setComment)(ast, ctx.options),
+        type: 'type',
+        code: '',
+    };
+    result.code = ast.params
+        .map((param) => {
+        ctx.pathKey = param.keyName;
+        return (0, utils_2.getValue)(ctx.next(param.ast, ctx.options), ctx.options);
+    })
+        .join(' | ');
+    return result;
+}
+function isNormalEnum(ast, ctx) {
+    return !ctx.options.noEnum
+        && ast.params.every(item => item.ast.type === type_1.ASTType.LITERAL
+            && ['string', 'number', 'integer'].includes((0, utils_1.getType)(item.ast.params))
+            && item.keyName);
+}
+function enumTypeGenerator(ast, ctx) {
+    if (ctx.path.length <= 1 && isNormalEnum(ast, ctx)) {
+        return normalEnumTypeGenerator(ast, ctx);
+    }
+    return otherEnumTypeGenerator(ast, ctx);
+}
+exports.default = {
+    type: type_1.ASTType.ENUM,
+    generate: enumTypeGenerator,
+};

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupTypeGenerator = groupTypeGenerator;
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function groupTypeGenerator(ast, ctx) {
+    const result = {
+        name: ast.keyName ?? '',
+        comment: (0, utils_1.setComment)(ast, ctx.options),
+        type: 'type',
+        code: '',
+    };
+    const groups = [];
+    ast.params.forEach((item) => {
+        ctx.pathKey = `${item.keyName}`;
+        const nextValue = ctx.next(item, ctx.options);
+        // Only wrap in parentheses when needed for operator precedence:
+        // In INTERSECTION (&), UNION/ENUM members need parens because `|` has lower precedence than `&`
+        //   e.g. (string | number) & Pet  vs  string | number & Pet (= string | (number & Pet))
+        // In UNION (|), INTERSECTION members do NOT need parens because `&` already binds tighter
+        const memberTsStr = (0, utils_1.getValue)(nextValue, ctx.options);
+        const producesUnionLike = item.type === type_1.ASTType.UNION || item.type === type_1.ASTType.ENUM;
+        const needsParens = ast.type === type_1.ASTType.INTERSECTION && producesUnionLike;
+        groups.push(needsParens ? `(${memberTsStr})` : memberTsStr);
+    });
+    switch (ast.type) {
+        case type_1.ASTType.INTERSECTION:
+            result.code = groups.join(' & ');
+            break;
+        case type_1.ASTType.UNION:
+            result.code = groups.join(' | ');
+            break;
+        default:
+            break;
+    }
+    return result;
+}
+exports.default = {
+    type: [type_1.ASTType.INTERSECTION, type_1.ASTType.UNION],
+    generate: groupTypeGenerator,
+};

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

@@ -0,0 +1,71 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCode = exports.getValue = exports.getTsStr = void 0;
+exports.astGenerate = astGenerate;
+const type_1 = require("../../../../type");
+const array_1 = __importDefault(require("./array"));
+const enum_1 = __importDefault(require("./enum"));
+const group_1 = __importDefault(require("./group"));
+const interface_1 = __importDefault(require("./interface"));
+const simple_1 = __importDefault(require("./simple"));
+const tuple_1 = __importDefault(require("./tuple"));
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "getTsStr", { enumerable: true, get: function () { return utils_1.getTsStr; } });
+Object.defineProperty(exports, "getValue", { enumerable: true, get: function () { return utils_1.getValue; } });
+Object.defineProperty(exports, "normalizeCode", { enumerable: true, get: function () { return utils_1.normalizeCode; } });
+__exportStar(require("./type"), exports);
+const supportGenerator = [
+    simple_1.default,
+    enum_1.default,
+    interface_1.default,
+    group_1.default,
+    array_1.default,
+    tuple_1.default,
+];
+function astGenerate(ast, options) {
+    const doGenerate = (ast, ctx) => {
+        const value = (0, utils_1.generate)(ast, ctx, supportGenerator);
+        if (!value) {
+            return simple_1.default.generate({
+                ...ast,
+                type: type_1.ASTType.UNKNOWN,
+            }, ctx);
+        }
+        return value;
+    };
+    const ctx = {
+        options,
+        path: ['$'],
+        next(ast, options) {
+            const { pathKey } = ctx;
+            if (pathKey) {
+                ctx.path.push(pathKey);
+                ctx.pathKey = '';
+            }
+            ctx.options = options;
+            const result = doGenerate(ast, ctx);
+            if (pathKey) {
+                ctx.path.pop();
+            }
+            return result;
+        },
+    };
+    return doGenerate(ast, ctx);
+}

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordTypeGenerator = recordTypeGenerator;
+exports.normalInterfaceGenerator = normalInterfaceGenerator;
+exports.interfaceTypeGenerator = interfaceTypeGenerator;
+const loader_1 = require("../../../../core/loader");
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function recordTypeGenerator(ast, ctx) {
+    const result = {
+        name: ast.keyName ?? '',
+        comment: (0, utils_1.setComment)(ast, ctx.options),
+        type: 'type',
+        code: '',
+    };
+    let addParamsStr = 'any';
+    if (ast.addParams) {
+        ctx.pathKey = '[key: string]';
+        const nextResult = ctx.next(ast.addParams, ctx.options);
+        addParamsStr = (0, utils_1.getValue)(nextResult, ctx.options);
+    }
+    result.code = `Record<string, ${addParamsStr}>`;
+    return result;
+}
+function normalInterfaceGenerator(ast, ctx) {
+    const result = {
+        name: ast.keyName ?? '',
+        comment: (0, utils_1.setComment)(ast, ctx.options),
+        type: 'interface',
+        code: '',
+    };
+    const lines = [`{`];
+    ast.params.forEach((param) => {
+        const optionalFlag = param.isRequired ? '' : '?';
+        const keyName = loader_1.standardLoader.validate(param.keyName) ? param.keyName : `"${param.keyName}"`;
+        ctx.pathKey = keyName;
+        const nextResult = ctx.next(param.ast, ctx.options);
+        const value = (0, utils_1.getValue)(nextResult, ctx.options);
+        `${nextResult.comment ?? ''}${keyName}${optionalFlag}: ${value}`.split('\n').forEach(line => lines.push(`  ${line}`));
+    });
+    if (ast.addParams) {
+        ctx.pathKey = '[key: string]';
+        const nextResult = ctx.next(ast.addParams, ctx.options);
+        lines.push(`  [key: string]: ${(0, utils_1.getValue)(nextResult, ctx.options) || 'any'}`);
+    }
+    lines.push(`}`);
+    result.code = lines.join('\n');
+    return result;
+}
+function interfaceTypeGenerator(ast, ctx) {
+    if (ast.params.length > 0) {
+        return normalInterfaceGenerator(ast, ctx);
+    }
+    return recordTypeGenerator(ast, ctx);
+}
+exports.default = {
+    type: type_1.ASTType.INTERFACE,
+    generate: interfaceTypeGenerator,
+};

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleTypeGenerator = simpleTypeGenerator;
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function simpleTypeGenerator(ast, ctx) {
+    const result = {
+        name: ast.keyName ?? '',
+        comment: (0, utils_1.setComment)(ast, ctx.options),
+        type: 'type',
+        code: '',
+    };
+    switch (ast.type) {
+        case type_1.ASTType.BOOLEAN:
+            result.code = 'boolean';
+            break;
+        case type_1.ASTType.NUMBER:
+            result.code = 'number';
+            break;
+        case type_1.ASTType.STRING:
+            result.code = 'string';
+            break;
+        case type_1.ASTType.OBJECT:
+            result.code = 'object';
+            break;
+        case type_1.ASTType.ANY:
+            result.code = 'any';
+            break;
+        case type_1.ASTType.NULL:
+            result.code = 'null';
+            break;
+        case type_1.ASTType.UNKNOWN:
+            result.code = 'unknown';
+            break;
+        case type_1.ASTType.NEVER:
+            result.code = 'never';
+            break;
+        case type_1.ASTType.LITERAL:
+            result.code = JSON.stringify(ast.params);
+            break;
+        case type_1.ASTType.REFERENCE: // reference
+            result.code = ast.params;
+            break;
+        case type_1.ASTType.CUSTOM:
+            result.code = ast.params;
+            break;
+        default:
+            break;
+    }
+    return result;
+}
+exports.default = {
+    type: [
+        type_1.ASTType.BOOLEAN,
+        type_1.ASTType.NUMBER,
+        type_1.ASTType.STRING,
+        type_1.ASTType.OBJECT,
+        type_1.ASTType.ANY,
+        type_1.ASTType.NULL,
+        type_1.ASTType.UNKNOWN,
+        type_1.ASTType.NEVER,
+        type_1.ASTType.REFERENCE,
+        type_1.ASTType.LITERAL,
+        type_1.ASTType.CUSTOM,
+    ],
+    generate: simpleTypeGenerator,
+};

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tupleTypeGenerator = tupleTypeGenerator;
+const type_1 = require("../../../../type");
+const utils_1 = require("./utils");
+function tupleTypeGenerator(ast, ctx) {
+    const result = {
+        name: ast.keyName ?? '',
+        comment: (0, utils_1.setComment)(ast, ctx.options),
+        type: 'type',
+        code: '',
+    };
+    const params = [...ast.params];
+    const minItems = Math.max(ast.minItems ?? 0, params.length);
+    const maxItems = Math.max(ast.maxItems ?? minItems - 1, params.length);
+    const spreadParam = ast.spreadParam ?? {
+        type: type_1.ASTType.ANY,
+    };
+    while (params.length < minItems) {
+        params.push(spreadParam);
+    }
+    const lines = [`[`];
+    params.forEach((param, idx, arr) => {
+        ctx.pathKey = param.keyName;
+        const value = (0, utils_1.getValue)(ctx.next(param, ctx.options), ctx.options);
+        const endText = idx === arr.length - 1 ? '' : ',';
+        `${value}${endText}`.split('\n').forEach(line => lines.push(` ${line}`));
+    });
+    if (maxItems < minItems) {
+        ctx.pathKey = spreadParam.keyName;
+        lines.push(`,\n...Array<${(0, utils_1.getValue)(ctx.next(spreadParam, ctx.options), ctx.options)}>`);
+    }
+    lines.push(`]`);
+    if (maxItems > minItems) {
+        const nextParams = [...params];
+        for (let i = 0; i < maxItems - minItems; i += 1) {
+            nextParams.push(spreadParam);
+            const nextResult = tupleTypeGenerator({
+                ...ast,
+                keyName: '',
+                params: nextParams,
+                minItems: nextParams.length,
+                maxItems: nextParams.length,
+            }, ctx);
+            lines.push(`\n| ${(0, utils_1.getValue)(nextResult, ctx.options)}`);
+        }
+    }
+    result.code = lines.join('\n');
+    return result;
+}
+exports.default = {
+    type: type_1.ASTType.TUPLE,
+    generate: tupleTypeGenerator,
+};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });