wormajs 0.0.1

package/dist/helper/document/index.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openApiHelper = exports.OpenApiHelper = exports.supportedApiMethods = void 0;
+const type_1 = require("../../type");
+const utils_1 = require("../../utils");
+/**
+ * 支持的API方法列表
+ * @see https://github.com/alovajs/alova/blob/main/packages/alova/typings/index.d.ts#L640
+ */
+exports.supportedApiMethods = [
+    type_1.HttpMethod.GET,
+    type_1.HttpMethod.PUT,
+    type_1.HttpMethod.POST,
+    type_1.HttpMethod.DELETE,
+    type_1.HttpMethod.PATCH,
+    type_1.HttpMethod.HEAD,
+    type_1.HttpMethod.OPTIONS,
+];
+class OpenApiHelper {
+    constructor() {
+        this.usedRefsCache = new Set();
+    }
+    load(document) {
+        this.document = document;
+        // reset cache when document changes
+        this.usedRefsCache.clear();
+        return this;
+    }
+    static load(document) {
+        const ins = new OpenApiHelper();
+        return ins.load(document);
+    }
+    getApiMethods() {
+        const paths = this.document.paths || [];
+        const apiMethods = [];
+        for (const [url, pathInfo] of Object.entries(paths)) {
+            if (!pathInfo) {
+                continue;
+            }
+            for (const [method, operationObject] of Object.entries(pathInfo)) {
+                if (!exports.supportedApiMethods.includes(method)) {
+                    continue;
+                }
+                if (typeof operationObject === 'string' || Array.isArray(operationObject)) {
+                    continue;
+                }
+                apiMethods.push({
+                    url,
+                    method,
+                    operationObject,
+                });
+            }
+        }
+        return apiMethods;
+    }
+    /**
+     * 将 ApiMethods 数组写回到 openapi document 的 paths 中。
+     * 仅更新传入的 url+method 对应的 operationObject，保留其它未涉及的内容。
+     */
+    saveApiMethods(apiMethods) {
+        this.document.paths = {};
+        // 构建 url -> { method -> operationObject } 映射，后写入覆盖前者
+        const grouped = {};
+        for (const item of apiMethods || []) {
+            if (!item || !item.url || !item.method || !item.operationObject) {
+                continue;
+            }
+            const method = String(item.method).toLowerCase();
+            if (!exports.supportedApiMethods.includes(method)) {
+                // 跳过不支持的 http 方法
+                continue;
+            }
+            if (!grouped[item.url]) {
+                grouped[item.url] = {};
+            }
+            grouped[item.url][method] = item.operationObject;
+        }
+        // 将分组后的方法写回到 document.paths
+        for (const [url, methodsMap] of Object.entries(grouped)) {
+            const pathInfo = (this.document.paths?.[url] || {});
+            for (const [method, operationObject] of Object.entries(methodsMap)) {
+                pathInfo[method] = operationObject;
+            }
+            if (this.document.paths) {
+                this.document.paths[url] = pathInfo;
+            }
+        }
+        // 更新后清除引用缓存，确保后续计算的使用引用为最新
+        this.usedRefsCache.clear();
+        return this;
+    }
+    /**
+     * 判断某个引用是否在文档中被使用
+     * @param ref ReferenceObject 或其 `$ref` 路径字符串
+     */
+    isReferenceUsed(ref) {
+        const refPath = typeof ref === 'string' ? ref : ref.$ref;
+        const usedSet = this.getUsedReferenceSet();
+        return usedSet.has(refPath);
+    }
+    /**
+     * 预计算并返回已使用的 `$ref` 集合，仅从 paths 可达
+     */
+    getUsedReferenceSet() {
+        if (this.usedRefsCache.size > 0) {
+            return this.usedRefsCache;
+        }
+        const used = this.usedRefsCache;
+        const visitedRefs = new Set();
+        const stack = [];
+        const roots = [];
+        if (this.document.paths) {
+            roots.push(this.document.paths);
+        }
+        stack.push(...roots);
+        while (stack.length) {
+            const node = stack.pop();
+            if (!node || typeof node !== 'object') {
+                continue;
+            }
+            if ((0, utils_1.isReferenceObject)(node)) {
+                const currentRef = node.$ref;
+                used.add(currentRef);
+                if (!visitedRefs.has(currentRef)) {
+                    visitedRefs.add(currentRef);
+                    try {
+                        const target = (0, utils_1.findBy$ref)(currentRef, this.document);
+                        stack.push(target);
+                    }
+                    catch {
+                        // ignore invalid refs
+                    }
+                }
+                continue;
+            }
+            if (Array.isArray(node)) {
+                for (const item of node) {
+                    stack.push(item);
+                }
+                continue;
+            }
+            for (const key of Object.keys(node)) {
+                stack.push(node[key]);
+            }
+        }
+        return used;
+    }
+    /**
+     * 过滤掉未使用的引用，返回仍被使用的引用列表
+     */
+    filterUsedReferences(refs) {
+        const usedSet = this.getUsedReferenceSet();
+        return (refs || []).filter((ref) => {
+            const refPath = typeof ref === 'string' ? ref : ref.$ref;
+            return usedSet.has(refPath);
+        });
+    }
+}
+exports.OpenApiHelper = OpenApiHelper;
+exports.openApiHelper = new OpenApiHelper();

package/dist/helper/index.js

@@ -0,0 +1,23 @@
+"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 });
+__exportStar(require("./comment"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./document"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./PluginDriver"), exports);
+__exportStar(require("./progress"), exports);
+__exportStar(require("./template"), exports);

package/dist/helper/logger/index.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const config_1 = require("../../config");
+const DEFAULT_CONFIG = (0, config_1.getGlobalConfig)();
+class Logger {
+    constructor() {
+        this.options = {
+            level: 'info',
+            timestamp: true,
+            colors: true,
+        };
+    }
+    configure(options) {
+        this.options = { ...this.options, ...options };
+        return this;
+    }
+    getTimestamp() {
+        return this.options.timestamp ? `[${new Date().toISOString()}] ` : '';
+    }
+    formatMessage(level, message, details) {
+        const timestamp = this.getTimestamp();
+        const prefix = this.options.prefix ? `[${this.options.prefix}] ` : '';
+        const detailsStr = details ? `\n${JSON.stringify(details, null, 2)}` : '';
+        if (this.options.colors) {
+            const colors = {
+                debug: '\x1B[34m', // blue
+                info: '\x1B[32m', // green
+                warn: '\x1B[33m', // yellow
+                error: '\x1B[31m', // red
+                reset: '\x1B[0m',
+            };
+            return `${timestamp}${prefix}${colors[level]}[${level.toUpperCase()}]${colors.reset} ${message}${detailsStr}`;
+        }
+        return `${timestamp}${prefix}[${level.toUpperCase()}] ${message}${detailsStr}`;
+    }
+    shouldLog(level) {
+        const levels = ['debug', 'info', 'warn', 'error'];
+        return levels.indexOf(level) >= levels.indexOf(this.options.level);
+    }
+    debug(message, details) {
+        if (this.shouldLog('debug')) {
+            // eslint-disable-next-line no-console
+            console.debug(this.formatMessage('debug', message, details));
+        }
+    }
+    info(message, details) {
+        if (this.shouldLog('info')) {
+            // eslint-disable-next-line no-console
+            console.info(this.formatMessage('info', message, details));
+        }
+    }
+    warn(message, details) {
+        if (this.shouldLog('warn')) {
+            console.warn(this.formatMessage('warn', message, details));
+        }
+    }
+    errorMsg(msg) {
+        return msg instanceof Error ? msg.message : msg;
+    }
+    error(message, details) {
+        if (this.shouldLog('error')) {
+            console.error(this.formatMessage('error', message, details));
+        }
+    }
+    throwError(error, details) {
+        this.debug(this.errorMsg(error), details);
+        return new DEFAULT_CONFIG.Error(this.errorMsg(error));
+    }
+}
+// 导出单例实例
+exports.logger = new Logger().configure({
+    level: 'info',
+    timestamp: true,
+    colors: true,
+});

package/dist/helper/progress.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noopReportProgress = exports.ProgressTracker = exports.GeneratorStage = exports.CORE_PROGRESS_SOURCE = void 0;
+exports.CORE_PROGRESS_SOURCE = 'core';
+/**
+ * Named stages for the generator lifecycle.
+ * These are used by the CLI renderer to display human-readable progress stages.
+ */
+exports.GeneratorStage = {
+    INIT: 'init',
+    BEFORE_OPENAPI_PARSE: 'beforeOpenapiParse',
+    PARSE_OPENAPI: 'parseOpenapi',
+    OPENAPI_PARSED: 'openapiParsed',
+    TEMPLATE_LOADED: 'templateLoaded',
+    TEMPLATE_DATA_PARSED: 'templateDataParsed',
+    BEFORE_CODE_GENERATE: 'beforeCodeGenerate',
+    PROCESS_TEMPLATES: 'processTemplates',
+    WRITE_FILES: 'writeFiles',
+    CODE_GENERATED: 'codeGenerated',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    SKIPPED: 'skipped',
+};
+class ProgressTracker {
+    constructor(listener, interval = 500) {
+        this.snapshot = {};
+        this.dirty = false;
+        this.timer = null;
+        this.listener = listener;
+        this.interval = interval;
+    }
+    start() {
+        if (!this.listener || this.timer || this.interval <= 0) {
+            return;
+        }
+        this.timer = setInterval(() => this.flush(), this.interval);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.flush();
+    }
+    update(source, progress, message) {
+        const clamped = Math.max(0, Math.min(100, progress));
+        this.snapshot[source] = { source, progress: clamped, message };
+        this.dirty = true;
+        if (this.listener && this.interval <= 0) {
+            this.flush();
+        }
+    }
+    flush() {
+        if (!this.dirty || !this.listener) {
+            return;
+        }
+        this.dirty = false;
+        this.listener({ ...this.snapshot });
+    }
+    reporterFor(source) {
+        return (progress, message) => this.update(source, progress, message);
+    }
+}
+exports.ProgressTracker = ProgressTracker;
+const noopReportProgress = () => { };
+exports.noopReportProgress = noopReportProgress;