wormajs 0.0.1

package/dist/generate.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const poolManager_1 = require("./core/workerPool/poolManager");
+const helper_1 = require("./helper");
+const GeneratorHelper_1 = require("./helper/config/GeneratorHelper");
+const progress_1 = require("./helper/progress");
+/**
+ * Generate relevant API information based on the configuration object.
+ *
+ * When `options.onProgress` is provided, each generator independently reports
+ * its lifecycle via {@link GeneratorProgressEvent} discriminated union events.
+ *
+ * @param config generating config
+ * @param options config rules that contains `force`, `projectPath`, `onProgress`
+ * @returns An array that contains the result of `generator` items in configuration whether generation is successful.
+ */
+async function generate(config, options) {
+    if (!config)
+        return [];
+    const projectPath = options?.projectPath ?? process.cwd();
+    const emit = options?.onProgress;
+    // Load phase (shared, no per-gen events during load) — plugins may modify generator configs
+    helper_1.logger.debug('Loading config', { projectPath });
+    await helper_1.configHelper.load(config, projectPath);
+    // Use the processed generators from ConfigManager (after plugin hooks have run)
+    const generators = helper_1.configHelper.getConfig().generator;
+    helper_1.logger.debug('Config loaded', { generatorCount: generators.length });
+    // Run all generators in parallel, each with its own ProgressTracker
+    const results = await Promise.all(generators.map(async (gen, i) => {
+        const generatorName = gen.input || `generator-${i}`;
+        helper_1.logger.debug(`Generator [${i}] starting`, { name: generatorName, input: gen.input, output: gen.output });
+        emit?.({ index: i, phase: 'active' });
+        const tracker = new progress_1.ProgressTracker((snapshot) => {
+            if (!emit)
+                return;
+            for (const [source, entry] of Object.entries(snapshot)) {
+                emit({
+                    index: i,
+                    phase: 'progress',
+                    progress: entry.progress,
+                    message: entry.message || '',
+                    source,
+                });
+            }
+        }, 16); // 16ms throttle (~60fps), avoids flooding the event loop on high-frequency updates
+        tracker.start();
+        try {
+            const result = await GeneratorHelper_1.GeneratorHelper.generate(gen, {
+                force: options?.force,
+                projectPath,
+                tracker,
+            });
+            emit?.({
+                index: i,
+                phase: result.success ? 'done' : 'skipped',
+                resolvedInput: result.resolvedInput,
+            });
+            helper_1.logger.debug(`Generator [${i}] finished`, {
+                name: generatorName,
+                success: result.success,
+                resolvedInput: result.resolvedInput,
+            });
+            return result.success;
+        }
+        catch (error) {
+            helper_1.logger.debug(`Generator [${i}] failed`, {
+                name: generatorName,
+                error: error.message,
+                stack: error.stack,
+            });
+            emit?.({ index: i, phase: 'failed', error: error.message });
+            return false;
+        }
+        finally {
+            tracker.stop();
+        }
+    }));
+    helper_1.logger.debug('Flushing template data cache', { projectPath });
+    await helper_1.TemplateHelper.flushAllData(projectPath);
+    poolManager_1.PoolManager.getInstance().releaseAll();
+    helper_1.logger.debug('Generation complete', { results });
+    return results;
+}
+exports.default = generate;

package/dist/helper/PluginDriver.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginDriver = void 0;
+const logger_1 = require("../helper/logger");
+const progress_1 = require("../helper/progress");
+/** A shared frozen empty context — avoids repeated allocations. */
+const CTX = Object.freeze({});
+/**
+ * PluginDriver — unified plugin hook scheduler.
+ *
+ * - Constructor accepts a `reporter` factory; all hooks auto-inject `reportProgress`.
+ * - Provides three execution strategies: parallelEach, seqEach (chaining), pipe (content transform).
+ */
+class PluginDriver {
+    constructor(plugins = [], opts) {
+        this.plugins = plugins.filter(Boolean);
+        this.reporter = opts?.reporter ?? (() => progress_1.noopReportProgress);
+    }
+    // ---- internal ----
+    /** Run a single hook on one plugin. Returns the handler's result or null. */
+    async _call(plugin, name, params) {
+        const handler = plugin[name];
+        if (typeof handler !== 'function')
+            return null;
+        return handler.call(plugin, params);
+    }
+    /** Resolve a human-readable name for a plugin (constructor name fallback). */
+    _pluginName(plugin) {
+        return plugin.name || plugin.constructor?.name || 'anonymous';
+    }
+    /** Build full params by auto-injecting reportProgress into the partial object. */
+    _params(plugin, partial) {
+        return { ...partial, reportProgress: this.reporter(plugin) };
+    }
+    // ---- public hooks ----
+    /**
+     * Execute hooks in parallel — each plugin gets independently built params.
+     * `makeArgs` returns only hook-specific fields; reportProgress is auto-injected.
+     */
+    async hookParallelEach(name, makeArgs) {
+        const pluginsWithHook = this.plugins.filter(p => typeof p[name] === 'function');
+        if (!pluginsWithHook.length) {
+            logger_1.logger.debug(`hookParallelEach [${name}] — no plugins registered`, { totalPlugins: this.plugins.length });
+            return;
+        }
+        logger_1.logger.debug(`hookParallelEach [${name}]`, {
+            plugins: pluginsWithHook.map(p => this._pluginName(p)),
+            totalPlugins: this.plugins.length,
+        });
+        await Promise.all(pluginsWithHook.map(p => this._call(p, name, this._params(p, makeArgs(p, CTX)))));
+    }
+    /**
+     * Execute hooks sequentially — each plugin's result is fed to the next via makeArgs.
+     * `prevResult` is the previous plugin's return value (or undefined for the first).
+     */
+    async hookSeqEach(name, makeArgs) {
+        const pluginsWithHook = this.plugins.filter(p => typeof p[name] === 'function');
+        if (!pluginsWithHook.length) {
+            logger_1.logger.debug(`hookSeqEach [${name}] — no plugins registered`, { totalPlugins: this.plugins.length });
+            return undefined;
+        }
+        logger_1.logger.debug(`hookSeqEach [${name}]`, {
+            plugins: pluginsWithHook.map(p => this._pluginName(p)),
+        });
+        let prev;
+        for (const plugin of pluginsWithHook) {
+            const result = await this._call(plugin, name, this._params(plugin, makeArgs(plugin, prev, CTX)));
+            if (result != null) {
+                logger_1.logger.debug(`hookSeqEach [${name}] — ${this._pluginName(plugin)} returned a result, chaining forward`);
+                prev = result;
+            }
+        }
+        return prev;
+    }
+    /**
+     * Pipe a value through all plugins sequentially.
+     * Each plugin with the named hook receives the current value and can return a modified one.
+     * Plugins without the hook are silently skipped (value passes through unchanged).
+     */
+    async hookPipe(name, initialValue, makeArgs) {
+        let current = initialValue;
+        let modifiedCount = 0;
+        for (const plugin of this.plugins) {
+            const handler = plugin[name];
+            if (typeof handler !== 'function')
+                continue;
+            const result = await handler.call(plugin, this._params(plugin, makeArgs(plugin, current, CTX)));
+            if (typeof result === 'string') {
+                modifiedCount++;
+                current = result;
+            }
+        }
+        logger_1.logger.debug(`hookPipe [${name}]`, { plugins: this.plugins.length, modifiedCount });
+        return current;
+    }
+}
+exports.PluginDriver = PluginDriver;
+exports.default = PluginDriver;

package/dist/helper/comment.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commentHelper = exports.CommentHelper = void 0;
+class CommentHelper {
+    constructor() {
+        this.type = 'line';
+        this.comment = '';
+        this.transformMap = {
+            '[deprecated]': '@deprecated',
+            '[required]': '[required]',
+            '[title]': (text) => {
+                const [, nextText = ''] = /\[title\](.*)/.exec(text) ?? [];
+                return `${nextText.trim()}\n---`;
+            },
+            '[cycle]': (text) => {
+                const [, nextText = ''] = /\[cycle\](.*)/.exec(text) ?? [];
+                return `${nextText.trim()}\n---`;
+            },
+            '[summary]': (text) => {
+                const [, nextText = ''] = /\[summary\](.*)/.exec(text) ?? [];
+                return `${nextText.trim()}\n---`;
+            },
+        };
+    }
+    static load(options) {
+        return new CommentHelper().load(options);
+    }
+    static parse(comment) {
+        return comment
+            .split('\n')
+            .map(span => span.replace(/^\/\*+|\*+\/|\*|\/\//, '').trim())
+            .filter(span => span);
+    }
+    static parseStr(comment) {
+        return this.parse(comment).join('\n');
+    }
+    load(options) {
+        this.type = options.type;
+        if (options.comment) {
+            this.comment = options.comment;
+        }
+        return this;
+    }
+    add(key, text = '') {
+        if (this.comment) {
+            this.comment += '\n';
+        }
+        this.comment += this.transformText(`${key} ${text}`)
+            .split('\n')
+            .map(span => `${this.preText()} ${span}`)
+            .join('\n');
+        return this;
+    }
+    end() {
+        const result = this.comment ? this.startText() + this.normalize() + this.endText() : '';
+        this.comment = '';
+        return result;
+    }
+    startText() {
+        return this.type === 'doc' ? '/**\n' : '';
+    }
+    preText() {
+        return this.type === 'doc' ? '*' : '//';
+    }
+    endText() {
+        return this.type === 'doc' ? '\n */\n' : '\n';
+    }
+    normalize() {
+        const comment = CommentHelper.parse(this.comment)
+            .map(span => `${this.preText()} ${span}`)
+            .join('\n');
+        return comment.replace('*/*', '* / *').replace('/*', '/ *').replace('*/', '* /');
+    }
+    transformText(text) {
+        text = text.trim();
+        if (this.type === 'line') {
+            return text;
+        }
+        const key = Object.keys(this.transformMap).find(key => text.startsWith(key));
+        if (key) {
+            const transformer = this.transformMap[key];
+            return typeof transformer === 'function' ? transformer(text) : (transformer ?? text);
+        }
+        return text;
+    }
+}
+exports.CommentHelper = CommentHelper;
+exports.commentHelper = new CommentHelper();

package/dist/helper/config/ConfigHelper.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configHelper = exports.ConfigHelper = void 0;
+const lodash_1 = require("lodash");
+const helper_1 = require("../../helper");
+const logger_1 = require("../../helper/logger");
+const ConfigManager_1 = require("./ConfigManager");
+const GeneratorHelper_1 = require("./GeneratorHelper");
+class ConfigHelper {
+    constructor() {
+        this.configManager = ConfigManager_1.ConfigManager.getInstance();
+    }
+    static getInstance() {
+        if (!ConfigHelper.instance) {
+            ConfigHelper.instance = new ConfigHelper();
+        }
+        return ConfigHelper.instance;
+    }
+    async load(config, projectPath = process.cwd(), tracker) {
+        this.projectPath = projectPath;
+        logger_1.logger.debug('ConfigHelper.load — loading config manager', { projectPath, generatorCount: config.generator?.length ?? 0 });
+        await this.configManager.load(config, projectPath, tracker);
+        logger_1.logger.debug('ConfigHelper.load — reading cache data');
+        await this.readAlovaJson();
+        logger_1.logger.debug('ConfigHelper.load — complete');
+    }
+    async readUserConfig(userConfig) {
+        if (typeof userConfig === 'function') {
+            return await userConfig();
+        }
+        return Promise.resolve(userConfig);
+    }
+    getConfig() {
+        return this.configManager.getConfig();
+    }
+    getProjectPath() {
+        return this.projectPath;
+    }
+    getTemplateType(idx) {
+        const { generator } = this.configManager.getConfig();
+        const templateType = (config) => GeneratorHelper_1.GeneratorHelper.getTemplateType(config, this.projectPath);
+        if ((0, lodash_1.isArray)(idx)) {
+            return generator.filter((_, index) => idx.includes(index)).map(item => templateType(item));
+        }
+        if (idx !== undefined && idx < generator.length && idx >= 0) {
+            return [templateType(generator[idx])];
+        }
+        return generator.map(item => templateType(item));
+    }
+    getOutput() {
+        return this.configManager.getConfig().generator.map(item => item.output);
+    }
+    getOpenApiData() {
+        return Promise.all(this.configManager
+            .getConfig()
+            .generator.map(item => GeneratorHelper_1.GeneratorHelper.openApiData(item, this.projectPath)));
+    }
+    async generate(options) {
+        const { tracker, force } = options;
+        const results = await Promise.all(this.configManager.getConfig().generator.map(item => GeneratorHelper_1.GeneratorHelper.generate(item, {
+            force,
+            projectPath: this.projectPath,
+            tracker,
+        })));
+        // Flush all in-memory cache entries to disk once after all generators complete,
+        // avoiding race conditions from parallel writes to the same .alova-cache.json.
+        await helper_1.TemplateHelper.flushAllData(this.projectPath);
+        return results.map(r => r.success);
+    }
+    readAlovaJson() {
+        const allAlovaJSon = this.configManager
+            .getConfig()
+            .generator
+            .map(async (item) => helper_1.TemplateHelper.readData(this.projectPath, item.output));
+        return Promise.all(allAlovaJSon);
+    }
+}
+exports.ConfigHelper = ConfigHelper;
+exports.configHelper = ConfigHelper.getInstance();

package/dist/helper/config/ConfigManager.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = exports.ConfigManager = void 0;
+const zod_validation_error_1 = require("zod-validation-error");
+const prepareConfig_1 = __importDefault(require("../../functions/prepareConfig"));
+const GeneratorHelper_1 = require("../../helper/config/GeneratorHelper");
+const logger_1 = require("../../helper/logger");
+const zType_1 = require("./zType");
+class ConfigManager {
+    constructor() {
+        this.defaultConfig = Object.freeze({
+            generator: [],
+        });
+        this.defaultGeneratorConfig = GeneratorHelper_1.generatorHelper.getDefaultConfig();
+        this.config = this.defaultConfig;
+    }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    /**
+     * 加载并验证配置
+     */
+    async load(config, projectPath = process.cwd(), tracker) {
+        // 处理配置
+        const userConfig = await this.handleConfig(config, projectPath, tracker);
+        // 验证配置
+        const validatedConfig = this.validateConfig(userConfig);
+        // 更新配置
+        this.config = validatedConfig;
+        this.readConfig = Object.freeze(this.config);
+        logger_1.logger.debug('Configuration loaded successfully', this.config);
+    }
+    /**
+     * 获取完整配置
+     */
+    getConfig() {
+        return this.readConfig;
+    }
+    /**
+     * 更新配置
+     */
+    async update(partialConfig) {
+        await this.load({ ...this.config, ...partialConfig });
+    }
+    async handleConfig(config, projectPath = process.cwd(), tracker) {
+        // 合并配置
+        const userConfig = this.mergeConfig(this.defaultConfig, config);
+        // 处理插件的config配置
+        userConfig.generator = await Promise.all(userConfig.generator.map(item => (0, prepareConfig_1.default)(item, projectPath, tracker)));
+        return userConfig;
+    }
+    /**
+     * 验证配置
+     */
+    validateConfig(config) {
+        let result = config;
+        try {
+            result = zType_1.zConfig.parse(config);
+        }
+        catch (error) {
+            const zError = (0, zod_validation_error_1.fromError)(error);
+            throw logger_1.logger.throwError(zError.message, zError.details);
+        }
+        return result;
+    }
+    /**
+     * 合并配置（浅拷贝）
+     */
+    mergeConfig(defaultConfig, userConfig) {
+        const result = { ...defaultConfig, ...userConfig };
+        if (userConfig.generator) {
+            result.generator = userConfig.generator.map(config => ({
+                ...this.defaultGeneratorConfig,
+                ...config,
+            }));
+        }
+        return result;
+    }
+}
+exports.ConfigManager = ConfigManager;
+// 导出单例实例
+exports.configManager = ConfigManager.getInstance();