wormajs 0.0.1

package/dist/helper/template/index.js

@@ -0,0 +1,475 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateHelper = exports.TemplateHelper = exports.MODULE_TYPES = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const handlebars_1 = __importDefault(require("handlebars"));
+const constant_1 = require("../../constant");
+const wormaJson_1 = require("../../functions/wormaJson");
+const logger_1 = require("../../helper/logger");
+const utils_1 = require("../../utils");
+/** M1-A2: Handlebars 实例缓存 —— 同 templatePath 复用编译好的 partials 和 helpers */
+const hbsInstanceCache = new Map();
+const templateCompileCache = new Map();
+function cacheKey(projectPath, output) {
+    return `${projectPath}::${output}`;
+}
+/** 模块类型目录名（与 config.type 不同：commonjs -> common） */
+exports.MODULE_TYPES = [constant_1.ModuleTypeDir.TYPESCRIPT, constant_1.ModuleTypeDir.MODULE, constant_1.ModuleTypeDir.COMMON];
+// ---- helpers ----
+const TEMPLATE_EXTENSIONS = [
+    constant_1.FileExtension.HBS,
+    constant_1.FileExtension.HANDLEBARS,
+    constant_1.FileExtension.TS,
+    constant_1.FileExtension.TSX,
+    constant_1.FileExtension.JS,
+    constant_1.FileExtension.JSX,
+    constant_1.FileExtension.MJS,
+    constant_1.FileExtension.CJS,
+    constant_1.FileExtension.D_TS,
+    constant_1.FileExtension.D_CTS,
+    constant_1.FileExtension.D_MTS,
+];
+function isTemplateFile(name) {
+    return TEMPLATE_EXTENSIONS.some(ext => name.endsWith(ext));
+}
+function parseEntryName(raw) {
+    const noOverwrite = raw.startsWith('#');
+    return { isNoOverwrite: noOverwrite, name: noOverwrite ? raw.slice(1) : raw };
+}
+function detectTemplateType(fileName, allowTag = true) {
+    if (allowTag && fileName.includes(constant_1.TemplatePlaceholder.TAG))
+        return 'tag';
+    if (fileName.includes(constant_1.TemplatePlaceholder.API))
+        return 'api';
+    return undefined;
+}
+function normalizeSlashes(p) {
+    return p.replace(/\\/g, '/');
+}
+function stripExt(fileName) {
+    if (fileName.endsWith(constant_1.FileExtension.HANDLEBARS))
+        return fileName.slice(0, -constant_1.FileExtension.HANDLEBARS.length);
+    if (fileName.endsWith(constant_1.FileExtension.HBS))
+        return fileName.slice(0, -constant_1.FileExtension.HBS.length);
+    return fileName;
+}
+function joinPath(...parts) {
+    const p = node_path_1.default.join(...parts);
+    return p ? normalizeSlashes(p) : p;
+}
+class TemplateHelper {
+    // ============ hasTagTemplates / instance ============
+    static async hasTagTemplates(templatePath, type) {
+        try {
+            const helper = TemplateHelper.load({ type, templatePath });
+            const files = await helper.resolveTemplateFiles(templatePath);
+            return files.some(f => f.templateType != null);
+        }
+        catch {
+            return false;
+        }
+    }
+    static getInstance() {
+        if (!TemplateHelper.instance)
+            TemplateHelper.instance = new TemplateHelper();
+        return TemplateHelper.instance;
+    }
+    constructor(config) {
+        if (config)
+            this.config = config;
+    }
+    load(config) {
+        this.config = config;
+        return this;
+    }
+    static load(config) { return new TemplateHelper(config); }
+    getExt() { return TemplateHelper.getExt(this.config.type); }
+    getModuleType() { return TemplateHelper.getModuleType(this.config.type); }
+    static getExt(type) { return type === constant_1.TemplateTypeEnum.TYPESCRIPT ? constant_1.FileExtension.TS : constant_1.FileExtension.JS; }
+    static getModuleType(type) {
+        return constant_1.MODULE_TYPE_TO_KIND[type] ?? constant_1.ModuleKind.ES_MODULE;
+    }
+    // ============ 缓存 ============
+    static async readData(projectPath, output) {
+        const key = cacheKey(projectPath, output);
+        const cached = TemplateHelper._cacheData.get(key);
+        if (cached)
+            return cached;
+        try {
+            const data = await (0, wormaJson_1.readCacheApis)(projectPath, output);
+            if (!data) {
+                TemplateHelper._cacheData.delete(key);
+                return null;
+            }
+            TemplateHelper._cacheData.set(key, data);
+            return data;
+        }
+        catch {
+            TemplateHelper._cacheData.delete(key);
+            return null;
+        }
+    }
+    static getData(projectPath, output) {
+        return TemplateHelper._cacheData.get(cacheKey(projectPath, output));
+    }
+    static async setData(templateData, projectPath, output, config) {
+        TemplateHelper._cacheData.set(cacheKey(projectPath, output), {
+            path: output,
+            serverName: config?.serverName || templateData.title || '',
+            apis: templateData.allApis || [],
+        });
+    }
+    /** Flush all in-memory cache entries to disk using directory-based format. Only flushes entries belonging to the given projectPath. */
+    static async flushAllData(projectPath) {
+        const prefix = `${projectPath}::`;
+        for (const [key, cd] of TemplateHelper._cacheData) {
+            if (!key.startsWith(prefix))
+                continue;
+            const apis = cd.apis || [];
+            const hashInfo = (0, wormaJson_1.computePerTagHashes)(apis);
+            await (0, wormaJson_1.writeCacheEntry)(projectPath, cd.path, cd.serverName || '', apis, hashInfo);
+        }
+    }
+    // ============ unlink ============
+    unlink(_files, { output }) {
+        const ext = this.getExt();
+        const list = _files.filter(Boolean).map(item => typeof item === 'string' ? { fileName: item, output, ext } : Object.assign({ output, ext }, item));
+        return Promise.all(list.map(async ({ output, fileName, ext }) => {
+            const p = node_path_1.default.join(output, `${fileName}${ext}`);
+            if (await (0, utils_1.existsPromise)(p))
+                await promises_1.default.unlink(p);
+        }));
+    }
+    // ============ 模板解析 ============
+    async resolveTemplateFiles(templatePath) {
+        const absolute = node_path_1.default.isAbsolute(templatePath) ? templatePath : node_path_1.default.resolve(process.cwd(), templatePath);
+        if (!(await (0, utils_1.existsPromise)(absolute)))
+            throw logger_1.logger.throwError(`Template path not found: ${absolute}`);
+        if (await this.checkModuleTypeDirs(absolute)) {
+            const mt = this.resolveModuleType();
+            const md = node_path_1.default.join(absolute, mt);
+            if (await (0, utils_1.existsPromise)(md)) {
+                logger_1.logger.debug('Resolving template files via module-type dir', { moduleType: mt, templatePath: absolute });
+                return this.scanDir(md, '');
+            }
+            const supported = [];
+            for (const m of exports.MODULE_TYPES) {
+                if (await (0, utils_1.existsPromise)(node_path_1.default.join(absolute, m)))
+                    supported.push(m);
+            }
+            throw logger_1.logger.throwError(`Template "${node_path_1.default.basename(absolute)}" does not support module type "${this.config.type}". Supported types: ${supported.join(', ')}`);
+        }
+        return this.scanAllTemplateDirs(absolute);
+    }
+    async checkModuleTypeDirs(tpl) {
+        for (const m of exports.MODULE_TYPES) {
+            const d = node_path_1.default.join(tpl, m);
+            if (await (0, utils_1.existsPromise)(d) && (await promises_1.default.stat(d)).isDirectory())
+                return true;
+        }
+        return false;
+    }
+    resolveModuleType() {
+        const m = {
+            [constant_1.TemplateTypeEnum.TYPESCRIPT]: constant_1.ModuleTypeDir.TYPESCRIPT,
+            [constant_1.TemplateTypeEnum.MODULE]: constant_1.ModuleTypeDir.MODULE,
+            commonjs: constant_1.ModuleTypeDir.COMMON,
+        };
+        return m[this.config.type] ?? constant_1.ModuleTypeDir.TYPESCRIPT;
+    }
+    // ---- scan ----
+    async scanDir(dir, base, insideTagDir = false) {
+        const out = [];
+        for (const e of await promises_1.default.readdir(dir, { withFileTypes: true })) {
+            const fp = node_path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (e.name === constant_1.TemplateSkipDir.PARTIALS)
+                    continue;
+                if (e.name === constant_1.TemplateSkipDir.TAG_DIR) {
+                    if (insideTagDir)
+                        throw logger_1.logger.throwError(`Nested ${constant_1.TemplatePlaceholder.TAG} directory is not allowed: "${joinPath(base, constant_1.TemplatePlaceholder.TAG)}".`);
+                    out.push(...await this.scanDir(fp, joinPath(base, constant_1.TemplatePlaceholder.TAG), true));
+                }
+                else {
+                    out.push(...await this.scanDir(fp, joinPath(base, e.name), insideTagDir));
+                }
+            }
+            else if (e.isFile() && isTemplateFile(e.name)) {
+                out.push(this.makeFileInfo(e.name, fp, base, insideTagDir));
+            }
+        }
+        return out;
+    }
+    async scanAllTemplateDirs(tpl) {
+        const out = [];
+        for (const e of await promises_1.default.readdir(tpl, { withFileTypes: true })) {
+            const fp = node_path_1.default.join(tpl, e.name);
+            if (e.isDirectory()) {
+                if (e.name === constant_1.TemplateSkipDir.PARTIALS)
+                    continue;
+                if (e.name === constant_1.TemplateSkipDir.TAG_DIR)
+                    out.push(...await this.scanDir(fp, constant_1.TemplatePlaceholder.TAG, true));
+                else
+                    out.push(...await this.scanDir(fp, e.name));
+            }
+            else if (e.isFile() && isTemplateFile(e.name)) {
+                out.push(this.makeFileInfo(e.name, fp, ''));
+            }
+        }
+        return out;
+    }
+    makeFileInfo(rawName, absolutePath, base, insideTagDir = false) {
+        const { isNoOverwrite, name: actual } = parseEntryName(rawName);
+        if (insideTagDir && actual.includes(constant_1.TemplatePlaceholder.TAG))
+            throw logger_1.logger.throwError(`Nested ${constant_1.TemplatePlaceholder.TAG} template not allowed: "${joinPath(base, actual)}".`);
+        return {
+            absolutePath,
+            relativePath: base ? joinPath(base, actual) : actual,
+            fileName: actual,
+            isNoOverwrite,
+            templateType: detectTemplateType(actual, !insideTagDir),
+            insideTagDir,
+        };
+    }
+    // ============ 渲染 & 输出 ============
+    async renderTemplate(templateFilePath, data) {
+        const p = node_path_1.default.isAbsolute(this.config.templatePath)
+            ? node_path_1.default.join(this.config.templatePath, `${templateFilePath}${constant_1.FileExtension.HANDLEBARS}`)
+            : node_path_1.default.resolve(process.cwd(), this.config.templatePath, `${templateFilePath}${constant_1.FileExtension.HANDLEBARS}`);
+        if (await (0, utils_1.existsPromise)(p)) {
+            const hbs = await this.createHbs();
+            return hbs.compile(await promises_1.default.readFile(p, 'utf-8'))(data);
+        }
+        throw logger_1.logger.throwError(`Template not found: ${templateFilePath}`);
+    }
+    async renderTemplateFromPath(hbs, absolutePath, data) {
+        let template = templateCompileCache.get(absolutePath);
+        if (!template) {
+            template = hbs.compile(await promises_1.default.readFile(absolutePath, 'utf-8'));
+            templateCompileCache.set(absolutePath, template);
+        }
+        return template(data);
+    }
+    /** M1-A2: 清除 Handlebars 编译和实例缓存（供测试与 watch 模式使用） */
+    static clearTemplateCache() {
+        hbsInstanceCache.clear();
+        templateCompileCache.clear();
+    }
+    async createHbs() {
+        const cacheKey = this.config.templatePath;
+        const cached = hbsInstanceCache.get(cacheKey);
+        if (cached) {
+            logger_1.logger.debug('Handlebars instance loaded from cache', { templatePath: cacheKey });
+            return cached;
+        }
+        logger_1.logger.debug('Creating new Handlebars instance', { templatePath: cacheKey });
+        const hbs = handlebars_1.default.create();
+        (0, utils_1.registerCommonHelpers)(hbs);
+        await (0, utils_1.registerPartials)(this.config.templatePath, hbs);
+        if (this.config.onHandlebarsCreated?.length) {
+            logger_1.logger.debug('Running onHandlebarsCreated callbacks', { count: this.config.onHandlebarsCreated.length });
+            for (const fn of this.config.onHandlebarsCreated) {
+                if (typeof fn === 'function')
+                    await fn(hbs);
+            }
+        }
+        hbsInstanceCache.set(cacheKey, hbs);
+        return hbs;
+    }
+    /**
+     * 9.2.3: Private file writing — now internal to the streaming pipeline.
+     * Prettier formatting applied at file level (9.5.2).
+     */
+    async outputFiles(files, output, writeConcurrency = 32, formatFile = true) {
+        const entries = Object.entries(files);
+        if (!entries.length)
+            return;
+        // Collect unique directories and create them
+        const dirs = new Set();
+        for (const [rp] of entries) {
+            const op = node_path_1.default.isAbsolute(rp) ? rp : node_path_1.default.join(output, rp);
+            dirs.add(node_path_1.default.dirname(op));
+        }
+        await Promise.all([...dirs].map(async (d) => {
+            if (!(await (0, utils_1.existsPromise)(d)))
+                await promises_1.default.mkdir(d, { recursive: true });
+        }));
+        // Batch concurrent writes to avoid too many file handles
+        const concurrency = Math.max(1, writeConcurrency);
+        for (let i = 0; i < entries.length; i += concurrency) {
+            const batch = entries.slice(i, i + concurrency);
+            await Promise.all(batch.map(async ([rp, content]) => {
+                const op = node_path_1.default.isAbsolute(rp) ? rp : node_path_1.default.join(output, rp);
+                // 9.5.2: Apply prettier at file level for .ts/.js files
+                let finalContent = content;
+                if (formatFile && /\.(?:ts|js|mjs|cjs|tsx|jsx)$/.test(rp)) {
+                    try {
+                        finalContent = await (0, utils_1.format)(content);
+                    }
+                    catch {
+                        // Prettier format failed, use original content
+                    }
+                }
+                return promises_1.default.writeFile(op, finalContent);
+            }));
+        }
+        logger_1.logger.debug('Batch file write complete', {
+            total: entries.length,
+            concurrency,
+            formatFile,
+            outputDir: output,
+        });
+    }
+    /** Convenience: load template and render to directory in one call */
+    static async renderToDir(params) {
+        const helper = TemplateHelper.load({ type: params.type, templatePath: params.templatePath });
+        return helper.generateFromTemplateDir(params.templatePath, params.outputDir, params.data, params.options);
+    }
+    // ============ generateFromTemplateDir (unified streaming pipeline) ============
+    /**
+     * 9.2.1 & 9.2.2: Unified streaming pipeline — the only generation method.
+     * Renders per-tag files and writes them immediately, then renders global files.
+     * Supports `beforeFileWrite` callback for plugin content modification (9.1.2).
+     * Collects and returns all file paths for `codeGenerated` hook (9.1.1).
+     */
+    async generateFromTemplateDir(templatePath, outputDir, data, options) {
+        const tpls = await this.resolveTemplateFiles(templatePath);
+        if (!tpls.length)
+            throw logger_1.logger.throwError(`No template files found in: ${templatePath}`);
+        const totalTemplates = tpls.length;
+        const tagTemplates = tpls.filter(f => f.templateType === 'tag').length;
+        const apiTemplates = tpls.filter(f => f.templateType === 'api').length;
+        const staticTemplates = totalTemplates - tagTemplates - apiTemplates;
+        logger_1.logger.debug('Template files resolved', {
+            total: totalTemplates,
+            tagTemplates,
+            apiTemplates,
+            staticTemplates,
+        });
+        const { changedTags, beforeFileWrite, writeConcurrency = 32, formatFile = true } = options ?? {};
+        const hbs = await this.createHbs();
+        const tags = data.tagedApis?.map(item => item.tagName) || [];
+        const apis = data.allApis || [];
+        const tagApisMap = new Map();
+        data.tagedApis?.forEach(item => tagApisMap.set(item.tagName, item));
+        // Collect all file paths for codeGenerated notification
+        const allFilePaths = [];
+        // --- Phase 1: Per-tag streaming (render → collect → batch write) ---
+        const nonDirTagTpls = tpls.filter(f => !f.insideTagDir && f.templateType === 'tag');
+        const dirTpls = tpls.filter(f => f.insideTagDir);
+        const effectiveTags = changedTags ? tags.filter(t => changedTags.has(t)) : tags;
+        let tagFilesWritten = 0;
+        logger_1.logger.debug('Phase 1: Per-tag streaming', {
+            totalTags: tags.length,
+            effectiveTags: effectiveTags.length,
+            changedMode: !!changedTags,
+        });
+        // P1: Collect all per-tag files across all tags, then write in ONE batch.
+        // Previously each tag wrote its files immediately via outputFiles(), which
+        // meant 35+ small sequential write batches instead of one fully-concurrent batch.
+        const allTagFiles = {};
+        for (const tag of effectiveTags) {
+            const tagApis = tagApisMap.get(tag);
+            if (!tagApis)
+                continue;
+            const tagFiles = {};
+            const ctx = { ...data, tagedApis: [tagApis], currentTag: tagApis };
+            for (const tf of nonDirTagTpls) {
+                Object.assign(tagFiles, await this.renderOne(hbs, tf, ctx, outputDir, { tag, api: undefined }));
+            }
+            for (const tf of dirTpls) {
+                if (tf.templateType === 'api') {
+                    await this.expandByApi(hbs, tf, ctx, tagApis.apis, api => ({ ...ctx, currentApi: api }), tagFiles, outputDir, tag);
+                }
+                else {
+                    Object.assign(tagFiles, await this.renderOne(hbs, tf, ctx, outputDir, { tag, api: undefined }));
+                }
+            }
+            // Apply beforeFileWrite with per-tag metadata, then collect into allTagFiles
+            if (beforeFileWrite) {
+                for (const [rp, content] of Object.entries(tagFiles)) {
+                    tagFiles[rp] = await beforeFileWrite({
+                        filePath: rp,
+                        content,
+                        meta: { templateType: 'tag', tag, api: undefined },
+                    });
+                }
+            }
+            // Collect paths for codeGenerated notification
+            for (const rp of Object.keys(tagFiles)) {
+                const op = node_path_1.default.isAbsolute(rp) ? rp : node_path_1.default.resolve(outputDir, rp);
+                allFilePaths.push(op);
+            }
+            Object.assign(allTagFiles, tagFiles);
+            tagFilesWritten += Object.keys(tagFiles).length;
+        }
+        // P1: Single batch write for ALL per-tag files — fully utilizes writeConcurrency
+        if (Object.keys(allTagFiles).length) {
+            await this.outputFiles(allTagFiles, outputDir, writeConcurrency, formatFile);
+        }
+        logger_1.logger.debug('Phase 1 complete', { tagFilesWritten });
+        // --- Phase 2: Global files (API-level + non-tag templates) ---
+        const globalFiles = {};
+        const globalTpls = tpls.filter(f => !f.insideTagDir);
+        logger_1.logger.debug('Phase 2: Global files', { globalTemplateCount: globalTpls.length });
+        for (const tf of globalTpls) {
+            if (tf.templateType === 'tag' && tags.length)
+                continue;
+            if (tf.templateType === 'api' && apis.length) {
+                await this.expandByApi(hbs, tf, data, apis, api => api, globalFiles, outputDir);
+            }
+            else if (tf.templateType !== 'tag') {
+                Object.assign(globalFiles, await this.renderOne(hbs, tf, data, outputDir));
+            }
+        }
+        await this.applyHooksAndWrite(globalFiles, outputDir, beforeFileWrite, undefined, undefined, undefined, writeConcurrency, formatFile, allFilePaths);
+        logger_1.logger.debug('Phase 2 complete', { globalFilesWritten: Object.keys(globalFiles).length });
+        logger_1.logger.debug('Generation summary', { totalOutputFiles: allFilePaths.length });
+        return { filePaths: allFilePaths };
+    }
+    async applyHooksAndWrite(files, outputDir, beforeFileWrite, templateType, tag, api, writeConcurrency, formatFile, allFilePaths) {
+        if (beforeFileWrite) {
+            // Apply beforeFileWrite to each file sequentially for determinism
+            for (const [rp, content] of Object.entries(files)) {
+                const newContent = await beforeFileWrite({
+                    filePath: rp,
+                    content,
+                    meta: { templateType, tag, api },
+                });
+                files[rp] = newContent;
+            }
+        }
+        // Collect paths
+        for (const rp of Object.keys(files)) {
+            const op = node_path_1.default.isAbsolute(rp) ? rp : node_path_1.default.resolve(outputDir, rp);
+            allFilePaths.push(op);
+        }
+        await this.outputFiles(files, outputDir, writeConcurrency, formatFile);
+    }
+    async expandByApi(hbs, tf, _data, apis, ctxFn, out, outputDir, tag) {
+        for (const api of apis) {
+            Object.assign(out, await this.renderOne(hbs, tf, ctxFn(api), outputDir, { tag, api: api.name }));
+        }
+    }
+    async renderOne(hbs, tf, data, outputDir, placeholders) {
+        const renderData = data.config ? { ...data.config, ...data } : data;
+        const content = await this.renderTemplateFromPath(hbs, tf.absolutePath, renderData);
+        let relPath = tf.relativePath;
+        if (placeholders?.tag)
+            relPath = relPath.replace(constant_1.TemplatePlaceholder.TAG, placeholders.tag);
+        if (placeholders?.api)
+            relPath = relPath.replace(constant_1.TemplatePlaceholder.API, placeholders.api);
+        relPath = stripExt(normalizeSlashes(relPath));
+        if (tf.isNoOverwrite && await (0, utils_1.existsPromise)(node_path_1.default.join(outputDir, relPath)))
+            return {};
+        return { [relPath]: `${content.trim()}\n` };
+    }
+}
+exports.TemplateHelper = TemplateHelper;
+/** Runtime cache of parsed template data, keyed by `${projectPath}::${output}`. Flushed to disk via flushAllData. */
+TemplateHelper._cacheData = new Map();
+exports.templateHelper = TemplateHelper.getInstance();

package/dist/index.js

@@ -0,0 +1,33 @@
+"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.resolveWorkspaces = exports.logger = exports.generate = exports.defineConfig = exports.createConfig = exports.setGlobalConfig = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "setGlobalConfig", { enumerable: true, get: function () { return config_1.setGlobalConfig; } });
+var createConfig_1 = require("./createConfig");
+Object.defineProperty(exports, "createConfig", { enumerable: true, get: function () { return __importDefault(createConfig_1).default; } });
+var defineConfig_1 = require("./defineConfig");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return defineConfig_1.defineConfig; } });
+var generate_1 = require("./generate");
+Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return __importDefault(generate_1).default; } });
+var helper_1 = require("./helper");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return helper_1.logger; } });
+__exportStar(require("./readConfig"), exports);
+var resolveWorkspaces_1 = require("./resolveWorkspaces");
+Object.defineProperty(exports, "resolveWorkspaces", { enumerable: true, get: function () { return __importDefault(resolveWorkspaces_1).default; } });

package/dist/plugins/createPlugin.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlugin = createPlugin;
+/**
+ * Creates a plugin factory function with proper typing
+ *
+ * @param plugin - Function that creates a plugin instance
+ * @returns The original plugin function with proper typing
+ *
+ * @example
+ * // Create a custom plugin
+ * const myPlugin = createPlugin((options: MyOptions) => ({
+ *   handleApi: (apiDescriptor) => {
+ *     // Plugin implementation
+ *     return apiDescriptor;
+ *   }
+ * }));
+ *
+ * // Use the plugin
+ * generate({
+ *   generator: [{
+ *     // ...
+ *     plugins: [myPlugin({ key: 'value' })]
+ *   }]
+ * });
+ */
+function createPlugin(plugin) {
+    return plugin;
+}
+exports.default = createPlugin;

package/dist/plugins/index.js

@@ -0,0 +1,34 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ky = exports.config = exports.axios = exports.alovaGlobals = exports.alova = void 0;
+__exportStar(require("./createPlugin"), exports);
+__exportStar(require("./presets/aiDoc"), exports);
+__exportStar(require("./presets/apifox"), exports);
+__exportStar(require("./presets/filterApi"), exports);
+__exportStar(require("./presets/importType"), exports);
+__exportStar(require("./presets/payloadModifier"), exports);
+__exportStar(require("./presets/platform"), exports);
+__exportStar(require("./presets/rename"), exports);
+__exportStar(require("./presets/tagModifier"), exports);
+// Template preset plugins
+var template_1 = require("../template");
+Object.defineProperty(exports, "alova", { enumerable: true, get: function () { return template_1.alova; } });
+Object.defineProperty(exports, "alovaGlobals", { enumerable: true, get: function () { return template_1.alovaGlobals; } });
+Object.defineProperty(exports, "axios", { enumerable: true, get: function () { return template_1.axios; } });
+Object.defineProperty(exports, "config", { enumerable: true, get: function () { return template_1.config; } });
+Object.defineProperty(exports, "fetch", { enumerable: true, get: function () { return template_1.fetch; } });
+Object.defineProperty(exports, "ky", { enumerable: true, get: function () { return template_1.ky; } });