An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later
package streams
import (
"math"
"github.com/dop251/goja"
)
// extractHighWaterMark 对应规范 ExtractHighWaterMark:strategy.highWaterMark 缺省时取 defaultHWM;否则转换为
// 数值并要求非 NaN、非负,否则抛 RangeError。
func extractHighWaterMark(rt *goja.Runtime, strategy goja.Value, defaultHWM float64) float64 {
object, ok := strategyObjectOf(strategy)
if !ok {
return defaultHWM
}
hwm := object.Get("highWaterMark")
if hwm == nil || goja.IsUndefined(hwm) {
return defaultHWM
}
value := hwm.ToFloat()
if math.IsNaN(value) || value < 0 {
panic(rangeErrorf(rt, "Invalid highWaterMark"))
}
return value
}
// rangeErrorf 构造一个 name 为 RangeError 的普通 Error(本沙箱沿用 streamError 的做法,不提供原生 RangeError
// 包装)。
func rangeErrorf(rt *goja.Runtime, message string) goja.Value {
return streamError(rt, "RangeError", message)
}
// strategyObjectOf 把 QueuingStrategy 字典参数转换为对象:undefined/null 视为空字典,其余非对象值抛错由
// 调用方按需处理(这里简单返回 ok=false 让调用方套用缺省值,与"空字典"等价,和规范对 undefined/null 的处理
// 一致;真正传入非对象、非 nullish 值时 WebIDL 本应抛错,但 strategy 参数在本包内只有宿主自己构造的调用点,
// 不会传入这类值,因此未做严格校验)。
func strategyObjectOf(strategy goja.Value) (*goja.Object, bool) {
if strategy == nil || goja.IsUndefined(strategy) || goja.IsNull(strategy) {
return nil, false
}
object, ok := strategy.(*goja.Object)
return object, ok
}
// extractSizeAlgorithm 对应规范 ExtractSizeAlgorithm:strategy.size 缺省时返回"任意 chunk 大小为 1"的算法,
// 否则返回调用该函数的算法(异常原样向上抛出)。
func extractSizeAlgorithm(rt *goja.Runtime, strategy goja.Value) func(goja.Value) float64 {
object, ok := strategyObjectOf(strategy)
if !ok {
return defaultSizeAlgorithm
}
size := object.Get("size")
if size == nil || goja.IsUndefined(size) {
return defaultSizeAlgorithm
}
fn, ok := goja.AssertFunction(size)
if !ok {
panic(typeErrorf(rt, "size member of QueuingStrategy must be a function"))
}
return func(chunk goja.Value) float64 {
result, err := fn(goja.Undefined(), chunk)
if err != nil {
panic(err)
}
return result.ToFloat()
}
}
// newCountQueuingStrategyConstructor 构造 CountQueuingStrategy:{highWaterMark} -> 对象,size() 恒定为 1,
// highWaterMark 为构造时传入的值。
func newCountQueuingStrategyConstructor(h *Host) *goja.Object {
rt := h.rt
prototype := rt.NewObject()
defineMethod(rt, prototype, "size", 0, func(call goja.FunctionCall) goja.Value { return rt.ToValue(1) })
defineToStringTag(rt, prototype, "CountQueuingStrategy")
return newInterfaceConstructor(rt, "CountQueuingStrategy", 1, prototype, func(call goja.ConstructorCall) *goja.Object {
instance := rt.NewObject()
must(instance.SetPrototype(call.This.Prototype()))
must(instance.DefineDataProperty("highWaterMark", rt.ToValue(highWaterMarkMemberOf(rt, call.Argument(0))),
goja.FLAG_TRUE, goja.FLAG_TRUE, goja.FLAG_FALSE))
return instance
})
}
// newByteLengthQueuingStrategyConstructor 构造 ByteLengthQueuingStrategy:{highWaterMark} -> 对象,
// size(chunk) 返回 chunk.byteLength,highWaterMark 为构造时传入的值。
func newByteLengthQueuingStrategyConstructor(h *Host) *goja.Object {
rt := h.rt
prototype := rt.NewObject()
defineMethod(rt, prototype, "size", 1, func(call goja.FunctionCall) goja.Value {
chunk := call.Argument(0)
if chunkObj, ok := chunk.(*goja.Object); ok {
if byteLength := chunkObj.Get("byteLength"); byteLength != nil {
return byteLength
}
}
return rt.ToValue(0)
})
defineToStringTag(rt, prototype, "ByteLengthQueuingStrategy")
return newInterfaceConstructor(rt, "ByteLengthQueuingStrategy", 1, prototype, func(call goja.ConstructorCall) *goja.Object {
instance := rt.NewObject()
must(instance.SetPrototype(call.This.Prototype()))
must(instance.DefineDataProperty("highWaterMark", rt.ToValue(highWaterMarkMemberOf(rt, call.Argument(0))),
goja.FLAG_TRUE, goja.FLAG_TRUE, goja.FLAG_FALSE))
return instance
})
}
// highWaterMarkMemberOf 读取 QueuingStrategyInit 字典的必填 highWaterMark 成员(无默认值,必须显式提供)。
func highWaterMarkMemberOf(rt *goja.Runtime, init goja.Value) float64 {
object, ok := init.(*goja.Object)
if !ok {
panic(typeErrorf(rt, "QueuingStrategyInit: can't be converted to a dictionary"))
}
hwm := object.Get("highWaterMark")
if hwm == nil || goja.IsUndefined(hwm) {
panic(typeErrorf(rt, "QueuingStrategyInit: highWaterMark is required"))
}
return hwm.ToFloat()
}