@tdesign-react/chat 1.0.2-alpha.8 → 1.1.0-alpha.1

package/es/chat-engine/core/a2ui/processor/A2uiMessageProcessor.d.ts

@@ -0,0 +1,197 @@
+/**
+ * A2UI 消息处理器 v2
+ * 完全按照 A2UI v0.9 协议实现
+ *
+ * 支持四种消息类型：
+ * - createSurface: 创建 Surface
+ * - updateComponents: 更新组件
+ * - updateDataModel: 更新数据模型
+ * - deleteSurface: 删除 Surface
+ *
+ * 实现 External Store 模式，支持 useSyncExternalStore
+ */
+import type { A2UISurface, A2UIComponentBase, A2UIServerMessage, A2UIAction, ActionHandler, SkeletonHint, ResolvedComponent, UserActionMessage } from '../types';
+export type SurfaceSnapshot = Map<string, A2UISurface>;
+export type SurfaceListener = () => void;
+/**
+ * A2UI 消息处理器配置
+ */
+export interface A2uiMessageProcessorOptions {
+    /** Action 处理回调 */
+    onAction?: ActionHandler;
+    /** 用户行为消息发送回调 */
+    onSendMessage?: (message: UserActionMessage) => void;
+    /** 数据变更回调 */
+    onDataChange?: (surfaceId: string, path: string, value: unknown) => void;
+    /** 验证错误回调 */
+    onValidationError?: (errors: Array<{
+        type: string;
+        message: string;
+        path?: string;
+    }>) => void;
+}
+/**
+ * A2UI 消息处理器
+ *
+ * 核心功能：
+ * 1. 处理 A2UI v0.9 协议消息
+ * 2. 管理 Surface 生命周期
+ * 3. 维护组件注册表和数据模型
+ * 4. 构建组件树
+ * 5. 支持 useSyncExternalStore 订阅
+ */
+export declare class A2uiMessageProcessor {
+    private surfaces;
+    private listeners;
+    private pathResolver;
+    private options;
+    private cachedSnapshot;
+    private snapshotVersion;
+    constructor(options?: A2uiMessageProcessorOptions);
+    /**
+     * 订阅状态变化（供 useSyncExternalStore 使用）
+     */
+    subscribe(listener: SurfaceListener): () => void;
+    /**
+     * 获取当前快照（供 useSyncExternalStore 使用）
+     * 返回缓存的快照，确保引用稳定
+     */
+    getSnapshot(): SurfaceSnapshot;
+    /**
+     * 获取服务端快照（SSR 场景）
+     */
+    getServerSnapshot(): SurfaceSnapshot;
+    /**
+     * 更新缓存的快照
+     * 只在数据变更时调用
+     */
+    private updateCachedSnapshot;
+    /**
+     * 处理单条 A2UI v0.9 消息
+     */
+    processMessage(message: A2UIServerMessage): void;
+    /**
+     * 批量处理消息
+     */
+    processMessages(messages: A2UIServerMessage[]): void;
+    /**
+     * 增量处理消息（性能优化）
+     * 当已知消息是新增的时候使用，避免重复处理
+     */
+    processMessagesIncremental(messages: A2UIServerMessage[]): void;
+    /**
+     * 内部消息处理（不触发 emitChange）
+     */
+    private processMessageInternal;
+    /**
+     * 处理 createSurface 消息
+     */
+    private handleCreateSurface;
+    /**
+     * 处理 updateComponents 消息
+     */
+    private handleUpdateComponents;
+    /**
+     * 处理 updateDataModel 消息
+     */
+    private handleUpdateDataModel;
+    /**
+     * 检查是否需要重建组件树
+     * 优化：只有当路径可能影响 template 渲染时才需要重建
+     */
+    private needsTreeRebuild;
+    /**
+     * 只更新数据模型，不重建组件树（性能优化）
+     * 适用于不影响组件结构的数据更新（如表单输入）
+     */
+    updateDataOnly(surfaceId: string, path: string, value: unknown): void;
+    /**
+     * 处理 deleteSurface 消息
+     */
+    private handleDeleteSurface;
+    /**
+     * 重建组件树
+     */
+    private rebuildComponentTree;
+    /**
+     * 获取数据
+     * @param surfaceId Surface ID
+     * @param path 数据路径
+     * @param dataContextPath 当前组件的数据上下文
+     */
+    getData(surfaceId: string, path: string, dataContextPath?: string): unknown;
+    /**
+     * 设置数据（双向绑定）
+     */
+    setData(surfaceId: string, path: string, dataContextPath: string, value: unknown): void;
+    /**
+     * 更新数据值（简化接口，不需要 dataContextPath）
+     */
+    updateDataValue(surfaceId: string, path: string, value: unknown): void;
+    /**
+     * 分发 Action
+     */
+    dispatchAction(action: A2UIAction, surfaceId?: string, componentId?: string): void;
+    /**
+     * 创建 Pending 状态的 Surface（用于显示骨架屏）
+     */
+    createPendingSurface(surfaceId: string, skeletonHint?: SkeletonHint): void;
+    /**
+     * 激活 Surface
+     */
+    activateSurface(surfaceId: string): void;
+    /**
+     * 关闭 Surface
+     */
+    closeSurface(surfaceId: string): void;
+    /**
+     * 直接设置整个数据模型
+     */
+    setSurfaceData(surfaceId: string, data: Record<string, unknown>): void;
+    /**
+     * 合并数据（保留用户输入）
+     */
+    mergeSurfaceData(surfaceId: string, data: Record<string, unknown>): void;
+    /**
+     * 获取单个 Surface
+     */
+    getSurface(surfaceId: string): A2UISurface | undefined;
+    /**
+     * 获取所有 Surface ID
+     */
+    getSurfaceIds(): string[];
+    /**
+     * 获取所有 Surface
+     */
+    getAllSurfaces(): A2UISurface[];
+    /**
+     * 获取组件树
+     */
+    getComponentTree(surfaceId: string): ResolvedComponent | null;
+    /**
+     * 查找组件
+     */
+    findComponent(surfaceId: string, componentId: string): A2UIComponentBase | undefined;
+    /**
+     * 清空所有 Surface
+     */
+    clear(): void;
+    /**
+     * 清空所有 Surface（别名）
+     */
+    clearAllSurfaces(): void;
+    /**
+     * 销毁处理器
+     */
+    destroy(): void;
+    /**
+     * 通知所有订阅者
+     * 先更新缓存快照，再通知订阅者
+     */
+    private emitChange;
+}
+/**
+ * 创建 A2UI 消息处理器实例
+ */
+export declare function createA2uiProcessor(options?: A2uiMessageProcessorOptions): A2uiMessageProcessor;
+export default A2uiMessageProcessor;

package/es/chat-engine/core/a2ui/processor/A2uiMessageProcessor.js

@@ -0,0 +1,438 @@
+/**
+ * tdesign v1.0.2-alpha.14
+ * (c) 2026 tdesign
+ * @license MIT
+ */
+
+import _typeof from '@babel/runtime/helpers/typeof';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { DataStore } from './DataStore.js';
+import { ComponentTree } from './ComponentTree.js';
+import { PathResolver } from './PathResolver.js';
+import '@babel/runtime/helpers/slicedToArray';
+import '@babel/runtime/helpers/toArray';
+
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var A2uiMessageProcessor = /*#__PURE__*/function () {
+  function A2uiMessageProcessor() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, A2uiMessageProcessor);
+    _defineProperty(this, "surfaces", /* @__PURE__ */new Map());
+    _defineProperty(this, "listeners", /* @__PURE__ */new Set());
+    _defineProperty(this, "pathResolver", new PathResolver());
+    _defineProperty(this, "cachedSnapshot", /* @__PURE__ */new Map());
+    _defineProperty(this, "snapshotVersion", 0);
+    this.options = options;
+    this.subscribe = this.subscribe.bind(this);
+    this.getSnapshot = this.getSnapshot.bind(this);
+    this.getServerSnapshot = this.getServerSnapshot.bind(this);
+  }
+  return _createClass(A2uiMessageProcessor, [{
+    key: "subscribe",
+    value: function subscribe(listener) {
+      var _this = this;
+      this.listeners.add(listener);
+      return function () {
+        _this.listeners["delete"](listener);
+      };
+    }
+  }, {
+    key: "getSnapshot",
+    value: function getSnapshot() {
+      return this.cachedSnapshot;
+    }
+  }, {
+    key: "getServerSnapshot",
+    value: function getServerSnapshot() {
+      return this.cachedSnapshot;
+    }
+  }, {
+    key: "updateCachedSnapshot",
+    value: function updateCachedSnapshot() {
+      var snapshot = /* @__PURE__ */new Map();
+      this.surfaces.forEach(function (internal, id) {
+        var _internal$componentTr;
+        snapshot.set(id, {
+          id: internal.id,
+          catalogId: internal.catalogId,
+          state: internal.state,
+          components: internal.components,
+          root: ((_internal$componentTr = internal.componentTree) === null || _internal$componentTr === void 0 ? void 0 : _internal$componentTr.root) || null,
+          data: internal.dataStore.getSnapshot(),
+          skeletonHint: internal.skeletonHint,
+          updatedAt: internal.updatedAt
+        });
+      });
+      this.cachedSnapshot = snapshot;
+      this.snapshotVersion++;
+    }
+  }, {
+    key: "processMessage",
+    value: function processMessage(message) {
+      this.processMessageInternal(message);
+      this.emitChange();
+    }
+  }, {
+    key: "processMessages",
+    value: function processMessages(messages) {
+      var _iterator = _createForOfIteratorHelper(messages),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var message = _step.value;
+          this.processMessageInternal(message);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      this.emitChange();
+    }
+  }, {
+    key: "processMessagesIncremental",
+    value: function processMessagesIncremental(messages) {
+      if (messages.length === 0) return;
+      var _iterator2 = _createForOfIteratorHelper(messages),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var message = _step2.value;
+          this.processMessageInternal(message);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      this.emitChange();
+    }
+  }, {
+    key: "processMessageInternal",
+    value: function processMessageInternal(message) {
+      if ("createSurface" in message) {
+        this.handleCreateSurface(message.createSurface);
+      } else if ("updateComponents" in message) {
+        this.handleUpdateComponents(message.updateComponents);
+      } else if ("updateDataModel" in message) {
+        this.handleUpdateDataModel(message.updateDataModel);
+      } else if ("deleteSurface" in message) {
+        this.handleDeleteSurface(message.deleteSurface);
+      }
+    }
+  }, {
+    key: "handleCreateSurface",
+    value: function handleCreateSurface(payload) {
+      var surface = {
+        id: payload.surfaceId,
+        catalogId: payload.catalogId,
+        state: "pending",
+        components: /* @__PURE__ */new Map(),
+        dataStore: new DataStore(),
+        componentTree: null,
+        updatedAt: Date.now()
+      };
+      this.surfaces.set(payload.surfaceId, surface);
+    }
+  }, {
+    key: "handleUpdateComponents",
+    value: function handleUpdateComponents(payload) {
+      var surface = this.surfaces.get(payload.surfaceId);
+      if (!surface) {
+        console.warn("[A2UI] Surface ".concat(payload.surfaceId, " not found, auto-creating"));
+        surface = {
+          id: payload.surfaceId,
+          catalogId: "default",
+          state: "pending",
+          components: /* @__PURE__ */new Map(),
+          dataStore: new DataStore(),
+          componentTree: null,
+          updatedAt: Date.now()
+        };
+        this.surfaces.set(payload.surfaceId, surface);
+      }
+      var _iterator3 = _createForOfIteratorHelper(payload.components),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var component = _step3.value;
+          surface.components.set(component.id, component);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      this.rebuildComponentTree(surface);
+      if (surface.components.has("root") && surface.state === "pending") {
+        surface.state = "active";
+      }
+      surface.updatedAt = Date.now();
+    }
+  }, {
+    key: "handleUpdateDataModel",
+    value: function handleUpdateDataModel(payload) {
+      var surface = this.surfaces.get(payload.surfaceId);
+      if (!surface) {
+        console.warn("[A2UI] Surface ".concat(payload.surfaceId, " not found"));
+        return;
+      }
+      var path = payload.path || "/";
+      var op = payload.op || "replace";
+      if (op === "remove") {
+        surface.dataStore.remove(path);
+      } else {
+        surface.dataStore.set(path, payload.value);
+      }
+      if (this.needsTreeRebuild(surface, path)) {
+        this.rebuildComponentTree(surface);
+      }
+      surface.updatedAt = Date.now();
+    }
+  }, {
+    key: "needsTreeRebuild",
+    value: function needsTreeRebuild(surface, path) {
+      if (path === "/" || path === "") {
+        return true;
+      }
+      var _iterator4 = _createForOfIteratorHelper(surface.components.values()),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var component = _step4.value;
+          var children = component.children;
+          if (children && _typeof(children) === "object" && !Array.isArray(children)) {
+            var templatePath = children.path;
+            if (templatePath && (path.startsWith(templatePath) || templatePath.startsWith(path))) {
+              return true;
+            }
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      return false;
+    }
+  }, {
+    key: "updateDataOnly",
+    value: function updateDataOnly(surfaceId, path, value) {
+      var _this$options$onDataC, _this$options;
+      var surface = this.surfaces.get(surfaceId);
+      if (!surface) return;
+      surface.dataStore.set(path, value);
+      surface.updatedAt = Date.now();
+      this.updateCachedSnapshot();
+      this.listeners.forEach(function (listener) {
+        return listener();
+      });
+      (_this$options$onDataC = (_this$options = this.options).onDataChange) === null || _this$options$onDataC === void 0 || _this$options$onDataC.call(_this$options, surfaceId, path, value);
+    }
+  }, {
+    key: "handleDeleteSurface",
+    value: function handleDeleteSurface(payload) {
+      this.surfaces["delete"](payload.surfaceId);
+    }
+  }, {
+    key: "rebuildComponentTree",
+    value: function rebuildComponentTree(surface) {
+      if (!surface.components.has("root")) {
+        surface.componentTree = null;
+        return;
+      }
+      surface.componentTree = new ComponentTree(surface.components, surface.dataStore, this.pathResolver);
+    }
+  }, {
+    key: "getData",
+    value: function getData(surfaceId, path) {
+      var dataContextPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "";
+      var surface = this.surfaces.get(surfaceId);
+      if (!surface) return void 0;
+      var resolvedPath = this.pathResolver.resolve(path, dataContextPath);
+      return surface.dataStore.get(resolvedPath);
+    }
+  }, {
+    key: "setData",
+    value: function setData(surfaceId, path, dataContextPath, value) {
+      var _this$options$onDataC2, _this$options2;
+      var surface = this.surfaces.get(surfaceId);
+      if (!surface) return;
+      var resolvedPath = this.pathResolver.resolve(path, dataContextPath);
+      surface.dataStore.set(resolvedPath, value);
+      this.rebuildComponentTree(surface);
+      surface.updatedAt = Date.now();
+      this.emitChange();
+      (_this$options$onDataC2 = (_this$options2 = this.options).onDataChange) === null || _this$options$onDataC2 === void 0 || _this$options$onDataC2.call(_this$options2, surfaceId, resolvedPath, value);
+    }
+  }, {
+    key: "updateDataValue",
+    value: function updateDataValue(surfaceId, path, value) {
+      this.setData(surfaceId, path, "", value);
+    }
+  }, {
+    key: "dispatchAction",
+    value: function dispatchAction(action, surfaceId, componentId) {
+      var _this2 = this;
+      if (this.options.onAction) {
+        var context = surfaceId ? {
+          surfaceId: surfaceId,
+          componentId: componentId,
+          updateData: function updateData(path, value) {
+            _this2.updateDataValue(surfaceId, path, value);
+          },
+          getData: function getData(path) {
+            var surface = _this2.surfaces.get(surfaceId);
+            if (!surface) return void 0;
+            return path ? surface.dataStore.get(path) : surface.dataStore.getSnapshot();
+          }
+        } : void 0;
+        this.options.onAction(action, context);
+      }
+      if (this.options.onSendMessage && surfaceId && componentId) {
+        this.options.onSendMessage({
+          userAction: {
+            name: action.name,
+            surfaceId: surfaceId,
+            sourceComponentId: componentId,
+            timestamp: new Date().toISOString(),
+            context: action.context || {}
+          }
+        });
+      }
+    }
+  }, {
+    key: "createPendingSurface",
+    value: function createPendingSurface(surfaceId, skeletonHint) {
+      if (this.surfaces.has(surfaceId)) return;
+      var surface = {
+        id: surfaceId,
+        catalogId: "default",
+        state: "pending",
+        components: /* @__PURE__ */new Map(),
+        dataStore: new DataStore(),
+        componentTree: null,
+        skeletonHint: skeletonHint,
+        updatedAt: Date.now()
+      };
+      this.surfaces.set(surfaceId, surface);
+      this.emitChange();
+    }
+  }, {
+    key: "activateSurface",
+    value: function activateSurface(surfaceId) {
+      var surface = this.surfaces.get(surfaceId);
+      if (!surface) return;
+      surface.state = "active";
+      surface.updatedAt = Date.now();
+      this.emitChange();
+    }
+  }, {
+    key: "closeSurface",
+    value: function closeSurface(surfaceId) {
+      var surface = this.surfaces.get(surfaceId);
+      if (!surface) return;
+      surface.state = "closed";
+      surface.updatedAt = Date.now();
+      this.emitChange();
+    }
+  }, {
+    key: "setSurfaceData",
+    value: function setSurfaceData(surfaceId, data) {
+      var surface = this.surfaces.get(surfaceId);
+      if (!surface) return;
+      surface.dataStore.set("/", data);
+      this.rebuildComponentTree(surface);
+      surface.updatedAt = Date.now();
+      this.emitChange();
+    }
+  }, {
+    key: "mergeSurfaceData",
+    value: function mergeSurfaceData(surfaceId, data) {
+      var surface = this.surfaces.get(surfaceId);
+      if (!surface) return;
+      surface.dataStore.merge("/", data);
+      this.rebuildComponentTree(surface);
+      surface.updatedAt = Date.now();
+      this.emitChange();
+    }
+  }, {
+    key: "getSurface",
+    value: function getSurface(surfaceId) {
+      var _internal$componentTr2;
+      var internal = this.surfaces.get(surfaceId);
+      if (!internal) return void 0;
+      return {
+        id: internal.id,
+        catalogId: internal.catalogId,
+        state: internal.state,
+        components: internal.components,
+        root: ((_internal$componentTr2 = internal.componentTree) === null || _internal$componentTr2 === void 0 ? void 0 : _internal$componentTr2.root) || null,
+        data: internal.dataStore.getSnapshot(),
+        skeletonHint: internal.skeletonHint,
+        updatedAt: internal.updatedAt
+      };
+    }
+  }, {
+    key: "getSurfaceIds",
+    value: function getSurfaceIds() {
+      return Array.from(this.surfaces.keys());
+    }
+  }, {
+    key: "getAllSurfaces",
+    value: function getAllSurfaces() {
+      var _this3 = this;
+      return this.getSurfaceIds().map(function (id) {
+        return _this3.getSurface(id);
+      });
+    }
+  }, {
+    key: "getComponentTree",
+    value: function getComponentTree(surfaceId) {
+      var _surface$componentTre;
+      var surface = this.surfaces.get(surfaceId);
+      return (surface === null || surface === void 0 || (_surface$componentTre = surface.componentTree) === null || _surface$componentTre === void 0 ? void 0 : _surface$componentTre.root) || null;
+    }
+  }, {
+    key: "findComponent",
+    value: function findComponent(surfaceId, componentId) {
+      var surface = this.surfaces.get(surfaceId);
+      return surface === null || surface === void 0 ? void 0 : surface.components.get(componentId);
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.surfaces.clear();
+      this.emitChange();
+    }
+  }, {
+    key: "clearAllSurfaces",
+    value: function clearAllSurfaces() {
+      this.clear();
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.clear();
+      this.listeners.clear();
+    }
+  }, {
+    key: "emitChange",
+    value: function emitChange() {
+      this.updateCachedSnapshot();
+      this.listeners.forEach(function (listener) {
+        listener();
+      });
+    }
+  }]);
+}();
+function createA2uiProcessor(options) {
+  return new A2uiMessageProcessor(options);
+}
+
+export { A2uiMessageProcessor, createA2uiProcessor, A2uiMessageProcessor as default };
+//# sourceMappingURL=A2uiMessageProcessor.js.map