@antglobal/copilot-cards-mini-program 0.0.0 → 0.0.20260724033338-dev.13

package/dist/streaming/index.d.ts

@@ -0,0 +1,80 @@
+import { StreamingCommand, ExpressionContext, StreamingParserOptions } from '@antglobal/copilot-cards-core';
+import { MiniProgramRenderNode } from '../renderer/index.js';
+import { MiniProgramAdapter } from '../adapter/index.js';
+
+/**
+ * Streaming Adapter for Mini-Program — enables progressive card rendering
+ * in WeChat/Alipay/DingTalk mini-programs via streaming commands.
+ *
+ * Since mini-programs cannot directly manipulate DOM, this module
+ * produces incremental setData patches that the framework can apply efficiently.
+ *
+ * Key differences from Web streaming:
+ * - Returns data patches instead of manipulating DOM
+ * - Uses path-based setData for efficient mini-program updates
+ * - Computes minimal diff for appendContent operations
+ */
+
+interface MiniProgramStreamingOptions {
+    /** Platform adapter instance */
+    adapter: MiniProgramAdapter;
+    /** Initial variables data context */
+    data?: ExpressionContext;
+    /** Bot ID for bot-scoped action handlers */
+    botId?: string;
+    /** Event emitter — called when an emit action fires */
+    onEmit?: (eventName: string, payload?: unknown) => void;
+    /** Parser options */
+    parserOptions?: StreamingParserOptions;
+}
+/**
+ * Represents a data patch that should be applied via mini-program's setData.
+ */
+interface DataPatch {
+    /** The path-value pairs for setData, e.g. { 'tree.children[0].props.content': 'new text' } */
+    data: Record<string, any>;
+}
+interface MiniProgramStreamingCardInstance {
+    /** Apply a single streaming command, returns setData patch or null */
+    applyCommand(command: StreamingCommand): DataPatch | null;
+    /** Apply multiple commands, returns array of patches */
+    applyCommands(commands: StreamingCommand[]): DataPatch[];
+    /** Feed raw text chunk, returns array of patches */
+    feed(chunk: string): DataPatch[];
+    /** Flush parser buffer, returns remaining patches */
+    flush(): DataPatch[];
+    /** Get current full render data */
+    getData(): {
+        tree: MiniProgramRenderNode | null;
+    };
+    /** Handle a component event */
+    handleEvent(nodeId: string, eventName: string, eventDetail?: any): Promise<DataPatch | null>;
+    /** Dispose the instance */
+    dispose(): void;
+}
+/**
+ * Create a mini-program streaming card instance.
+ *
+ * Unlike the web streaming renderer which directly updates DOM,
+ * this returns data patches that should be applied via the
+ * mini-program framework's setData mechanism.
+ *
+ * @example
+ * ```ts
+ * // In mini-program component
+ * const streaming = createStreamingCardInstance({
+ *   adapter: new AlipayAdapter(),
+ *   data: { userName: 'Alice' },
+ * });
+ *
+ * // Feed streaming data (e.g. from WebSocket)
+ * socket.onmessage = (e) => {
+ *   const patches = streaming.feed(e.data);
+ *   patches.forEach(patch => this.setData(patch.data));
+ * };
+ * ```
+ */
+declare function createStreamingCardInstance(options: MiniProgramStreamingOptions): MiniProgramStreamingCardInstance;
+
+export { createStreamingCardInstance };
+export type { DataPatch, MiniProgramStreamingCardInstance, MiniProgramStreamingOptions };

package/dist/streaming/index.js

@@ -0,0 +1,230 @@
+import { StreamingParser, StreamingEngine, normalizeSchema } from '@antglobal/copilot-cards-core';
+import { renderForMiniProgram } from '../renderer/index.js';
+
+/**
+ * Streaming Adapter for Mini-Program — enables progressive card rendering
+ * in WeChat/Alipay/DingTalk mini-programs via streaming commands.
+ *
+ * Since mini-programs cannot directly manipulate DOM, this module
+ * produces incremental setData patches that the framework can apply efficiently.
+ *
+ * Key differences from Web streaming:
+ * - Returns data patches instead of manipulating DOM
+ * - Uses path-based setData for efficient mini-program updates
+ * - Computes minimal diff for appendContent operations
+ */
+// ─── Main API ────────────────────────────────────────────────────
+/**
+ * Create a mini-program streaming card instance.
+ *
+ * Unlike the web streaming renderer which directly updates DOM,
+ * this returns data patches that should be applied via the
+ * mini-program framework's setData mechanism.
+ *
+ * @example
+ * ```ts
+ * // In mini-program component
+ * const streaming = createStreamingCardInstance({
+ *   adapter: new AlipayAdapter(),
+ *   data: { userName: 'Alice' },
+ * });
+ *
+ * // Feed streaming data (e.g. from WebSocket)
+ * socket.onmessage = (e) => {
+ *   const patches = streaming.feed(e.data);
+ *   patches.forEach(patch => this.setData(patch.data));
+ * };
+ * ```
+ */
+function createStreamingCardInstance(options) {
+    const parser = new StreamingParser(options.parserOptions);
+    let currentInstance = null;
+    let currentTree = null;
+    let variables = { ...options.data };
+    // Track node paths for efficient patching
+    const nodePathMap = new Map(); // elementId → setData path
+    /**
+     * Build the node path map by traversing the tree.
+     */
+    function buildNodePaths(node, basePath) {
+        nodePathMap.set(node.id, basePath);
+        node.children.forEach((child, index) => {
+            buildNodePaths(child, `${basePath}.children[${index}]`);
+        });
+    }
+    /**
+     * Create a full tree patch (for initial render or full re-render).
+     */
+    function createFullPatch() {
+        return { data: { tree: currentTree } };
+    }
+    // ─── Engine Setup ───────────────────────────────────────────────
+    const pendingPatches = [];
+    const engine = new StreamingEngine({
+        onSurfaceCreated(surfaceId, schemaInput) {
+            if (schemaInput) {
+                const schema = normalizeSchema(schemaInput);
+                variables = { ...schema.variables, ...options.data };
+                currentInstance = renderForMiniProgram(schema, {
+                    adapter: options.adapter,
+                    data: variables,
+                    botId: options.botId,
+                    onEmit: options.onEmit,
+                });
+                currentTree = currentInstance.getData().tree;
+                if (currentTree) {
+                    nodePathMap.clear();
+                    buildNodePaths(currentTree, 'tree');
+                }
+                pendingPatches.push(createFullPatch());
+            }
+        },
+        onComponentsUpdated(surfaceId, changes) {
+            // For mini-program, component tree changes require full re-render
+            // because we can't insert DOM nodes — we need to regenerate the data tree
+            const schema = engine.getSchema(surfaceId);
+            if (!schema)
+                return;
+            currentInstance = renderForMiniProgram(schema, {
+                adapter: options.adapter,
+                data: variables,
+                botId: options.botId,
+                onEmit: options.onEmit,
+            });
+            currentTree = currentInstance.getData().tree;
+            if (currentTree) {
+                nodePathMap.clear();
+                buildNodePaths(currentTree, 'tree');
+            }
+            pendingPatches.push(createFullPatch());
+        },
+        onDataModelUpdated(surfaceId, path, value) {
+            if (!currentInstance)
+                return;
+            // Update variables and regenerate tree
+            const pathParts = path.replace(/^\//, '').split('/').filter(Boolean);
+            if (pathParts.length === 0) {
+                if (typeof value === 'object' && value !== null) {
+                    variables = { ...variables, ...value };
+                }
+            }
+            else {
+                let current = variables;
+                for (let i = 0; i < pathParts.length - 1; i++) {
+                    if (current[pathParts[i]] === undefined)
+                        current[pathParts[i]] = {};
+                    current = current[pathParts[i]];
+                }
+                current[pathParts[pathParts.length - 1]] = value;
+            }
+            const result = currentInstance.updateVariables(variables);
+            currentTree = result.tree;
+            if (currentTree) {
+                nodePathMap.clear();
+                buildNodePaths(currentTree, 'tree');
+            }
+            pendingPatches.push(createFullPatch());
+        },
+        onContentAppended(surfaceId, elementId, content) {
+            // Try to do a targeted patch for text content
+            const nodePath = nodePathMap.get(elementId);
+            if (nodePath && currentTree) {
+                // Find the node and update its content in-place
+                const node = findNodeById(currentTree, elementId);
+                if (node) {
+                    const currentContent = typeof node.props.content === 'string'
+                        ? node.props.content : '';
+                    node.props.content = currentContent + content;
+                    // Generate a path-based setData patch for efficiency
+                    pendingPatches.push({
+                        data: { [`${nodePath}.props.content`]: node.props.content },
+                    });
+                    return;
+                }
+            }
+            // Fallback: full re-render
+            if (currentInstance) {
+                const schema = engine.getSchema(surfaceId);
+                if (schema) {
+                    variables = { ...schema.variables, ...variables };
+                    const result = currentInstance.updateVariables(variables);
+                    currentTree = result.tree;
+                    pendingPatches.push(createFullPatch());
+                }
+            }
+        },
+        onSurfaceDeleted(surfaceId) {
+            currentInstance?.dispose();
+            currentInstance = null;
+            currentTree = null;
+            nodePathMap.clear();
+            pendingPatches.push({ data: { tree: null } });
+        },
+    });
+    // ─── Helpers ────────────────────────────────────────────────────
+    function findNodeById(node, id) {
+        if (node.id === id)
+            return node;
+        for (const child of node.children) {
+            const found = findNodeById(child, id);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    function drainPatches() {
+        const patches = [...pendingPatches];
+        pendingPatches.length = 0;
+        return patches;
+    }
+    // ─── Public API ─────────────────────────────────────────────────
+    return {
+        applyCommand(command) {
+            engine.apply(command);
+            const patches = drainPatches();
+            return patches.length > 0 ? patches[patches.length - 1] : null;
+        },
+        applyCommands(commands) {
+            engine.applyBatch(commands);
+            return drainPatches();
+        },
+        feed(chunk) {
+            const commands = parser.parse(chunk);
+            for (const cmd of commands) {
+                engine.apply(cmd);
+            }
+            return drainPatches();
+        },
+        flush() {
+            const commands = parser.flush();
+            for (const cmd of commands) {
+                engine.apply(cmd);
+            }
+            return drainPatches();
+        },
+        getData() {
+            return { tree: currentTree };
+        },
+        async handleEvent(nodeId, eventName, eventDetail) {
+            if (!currentInstance)
+                return null;
+            await currentInstance.handleEvent(nodeId, eventName, eventDetail);
+            currentTree = currentInstance.getData().tree;
+            if (currentTree) {
+                nodePathMap.clear();
+                buildNodePaths(currentTree, 'tree');
+            }
+            return createFullPatch();
+        },
+        dispose() {
+            currentInstance?.dispose();
+            currentInstance = null;
+            currentTree = null;
+            nodePathMap.clear();
+            engine.dispose();
+            parser.reset();
+        },
+    };
+}
+
+export { createStreamingCardInstance };

package/package.json

@@ -1,12 +1,43 @@
 {
   "name": "@antglobal/copilot-cards-mini-program",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
+  "version": "0.0.20260724033338-dev.13",
+  "description": "Mini-program native renderer for copilot bot card SDK — adapts to WeChat / Alipay / DingTalk mini-program templates",
+  "type": "module",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "miniprogram": "dist",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p ../copilot-cards-mini-program/tsconfig.json --noEmit && rollup -c && node scripts/postbuild.mjs"
+  },
+  "keywords": [
+    "copilot",
+    "bot",
+    "card",
+    "mini-program",
+    "wechat",
+    "alipay"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@antglobal/copilot-cards-core": "0.0.20260724033338-dev.13",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "rollup": "^4.9.0",
+    "rollup-plugin-dts": "^6.1.0",
+    "typescript": "^5.3.0"
   },
-  "keywords": [],
-  "author": "",
-  "license": "MIT"
+  "marmotId": "180020050100014006"
 }

package/LEGAL.md

@@ -1,7 +0,0 @@
-Legal Disclaimer
-
-Within this source code, the comments in Chinese shall be the original, governing version. Any comment in other languages are for reference only. In the event of any conflict between the Chinese language version comments and other language version comments, the Chinese language version shall prevail.
-
-法律免责声明
-
-关于代码注释部分，中文注释为官方版本，其它语言注释仅做参考。中文注释可能与其它语言注释存在不一致，当中文注释与其它语言注释存在不一致时，请以中文注释为准。