npm - @tdesign-react/chat - Versions diffs - 1.0.2-alpha.9 → 1.0.3-alpha.2 - Mend

@tdesign-react/chat 1.0.2-alpha.9 → 1.0.3-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (503) hide show

package/es/chat-engine/core/store/reactiveState.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"reactiveState.js","sources":["../../../../../../node_modules/.pnpm/immer@10.1.1/node_modules/immer/dist/immer.mjs","../../../../../pro-components/chat/chat-engine/core/store/reactiveState.ts"],"sourcesContent":["// src/utils/env.ts\nvar NOTHING = Symbol.for(\"immer-nothing\");\nvar DRAFTABLE = Symbol.for(\"immer-draftable\");\nvar DRAFT_STATE = Symbol.for(\"immer-state\");\n\n// src/utils/errors.ts\nvar errors = process.env.NODE_ENV !== \"production\" ? [\n // All error codes, starting by 0:\n function(plugin) {\n return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \\`enable${plugin}()\\` when initializing your application.`;\n },\n function(thing) {\n return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;\n },\n \"This object has been frozen and should not be mutated\",\n function(data) {\n return \"Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? \" + data;\n },\n \"An immer producer returned a new value and modified its draft. Either return a new value or modify the draft.\",\n \"Immer forbids circular references\",\n \"The first or second argument to `produce` must be a function\",\n \"The third argument to `produce` must be a function or undefined\",\n \"First argument to `createDraft` must be a plain object, an array, or an immerable object\",\n \"First argument to `finishDraft` must be a draft returned by `createDraft`\",\n function(thing) {\n return `'current' expects a draft, got: ${thing}`;\n },\n \"Object.defineProperty() cannot be used on an Immer draft\",\n \"Object.setPrototypeOf() cannot be used on an Immer draft\",\n \"Immer only supports deleting array indices\",\n \"Immer only supports setting array indices and the 'length' property\",\n function(thing) {\n return `'original' expects a draft, got: ${thing}`;\n }\n // Note: if more errors are added, the errorOffset in Patches.ts should be increased\n // See Patches.ts for additional errors\n] : [];\nfunction die(error, ...args) {\n if (process.env.NODE_ENV !== \"production\") {\n const e = errors[error];\n const msg = typeof e === \"function\" ? e.apply(null, args) : e;\n throw new Error(`[Immer] ${msg}`);\n }\n throw new Error(\n `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`\n );\n}\n\n// src/utils/common.ts\nvar getPrototypeOf = Object.getPrototypeOf;\nfunction isDraft(value) {\n return !!value && !!value[DRAFT_STATE];\n}\nfunction isDraftable(value) {\n if (!value)\n return false;\n return isPlainObject(value) \|\| Array.isArray(value) \|\| !!value[DRAFTABLE] \|\| !!value.constructor?.[DRAFTABLE] \|\| isMap(value) \|\| isSet(value);\n}\nvar objectCtorString = Object.prototype.constructor.toString();\nfunction isPlainObject(value) {\n if (!value \|\| typeof value !== \"object\")\n return false;\n const proto = getPrototypeOf(value);\n if (proto === null) {\n return true;\n }\n const Ctor = Object.hasOwnProperty.call(proto, \"constructor\") && proto.constructor;\n if (Ctor === Object)\n return true;\n return typeof Ctor == \"function\" && Function.toString.call(Ctor) === objectCtorString;\n}\nfunction original(value) {\n if (!isDraft(value))\n die(15, value);\n return value[DRAFT_STATE].base_;\n}\nfunction each(obj, iter) {\n if (getArchtype(obj) === 0 /* Object /) {\n Reflect.ownKeys(obj).forEach((key) => {\n iter(key, obj[key], obj);\n });\n } else {\n obj.forEach((entry, index) => iter(index, entry, obj));\n }\n}\nfunction getArchtype(thing) {\n const state = thing[DRAFT_STATE];\n return state ? state.type_ : Array.isArray(thing) ? 1 / Array / : isMap(thing) ? 2 / Map / : isSet(thing) ? 3 / Set / : 0 / Object /;\n}\nfunction has(thing, prop) {\n return getArchtype(thing) === 2 / Map / ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);\n}\nfunction get(thing, prop) {\n return getArchtype(thing) === 2 / Map / ? thing.get(prop) : thing[prop];\n}\nfunction set(thing, propOrOldValue, value) {\n const t = getArchtype(thing);\n if (t === 2 / Map /)\n thing.set(propOrOldValue, value);\n else if (t === 3 / Set /) {\n thing.add(value);\n } else\n thing[propOrOldValue] = value;\n}\nfunction is(x, y) {\n if (x === y) {\n return x !== 0 \|\| 1 / x === 1 / y;\n } else {\n return x !== x && y !== y;\n }\n}\nfunction isMap(target) {\n return target instanceof Map;\n}\nfunction isSet(target) {\n return target instanceof Set;\n}\nfunction latest(state) {\n return state.copy_ \|\| state.base_;\n}\nfunction shallowCopy(base, strict) {\n if (isMap(base)) {\n return new Map(base);\n }\n if (isSet(base)) {\n return new Set(base);\n }\n if (Array.isArray(base))\n return Array.prototype.slice.call(base);\n const isPlain = isPlainObject(base);\n if (strict === true \|\| strict === \"class_only\" && !isPlain) {\n const descriptors = Object.getOwnPropertyDescriptors(base);\n delete descriptors[DRAFT_STATE];\n let keys = Reflect.ownKeys(descriptors);\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i];\n const desc = descriptors[key];\n if (desc.writable === false) {\n desc.writable = true;\n desc.configurable = true;\n }\n if (desc.get \|\| desc.set)\n descriptors[key] = {\n configurable: true,\n writable: true,\n // could live with !!desc.set as well here...\n enumerable: desc.enumerable,\n value: base[key]\n };\n }\n return Object.create(getPrototypeOf(base), descriptors);\n } else {\n const proto = getPrototypeOf(base);\n if (proto !== null && isPlain) {\n return { ...base };\n }\n const obj = Object.create(proto);\n return Object.assign(obj, base);\n }\n}\nfunction freeze(obj, deep = false) {\n if (isFrozen(obj) \|\| isDraft(obj) \|\| !isDraftable(obj))\n return obj;\n if (getArchtype(obj) > 1) {\n obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;\n }\n Object.freeze(obj);\n if (deep)\n Object.entries(obj).forEach(([key, value]) => freeze(value, true));\n return obj;\n}\nfunction dontMutateFrozenCollections() {\n die(2);\n}\nfunction isFrozen(obj) {\n return Object.isFrozen(obj);\n}\n\n// src/utils/plugins.ts\nvar plugins = {};\nfunction getPlugin(pluginKey) {\n const plugin = plugins[pluginKey];\n if (!plugin) {\n die(0, pluginKey);\n }\n return plugin;\n}\nfunction loadPlugin(pluginKey, implementation) {\n if (!plugins[pluginKey])\n plugins[pluginKey] = implementation;\n}\n\n// src/core/scope.ts\nvar currentScope;\nfunction getCurrentScope() {\n return currentScope;\n}\nfunction createScope(parent_, immer_) {\n return {\n drafts_: [],\n parent_,\n immer_,\n // Whenever the modified draft contains a draft from another scope, we\n // need to prevent auto-freezing so the unowned draft can be finalized.\n canAutoFreeze_: true,\n unfinalizedDrafts_: 0\n };\n}\nfunction usePatchesInScope(scope, patchListener) {\n if (patchListener) {\n getPlugin(\"Patches\");\n scope.patches_ = [];\n scope.inversePatches_ = [];\n scope.patchListener_ = patchListener;\n }\n}\nfunction revokeScope(scope) {\n leaveScope(scope);\n scope.drafts_.forEach(revokeDraft);\n scope.drafts_ = null;\n}\nfunction leaveScope(scope) {\n if (scope === currentScope) {\n currentScope = scope.parent_;\n }\n}\nfunction enterScope(immer2) {\n return currentScope = createScope(currentScope, immer2);\n}\nfunction revokeDraft(draft) {\n const state = draft[DRAFT_STATE];\n if (state.type_ === 0 / Object / \|\| state.type_ === 1 / Array /)\n state.revoke_();\n else\n state.revoked_ = true;\n}\n\n// src/core/finalize.ts\nfunction processResult(result, scope) {\n scope.unfinalizedDrafts_ = scope.drafts_.length;\n const baseDraft = scope.drafts_[0];\n const isReplaced = result !== void 0 && result !== baseDraft;\n if (isReplaced) {\n if (baseDraft[DRAFT_STATE].modified_) {\n revokeScope(scope);\n die(4);\n }\n if (isDraftable(result)) {\n result = finalize(scope, result);\n if (!scope.parent_)\n maybeFreeze(scope, result);\n }\n if (scope.patches_) {\n getPlugin(\"Patches\").generateReplacementPatches_(\n baseDraft[DRAFT_STATE].base_,\n result,\n scope.patches_,\n scope.inversePatches_\n );\n }\n } else {\n result = finalize(scope, baseDraft, []);\n }\n revokeScope(scope);\n if (scope.patches_) {\n scope.patchListener_(scope.patches_, scope.inversePatches_);\n }\n return result !== NOTHING ? result : void 0;\n}\nfunction finalize(rootScope, value, path) {\n if (isFrozen(value))\n return value;\n const state = value[DRAFT_STATE];\n if (!state) {\n each(\n value,\n (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)\n );\n return value;\n }\n if (state.scope_ !== rootScope)\n return value;\n if (!state.modified_) {\n maybeFreeze(rootScope, state.base_, true);\n return state.base_;\n }\n if (!state.finalized_) {\n state.finalized_ = true;\n state.scope_.unfinalizedDrafts_--;\n const result = state.copy_;\n let resultEach = result;\n let isSet2 = false;\n if (state.type_ === 3 / Set /) {\n resultEach = new Set(result);\n result.clear();\n isSet2 = true;\n }\n each(\n resultEach,\n (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)\n );\n maybeFreeze(rootScope, result, false);\n if (path && rootScope.patches_) {\n getPlugin(\"Patches\").generatePatches_(\n state,\n path,\n rootScope.patches_,\n rootScope.inversePatches_\n );\n }\n }\n return state.copy_;\n}\nfunction finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {\n if (process.env.NODE_ENV !== \"production\" && childValue === targetObject)\n die(5);\n if (isDraft(childValue)) {\n const path = rootPath && parentState && parentState.type_ !== 3 / Set / && // Set objects are atomic since they have no keys.\n !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;\n const res = finalize(rootScope, childValue, path);\n set(targetObject, prop, res);\n if (isDraft(res)) {\n rootScope.canAutoFreeze_ = false;\n } else\n return;\n } else if (targetIsSet) {\n targetObject.add(childValue);\n }\n if (isDraftable(childValue) && !isFrozen(childValue)) {\n if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {\n return;\n }\n finalize(rootScope, childValue);\n if ((!parentState \|\| !parentState.scope_.parent_) && typeof prop !== \"symbol\" && Object.prototype.propertyIsEnumerable.call(targetObject, prop))\n maybeFreeze(rootScope, childValue);\n }\n}\nfunction maybeFreeze(scope, value, deep = false) {\n if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {\n freeze(value, deep);\n }\n}\n\n// src/core/proxy.ts\nfunction createProxyProxy(base, parent) {\n const isArray = Array.isArray(base);\n const state = {\n type_: isArray ? 1 / Array / : 0 / Object /,\n // Track which produce call this is associated with.\n scope_: parent ? parent.scope_ : getCurrentScope(),\n // True for both shallow and deep changes.\n modified_: false,\n // Used during finalization.\n finalized_: false,\n // Track which properties have been assigned (true) or deleted (false).\n assigned_: {},\n // The parent draft state.\n parent_: parent,\n // The base state.\n base_: base,\n // The base proxy.\n draft_: null,\n // set below\n // The base copy with any updated values.\n copy_: null,\n // Called by the `produce` function.\n revoke_: null,\n isManual_: false\n };\n let target = state;\n let traps = objectTraps;\n if (isArray) {\n target = [state];\n traps = arrayTraps;\n }\n const { revoke, proxy } = Proxy.revocable(target, traps);\n state.draft_ = proxy;\n state.revoke_ = revoke;\n return proxy;\n}\nvar objectTraps = {\n get(state, prop) {\n if (prop === DRAFT_STATE)\n return state;\n const source = latest(state);\n if (!has(source, prop)) {\n return readPropFromProto(state, source, prop);\n }\n const value = source[prop];\n if (state.finalized_ \|\| !isDraftable(value)) {\n return value;\n }\n if (value === peek(state.base_, prop)) {\n prepareCopy(state);\n return state.copy_[prop] = createProxy(value, state);\n }\n return value;\n },\n has(state, prop) {\n return prop in latest(state);\n },\n ownKeys(state) {\n return Reflect.ownKeys(latest(state));\n },\n set(state, prop, value) {\n const desc = getDescriptorFromProto(latest(state), prop);\n if (desc?.set) {\n desc.set.call(state.draft_, value);\n return true;\n }\n if (!state.modified_) {\n const current2 = peek(latest(state), prop);\n const currentState = current2?.[DRAFT_STATE];\n if (currentState && currentState.base_ === value) {\n state.copy_[prop] = value;\n state.assigned_[prop] = false;\n return true;\n }\n if (is(value, current2) && (value !== void 0 \|\| has(state.base_, prop)))\n return true;\n prepareCopy(state);\n markChanged(state);\n }\n if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'\n (value !== void 0 \|\| prop in state.copy_) \|\| // special case: NaN\n Number.isNaN(value) && Number.isNaN(state.copy_[prop]))\n return true;\n state.copy_[prop] = value;\n state.assigned_[prop] = true;\n return true;\n },\n deleteProperty(state, prop) {\n if (peek(state.base_, prop) !== void 0 \|\| prop in state.base_) {\n state.assigned_[prop] = false;\n prepareCopy(state);\n markChanged(state);\n } else {\n delete state.assigned_[prop];\n }\n if (state.copy_) {\n delete state.copy_[prop];\n }\n return true;\n },\n // Note: We never coerce `desc.value` into an Immer draft, because we can't make\n // the same guarantee in ES5 mode.\n getOwnPropertyDescriptor(state, prop) {\n const owner = latest(state);\n const desc = Reflect.getOwnPropertyDescriptor(owner, prop);\n if (!desc)\n return desc;\n return {\n writable: true,\n configurable: state.type_ !== 1 / Array / \|\| prop !== \"length\",\n enumerable: desc.enumerable,\n value: owner[prop]\n };\n },\n defineProperty() {\n die(11);\n },\n getPrototypeOf(state) {\n return getPrototypeOf(state.base_);\n },\n setPrototypeOf() {\n die(12);\n }\n};\nvar arrayTraps = {};\neach(objectTraps, (key, fn) => {\n arrayTraps[key] = function() {\n arguments[0] = arguments[0][0];\n return fn.apply(this, arguments);\n };\n});\narrayTraps.deleteProperty = function(state, prop) {\n if (process.env.NODE_ENV !== \"production\" && isNaN(parseInt(prop)))\n die(13);\n return arrayTraps.set.call(this, state, prop, void 0);\n};\narrayTraps.set = function(state, prop, value) {\n if (process.env.NODE_ENV !== \"production\" && prop !== \"length\" && isNaN(parseInt(prop)))\n die(14);\n return objectTraps.set.call(this, state[0], prop, value, state[0]);\n};\nfunction peek(draft, prop) {\n const state = draft[DRAFT_STATE];\n const source = state ? latest(state) : draft;\n return source[prop];\n}\nfunction readPropFromProto(state, source, prop) {\n const desc = getDescriptorFromProto(source, prop);\n return desc ? `value` in desc ? desc.value : (\n // This is a very special case, if the prop is a getter defined by the\n // prototype, we should invoke it with the draft as context!\n desc.get?.call(state.draft_)\n ) : void 0;\n}\nfunction getDescriptorFromProto(source, prop) {\n if (!(prop in source))\n return void 0;\n let proto = getPrototypeOf(source);\n while (proto) {\n const desc = Object.getOwnPropertyDescriptor(proto, prop);\n if (desc)\n return desc;\n proto = getPrototypeOf(proto);\n }\n return void 0;\n}\nfunction markChanged(state) {\n if (!state.modified_) {\n state.modified_ = true;\n if (state.parent_) {\n markChanged(state.parent_);\n }\n }\n}\nfunction prepareCopy(state) {\n if (!state.copy_) {\n state.copy_ = shallowCopy(\n state.base_,\n state.scope_.immer_.useStrictShallowCopy_\n );\n }\n}\n\n// src/core/immerClass.ts\nvar Immer2 = class {\n constructor(config) {\n this.autoFreeze_ = true;\n this.useStrictShallowCopy_ = false;\n /\n The `produce` function takes a value and a \"recipe function\" (whose\n * return value often depends on the base state). The recipe function is\n * free to mutate its first argument however it wants. All mutations are\n * only ever applied to a __copy__ of the base state.\n \n Pass only a function to create a \"curried producer\" which relieves you\n * from passing the recipe function every time.\n \n Only plain objects and arrays are made mutable. All other objects are\n * considered uncopyable.\n \n Note: This function is __bound__ to its `Immer` instance.\n \n @param {any} base - the initial state\n * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified\n * @param {Function} patchListener - optional function that will be called with all the patches produced here\n * @returns {any} a new state, or the initial state if nothing was modified\n /\n this.produce = (base, recipe, patchListener) => {\n if (typeof base === \"function\" && typeof recipe !== \"function\") {\n const defaultBase = recipe;\n recipe = base;\n const self = this;\n return function curriedProduce(base2 = defaultBase, ...args) {\n return self.produce(base2, (draft) => recipe.call(this, draft, ...args));\n };\n }\n if (typeof recipe !== \"function\")\n die(6);\n if (patchListener !== void 0 && typeof patchListener !== \"function\")\n die(7);\n let result;\n if (isDraftable(base)) {\n const scope = enterScope(this);\n const proxy = createProxy(base, void 0);\n let hasError = true;\n try {\n result = recipe(proxy);\n hasError = false;\n } finally {\n if (hasError)\n revokeScope(scope);\n else\n leaveScope(scope);\n }\n usePatchesInScope(scope, patchListener);\n return processResult(result, scope);\n } else if (!base \|\| typeof base !== \"object\") {\n result = recipe(base);\n if (result === void 0)\n result = base;\n if (result === NOTHING)\n result = void 0;\n if (this.autoFreeze_)\n freeze(result, true);\n if (patchListener) {\n const p = [];\n const ip = [];\n getPlugin(\"Patches\").generateReplacementPatches_(base, result, p, ip);\n patchListener(p, ip);\n }\n return result;\n } else\n die(1, base);\n };\n this.produceWithPatches = (base, recipe) => {\n if (typeof base === \"function\") {\n return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));\n }\n let patches, inversePatches;\n const result = this.produce(base, recipe, (p, ip) => {\n patches = p;\n inversePatches = ip;\n });\n return [result, patches, inversePatches];\n };\n if (typeof config?.autoFreeze === \"boolean\")\n this.setAutoFreeze(config.autoFreeze);\n if (typeof config?.useStrictShallowCopy === \"boolean\")\n this.setUseStrictShallowCopy(config.useStrictShallowCopy);\n }\n createDraft(base) {\n if (!isDraftable(base))\n die(8);\n if (isDraft(base))\n base = current(base);\n const scope = enterScope(this);\n const proxy = createProxy(base, void 0);\n proxy[DRAFT_STATE].isManual_ = true;\n leaveScope(scope);\n return proxy;\n }\n finishDraft(draft, patchListener) {\n const state = draft && draft[DRAFT_STATE];\n if (!state \|\| !state.isManual_)\n die(9);\n const { scope_: scope } = state;\n usePatchesInScope(scope, patchListener);\n return processResult(void 0, scope);\n }\n /\n Pass true to automatically freeze all copies created by Immer.\n \n By default, auto-freezing is enabled.\n /\n setAutoFreeze(value) {\n this.autoFreeze_ = value;\n }\n /\n Pass true to enable strict shallow copy.\n \n By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.\n /\n setUseStrictShallowCopy(value) {\n this.useStrictShallowCopy_ = value;\n }\n applyPatches(base, patches) {\n let i;\n for (i = patches.length - 1; i >= 0; i--) {\n const patch = patches[i];\n if (patch.path.length === 0 && patch.op === \"replace\") {\n base = patch.value;\n break;\n }\n }\n if (i > -1) {\n patches = patches.slice(i + 1);\n }\n const applyPatchesImpl = getPlugin(\"Patches\").applyPatches_;\n if (isDraft(base)) {\n return applyPatchesImpl(base, patches);\n }\n return this.produce(\n base,\n (draft) => applyPatchesImpl(draft, patches)\n );\n }\n};\nfunction createProxy(value, parent) {\n const draft = isMap(value) ? getPlugin(\"MapSet\").proxyMap_(value, parent) : isSet(value) ? getPlugin(\"MapSet\").proxySet_(value, parent) : createProxyProxy(value, parent);\n const scope = parent ? parent.scope_ : getCurrentScope();\n scope.drafts_.push(draft);\n return draft;\n}\n\n// src/core/current.ts\nfunction current(value) {\n if (!isDraft(value))\n die(10, value);\n return currentImpl(value);\n}\nfunction currentImpl(value) {\n if (!isDraftable(value) \|\| isFrozen(value))\n return value;\n const state = value[DRAFT_STATE];\n let copy;\n if (state) {\n if (!state.modified_)\n return state.base_;\n state.finalized_ = true;\n copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);\n } else {\n copy = shallowCopy(value, true);\n }\n each(copy, (key, childValue) => {\n set(copy, key, currentImpl(childValue));\n });\n if (state) {\n state.finalized_ = false;\n }\n return copy;\n}\n\n// src/plugins/patches.ts\nfunction enablePatches() {\n const errorOffset = 16;\n if (process.env.NODE_ENV !== \"production\") {\n errors.push(\n 'Sets cannot have \"replace\" patches.',\n function(op) {\n return \"Unsupported patch operation: \" + op;\n },\n function(path) {\n return \"Cannot apply patch, path doesn't resolve: \" + path;\n },\n \"Patching reserved attributes like __proto__, prototype and constructor is not allowed\"\n );\n }\n const REPLACE = \"replace\";\n const ADD = \"add\";\n const REMOVE = \"remove\";\n function generatePatches_(state, basePath, patches, inversePatches) {\n switch (state.type_) {\n case 0 / Object /:\n case 2 / Map /:\n return generatePatchesFromAssigned(\n state,\n basePath,\n patches,\n inversePatches\n );\n case 1 / Array /:\n return generateArrayPatches(state, basePath, patches, inversePatches);\n case 3 / Set /:\n return generateSetPatches(\n state,\n basePath,\n patches,\n inversePatches\n );\n }\n }\n function generateArrayPatches(state, basePath, patches, inversePatches) {\n let { base_, assigned_ } = state;\n let copy_ = state.copy_;\n if (copy_.length < base_.length) {\n ;\n [base_, copy_] = [copy_, base_];\n [patches, inversePatches] = [inversePatches, patches];\n }\n for (let i = 0; i < base_.length; i++) {\n if (assigned_[i] && copy_[i] !== base_[i]) {\n const path = basePath.concat([i]);\n patches.push({\n op: REPLACE,\n path,\n // Need to maybe clone it, as it can in fact be the original value\n // due to the base/copy inversion at the start of this function\n value: clonePatchValueIfNeeded(copy_[i])\n });\n inversePatches.push({\n op: REPLACE,\n path,\n value: clonePatchValueIfNeeded(base_[i])\n });\n }\n }\n for (let i = base_.length; i < copy_.length; i++) {\n const path = basePath.concat([i]);\n patches.push({\n op: ADD,\n path,\n // Need to maybe clone it, as it can in fact be the original value\n // due to the base/copy inversion at the start of this function\n value: clonePatchValueIfNeeded(copy_[i])\n });\n }\n for (let i = copy_.length - 1; base_.length <= i; --i) {\n const path = basePath.concat([i]);\n inversePatches.push({\n op: REMOVE,\n path\n });\n }\n }\n function generatePatchesFromAssigned(state, basePath, patches, inversePatches) {\n const { base_, copy_ } = state;\n each(state.assigned_, (key, assignedValue) => {\n const origValue = get(base_, key);\n const value = get(copy_, key);\n const op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD;\n if (origValue === value && op === REPLACE)\n return;\n const path = basePath.concat(key);\n patches.push(op === REMOVE ? { op, path } : { op, path, value });\n inversePatches.push(\n op === ADD ? { op: REMOVE, path } : op === REMOVE ? { op: ADD, path, value: clonePatchValueIfNeeded(origValue) } : { op: REPLACE, path, value: clonePatchValueIfNeeded(origValue) }\n );\n });\n }\n function generateSetPatches(state, basePath, patches, inversePatches) {\n let { base_, copy_ } = state;\n let i = 0;\n base_.forEach((value) => {\n if (!copy_.has(value)) {\n const path = basePath.concat([i]);\n patches.push({\n op: REMOVE,\n path,\n value\n });\n inversePatches.unshift({\n op: ADD,\n path,\n value\n });\n }\n i++;\n });\n i = 0;\n copy_.forEach((value) => {\n if (!base_.has(value)) {\n const path = basePath.concat([i]);\n patches.push({\n op: ADD,\n path,\n value\n });\n inversePatches.unshift({\n op: REMOVE,\n path,\n value\n });\n }\n i++;\n });\n }\n function generateReplacementPatches_(baseValue, replacement, patches, inversePatches) {\n patches.push({\n op: REPLACE,\n path: [],\n value: replacement === NOTHING ? void 0 : replacement\n });\n inversePatches.push({\n op: REPLACE,\n path: [],\n value: baseValue\n });\n }\n function applyPatches_(draft, patches) {\n patches.forEach((patch) => {\n const { path, op } = patch;\n let base = draft;\n for (let i = 0; i < path.length - 1; i++) {\n const parentType = getArchtype(base);\n let p = path[i];\n if (typeof p !== \"string\" && typeof p !== \"number\") {\n p = \"\" + p;\n }\n if ((parentType === 0 / Object / \|\| parentType === 1 / Array /) && (p === \"__proto__\" \|\| p === \"constructor\"))\n die(errorOffset + 3);\n if (typeof base === \"function\" && p === \"prototype\")\n die(errorOffset + 3);\n base = get(base, p);\n if (typeof base !== \"object\")\n die(errorOffset + 2, path.join(\"/\"));\n }\n const type = getArchtype(base);\n const value = deepClonePatchValue(patch.value);\n const key = path[path.length - 1];\n switch (op) {\n case REPLACE:\n switch (type) {\n case 2 / Map /:\n return base.set(key, value);\n case 3 / Set /:\n die(errorOffset);\n default:\n return base[key] = value;\n }\n case ADD:\n switch (type) {\n case 1 / Array /:\n return key === \"-\" ? base.push(value) : base.splice(key, 0, value);\n case 2 / Map /:\n return base.set(key, value);\n case 3 / Set /:\n return base.add(value);\n default:\n return base[key] = value;\n }\n case REMOVE:\n switch (type) {\n case 1 / Array /:\n return base.splice(key, 1);\n case 2 / Map /:\n return base.delete(key);\n case 3 / Set /:\n return base.delete(patch.value);\n default:\n return delete base[key];\n }\n default:\n die(errorOffset + 1, op);\n }\n });\n return draft;\n }\n function deepClonePatchValue(obj) {\n if (!isDraftable(obj))\n return obj;\n if (Array.isArray(obj))\n return obj.map(deepClonePatchValue);\n if (isMap(obj))\n return new Map(\n Array.from(obj.entries()).map(([k, v]) => [k, deepClonePatchValue(v)])\n );\n if (isSet(obj))\n return new Set(Array.from(obj).map(deepClonePatchValue));\n const cloned = Object.create(getPrototypeOf(obj));\n for (const key in obj)\n cloned[key] = deepClonePatchValue(obj[key]);\n if (has(obj, DRAFTABLE))\n cloned[DRAFTABLE] = obj[DRAFTABLE];\n return cloned;\n }\n function clonePatchValueIfNeeded(obj) {\n if (isDraft(obj)) {\n return deepClonePatchValue(obj);\n } else\n return obj;\n }\n loadPlugin(\"Patches\", {\n applyPatches_,\n generatePatches_,\n generateReplacementPatches_\n });\n}\n\n// src/plugins/mapset.ts\nfunction enableMapSet() {\n class DraftMap extends Map {\n constructor(target, parent) {\n super();\n this[DRAFT_STATE] = {\n type_: 2 / Map /,\n parent_: parent,\n scope_: parent ? parent.scope_ : getCurrentScope(),\n modified_: false,\n finalized_: false,\n copy_: void 0,\n assigned_: void 0,\n base_: target,\n draft_: this,\n isManual_: false,\n revoked_: false\n };\n }\n get size() {\n return latest(this[DRAFT_STATE]).size;\n }\n has(key) {\n return latest(this[DRAFT_STATE]).has(key);\n }\n set(key, value) {\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n if (!latest(state).has(key) \|\| latest(state).get(key) !== value) {\n prepareMapCopy(state);\n markChanged(state);\n state.assigned_.set(key, true);\n state.copy_.set(key, value);\n state.assigned_.set(key, true);\n }\n return this;\n }\n delete(key) {\n if (!this.has(key)) {\n return false;\n }\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n prepareMapCopy(state);\n markChanged(state);\n if (state.base_.has(key)) {\n state.assigned_.set(key, false);\n } else {\n state.assigned_.delete(key);\n }\n state.copy_.delete(key);\n return true;\n }\n clear() {\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n if (latest(state).size) {\n prepareMapCopy(state);\n markChanged(state);\n state.assigned_ = / @__PURE__ / new Map();\n each(state.base_, (key) => {\n state.assigned_.set(key, false);\n });\n state.copy_.clear();\n }\n }\n forEach(cb, thisArg) {\n const state = this[DRAFT_STATE];\n latest(state).forEach((_value, key, _map) => {\n cb.call(thisArg, this.get(key), key, this);\n });\n }\n get(key) {\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n const value = latest(state).get(key);\n if (state.finalized_ \|\| !isDraftable(value)) {\n return value;\n }\n if (value !== state.base_.get(key)) {\n return value;\n }\n const draft = createProxy(value, state);\n prepareMapCopy(state);\n state.copy_.set(key, draft);\n return draft;\n }\n keys() {\n return latest(this[DRAFT_STATE]).keys();\n }\n values() {\n const iterator = this.keys();\n return {\n [Symbol.iterator]: () => this.values(),\n next: () => {\n const r = iterator.next();\n if (r.done)\n return r;\n const value = this.get(r.value);\n return {\n done: false,\n value\n };\n }\n };\n }\n entries() {\n const iterator = this.keys();\n return {\n [Symbol.iterator]: () => this.entries(),\n next: () => {\n const r = iterator.next();\n if (r.done)\n return r;\n const value = this.get(r.value);\n return {\n done: false,\n value: [r.value, value]\n };\n }\n };\n }\n [(DRAFT_STATE, Symbol.iterator)]() {\n return this.entries();\n }\n }\n function proxyMap_(target, parent) {\n return new DraftMap(target, parent);\n }\n function prepareMapCopy(state) {\n if (!state.copy_) {\n state.assigned_ = / @__PURE__ / new Map();\n state.copy_ = new Map(state.base_);\n }\n }\n class DraftSet extends Set {\n constructor(target, parent) {\n super();\n this[DRAFT_STATE] = {\n type_: 3 / Set /,\n parent_: parent,\n scope_: parent ? parent.scope_ : getCurrentScope(),\n modified_: false,\n finalized_: false,\n copy_: void 0,\n base_: target,\n draft_: this,\n drafts_: / @__PURE__ / new Map(),\n revoked_: false,\n isManual_: false\n };\n }\n get size() {\n return latest(this[DRAFT_STATE]).size;\n }\n has(value) {\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n if (!state.copy_) {\n return state.base_.has(value);\n }\n if (state.copy_.has(value))\n return true;\n if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value)))\n return true;\n return false;\n }\n add(value) {\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n if (!this.has(value)) {\n prepareSetCopy(state);\n markChanged(state);\n state.copy_.add(value);\n }\n return this;\n }\n delete(value) {\n if (!this.has(value)) {\n return false;\n }\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n prepareSetCopy(state);\n markChanged(state);\n return state.copy_.delete(value) \|\| (state.drafts_.has(value) ? state.copy_.delete(state.drafts_.get(value)) : (\n / istanbul ignore next /\n false\n ));\n }\n clear() {\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n if (latest(state).size) {\n prepareSetCopy(state);\n markChanged(state);\n state.copy_.clear();\n }\n }\n values() {\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n prepareSetCopy(state);\n return state.copy_.values();\n }\n entries() {\n const state = this[DRAFT_STATE];\n assertUnrevoked(state);\n prepareSetCopy(state);\n return state.copy_.entries();\n }\n keys() {\n return this.values();\n }\n [(DRAFT_STATE, Symbol.iterator)]() {\n return this.values();\n }\n forEach(cb, thisArg) {\n const iterator = this.values();\n let result = iterator.next();\n while (!result.done) {\n cb.call(thisArg, result.value, result.value, this);\n result = iterator.next();\n }\n }\n }\n function proxySet_(target, parent) {\n return new DraftSet(target, parent);\n }\n function prepareSetCopy(state) {\n if (!state.copy_) {\n state.copy_ = / @__PURE__ / new Set();\n state.base_.forEach((value) => {\n if (isDraftable(value)) {\n const draft = createProxy(value, state);\n state.drafts_.set(value, draft);\n state.copy_.add(draft);\n } else {\n state.copy_.add(value);\n }\n });\n }\n }\n function assertUnrevoked(state) {\n if (state.revoked_)\n die(3, JSON.stringify(latest(state)));\n }\n loadPlugin(\"MapSet\", { proxyMap_, proxySet_ });\n}\n\n// src/immer.ts\nvar immer = new Immer2();\nvar produce = immer.produce;\nvar produceWithPatches = immer.produceWithPatches.bind(\n immer\n);\nvar setAutoFreeze = immer.setAutoFreeze.bind(immer);\nvar setUseStrictShallowCopy = immer.setUseStrictShallowCopy.bind(immer);\nvar applyPatches = immer.applyPatches.bind(immer);\nvar createDraft = immer.createDraft.bind(immer);\nvar finishDraft = immer.finishDraft.bind(immer);\nfunction castDraft(value) {\n return value;\n}\nfunction castImmutable(value) {\n return value;\n}\nexport {\n Immer2 as Immer,\n applyPatches,\n castDraft,\n castImmutable,\n createDraft,\n current,\n enableMapSet,\n enablePatches,\n finishDraft,\n freeze,\n DRAFTABLE as immerable,\n isDraft,\n isDraftable,\n NOTHING as nothing,\n original,\n produce,\n produceWithPatches,\n setAutoFreeze,\n setUseStrictShallowCopy\n};\n//# sourceMappingURL=immer.mjs.map","import { enablePatches, produceWithPatches } from 'immer';\n\n/\n 状态订阅者回调函数类型\n * @template T 状态类型\n * @param state 只读的最新状态\n * @param changes 发生变更的路径数组（只读）\n /\nexport type Subscriber<T> = (state: Readonly<T>, changes: readonly string[]) => void;\n\n// 启用immer的patch支持，用于追踪状态变更路径\nenablePatches();\n\n/\n 响应式状态管理类，提供高效的状态管理和变更追踪功能\n * @template T 状态对象类型，必须为object类型\n /\nexport default class ReactiveState<T extends object> {\n private currentState: T; // 当前状态（始终为冻结对象）\n\n private subscribers = new Set<{ handler: Subscriber<T>; paths?: string[] }>(); // 订阅者集合（包含路径过滤条件）\n\n private pendingChanges: string[] = []; // 待处理的变更路径（自动去重）\n\n private notificationScheduled = false; // 通知调度锁（防止重复调度）\n\n private pathSubscribers = new Map<string, Set<{ handler: Subscriber<T> }>>(); // 增加订阅者分组缓存\n\n /\n 初始化响应式状态\n * @param initialState 初始状态（会自动冻结）\n /\n public initialize(initialState: T) {\n this.currentState = Object.freeze(initialState);\n }\n\n /\n 更新状态方法\n * @param updater 状态更新函数（使用immer的draft机制）\n * @param paths 可选的手动指定变更路径（自动模式会从immer patches中提取）\n /\n public setState(updater: (draft: T) => void, paths?: string[]): void {\n // 使用produceWithPatches来获取变更路径，生成新状态和变更记录\n const [nextState, patches] = produceWithPatches(this.currentState, updater);\n\n // 处理变更路径：优先使用手动指定路径，否则从patches中提取\n const changes =\n paths \|\| patches.filter((p) => ['replace', 'add', 'remove'].includes(p.op)).map((p) => p.path.join('.'));\n\n if (changes.length > 0) {\n this.pendingChanges.push(...changes);\n this.currentState = Object.freeze(nextState) as T;\n this.scheduleNotification();\n }\n }\n\n /\n 获取当前状态\n * @param cloned 是否返回克隆副本（默认false）\n * @returns 当前状态的只读引用或克隆副本\n /\n public getState(cloned = false): Readonly<T> {\n return cloned ? structuredClone(this.currentState) : this.currentState;\n }\n\n /\n 订阅状态变更（支持路径过滤），订阅时维护路径索引\n * @param subscriber 订阅回调函数\n * @param paths 可选的要监听的属性路径数组\n * @returns 取消订阅的函数\n /\n public subscribe(subscriber: Subscriber<T>, paths?: string[]): () => void {\n const subscription = { handler: subscriber, paths };\n this.subscribers.add(subscription);\n // 维护路径索引\n paths?.forEach((path) => {\n if (!this.pathSubscribers.has(path)) {\n this.pathSubscribers.set(path, new Set());\n }\n this.pathSubscribers.get(path)?.add(subscription);\n });\n\n return () => {\n this.subscribers.delete(subscription);\n paths?.forEach((path) => {\n this.pathSubscribers.get(path)?.delete(subscription);\n });\n };\n }\n\n /\n 调度通知（使用微任务批量处理）\n /\n private scheduleNotification() {\n if (this.notificationScheduled) return;\n this.notificationScheduled = true;\n\n // 使用微任务进行批处理，确保在同一个事件循环内的多次更新只会触发一次通知\n queueMicrotask(() => {\n // 去重变更路径并重置待处理队列\n const changedPaths = [...new Set(this.pendingChanges)];\n this.pendingChanges = [];\n this.notificationScheduled = false;\n\n // 冻结状态和路径数组，防止订阅者意外修改\n const frozenState = Object.freeze(this.currentState);\n const frozenPaths = Object.freeze(changedPaths);\n\n // 安全通知所有订阅者\n this.subscribers.forEach(({ handler, paths }) => {\n try {\n // 如果没有设置监听路径，或变更路径中有匹配项，则触发回调\n if (\n !paths \|\|\n frozenPaths.some((p) =>\n paths.some((target) => {\n const targetParts = target.split('.');\n const pathParts = p.split('.');\n return targetParts.every((part, i) => pathParts[i] === part);\n }),\n )\n ) {\n handler(frozenState, frozenPaths);\n }\n } catch (error) {\n console.error('Subscriber error:', error);\n }\n });\n });\n }\n\n /\n 调试方法（开发时使用）\n * @param label 调试标签（默认'State'）\n * @returns 当前实例（支持链式调用）\n */\n public debug(label = 'State'): this {\n this.subscribe((state, paths) => {\n console.groupCollapsed(`%c${label} Update`, 'color: #4CAF50; font-weight: bold;');\n console.log('Changed Paths:', paths);\n console.log('New State:', state);\n console.groupEnd();\n });\n return this;\n }\n}\n"],"names":["NOTHING","Symbol","DRAFTABLE","DRAFT_STATE","enablePatches","ReactiveState","_classCallCheck","_defineProperty","Set","Map","_createClass","key","value","initialize","initialState","currentState","Object","freeze","setState","updater","paths","_produceWithPatches","produceWithPatches","_produceWithPatches2","_slicedToArray","nextState","patches","changes","filter","p","includes","op","map","path","join","length","_this$pendingChanges","pendingChanges","push","apply","_toConsumableArray","scheduleNotification","getState","cloned","structuredClone","subscribe","subscriber","_this","subscription","handler","subscribers","add","forEach","_this$pathSubscribers","pathSubscribers","has","set","get","_this$pathSubscribers2","_this2","notificationScheduled","queueMicrotask","changedPaths","frozenState","frozenPaths","_ref","some","target","targetParts","split","pathParts","every","part","i","error","console","debug","label","state","groupCollapsed","concat","log","groupEnd"],"mappings":"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"}
1	+ {"version":3,"file":"reactiveState.js","sources":["../../../../../pro-components/chat/chat-engine/core/store/reactiveState.ts"],"sourcesContent":["import { enablePatches, produceWithPatches } from 'immer';\n\n/*\n 状态订阅者回调函数类型\n * @template T 状态类型\n * @param state 只读的最新状态\n * @param changes 发生变更的路径数组（只读）\n /\nexport type Subscriber<T> = (state: Readonly<T>, changes: readonly string[]) => void;\n\n// 启用immer的patch支持，用于追踪状态变更路径\nenablePatches();\n\n/\n 响应式状态管理类，提供高效的状态管理和变更追踪功能\n * @template T 状态对象类型，必须为object类型\n /\nexport default class ReactiveState<T extends object> {\n private currentState: T; // 当前状态（始终为冻结对象）\n\n private subscribers = new Set<{ handler: Subscriber<T>; paths?: string[] }>(); // 订阅者集合（包含路径过滤条件）\n\n private pendingChanges: string[] = []; // 待处理的变更路径（自动去重）\n\n private notificationScheduled = false; // 通知调度锁（防止重复调度）\n\n private pathSubscribers = new Map<string, Set<{ handler: Subscriber<T> }>>(); // 增加订阅者分组缓存\n\n /\n 初始化响应式状态\n * @param initialState 初始状态（会自动冻结）\n /\n public initialize(initialState: T) {\n this.currentState = Object.freeze(initialState);\n }\n\n /\n 更新状态方法\n * @param updater 状态更新函数（使用immer的draft机制）\n * @param paths 可选的手动指定变更路径（自动模式会从immer patches中提取）\n /\n public setState(updater: (draft: T) => void, paths?: string[]): void {\n // 使用produceWithPatches来获取变更路径，生成新状态和变更记录\n const [nextState, patches] = produceWithPatches(this.currentState, updater);\n\n // 处理变更路径：优先使用手动指定路径，否则从patches中提取\n const changes =\n paths \|\| patches.filter((p) => ['replace', 'add', 'remove'].includes(p.op)).map((p) => p.path.join('.'));\n\n if (changes.length > 0) {\n this.pendingChanges.push(...changes);\n this.currentState = Object.freeze(nextState) as T;\n this.scheduleNotification();\n }\n }\n\n /\n 获取当前状态\n * @param cloned 是否返回克隆副本（默认false）\n * @returns 当前状态的只读引用或克隆副本\n /\n public getState(cloned = false): Readonly<T> {\n return cloned ? structuredClone(this.currentState) : this.currentState;\n }\n\n /\n 订阅状态变更（支持路径过滤），订阅时维护路径索引\n * @param subscriber 订阅回调函数\n * @param paths 可选的要监听的属性路径数组\n * @returns 取消订阅的函数\n /\n public subscribe(subscriber: Subscriber<T>, paths?: string[]): () => void {\n const subscription = { handler: subscriber, paths };\n this.subscribers.add(subscription);\n // 维护路径索引\n paths?.forEach((path) => {\n if (!this.pathSubscribers.has(path)) {\n this.pathSubscribers.set(path, new Set());\n }\n this.pathSubscribers.get(path)?.add(subscription);\n });\n\n return () => {\n this.subscribers.delete(subscription);\n paths?.forEach((path) => {\n this.pathSubscribers.get(path)?.delete(subscription);\n });\n };\n }\n\n /\n 调度通知（使用微任务批量处理）\n /\n private scheduleNotification() {\n if (this.notificationScheduled) return;\n this.notificationScheduled = true;\n\n // 使用微任务进行批处理，确保在同一个事件循环内的多次更新只会触发一次通知\n queueMicrotask(() => {\n // 去重变更路径并重置待处理队列\n const changedPaths = [...new Set(this.pendingChanges)];\n this.pendingChanges = [];\n this.notificationScheduled = false;\n\n // 冻结状态和路径数组，防止订阅者意外修改\n const frozenState = Object.freeze(this.currentState);\n const frozenPaths = Object.freeze(changedPaths);\n\n // 安全通知所有订阅者\n this.subscribers.forEach(({ handler, paths }) => {\n try {\n // 如果没有设置监听路径，或变更路径中有匹配项，则触发回调\n if (\n !paths \|\|\n frozenPaths.some((p) =>\n paths.some((target) => {\n const targetParts = target.split('.');\n const pathParts = p.split('.');\n return targetParts.every((part, i) => pathParts[i] === part);\n }),\n )\n ) {\n handler(frozenState, frozenPaths);\n }\n } catch (error) {\n console.error('Subscriber error:', error);\n }\n });\n });\n }\n\n /\n 销毁方法，清理资源\n /\n public destroy() {\n this.subscribers.clear();\n this.pathSubscribers.clear();\n this.pendingChanges = [];\n this.notificationScheduled = false;\n }\n\n /\n 调试方法（开发时使用）\n * @param label 调试标签（默认'State'）\n * @returns 当前实例（支持链式调用）\n */\n public debug(label = 'State'): this {\n this.subscribe((state, paths) => {\n console.groupCollapsed(`%c${label} Update`, 'color: #4CAF50; font-weight: bold;');\n console.log('Changed Paths:', paths);\n console.log('New State:', state);\n console.groupEnd();\n });\n return this;\n }\n}\n"],"names":["enablePatches","ReactiveState","_classCallCheck","_defineProperty","Set","Map","_createClass","key","value","initialize","initialState","currentState","Object","freeze","setState","updater","paths","_produceWithPatches","produceWithPatches","_produceWithPatches2","_slicedToArray","nextState","patches","changes","filter","p","includes","op","map","path","join","length","_this$pendingChanges","pendingChanges","push","apply","_toConsumableArray","scheduleNotification","getState","cloned","structuredClone","subscribe","subscriber","_this","subscription","handler","subscribers","add","forEach","_this$pathSubscribers","pathSubscribers","has","set","get","_this$pathSubscribers2","_this2","notificationScheduled","queueMicrotask","changedPaths","frozenState","frozenPaths","_ref","some","target","targetParts","split","pathParts","every","part","i","error","console","destroy","clear","debug","label","state","groupCollapsed","concat","log","groupEnd"],"mappings":"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"}

package/es/chat-engine/core/type.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import type { ToolCallEventType } from './adapters/agui/events';
+import type { ToolCallEventType } from './adapters/agui/types/events';
 export type ChatMessageRole = 'user' | 'assistant' | 'system';
 export type ChatMessageStatus = 'pending' | 'streaming' | 'complete' | 'stop' | 'error';
 export type ChatStatus = 'idle' | ChatMessageStatus;
@@ -69,6 +69,11 @@ export type ActivityData<TContent = Record<string, any>> = {
     activityType: string;
     messageId?: string;
     content: TContent;
+    /** 增量更新信息 */
+    deltaInfo?: {
+        fromIndex: number;
+        toIndex: number;
+    };
 };
 export type ActivityContent<TContent = Record<string, any>> = ChatBaseContent<'activity', ActivityData<TContent>>;
 export interface ChatBaseMessage {
@@ -147,6 +152,25 @@ export interface DefaultEngineCallbacks {
     onAbort?: () => Promise<void>;
     /** 错误处理 */
     onError?: (err: Error | Response) => void;
+    /**
+     * Chunk 验证器 - 用于验证 SSE 数据块是否有效
+     *
+     * 当后端返回空内容或无效数据时，可以通过此配置判断 chunk 是否有效，
+     * 只有有效的 chunk 才会被处理，避免过早进入 streaming 状态。
+     *
+     * @param chunk SSE 数据块
+     * @returns 返回 true 表示该 chunk 有效（需要处理），返回 false 表示无效（跳过）
+     *
+     * @example
+     * ```ts
+     * // 只处理 content 不为空的 chunk
+     * isValidChunk: (chunk) => {
+     *   const content = chunk.data?.choices?.[0]?.delta?.content;
+     *   return content !== '' && content !== undefined;
+     * }
+     * ```
+     */
+    isValidChunk?: (chunk: SSEChunkData) => boolean;
 }
 export interface ChatServiceConfig extends ChatNetworkConfig, DefaultEngineCallbacks {
 }

package/es/chat-engine/core/type.js CHANGED Viewed

@@ -1,5 +1,5 @@
 /**
- * tdesign v1.0.2-alpha.6
+ * tdesign v1.1.0-alpha.11
  * (c) 2026 tdesign
  * @license MIT
  */

package/es/chat-engine/core/utils/eventEmitter.js CHANGED Viewed

@@ -1,5 +1,5 @@
 /**
- * tdesign v1.0.2-alpha.6
+ * tdesign v1.1.0-alpha.11
  * (c) 2026 tdesign
  * @license MIT
  */

package/es/chat-engine/core/utils/immutable-patch.d.ts ADDED Viewed

@@ -0,0 +1,61 @@
+/**
+ * Immutable JSON Patch with Structural Sharing
+ *
+ * 核心特性：
+ * - 只重建被修改路径上的节点
+ * - 未修改的节点保持原引用（实现结构共享）
+ * - 支持标准 JSON Patch 操作：add, remove, replace, move, copy
+ * - 支持扩展操作：append（字符串追加）
+ *
+ * 性能优势：
+ * - 配合 React.memo / useSyncExternalStore 使用时，未变化的组件不会重渲染
+ * - 避免深拷贝带来的性能开销
+ */
+export type Operation = {
+    op: 'add';
+    path: string;
+    value: any;
+} | {
+    op: 'remove';
+    path: string;
+} | {
+    op: 'replace';
+    path: string;
+    value: any;
+} | {
+    op: 'move';
+    path: string;
+    from: string;
+} | {
+    op: 'copy';
+    path: string;
+    from: string;
+} | {
+    op: 'append';
+    path: string;
+    value: string;
+};
+/**
+ * 应用 JSON Patch 数组（结构共享版本）
+ *
+ * @param document 原始文档
+ * @param patch 操作数组
+ * @returns 新文档（未修改的节点保持原引用）
+ *
+ * @example
+ * const tree = { elements: { a: { props: { x: 1 } }, b: { props: { y: 2 } } } };
+ * const newTree = applyPatchImmutable(tree, [
+ *   { op: 'replace', path: '/elements/a/props/x', value: 10 }
+ * ]);
+ *
+ * // 结构共享验证：
+ * tree.elements.b === newTree.elements.b  // true - b 节点未变，保持原引用
+ * tree.elements.a === newTree.elements.a  // false - a 节点被修改，是新引用
+ */
+export declare function applyPatchImmutable<T>(document: T, patch: Operation[]): T;
+/**
+ * 兼容原有 applyPatch 的返回格式
+ */
+export declare function applyPatch<T>(document: T, patch: Operation[]): {
+    newDocument: T;
+};

package/es/chat-engine/core/utils/immutable-patch.js ADDED Viewed

@@ -0,0 +1,147 @@
+/**
+ * tdesign v1.1.0-alpha.11
+ * (c) 2026 tdesign
+ * @license MIT
+ */
+import _typeof from '@babel/runtime/helpers/typeof';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _toArray from '@babel/runtime/helpers/toArray';
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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; }
+function parsePath(path) {
+  if (path === "" || path === "/") return [];
+  return path.split("/").slice(1).map(function (s) {
+    return s.replace(/~1/g, "/").replace(/~0/g, "~");
+  });
+}
+function getByPath(obj, path) {
+  var current = obj;
+  var _iterator = _createForOfIteratorHelper(path),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      if (current == null) return void 0;
+      current = current[key];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return current;
+}
+function setByPath(obj, path, value) {
+  if (path.length === 0) {
+    return value;
+  }
+  var _path = _toArray(path),
+    head = _path[0],
+    tail = _path.slice(1);
+  var current = obj;
+  var isArray = Array.isArray(current);
+  var index = isArray ? head === "-" ? current.length : parseInt(head, 10) : head;
+  if (tail.length === 0) {
+    if (isArray) {
+      var newArr = _toConsumableArray(current);
+      newArr[index] = value;
+      return newArr;
+    } else {
+      return _objectSpread(_objectSpread({}, current), {}, _defineProperty({}, head, value));
+    }
+  }
+  var child = current[head];
+  var newChild = setByPath(child, tail, value);
+  if (isArray) {
+    var _newArr = _toConsumableArray(current);
+    _newArr[index] = newChild;
+    return _newArr;
+  } else {
+    return _objectSpread(_objectSpread({}, current), {}, _defineProperty({}, head, newChild));
+  }
+}
+function removeByPath(obj, path) {
+  if (path.length === 0) {
+    return void 0;
+  }
+  var _path2 = _toArray(path),
+    head = _path2[0],
+    tail = _path2.slice(1);
+  var current = obj;
+  var isArray = Array.isArray(current);
+  if (tail.length === 0) {
+    if (isArray) {
+      var index = parseInt(head, 10);
+      var newArr = _toConsumableArray(current);
+      newArr.splice(index, 1);
+      return newArr;
+    } else {
+      var _ = current[head],
+        rest = _objectWithoutProperties(current, [head].map(_toPropertyKey));
+      return rest;
+    }
+  }
+  var child = current[head];
+  var newChild = removeByPath(child, tail);
+  if (isArray) {
+    var _index = parseInt(head, 10);
+    var _newArr2 = _toConsumableArray(current);
+    _newArr2[_index] = newChild;
+    return _newArr2;
+  } else {
+    return _objectSpread(_objectSpread({}, current), {}, _defineProperty({}, head, newChild));
+  }
+}
+function applyOperationImmutable(document, operation) {
+  var path = parsePath(operation.path);
+  switch (operation.op) {
+    case "add":
+    case "replace":
+      return setByPath(document, path, operation.value);
+    case "remove":
+      return removeByPath(document, path);
+    case "append":
+      {
+        var existing = getByPath(document, path);
+        var newValue = existing == null ? operation.value : String(existing) + operation.value;
+        return setByPath(document, path, newValue);
+      }
+    case "move":
+      {
+        var fromPath = parsePath(operation.from);
+        var value = getByPath(document, fromPath);
+        var afterRemove = removeByPath(document, fromPath);
+        return setByPath(afterRemove, path, value);
+      }
+    case "copy":
+      {
+        var _fromPath = parsePath(operation.from);
+        var _value = getByPath(document, _fromPath);
+        return setByPath(document, path, JSON.parse(JSON.stringify(_value)));
+      }
+    default:
+      return document;
+  }
+}
+function applyPatchImmutable(document, patch) {
+  return patch.reduce(function (doc, op) {
+    return applyOperationImmutable(doc, op);
+  }, document);
+}
+function applyPatch(document, patch) {
+  return {
+    newDocument: applyPatchImmutable(document, patch)
+  };
+}
+export { applyPatch, applyPatchImmutable };
+//# sourceMappingURL=immutable-patch.js.map

package/es/chat-engine/core/utils/immutable-patch.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"immutable-patch.js","sources":["../../../../../pro-components/chat/chat-engine/core/utils/immutable-patch.ts"],"sourcesContent":["/**\n * Immutable JSON Patch with Structural Sharing\n * \n * 核心特性：\n * - 只重建被修改路径上的节点\n * - 未修改的节点保持原引用（实现结构共享）\n * - 支持标准 JSON Patch 操作：add, remove, replace, move, copy\n * - 支持扩展操作：append（字符串追加）\n * \n * 性能优势：\n * - 配合 React.memo / useSyncExternalStore 使用时，未变化的组件不会重渲染\n * - 避免深拷贝带来的性能开销\n */\n\nexport type Operation = \n | { op: 'add'; path: string; value: any }\n | { op: 'remove'; path: string }\n | { op: 'replace'; path: string; value: any }\n | { op: 'move'; path: string; from: string }\n | { op: 'copy'; path: string; from: string }\n | { op: 'append'; path: string; value: string };\n\n/**\n * 解析 JSON Pointer 路径\n * \"/elements/deep-progress/props/percentage\" => [\"elements\", \"deep-progress\", \"props\", \"percentage\"]\n */\nfunction parsePath(path: string): string[] {\n if (path === '' || path === '/') return [];\n return path.split('/').slice(1).map(s => s.replace(/~1/g, '/').replace(/~0/g, '~'));\n}\n\n/**\n * 获取嵌套值\n */\nfunction getByPath(obj: any, path: string[]): any {\n let current = obj;\n for (const key of path) {\n if (current == null) return undefined;\n current = current[key];\n }\n return current;\n}\n\n/**\n * 不可变地设置嵌套值（结构共享）\n * 只重建路径上的节点，其他节点保持原引用\n */\nfunction setByPath<T>(obj: T, path: string[], value: any): T {\n if (path.length === 0) {\n return value;\n }\n \n const [head, ...tail] = path;\n const current = obj as any;\n \n // 判断当前层是数组还是对象\n const isArray = Array.isArray(current);\n const index = isArray ? (head === '-' ? current.length : parseInt(head, 10)) : head;\n \n if (tail.length === 0) {\n // 到达目标位置，设置值\n if (isArray) {\n const newArr = [...current];\n newArr[index as number] = value;\n return newArr as unknown as T;\n } else {\n return { ...current, [head]: value };\n }\n }\n \n // 递归处理子路径\n const child = current[head];\n const newChild = setByPath(child, tail, value);\n \n if (isArray) {\n const newArr = [...current];\n newArr[index as number] = newChild;\n return newArr as unknown as T;\n } else {\n return { ...current, [head]: newChild };\n }\n}\n\n/**\n * 不可变地删除嵌套值（结构共享）\n */\nfunction removeByPath<T>(obj: T, path: string[]): T {\n if (path.length === 0) {\n return undefined as unknown as T;\n }\n \n const [head, ...tail] = path;\n const current = obj as any;\n const isArray = Array.isArray(current);\n \n if (tail.length === 0) {\n // 到达目标位置，删除值\n if (isArray) {\n const index = parseInt(head, 10);\n const newArr = [...current];\n newArr.splice(index, 1);\n return newArr as unknown as T;\n } else {\n const { [head]: _, ...rest } = current;\n return rest as T;\n }\n }\n \n // 递归处理子路径\n const child = current[head];\n const newChild = removeByPath(child, tail);\n \n if (isArray) {\n const index = parseInt(head, 10);\n const newArr = [...current];\n newArr[index] = newChild;\n return newArr as unknown as T;\n } else {\n return { ...current, [head]: newChild };\n }\n}\n\n/**\n * 应用单个操作（结构共享）\n */\nfunction applyOperationImmutable<T>(document: T, operation: Operation): T {\n const path = parsePath(operation.path);\n \n switch (operation.op) {\n case 'add':\n case 'replace':\n return setByPath(document, path, operation.value);\n \n case 'remove':\n return removeByPath(document, path);\n \n case 'append': {\n const existing = getByPath(document, path);\n const newValue = existing == null ? operation.value : String(existing) + operation.value;\n return setByPath(document, path, newValue);\n }\n \n case 'move': {\n const fromPath = parsePath(operation.from);\n const value = getByPath(document, fromPath);\n const afterRemove = removeByPath(document, fromPath);\n return setByPath(afterRemove, path, value);\n }\n \n case 'copy': {\n const fromPath = parsePath(operation.from);\n const value = getByPath(document, fromPath);\n // 深拷贝 copy 的值，避免共享引用\n return setByPath(document, path, JSON.parse(JSON.stringify(value)));\n }\n \n default:\n return document;\n }\n}\n\n/**\n * 应用 JSON Patch 数组（结构共享版本）\n * \n * @param document 原始文档\n * @param patch 操作数组\n * @returns 新文档（未修改的节点保持原引用）\n * \n * @example\n * const tree = { elements: { a: { props: { x: 1 } }, b: { props: { y: 2 } } } };\n * const newTree = applyPatchImmutable(tree, [\n * { op: 'replace', path: '/elements/a/props/x', value: 10 }\n * ]);\n * \n * // 结构共享验证：\n * tree.elements.b === newTree.elements.b // true - b 节点未变，保持原引用\n * tree.elements.a === newTree.elements.a // false - a 节点被修改，是新引用\n */\nexport function applyPatchImmutable<T>(document: T, patch: Operation[]): T {\n return patch.reduce((doc, op) => applyOperationImmutable(doc, op), document);\n}\n\n/**\n * 兼容原有 applyPatch 的返回格式\n */\nexport function applyPatch<T>(document: T, patch: Operation[]): { newDocument: T } {\n return {\n newDocument: applyPatchImmutable(document, patch)\n };\n}\n"],"names":["parsePath","path","split","slice","map","s","replace","getByPath","obj","current","_iterator","_createForOfIteratorHelper","_step","n","done","key","err","e","f","setByPath","value","length","_path","_toArray","head","tail","isArray","Array","index","parseInt","newArr","_toConsumableArray","_objectSpread","_defineProperty","child","newChild","removeByPath","_path2","splice","_","rest","_objectWithoutProperties","_toPropertyKey","applyOperationImmutable","document","operation","op","existing","newValue","String","fromPath","from","afterRemove","JSON","parse","stringify","applyPatchImmutable","patch","reduce","doc","applyPatch","newDocument"],"mappings":"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"}

package/es/chat-engine/core/utils/index.d.ts CHANGED Viewed

@@ -1,10 +1,15 @@
 import type { ActivityContent, AIMessageContent, AttachmentContent, ChatMessagesData, ImageContent, MarkdownContent, SearchContent, SuggestionContent, TextContent, ThinkingContent, ToolCallContent, UserMessageContent } from '../type';
 /**
  * 应用JSON Patch操作到状态对象
- * 使用fast-json-patch库实现RFC6902规范的JSON Patch操作
+ *
+ * 使用 Immutable Patch + Structural Sharing：
+ * - 只重建被修改路径上的节点
+ * - 未修改的节点保持原引用
+ * - 配合 React.memo 使用时，未变化的组件不会重渲染
+ *
  * @param state 原始状态对象
  * @param delta 包含patch操作的数组
- * @returns 更新后的新状态对象
+ * @returns 更新后的新状态对象（结构共享）
  */
 export declare function applyJsonPatch(state: any, delta: any[]): any;
 /**