@cloudpss/ubjson 0.4.32 → 0.4.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudpss/ubjson",
-  "version": "0.4.32",
+  "version": "0.4.34",
   "author": "CloudPSS",
   "license": "MIT",
   "keywords": [
@@ -50,7 +50,8 @@
   },
   "devDependencies": {
     "@msgpack/msgpack": "^3.0.0-beta2",
-    "@types/lodash": "^4.14.197"
+    "@types/lodash": "^4.14.197",
+    "msgpackr": "^1.9.7"
   },
   "dependencies": {
     "rxjs": "^7.8.1"

package/src/common/constants.ts

@@ -1,24 +1,25 @@
 /** Constants of markers */
+export const enum constants {
+    NULL = 90, //'Z'.charCodeAt(0)
+    NO_OP = 78, //'N'.charCodeAt(0)
+    TRUE = 84, //'T'.charCodeAt(0)
+    FALSE = 70, //'F'.charCodeAt(0)
+    INT8 = 105, //'i'.charCodeAt(0)
+    UINT8 = 85, //'U'.charCodeAt(0)
+    INT16 = 73, //'I'.charCodeAt(0)
+    INT32 = 108, //'l'.charCodeAt(0)
+    INT64 = 76, //'L'.charCodeAt(0)
+    FLOAT32 = 100, //'d'.charCodeAt(0)
+    FLOAT64 = 68, //'D'.charCodeAt(0)
+    HIGH_PRECISION_NUMBER = 72, //'H'.charCodeAt(0)
+    CHAR = 67, //'C'.charCodeAt(0)
+    STRING = 83, //'S'.charCodeAt(0)
 
-export const NULL = 'Z'.charCodeAt(0);
-export const NO_OP = 'N'.charCodeAt(0);
-export const TRUE = 'T'.charCodeAt(0);
-export const FALSE = 'F'.charCodeAt(0);
-export const INT8 = 'i'.charCodeAt(0);
-export const UINT8 = 'U'.charCodeAt(0);
-export const INT16 = 'I'.charCodeAt(0);
-export const INT32 = 'l'.charCodeAt(0);
-export const INT64 = 'L'.charCodeAt(0);
-export const FLOAT32 = 'd'.charCodeAt(0);
-export const FLOAT64 = 'D'.charCodeAt(0);
-export const HIGH_PRECISION_NUMBER = 'H'.charCodeAt(0);
-export const CHAR = 'C'.charCodeAt(0);
-export const STRING = 'S'.charCodeAt(0);
+    ARRAY = 91, //'['.charCodeAt(0)
+    ARRAY_END = 93, //']'.charCodeAt(0)
+    OBJECT = 123, //'{'.charCodeAt(0)
+    OBJECT_END = 125, //'}'.charCodeAt(0)
 
-export const ARRAY = '['.charCodeAt(0);
-export const ARRAY_END = ']'.charCodeAt(0);
-export const OBJECT = '{'.charCodeAt(0);
-export const OBJECT_END = '}'.charCodeAt(0);
-
-export const TYPE_MARKER = '$'.charCodeAt(0);
-export const COUNT_MARKER = '#'.charCodeAt(0);
+    TYPE_MARKER = 36, //'$'.charCodeAt(0)
+    COUNT_MARKER = 35, //'#'.charCodeAt(0)
+}

package/src/common/decoder.ts

@@ -1,44 +1,40 @@
-import * as constants from './constants.js';
-import { StringDecoder } from './string-decoder.js';
+import { UnexpectedEof, toUint8Array } from '../utils.js';
+import { constants } from './constants.js';
+import { decode, decodeKey } from './string-decoder.js';
 
-/** 未结束的流 */
-export class UnexpectedEof extends Error {
-    constructor() {
-        super('Unexpected EOF');
-    }
-}
+const fromEntries = Object.fromEntries;
 
 /** decoder */
 export class Decoder {
     protected readonly view: DataView;
+    protected readonly data: Uint8Array;
     /** 当前读指针位置 */
     protected offset = 0;
-    constructor(readonly data: Uint8Array) {
-        this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    constructor(data: BinaryData) {
+        this.data = toUint8Array(data, true);
+        this.view = new DataView(this.data.buffer, this.data.byteOffset, this.data.byteLength);
     }
     /** 解码 */
     decode(): unknown {
-        return this.read();
-    }
-
-    /** 检查是否有给定字节数的未读数据 */
-    protected ensureData(byteLength: number): void {
-        if (this.offset + byteLength > this.data.byteLength) {
-            throw new UnexpectedEof();
-        }
+        const marker = this.readMarker();
+        if (marker === undefined) return undefined;
+        return this.readData(marker);
     }
 
     /** 读取数据 */
     private read(): unknown {
-        return this.readData(this.readMarker());
+        const marker = this.readMarker();
+        if (marker === undefined) {
+            throw new UnexpectedEof();
+        }
+        return this.readData(marker);
     }
 
     /** 读取 marker，跳过 noop */
-    private readMarker(): number {
+    private readMarker(): number | undefined {
         let marker = constants.NO_OP;
         do {
-            if (this.offset >= this.data.byteLength) break;
-            marker = this.view.getUint8(this.offset++);
+            marker = this.data[this.offset++];
         } while (marker === constants.NO_OP);
         return marker;
     }
@@ -47,12 +43,126 @@ export class Decoder {
     private readData(marker: number): unknown {
         // 按照出现频率排序
         switch (marker) {
-            case constants.STRING:
-                return this.readStringData();
-            case constants.ARRAY:
-                return this.readArray();
-            case constants.OBJECT:
-                return this.readObject();
+            case constants.STRING: {
+                const length = this.readIntLength();
+                const begin = this.offset;
+                this.offset += length;
+                return decode(this.data, begin, this.offset);
+            }
+            case constants.OBJECT: {
+                const markers = this.readOptimizedFormatMarkers();
+                if (markers == null) {
+                    // 直到 '}'
+                    const object: Array<[string, unknown]> = [];
+                    while (this.readMarker() !== constants.OBJECT_END) {
+                        this.offset--;
+                        object.push([this.readKey(), this.read()]);
+                    }
+                    return fromEntries(object);
+                }
+
+                const { count, type } = markers;
+                const object: Array<[string, unknown]> = [];
+                object.length = count;
+                for (let i = 0; i < count; i++) {
+                    const key = this.readKey();
+                    const t = type ?? this.readMarker();
+                    if (t === undefined) throw new UnexpectedEof();
+                    const value = this.readData(t);
+                    object[i] = [key, value];
+                }
+                return fromEntries(object);
+            }
+            case constants.ARRAY: {
+                const markers = this.readOptimizedFormatMarkers();
+                if (markers == null) {
+                    const array = [];
+                    // 直到 ']'
+                    while (this.readMarker() !== constants.ARRAY_END) {
+                        this.offset--;
+                        array.push(this.read());
+                    }
+                    return array;
+                }
+
+                const { count, type } = markers;
+                switch (type) {
+                    case constants.UINT8:
+                        try {
+                            const buf = new Uint8Array(
+                                this.data.buffer,
+                                this.data.byteOffset + this.offset,
+                                count,
+                            ).slice();
+                            this.offset += count;
+                            return buf;
+                        } catch {
+                            throw new UnexpectedEof();
+                        }
+                    case constants.INT8:
+                        try {
+                            const buf = new Int8Array(
+                                this.data.buffer,
+                                this.data.byteOffset + this.offset,
+                                count,
+                            ).slice();
+                            this.offset += count;
+                            return buf;
+                        } catch {
+                            throw new UnexpectedEof();
+                        }
+                    case constants.INT16: {
+                        const result = new Int16Array(count);
+                        for (let i = 0; i < count; i++) {
+                            result[i] = this.readInt16Data();
+                        }
+                        return result;
+                    }
+                    case constants.INT32: {
+                        const result = new Int32Array(count);
+                        for (let i = 0; i < count; i++) {
+                            result[i] = this.readInt32Data();
+                        }
+                        return result;
+                    }
+                    case constants.FLOAT32: {
+                        const result = new Float32Array(count);
+                        for (let i = 0; i < count; i++) {
+                            result[i] = this.readFloat32Data();
+                        }
+                        return result;
+                    }
+                    case constants.FLOAT64: {
+                        const result = new Float64Array(count);
+                        for (let i = 0; i < count; i++) {
+                            result[i] = this.readFloat64Data();
+                        }
+                        return result;
+                    }
+                    case constants.INT64: {
+                        const result = new BigInt64Array(count);
+                        for (let i = 0; i < count; i++) {
+                            result[i] = this.readInt64Data();
+                        }
+                        throw new Error('Unsupported type int64');
+                        //return result;
+                    }
+                    case constants.NULL:
+                        return Array.from({ length: count }).fill(null);
+                    case constants.TRUE:
+                        return Array.from({ length: count }).fill(true);
+                    case constants.FALSE:
+                        return Array.from({ length: count }).fill(false);
+                    default:
+                        break;
+                }
+                const array: unknown[] = [];
+                array.length = count;
+                for (let i = 0; i < count; i++) {
+                    array[i] = type == null ? this.read() : this.readData(type);
+                }
+                return array;
+            }
             case constants.FLOAT64:
                 return this.readFloat64Data();
             case constants.UINT8:
@@ -62,7 +172,7 @@ export class Decoder {
             case constants.FLOAT32:
                 return this.readFloat32Data();
             case constants.CHAR:
-                return this.readCharData();
+                return String.fromCharCode(this.readUint8Data());
             case constants.INT32:
                 return this.readInt32Data();
             case constants.INT8:
@@ -73,12 +183,19 @@ export class Decoder {
                 return true;
             case constants.FALSE:
                 return false;
-            case constants.NO_OP:
-                return undefined;
             case constants.INT64:
                 return this.readInt64Data();
-            case constants.HIGH_PRECISION_NUMBER:
-                return this.readHighPrecisionNumberData();
+            case constants.HIGH_PRECISION_NUMBER: {
+                const length = this.readIntLength();
+                try {
+                    const _buffer = new Uint8Array(this.data.buffer, this.offset, length).slice();
+                    this.offset += length;
+                    // return buffer;
+                } catch {
+                    throw new UnexpectedEof();
+                }
+                throw new Error('Unsupported type high precision number');
+            }
         }
         throw new Error(`Unexpected marker '${String.fromCharCode(marker)}'(${marker})`);
     }
@@ -86,6 +203,7 @@ export class Decoder {
     /** 读取一个大于 0 的整数 */
     private readIntLength(): number {
         const marker = this.readMarker();
+        if (marker === undefined) throw new UnexpectedEof();
         let length;
         switch (marker) {
             case constants.INT8:
@@ -112,78 +230,77 @@ export class Decoder {
         return length;
     }
 
-    /** 字符串解码 */
-    private readonly stringDecoder = new StringDecoder();
-    /** readStringData */
-    private readStringData(): string {
+    /** readKey */
+    private readKey(): string {
         const length = this.readIntLength();
-        this.ensureData(length);
         const begin = this.offset;
         this.offset += length;
-        return this.stringDecoder.decode(this.data, begin, this.offset);
-    }
-    /** readHighPrecisionNumberData */
-    private readHighPrecisionNumberData(): never {
-        const length = this.readIntLength();
-        this.ensureData(length);
-        throw new Error('Unsupported type high precision number');
-        // const buffer = this.data.subarray(this.offset, this.offset + length);
-        // this.offset += length;
-        // return buffer.slice();
-    }
-    /** readStringData */
-    private readCharData(): string {
-        return String.fromCharCode(this.readUint8Data());
+        return decodeKey(this.data, begin, this.offset);
     }
     /** readInt8Data */
     private readInt8Data(): number {
-        this.ensureData(1);
-        const result = this.view.getInt8(this.offset);
-        this.offset += 1;
-        return result;
+        try {
+            return this.view.getInt8(this.offset++);
+        } catch {
+            throw new UnexpectedEof();
+        }
     }
     /** readUint8Data */
     private readUint8Data(): number {
-        this.ensureData(1);
-        const result = this.view.getUint8(this.offset);
-        this.offset += 1;
-        return result;
+        const num = this.data[this.offset++];
+        if (num === undefined) throw new UnexpectedEof();
+        return num;
     }
     /** readInt16Data */
     private readInt16Data(): number {
-        this.ensureData(2);
-        const result = this.view.getInt16(this.offset);
-        this.offset += 2;
-        return result;
+        try {
+            const result = this.view.getInt16(this.offset);
+            this.offset += 2;
+            return result;
+        } catch {
+            throw new UnexpectedEof();
+        }
     }
     /** readInt32Data */
     private readInt32Data(): number {
-        this.ensureData(4);
-        const result = this.view.getInt32(this.offset);
-        this.offset += 4;
-        return result;
+        try {
+            const result = this.view.getInt32(this.offset);
+            this.offset += 4;
+            return result;
+        } catch {
+            throw new UnexpectedEof();
+        }
     }
     /** readInt64Data */
     private readInt64Data(): never {
-        this.ensureData(8);
+        try {
+            const _result = this.view.getBigInt64(this.offset);
+            this.offset += 8;
+            // return result;
+        } catch {
+            throw new UnexpectedEof();
+        }
         throw new Error('Unsupported type int64');
-        // const result = this.view.getBigInt64(this.offset);
-        // this.offset += 8;
-        // return result;
     }
     /** readFloat32Data */
     private readFloat32Data(): number {
-        this.ensureData(4);
-        const result = this.view.getFloat32(this.offset);
-        this.offset += 4;
-        return result;
+        try {
+            const result = this.view.getFloat32(this.offset);
+            this.offset += 4;
+            return result;
+        } catch {
+            throw new UnexpectedEof();
+        }
     }
     /** readFloat64Data */
     private readFloat64Data(): number {
-        this.ensureData(8);
-        const result = this.view.getFloat64(this.offset);
-        this.offset += 8;
-        return result;
+        try {
+            const result = this.view.getFloat64(this.offset);
+            this.offset += 8;
+            return result;
+        } catch {
+            throw new UnexpectedEof();
+        }
     }
 
     /** 读取 Optimized Format 数据 */
@@ -207,86 +324,4 @@ export class Decoder {
         }
         return { type, count };
     }
-
-    /** 读取数组 */
-    private readArray(): unknown[] | ArrayBufferView {
-        const markers = this.readOptimizedFormatMarkers();
-        if (markers == null) {
-            const array = [];
-            // 直到 ']'
-            while (this.readMarker() !== constants.ARRAY_END) {
-                this.offset--;
-                array.push(this.read());
-            }
-            return array;
-        }
-
-        const { count, type } = markers;
-        switch (type) {
-            case constants.UINT8:
-                this.ensureData(count);
-                this.offset += count;
-                return new Uint8Array(this.data.buffer, this.data.byteOffset + this.offset - count, count).slice();
-            case constants.INT8:
-                this.ensureData(count);
-                this.offset += count;
-                return new Int8Array(this.data.buffer, this.data.byteOffset + this.offset - count, count).slice();
-            case constants.INT16:
-                this.ensureData(count * 2);
-                return Int16Array.from({ length: count }, () => this.readInt16Data());
-            case constants.INT32:
-                this.ensureData(count * 4);
-                return Int32Array.from({ length: count }, () => this.readInt32Data());
-            case constants.FLOAT32:
-                this.ensureData(count * 4);
-                return Float32Array.from({ length: count }, () => this.readFloat32Data());
-            case constants.FLOAT64: {
-                this.ensureData(count * 8);
-                const result = new Float64Array(count);
-                for (let i = 0; i < count; i++) {
-                    result[i] = this.readFloat64Data();
-                }
-                return result;
-            }
-            case constants.NULL:
-                return Array.from({ length: count }).fill(null);
-            case constants.TRUE:
-                return Array.from({ length: count }).fill(true);
-            case constants.FALSE:
-                return Array.from({ length: count }).fill(false);
-            case constants.INT64:
-                this.ensureData(count * 8);
-                return BigInt64Array.from({ length: count }, () => this.readInt64Data());
-            default:
-                break;
-        }
-        const array: unknown[] = [];
-        array.length = count;
-        for (let i = 0; i < count; i++) {
-            array[i] = type == null ? this.read() : this.readData(type);
-        }
-        return array;
-    }
-
-    /** 读对象 */
-    private readObject(): Record<string, unknown> {
-        const markers = this.readOptimizedFormatMarkers();
-        if (markers == null) {
-            // 直到 '}'
-            const object: Array<[string, unknown]> = [];
-            while (this.readMarker() !== constants.OBJECT_END) {
-                this.offset--;
-                object.push([this.readStringData(), this.read()]);
-            }
-            return Object.fromEntries(object);
-        }
-
-        const { count, type } = markers;
-        const object: Array<[string, unknown]> = [];
-        object.length = count;
-        for (let i = 0; i < count; i++) {
-            object[i] = [this.readStringData(), type == null ? this.read() : this.readData(type)];
-        }
-        return Object.fromEntries(object);
-    }
 }