@aigne/core 0.0.1

package/lib/cjs/types/assistant/mustache/ReadableMustache.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMustacheStream = renderMustacheStream;
+const web_1 = require("stream/web");
+const fastq_1 = __importDefault(require("fastq"));
+const render_message_1 = require("../../../utils/render-message");
+function renderMustacheStream(template, context) {
+    return new web_1.ReadableStream({
+        async start(controller) {
+            try {
+                // 异步任务队列，每个任务完成之后都会重新渲染模板并返回最新的结果到流中
+                const queue = fastq_1.default.promise(async (p) => {
+                    await p;
+                    await render();
+                }, 100);
+                let reject;
+                const errorPromise = new Promise((_, rej) => {
+                    reject = rej;
+                });
+                queue.error((error) => {
+                    if (error)
+                        reject?.(error);
+                });
+                // 任务缓存，每个任务的 key 为渲染后的子模板（其中可能包含参数）
+                const cache = new Map();
+                const ctx = context((fn) => {
+                    return async (template, render) => {
+                        const rendered = await render(template);
+                        const key = rendered;
+                        let task = cache.get(key);
+                        if (!task) {
+                            const res = fn(template, render, rendered);
+                            if (res instanceof Promise) {
+                                task = { promise: res };
+                                res
+                                    .then((value) => {
+                                    task.result = { data: value };
+                                })
+                                    .catch((error) => {
+                                    task.error = { error };
+                                });
+                                queue.push(res);
+                            }
+                            else {
+                                task = { result: { data: res } };
+                            }
+                            cache.set(key, task);
+                        }
+                        if (task.error)
+                            throw task.error.error;
+                        // 返回 promise 完成后的数据，没完成则返回 undefined，避免阻塞 mustache 渲染
+                        return task.result?.data;
+                    };
+                });
+                const render = async () => controller.enqueue(await (0, render_message_1.renderMessage)(template, ctx, { escapeJsonSymbols: true }));
+                await render();
+                // wait for all promise in the queue to be resolved
+                await Promise.race([queue.drained(), errorPromise]);
+            }
+            catch (error) {
+                controller.error(error);
+            }
+            controller.close();
+        },
+    });
+}

package/lib/cjs/types/assistant/mustache/directive.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDirectives = parseDirectives;
+const mustache_1 = __importDefault(require("./mustache"));
+function parseDirectives(...content) {
+    return content.flatMap((content) => {
+        // 捕获 api/{{var/api/task/{{list}} 这种错误
+        try {
+            const spans = mustache_1.default.parse(content);
+            const directives = [];
+            for (const span of spans) {
+                switch (span[0]) {
+                    case 'name': {
+                        const name = span[1];
+                        if (name)
+                            directives.push({ type: 'variable', name });
+                        break;
+                    }
+                    case 'text': {
+                        break;
+                    }
+                    default:
+                        console.warn('Unknown directive', span);
+                }
+            }
+            return directives;
+        }
+        catch (error) {
+            return [];
+        }
+    });
+}