dolphindb 0.0.1

package/browser.js

@@ -0,0 +1,1140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ddb = exports.DDB = exports.DdbFunction = exports.DdbPair = exports.DdbVectorAny = exports.DdbVectorDouble = exports.DdbVectorString = exports.DdbVectorInt = exports.DdbDouble = exports.DdbLong = exports.DdbString = exports.DdbInt = exports.DdbBool = exports.DdbObj = exports.nulls = exports.DdbFunctionType = exports.DdbType = exports.DdbForm = void 0;
+const tslib_1 = require("tslib");
+const dayjs_1 = (0, tslib_1.__importDefault)(require("dayjs"));
+require("xshell/prototype.browser");
+const utils_browser_1 = require("xshell/utils.browser");
+const chalk_browser_1 = require("xshell/chalk.browser");
+var DdbForm;
+(function (DdbForm) {
+    DdbForm[DdbForm["scalar"] = 0] = "scalar";
+    DdbForm[DdbForm["vector"] = 1] = "vector";
+    DdbForm[DdbForm["pair"] = 2] = "pair";
+    DdbForm[DdbForm["matrix"] = 3] = "matrix";
+    DdbForm[DdbForm["set"] = 4] = "set";
+    DdbForm[DdbForm["dict"] = 5] = "dict";
+    DdbForm[DdbForm["table"] = 6] = "table";
+    DdbForm[DdbForm["chart"] = 7] = "chart";
+    DdbForm[DdbForm["chunk"] = 8] = "chunk";
+})(DdbForm = exports.DdbForm || (exports.DdbForm = {}));
+var DdbType;
+(function (DdbType) {
+    DdbType[DdbType["void"] = 0] = "void";
+    DdbType[DdbType["bool"] = 1] = "bool";
+    DdbType[DdbType["char"] = 2] = "char";
+    DdbType[DdbType["short"] = 3] = "short";
+    DdbType[DdbType["int"] = 4] = "int";
+    DdbType[DdbType["long"] = 5] = "long";
+    DdbType[DdbType["date"] = 6] = "date";
+    DdbType[DdbType["month"] = 7] = "month";
+    DdbType[DdbType["time"] = 8] = "time";
+    DdbType[DdbType["minute"] = 9] = "minute";
+    DdbType[DdbType["second"] = 10] = "second";
+    DdbType[DdbType["datetime"] = 11] = "datetime";
+    DdbType[DdbType["timestamp"] = 12] = "timestamp";
+    DdbType[DdbType["nanotime"] = 13] = "nanotime";
+    DdbType[DdbType["nanotimestamp"] = 14] = "nanotimestamp";
+    DdbType[DdbType["float"] = 15] = "float";
+    DdbType[DdbType["double"] = 16] = "double";
+    DdbType[DdbType["symbol"] = 17] = "symbol";
+    DdbType[DdbType["string"] = 18] = "string";
+    DdbType[DdbType["uuid"] = 19] = "uuid";
+    DdbType[DdbType["functiondef"] = 20] = "functiondef";
+    DdbType[DdbType["handle"] = 21] = "handle";
+    DdbType[DdbType["code"] = 22] = "code";
+    DdbType[DdbType["datasource"] = 23] = "datasource";
+    DdbType[DdbType["resource"] = 24] = "resource";
+    DdbType[DdbType["any"] = 25] = "any";
+    DdbType[DdbType["compress"] = 26] = "compress";
+    DdbType[DdbType["dict"] = 27] = "dict";
+    DdbType[DdbType["datehour"] = 28] = "datehour";
+    DdbType[DdbType["ipaddr"] = 30] = "ipaddr";
+    DdbType[DdbType["int128"] = 31] = "int128";
+    DdbType[DdbType["blob"] = 32] = "blob";
+    DdbType[DdbType["complex"] = 34] = "complex";
+    DdbType[DdbType["point"] = 35] = "point";
+    DdbType[DdbType["duration"] = 36] = "duration";
+    DdbType[DdbType["symbol_extended"] = 145] = "symbol_extended";
+})(DdbType = exports.DdbType || (exports.DdbType = {}));
+var DdbFunctionType;
+(function (DdbFunctionType) {
+    DdbFunctionType[DdbFunctionType["SystemFunc"] = 0] = "SystemFunc";
+    DdbFunctionType[DdbFunctionType["SystemProc"] = 1] = "SystemProc";
+    DdbFunctionType[DdbFunctionType["OperatorFunc"] = 2] = "OperatorFunc";
+    DdbFunctionType[DdbFunctionType["UserDefinedFunc"] = 3] = "UserDefinedFunc";
+    DdbFunctionType[DdbFunctionType["PartialFunc"] = 4] = "PartialFunc";
+    DdbFunctionType[DdbFunctionType["DynamicFunc"] = 5] = "DynamicFunc";
+    DdbFunctionType[DdbFunctionType["PiecewiseFunc"] = 6] = "PiecewiseFunc";
+    DdbFunctionType[DdbFunctionType["JitFunc"] = 7] = "JitFunc";
+    DdbFunctionType[DdbFunctionType["JitPartialFunc"] = 8] = "JitPartialFunc";
+})(DdbFunctionType = exports.DdbFunctionType || (exports.DdbFunctionType = {}));
+exports.nulls = {
+    char: '\x80',
+    int16: -32768,
+    int32: -2147483648,
+    int64: -0x8000000000000000n, // -922_3372_0368_5477_5808
+};
+class DdbObj {
+    constructor(data) {
+        /** 是否为小端 (little endian) */
+        this.le = DdbObj.le_client;
+        Object.assign(this, data);
+    }
+    static parse(buf, le) {
+        if (!buf.length)
+            return new this({
+                le,
+                form: DdbForm.scalar,
+                type: DdbType.void,
+                length: 0,
+                value: undefined
+            });
+        const type = buf[0];
+        const form = buf[1];
+        if (buf.length <= 2) {
+            return new this({
+                le,
+                form,
+                type,
+                length: 2,
+                value: null,
+            });
+        }
+        // set 里面 data 嵌套了一个 vector, 跳过 vector 的 type 和 form
+        const i_data = form === DdbForm.set ? 4 : 2;
+        const buf_data = buf.subarray(i_data);
+        switch (form) {
+            case DdbForm.scalar: {
+                const [length, value] = this.parse_scalar(buf_data, le, type);
+                return new this({
+                    le,
+                    form,
+                    type,
+                    length: 2 + length,
+                    value,
+                });
+            }
+            case DdbForm.vector:
+            case DdbForm.pair:
+            case DdbForm.set: {
+                let vector = this.parse_vector(buf_data, le, type);
+                vector.length += 2;
+                vector.form = form;
+                return vector;
+            }
+            case DdbForm.table: {
+                // table([
+                //     [1, 2] as a,
+                //     [1, 2] as b
+                // ])
+                // <Buffer 
+                // 00 06 form = table
+                // 02 00 00 00 02 00 00 00 rows = 2, cols = 2
+                // 00 行名称
+                // 61 00 62 00 列名称 a, b
+                // 04 01 form = vector, type = int
+                // 02 00 00 00 01 00 00 00 cols = 2, rows = 1
+                // 01 00 00 00 02 00 00 00 
+                // 04 01 
+                // 02 00 00 00 01 00 00 00 
+                // 01 00 00 00 02 00 00 00>
+                const dv = new DataView(buf.buffer, buf.byteOffset + i_data);
+                const rows = dv.getUint32(0, le);
+                const cols = dv.getUint32(4, le);
+                const i_name_tail = buf_data.indexOf(0, 8);
+                const name = this.dec.decode(buf_data.subarray(8, i_name_tail));
+                const i_items_start = i_name_tail + 1;
+                const [len_items, colnames] = this.parse_vector_items(buf_data.subarray(i_items_start), le, DdbType.string, cols);
+                let value = new Array(cols);
+                let i_start = i_items_start + len_items;
+                for (let i = 0; i < cols; i++) {
+                    const type = buf_data[i_start];
+                    const i_vector_head = i_start + 2;
+                    let col = this.parse_vector(buf_data.subarray(i_vector_head), le, type);
+                    col.name = colnames[i];
+                    value[i] = col;
+                    i_start = i_vector_head + col.length;
+                }
+                return new this({
+                    le,
+                    form,
+                    type,
+                    length: i_start,
+                    name,
+                    rows,
+                    cols,
+                    value,
+                });
+            }
+            case DdbForm.dict: {
+                // <Buffer 19 05 type = any, form = dict
+                // 12 01 keys.type = string, keys.form = vector
+                // 03 00 00 00 01 00 00 00 keys.cols = 3, keys.rows = 1
+                // 63 00 62 00 61 00 
+                // 19 01 values.type = any, values.form = vector
+                // 03 00 00 00 01 00 00 00 values.cols = 3, values.rows = 1
+                // 04 00 03 00 00 00 04 00 02 00 00 00 04 00 01 00 00 00>
+                let keys = this.parse_vector(buf_data.subarray(2), le, buf_data[0]);
+                keys.length += 2;
+                let values = this.parse_vector(buf_data.subarray(keys.length + 2), le, buf_data[keys.length]);
+                values.length += 2;
+                return new this({
+                    le,
+                    form,
+                    type,
+                    length: 2 + keys.length + values.length,
+                    rows: keys.rows,
+                    cols: 2,
+                    value: [
+                        keys,
+                        values
+                    ],
+                });
+            }
+            case DdbForm.matrix: {
+                // matrix([
+                //     [1, 2, 3],
+                //     [3, 2, 1]
+                // ])
+                // <Buffer 00 has_row_label = , has_col_label = 
+                // 04 03 type = int, form = matrix
+                // 03 00 00 00 02 00 00 00 rows = 3, cols = 2
+                // 01 00 00 00 02 00 00 00 03 00 00 00 03 00 00 00 02 00 00 00 01 00 00 00>
+                const dv = new DataView(buf.buffer, buf.byteOffset + i_data);
+                const label_flags = buf_data[0];
+                const has_row_labels = Boolean(label_flags & 0x01);
+                const has_col_labels = Boolean(label_flags & 0x02);
+                if (has_row_labels || has_col_labels)
+                    throw new Error('matrix 暂不支持 row labels 和 col labels');
+                const datatype = buf_data[1];
+                const rows = dv.getUint32(3, le);
+                const cols = dv.getUint32(7, le);
+                const [len_items, value] = this.parse_vector_items(buf_data.subarray(11), le, datatype, rows * cols // 假设小于 2**32
+                );
+                return new this({
+                    le,
+                    form,
+                    type,
+                    length: 11 + len_items,
+                    rows,
+                    cols,
+                    datatype,
+                    value,
+                });
+            }
+            default:
+                return new this({
+                    le,
+                    form,
+                    type,
+                    length: buf_data.length,
+                    value: buf_data
+                });
+        }
+    }
+    static parse_scalar(buf, le, type) {
+        switch (type) {
+            case DdbType.void:
+                return [1, null];
+            case DdbType.bool:
+                return [1, Boolean(buf[0])];
+            case DdbType.char:
+                return [1, String.fromCharCode(buf[0])];
+            case DdbType.short: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                return [2, dv.getInt16(0, le)];
+            }
+            case DdbType.int:
+            // datetime
+            case DdbType.date:
+            case DdbType.month:
+            case DdbType.time:
+            case DdbType.minute:
+            case DdbType.second:
+            case DdbType.datetime:
+            case DdbType.datehour: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                return [4, dv.getInt32(0, le)];
+            }
+            case DdbType.float: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                return [4, dv.getFloat32(0, le)];
+            }
+            case DdbType.double: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                return [8, dv.getFloat64(0, le)];
+            }
+            case DdbType.long:
+            // timestamp
+            case DdbType.timestamp:
+            case DdbType.nanotime:
+            case DdbType.nanotimestamp: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                return [8, dv.getBigInt64(0, le)];
+            }
+            case DdbType.string:
+            case DdbType.symbol:
+            case DdbType.code:
+            case DdbType.functiondef: {
+                const i_head = type === DdbType.functiondef ? 1 : 0;
+                let i_zero = buf.indexOf(0, i_head);
+                let i_end; // 整个字符串（包括 0）的末尾，excluding
+                if (i_zero === -1)
+                    i_end = i_zero = buf.length;
+                else
+                    i_end = i_zero + 1;
+                // 调整了 i_zero 到字符串（不包括 0）的末尾，excluding
+                const str = this.dec.decode(buf.subarray(i_head, i_zero));
+                return [
+                    i_end,
+                    type === DdbType.functiondef ?
+                        {
+                            type: buf[0],
+                            name: str
+                        }
+                        :
+                            str
+                ];
+            }
+            case DdbType.uuid:
+            case DdbType.ipaddr:
+            case DdbType.int128:
+                return [
+                    16,
+                    buf.slice(0, 16)
+                ];
+            case DdbType.blob: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                const length = dv.getUint32(0, le);
+                return [
+                    4 + length,
+                    buf.slice(4, 4 + length)
+                ];
+            }
+            case DdbType.complex:
+            case DdbType.point: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                return [
+                    16,
+                    [
+                        dv.getFloat64(0, le),
+                        dv.getFloat64(8, le)
+                    ]
+                ];
+            }
+            default:
+                return [0, buf];
+        }
+    }
+    /** parse: rows, cols, items
+        返回的 ddbobj.length 不包括 vector 的 type 和 form
+    */
+    static parse_vector(buf, le, type) {
+        const dv = new DataView(buf.buffer, buf.byteOffset);
+        const rows = dv.getUint32(0, le);
+        const i_items_start = 8;
+        const [len_items, value] = this.parse_vector_items(buf.subarray(i_items_start), le, type, rows);
+        return new this({
+            le,
+            form: DdbForm.vector,
+            type,
+            length: i_items_start + len_items,
+            cols: 1,
+            rows,
+            value,
+        });
+    }
+    /** 有可能没有字节对齐，不能直接使用原有 message 的 arraybuffer, 统一复制出来，让原有 arraybuffer 被回收掉比较好 */
+    static parse_vector_items(buf, le, type, length) {
+        switch (type) {
+            case DdbType.bool:
+                return [length, buf.slice(0, length)];
+            case DdbType.char:
+                return [
+                    length,
+                    this.dec.decode(buf.subarray(0, length))
+                ];
+            case DdbType.short:
+                return [
+                    2 * length,
+                    new Int16Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + 2 * length))
+                ];
+            case DdbType.int:
+            // datetime
+            case DdbType.date:
+            case DdbType.month:
+            case DdbType.time:
+            case DdbType.minute:
+            case DdbType.second:
+            case DdbType.datetime:
+                return [
+                    4 * length,
+                    new Int32Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + 4 * length))
+                ];
+            case DdbType.float:
+                return [
+                    4 * length,
+                    new Float32Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + 4 * length))
+                ];
+            case DdbType.double:
+                return [
+                    8 * length,
+                    new Float64Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + 8 * length))
+                ];
+            case DdbType.long:
+            // timestamp
+            case DdbType.timestamp:
+            case DdbType.nanotime:
+            case DdbType.nanotimestamp:
+                return [
+                    8 * length,
+                    new BigInt64Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + 8 * length))
+                ];
+            case DdbType.string:
+            case DdbType.symbol:
+            case DdbType.code: {
+                let value = new Array(length);
+                let i_head = 0, i_tail = i_head;
+                for (let i = 0; i < length; i++) {
+                    i_tail = buf.indexOf(0, i_head);
+                    value[i] = this.dec.decode(buf.subarray(i_head, i_tail));
+                    i_head = i_tail + 1;
+                }
+                return [i_head, value];
+            }
+            case DdbType.symbol_extended: {
+                // <Buffer 91 01 type = symbol extended, form = vector
+                // 05 00 00 00 01 00 00 00 row = 5, col = 1
+                // buf:
+                // 00 00 00 00 symbol base id = 0 (uint32)
+                // 02 00 00 00 symbol base size = 2
+                // 00 61 61 00 以 \0 分割的字符串
+                // 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00>
+                const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+                const base_id = dv.getUint32(0, le);
+                const base_size = dv.getUint32(4, le);
+                let base_length = 0;
+                let base = this.symbol_bases[base_id];
+                // base_size 为 0 时复用之前的 symbol base
+                if (base_size) {
+                    [base_length, base] = this.parse_vector_items(buf.subarray(8), le, DdbType.string, base_size);
+                    this.symbol_bases[base_id] = base;
+                }
+                const value_start = 8 + base_length;
+                const value_end = value_start + length * 4;
+                const value = new Uint32Array(buf.buffer.slice(buf.byteOffset + value_start, buf.byteOffset + value_end));
+                return [
+                    value_end,
+                    {
+                        base_id,
+                        base,
+                        value
+                    }
+                ];
+            }
+            case DdbType.uuid:
+            case DdbType.ipaddr:
+            case DdbType.int128:
+                return [
+                    16 * length,
+                    new Uint8Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + 16 * length))
+                ];
+            case DdbType.blob: {
+                // <Buffer 20 01 type = blob, form = vector
+                // 02 00 00 00 01 00 00 00 cols = 2, rows = 1
+                // 04 00 00 00 61 62 63 64 
+                // 04 00 00 00 61 62 63 64>
+                let value = new Array(length);
+                const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+                let i_head = 0;
+                for (let i = 0; i < length; i++) {
+                    const sublen = dv.getUint32(i_head, le);
+                    const i_blob_head = i_head + 4;
+                    const i_blob_tail = i_blob_head + sublen;
+                    value[i] = buf.slice(i_blob_head, i_blob_tail);
+                    i_head = i_blob_tail;
+                }
+                return [i_head, value];
+            }
+            case DdbType.complex:
+            case DdbType.point:
+                return [
+                    16 * length,
+                    new Float64Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + 16 * length))
+                ];
+            case DdbType.any: {
+                // [1, 2, 'a', 'aaa']
+                // any[4](<Buffer 
+                // 04 00 DdbType.int, DdbForm.scalar
+                // 01 00 00 00 
+                // 04 00 DdbType.int, DdbForm.scalar
+                // 02 00 00 00 
+                // 02 00 DdbType.char, DdbForm.scalar
+                // 61 
+                // 12 00 DdbType.string, DdbForm.scalar
+                // 61 61 61 00>)
+                let values = new Array(length);
+                let i_head = 0;
+                for (let i = 0; i < length; i++) {
+                    const obj = this.parse(buf.subarray(i_head), le);
+                    values[i] = obj;
+                    i_head += obj.length;
+                }
+                return [
+                    i_head,
+                    values
+                ];
+            }
+            default:
+                return [0, buf];
+        }
+    }
+    pack() {
+        const { form, type, value } = this;
+        let header = new Uint8Array(new ArrayBuffer(2));
+        header[0] = type;
+        header[1] = form;
+        const body = (() => {
+            switch (form) {
+                case DdbForm.scalar:
+                    switch (type) {
+                        case DdbType.void:
+                            return [Uint8Array.of(1)];
+                        case DdbType.bool:
+                            return [Uint8Array.of(Number(value))];
+                        case DdbType.char:
+                            return [Uint8Array.of(value.charCodeAt(0))];
+                        case DdbType.short:
+                            return [Int16Array.of(value)];
+                        case DdbType.int:
+                        // datetime
+                        case DdbType.date:
+                        case DdbType.month:
+                        case DdbType.time:
+                        case DdbType.minute:
+                        case DdbType.second:
+                        case DdbType.datetime:
+                        case DdbType.datehour:
+                            return [Int32Array.of(value)];
+                        case DdbType.float:
+                            return [Float32Array.of(value)];
+                        case DdbType.double:
+                            return [Float64Array.of(value)];
+                        case DdbType.long:
+                        // timestamp
+                        case DdbType.timestamp:
+                        case DdbType.nanotime:
+                        case DdbType.nanotimestamp:
+                            return [BigInt64Array.of(this.value)];
+                        case DdbType.string:
+                        case DdbType.symbol:
+                        case DdbType.code:
+                            return [
+                                DdbObj.enc.encode(value),
+                                Uint8Array.of(0),
+                            ];
+                        case DdbType.functiondef:
+                            return [
+                                Uint8Array.of(value.type),
+                                DdbObj.enc.encode(value.name),
+                                Uint8Array.of(0)
+                            ];
+                        case DdbType.uuid:
+                        case DdbType.ipaddr:
+                        case DdbType.int128:
+                            return [this.value];
+                        case DdbType.blob:
+                            return [
+                                Uint32Array.of(this.value.byteLength),
+                                this.value
+                            ];
+                        case DdbType.complex:
+                        case DdbType.point:
+                            return [Float64Array.from(this.value)];
+                        case DdbType.duration:
+                            return [value];
+                        default:
+                            throw new Error(`${DdbType[type]} 暂时不支持序列化`);
+                    }
+                case DdbForm.vector:
+                case DdbForm.pair:
+                    return [
+                        Uint32Array.of(this.rows, 1),
+                        ...DdbObj.pack_vector_body(value, type, this.rows)
+                    ];
+                case DdbForm.set:
+                    return [
+                        new DdbObj({
+                            ...this,
+                            form: DdbForm.vector,
+                        }).pack()
+                    ];
+                case DdbForm.table:
+                    return [
+                        Uint32Array.of(this.rows, this.cols),
+                        DdbObj.enc.encode(this.name),
+                        Uint8Array.of(0),
+                        ...DdbObj.pack_vector_body(this.value.map(col => col.name), DdbType.string, this.cols),
+                        ...(() => {
+                            let cols = new Array(this.cols);
+                            for (let i = 0; i < cols.length; i++)
+                                cols[i] = this.value[i].pack();
+                            return cols;
+                        })()
+                    ];
+                case DdbForm.dict:
+                    return [
+                        value[0].pack(),
+                        value[1].pack(),
+                    ];
+                case DdbForm.matrix:
+                    return [
+                        Uint8Array.of(0, this.datatype, this.form),
+                        Uint32Array.of(this.rows, this.cols),
+                        ...DdbObj.pack_vector_body(value, this.datatype, this.rows * this.cols)
+                    ];
+                default:
+                    throw new Error(`${DdbForm[form]} 暂不支持序列化`);
+            }
+        })();
+        if (!body)
+            return new Uint8Array(0);
+        return (0, utils_browser_1.concat)([
+            header,
+            ...body
+        ]);
+    }
+    static pack_vector_body(value, type, length) {
+        switch (type) {
+            case DdbType.bool:
+                return [value];
+            case DdbType.char:
+                return [this.enc.encode(value)];
+            case DdbType.short:
+                return [value];
+            case DdbType.int:
+            // datetime
+            case DdbType.date:
+            case DdbType.month:
+            case DdbType.time:
+            case DdbType.minute:
+            case DdbType.second:
+            case DdbType.datetime:
+                return [value];
+            case DdbType.float:
+                return [value];
+            case DdbType.double:
+                return [value];
+            case DdbType.long:
+            // timestamp
+            case DdbType.timestamp:
+            case DdbType.nanotime:
+            case DdbType.nanotimestamp:
+                return [value];
+            case DdbType.string:
+            case DdbType.symbol:
+            case DdbType.code: {
+                let bufs = new Array(length * 2);
+                for (let i = 0; i < length; i++) {
+                    bufs[2 * i] = this.enc.encode(value[i]);
+                    bufs[2 * i + 1] = Uint8Array.of(0);
+                }
+                return bufs;
+            }
+            case DdbType.uuid:
+            case DdbType.ipaddr:
+            case DdbType.int128:
+                return [value];
+            case DdbType.blob: {
+                let bufs = new Array(length * 2);
+                for (let i = 0; i < length; i++) {
+                    const blob_value = value[i];
+                    bufs[2 * i] = Uint32Array.of(blob_value.length);
+                    bufs[2 * i + 1] = blob_value;
+                }
+                return bufs;
+            }
+            case DdbType.complex:
+            case DdbType.point:
+                return [value];
+            case DdbType.any: {
+                // [1, 2, 'a', 'aaa']
+                // any[4](<Buffer 
+                // 04 00 DdbType.int, DdbForm.scalar
+                // 01 00 00 00 
+                // 04 00 DdbType.int, DdbForm.scalar
+                // 02 00 00 00 
+                // 02 00 DdbType.char, DdbForm.scalar
+                // 61 
+                // 12 00 DdbType.string, DdbForm.scalar
+                // 61 61 61 00>)
+                let bufs = new Array(length);
+                for (let i = 0; i < length; i++)
+                    bufs[i] = value[i].pack();
+                return bufs;
+            }
+            default:
+                throw new Error(`vector ${DdbType[type]} 暂不支持序列化`);
+        }
+    }
+    toString() {
+        const type = (() => {
+            const tname = DdbType[this.type];
+            switch (this.form) {
+                case DdbForm.scalar:
+                    if (this.type === DdbType.functiondef)
+                        return `functiondef<${DdbFunctionType[this.value.type]}>`;
+                    return tname;
+                case DdbForm.vector:
+                    return `${tname}[${this.rows}]`;
+                case DdbForm.pair:
+                    return `pair<${tname}>`;
+                case DdbForm.set:
+                    return `set<${tname}>`;
+                case DdbForm.table:
+                    return `table[${this.rows} rows][${this.cols} cols]`;
+                case DdbForm.dict:
+                    return `dict<${DdbType[this.value[0].type]}, ${DdbType[this.value[1].type]}>`;
+                case DdbForm.matrix:
+                    return `matrix<${DdbType[this.datatype]}>[${this.rows} rows][${this.cols} cols]`;
+                default:
+                    return `${DdbForm[this.form]} ${tname}`;
+            }
+        })();
+        const data = (() => {
+            if (this.form === DdbForm.pair)
+                return `${this.value[0]}, ${this.value[1]}`;
+            if (this.form === DdbForm.scalar && this.type === DdbType.functiondef)
+                return `'${this.value.name}'`;
+            return this.value;
+        })();
+        return `${(0, chalk_browser_1.blue)(type)}(${this.name ? `'${(0, chalk_browser_1.yellow)(this.name)}', ` : ''}${data})\n`;
+    }
+    to_cols() {
+        return this.value.map(col => {
+            let col_ = {
+                title: col.name,
+                dataIndex: col.name,
+            };
+            switch (col.type) {
+                case DdbType.timestamp:
+                    col_.render = (value) => {
+                        if (value === exports.nulls.int64)
+                            return '';
+                        return (0, dayjs_1.default)(Number(value)).format('YYYY.MM.DD HH:mm:ss.SSS');
+                    };
+                    break;
+                case DdbType.date:
+                    col_.render = (value) => {
+                        if (value === exports.nulls.int32)
+                            return '';
+                        return (0, dayjs_1.default)(Number(1000 * 3600 * 24 * value)).format('YYYY.MM.DD');
+                    };
+                    break;
+                case DdbType.ipaddr:
+                    col_.render = value => value.slice().reverse().join('.').replace(/^(0\.)+/, '');
+                    break;
+            }
+            return col_;
+        });
+    }
+    to_rows() {
+        let rows = new Array(this.rows);
+        for (let i = 0; i < this.rows; i++) {
+            let row = {};
+            for (let j = 0; j < this.cols; j++) {
+                const c = this.value[j];
+                if (c.type === DdbType.ipaddr) {
+                    row[c.name] = c.value.subarray(16 * i, 16 * (i + 1));
+                    continue;
+                }
+                row[c.name] = c.value[i];
+            }
+            rows[i] = row;
+        }
+        return rows;
+    }
+}
+exports.DdbObj = DdbObj;
+DdbObj.dec = new TextDecoder('utf-8');
+DdbObj.enc = new TextEncoder();
+/** 维护已解析的 symbol base，比如流数据中后续的 symbol 向量可能只发送一个 base.id, base.size == 0, 依赖之前发送的 symbol base */
+DdbObj.symbol_bases = {};
+/** little endian (client) */
+DdbObj.le_client = Boolean(new Uint8Array(Uint32Array.of(1).buffer)[0]);
+class DdbBool extends DdbObj {
+    constructor(value) {
+        super({
+            form: DdbForm.scalar,
+            type: DdbType.bool,
+            length: 1,
+            value,
+        });
+    }
+}
+exports.DdbBool = DdbBool;
+class DdbInt extends DdbObj {
+    constructor(value) {
+        super({
+            form: DdbForm.scalar,
+            type: DdbType.int,
+            length: 4,
+            value
+        });
+    }
+}
+exports.DdbInt = DdbInt;
+class DdbString extends DdbObj {
+    constructor(value) {
+        super({
+            form: DdbForm.scalar,
+            type: DdbType.string,
+            length: 0,
+            value
+        });
+    }
+}
+exports.DdbString = DdbString;
+class DdbLong extends DdbObj {
+    constructor(value) {
+        super({
+            form: DdbForm.scalar,
+            type: DdbType.long,
+            length: 8,
+            value
+        });
+    }
+}
+exports.DdbLong = DdbLong;
+class DdbDouble extends DdbObj {
+    constructor(value) {
+        super({
+            form: DdbForm.scalar,
+            type: DdbType.double,
+            length: 8,
+            value
+        });
+    }
+}
+exports.DdbDouble = DdbDouble;
+class DdbVectorInt extends DdbObj {
+    constructor(value) {
+        super({
+            form: DdbForm.vector,
+            type: DdbType.int,
+            length: 0,
+            rows: value.length,
+            cols: 1,
+            value: Int32Array.from(value),
+        });
+    }
+}
+exports.DdbVectorInt = DdbVectorInt;
+class DdbVectorString extends DdbObj {
+    constructor(value) {
+        super({
+            form: DdbForm.vector,
+            type: DdbType.string,
+            length: 0,
+            rows: value.length,
+            cols: 1,
+            value
+        });
+    }
+}
+exports.DdbVectorString = DdbVectorString;
+class DdbVectorDouble extends DdbObj {
+    constructor(value) {
+        super({
+            form: DdbForm.vector,
+            type: DdbType.double,
+            length: 0,
+            rows: value.length,
+            cols: 1,
+            value: Float64Array.from(value)
+        });
+    }
+}
+exports.DdbVectorDouble = DdbVectorDouble;
+class DdbVectorAny extends DdbObj {
+    constructor(value) {
+        super({
+            form: DdbForm.vector,
+            type: DdbType.any,
+            length: 0,
+            rows: value.length,
+            cols: 1,
+            value
+        });
+    }
+}
+exports.DdbVectorAny = DdbVectorAny;
+class DdbPair extends DdbObj {
+    constructor(l, r = -2147483648) {
+        super({
+            form: DdbForm.pair,
+            type: DdbType.int,
+            length: 0,
+            rows: 2,
+            cols: 1,
+            value: Int32Array.of(l, r)
+        });
+    }
+}
+exports.DdbPair = DdbPair;
+class DdbFunction extends DdbObj {
+    constructor(name, type) {
+        super({
+            form: DdbForm.scalar,
+            type: DdbType.functiondef,
+            length: 0,
+            value: { type, name }
+        });
+    }
+}
+exports.DdbFunction = DdbFunction;
+class DDB {
+    constructor(ws_url) {
+        /** 当前的 session id (http 或 tcp) */
+        this.sid = '0';
+        /** utf-8 text decoder */
+        this.dec = new TextDecoder('utf-8');
+        this.enc = new TextEncoder();
+        this.ws = null;
+        /** little endian (server) */
+        this.le = true;
+        this.presult = Promise.resolve(null);
+        if (!ws_url) {
+            const url = new URL(location.href);
+            const hostname = url.searchParams.get('hostname') || location.hostname;
+            const port = url.searchParams.get('port') || location.port;
+            ws_url = `${location.protocol === 'https:' ? 'wss' : 'ws'}://${hostname}${port ? `:${port}` : ''}/`;
+        }
+        this.ws_url = ws_url;
+    }
+    /** resolver, rejector, promise of last rpc */
+    presolver(buf) { }
+    prejector(error) { }
+    /** 连接到 DolphinDB Server */
+    async connect({ ws_url = this.ws_url, login = true, username = 'admin', password = '123456', } = {}) {
+        this.ws_url = ws_url;
+        if (this.ws?.readyState === WebSocket.OPEN)
+            this.disconnect();
+        let ws = new WebSocket(ws_url);
+        // https://stackoverflow.com/questions/11821096/what-is-the-difference-between-an-arraybuffer-and-a-blob/39951543
+        ws.binaryType = 'arraybuffer';
+        this.ws = ws;
+        ws.addEventListener('open', ev => {
+            console.log(`${this.ws_url} opened`);
+            ws.send(`API ${this.sid} 8\n` +
+                'connect\n');
+        });
+        ws.addEventListener('close', ev => {
+            console.log(`${this.ws_url} closed with code = ${ev.code}, reason = '${ev.reason}'`);
+        });
+        ws.addEventListener('error', ev => {
+            console.log(`${this.ws_url} errored`, ev);
+        });
+        // 为首个 connect 响应报文初始化 presult 链表头结点
+        this.presult = new Promise((resolve, reject) => {
+            this.presolver = resolve;
+            this.prejector = reject;
+        });
+        ws.addEventListener('message', ({ data: buf }) => {
+            try {
+                this.presolver(this.parse_message(new Uint8Array(buf)));
+            }
+            catch (error) {
+                this.prejector(error);
+            }
+        });
+        await this.presult;
+        await this.eval('def pnode_run (nodes, func_name, args, add_node_alias = true) {\n' +
+            '    nargs = size(args)\n' +
+            '    func = funcByName(func_name)\n' +
+            '    \n' +
+            '    if (!nargs)\n' +
+            '        return pnodeRun(func, nodes, add_node_alias)\n' +
+            '    \n' +
+            '    args_partial = array(any, 1 + nargs, 1 + nargs)\n' +
+            '    args_partial[0] = func\n' +
+            '    args_partial[1:] = args\n' +
+            '    return pnodeRun(\n' +
+            '        unifiedCall(partial, args_partial),\n' +
+            '        nodes,\n' +
+            '        add_node_alias\n' +
+            '    )\n' +
+            '}\n', { urgent: true });
+        if (login)
+            await this.call('login', [username, password], { urgent: true });
+    }
+    disconnect() {
+        this.ws?.close(1000);
+    }
+    /** rpc through websocket (function command)
+        - type: API 类型: 'script' | 'function' | 'variable'
+        - options:
+            - urgent?: 决定 `行为标识` 那一行字符串的取值（只适用于 script 和 function）
+            - vars?: type === 'variable' 时必传，variable 指令中待上传的变量名
+    */
+    async rpc(type, { script, func, args = [], vars = [], urgent, }) {
+        if (!this.ws)
+            await this.connect();
+        if (this.ws.readyState !== WebSocket.OPEN)
+            throw new Error('ws 连接已断开');
+        // 临界区：保证多个 rpc 并发时形成 promise 链
+        // ddb 世界观：需要等待上一个 rpc 结果从 server 返回之后才能发起下一个调用  
+        // 违反世界观可能造成:  
+        // 1. 并发多个请求只返回第一个结果（阻塞，需后续请求疏通）
+        // 2. windows 下 ddb server 返回多个相同的结果
+        const ptail = this.presult;
+        let presolver;
+        let prejector;
+        const presult = this.presult = new Promise((resolve, reject) => {
+            presolver = resolve;
+            prejector = reject;
+        });
+        try {
+            await ptail;
+        }
+        catch { }
+        this.presolver = presolver;
+        this.prejector = prejector;
+        // 临界区结束，只有一个 rpc 请求可以写 WebSocket
+        if (urgent && type !== 'script' && type !== 'function')
+            throw new Error('urgent 只适用于 script 和 funciton');
+        this.to_ddbobjs(args);
+        const command = this.enc.encode((() => {
+            switch (type) {
+                case 'function':
+                    return 'function\n' +
+                        `${func}\n` +
+                        `${args.length}\n` +
+                        `${Number(DDB.le_client)}\n`;
+                case 'script':
+                    return 'script\n' +
+                        script;
+                case 'variable':
+                    return 'variable\n' +
+                        `${vars.join(',')}\n` +
+                        `${vars.length}\n` +
+                        `${Number(DDB.le_client)}\n`;
+            }
+        })());
+        const message = (0, utils_browser_1.concat)([
+            this.enc.encode(`API ${this.sid} ${command.length}${urgent ? ` / 1_1_8_8` : ''}\n`),
+            command,
+            ...args.map((arg) => arg.pack())
+        ]);
+        this.ws.send(message);
+        return DdbObj.parse(await presult, // data_buf
+        this.le);
+    }
+    /** eval script through websocket (script command) */
+    async eval(
+    /** 执行的脚本 */
+    script, 
+    /** 执行选项 */
+    { urgent } = {}) {
+        return this.rpc('script', { script, urgent });
+    }
+    /** call function through websocket (function command)
+        - func: 函数名
+        - args?: `[ ]` 调用参数 (传入的原生 string 和 boolean 会被自动转换为 DdbObj<string> 和 DdbObj<boolean>)
+        - options?: 调用选项
+            - urgent?: 紧急 flag，使用 urgent worker 处理，防止被其它作业阻塞
+            - node?: 设置结点 alias 时发送到集群中对应的结点执行 (使用 DolphinDB 中的 rpc 方法)
+            - nodes?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
+            - func_type?: 设置 node 参数时必传，需指定函数类型，其它情况下不传
+            - add_node_alias?: 设置 nodes 参数时选传，其它情况不传
+    */
+    async call(func, args = [], { urgent, node, nodes, func_type, add_node_alias } = {}) {
+        if (node) {
+            if (typeof func_type === 'undefined')
+                throw new Error('指定 node 时必须设置 func_type');
+            args = [
+                node,
+                new DdbFunction(func, func_type),
+                ...args
+            ];
+            func = 'rpc';
+        }
+        if (nodes) {
+            args = [
+                new DdbVectorString(nodes),
+                func,
+                new DdbVectorAny(this.to_ddbobjs(args)),
+                ...typeof add_node_alias === 'undefined' ? [] : [add_node_alias]
+            ];
+            func = 'pnode_run';
+        }
+        return this.rpc('function', {
+            func,
+            args,
+            urgent,
+        });
+    }
+    /** upload variable through websocket (variable command) */
+    async upload(
+    /** 上传的变量名 */
+    vars, 
+    /** 上传的变量值 */
+    args) {
+        if (!args.length || args.length !== vars.length)
+            throw new Error('variable 指令参数为空或参数名为空，或数量不匹配');
+        return this.rpc('variable', { vars, args });
+    }
+    /** 解析服务端响应报文，返回去掉 header 的 data buf */
+    parse_message(buf) {
+        // '1166953221 1 1\n'
+        // 'OK\n'
+        // '\x04\x00\x02\x00\x00\x00'
+        /** index of line feed 0 */
+        const i_lf_0 = buf.indexOf(0x0a); // '\n'
+        const parts = this.dec.decode(buf.subarray(0, i_lf_0)).split(' ');
+        /** session id */
+        const sid = parts[0];
+        if (sid !== this.sid) {
+            console.log(`sid 从 ${this.sid} 变为 ${sid}`);
+            this.sid = sid;
+        }
+        /** 返回对象的数量 */
+        const n_obj = Number(parts[1]);
+        /** 大小端: 协议中大端为 0, 小端为 1 */
+        this.le = Number(parts[2]) !== 0;
+        const i_ls_1 = i_lf_0 + 1;
+        const i_lf_1 = buf.indexOf(0x0a, i_ls_1); // '\n'
+        /** 'OK' 表示成功，其它文本表示失败 */
+        const message = this.dec.decode(buf.subarray(i_ls_1, i_lf_1));
+        if (message !== 'OK')
+            throw new Error(message);
+        return buf.subarray(i_lf_1 + 1);
+    }
+    /** 自动转换 js string, boolean 为 DdbObj */
+    to_ddbobj(value) {
+        if (value instanceof DdbObj)
+            return value;
+        const type = typeof value;
+        switch (type) {
+            case 'string':
+                return new DdbString(value);
+            case 'boolean':
+                return new DdbBool(value);
+            default:
+                throw new Error(`不能自动转换 ${type} 至 DdbObj`);
+        }
+    }
+    /** 转换 js 数组为 DdbObj[] (in place, 会修改原数组) */
+    to_ddbobjs(values) {
+        for (let i = 0; i < values.length; i++)
+            values[i] = this.to_ddbobj(values[i]);
+        return values;
+    }
+}
+exports.DDB = DDB;
+/** little endian (client) */
+DDB.le_client = Boolean(new Uint8Array(Uint32Array.of(1).buffer)[0]);
+exports.ddb = window.ddb = new DDB();
+exports.default = exports.ddb;
+//# sourceMappingURL=browser.js.map