@cloudpss/ubjson 0.5.39 → 0.5.41

package/src/base/encoder.ts

@@ -1,12 +1,26 @@
 import { constants } from '../helper/constants.js';
-import { type EncodeCursor, writeLength, writeTypedArrayHeader } from '../helper/encode.js';
-import { unsupportedType, unsupportedView } from '../helper/errors.js';
+import {
+    type EncodeCursor,
+    I8_MASK,
+    type TypedArrayType,
+    writeNumber,
+    writeTypedArray,
+    writeTypedArrayData,
+    writeTypedArrayHeader,
+} from '../helper/encode.js';
+import { unsupportedType } from '../helper/errors.js';
 import { stringByteLength, encodeInto } from '../helper/string-encoder.js';
 
 const LARGE_DATA_LENGTH = 65536;
+const { isArray } = Array;
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const { isView } = ArrayBuffer;
+const { keys: objectKeys } = Object;
 
 /** 编码至 ubjson */
 export abstract class EncoderBase {
+    /** 序列化对象时排序属性 */
+    sortObjectKeys = false;
     /** 当前写指针位置 */
     protected length = 0;
     /** 数据 */
@@ -43,47 +57,14 @@ export abstract class EncoderBase {
                 }
                 return;
             case 'number':
-                // eslint-disable-next-line unicorn/prefer-math-trunc
-                if ((value | 0) === value) {
-                    if (value >= 0 && value <= 255) {
-                        this.ensureCapacity(2);
-                        this.data[this.length++] = constants.UINT8;
-                        this.data[this.length++] = value;
-                    } else if (value >= -128 && value <= 127) {
-                        this.ensureCapacity(2);
-                        this.data[this.length++] = constants.INT8;
-                        this.data[this.length++] = value;
-                    } else if (value >= -32768 && value <= 32767) {
-                        this.ensureCapacity(3);
-                        this.data[this.length++] = constants.INT16;
-                        this.data[this.length++] = value >> 8;
-                        this.data[this.length++] = value & 0xff;
-                    } else {
-                        this.ensureCapacity(5);
-                        this.data[this.length++] = constants.INT32;
-                        this.view.setInt32(this.length, value);
-                        this.length += 4;
-                    }
-                } else if (Number.isNaN(value) || Math.fround(value) === value) {
-                    // 如果不会损失精度，使用 32 位浮点
-                    this.ensureCapacity(5);
-                    this.data[this.length++] = constants.FLOAT32;
-                    this.view.setFloat32(this.length, value);
-                    this.length += 4;
-                } else {
-                    this.ensureCapacity(9);
-                    this.data[this.length++] = constants.FLOAT64;
-                    this.view.setFloat64(this.length, value);
-                    this.length += 8;
-                }
-                return;
+                return writeNumber(this as this & EncodeCursor, value);
             case 'object': {
                 if (value === null) {
                     this.ensureCapacity(1);
                     this.data[this.length++] = constants.NULL;
                     return;
                 }
-                if (Array.isArray(value)) {
+                if (isArray(value)) {
                     this.ensureCapacity(1);
                     this.data[this.length++] = constants.ARRAY;
                     const size = value.length;
@@ -101,95 +82,37 @@ export abstract class EncoderBase {
                     this.data[this.length++] = constants.ARRAY_END;
                     return;
                 }
-                if (!ArrayBuffer.isView(value)) {
-                    const { toJSON } = value as Record<string, unknown>;
-                    if (typeof toJSON == 'function') {
-                        this.write(toJSON.call(value));
+                if (isView(value)) {
+                    if (value.byteLength <= LARGE_DATA_LENGTH) {
+                        writeTypedArray(this as this & EncodeCursor, value);
                         return;
                     }
-                    this.ensureCapacity(1);
-                    this.data[this.length++] = constants.OBJECT;
-                    // 生成稳定的结果以便 hash 计算
-                    const keys = Object.keys(value).sort();
-                    const size = keys.length;
-                    for (let index = 0; index < size; index++) {
-                        const key = keys[index]!;
-                        const element = (value as Record<string, unknown>)[key];
-                        if (element === undefined || typeof element == 'function') continue;
-                        this.writeStringData(key);
-                        this.write(element);
-                    }
-                    this.ensureCapacity(1);
-                    this.data[this.length++] = constants.OBJECT_END;
+                    const type = writeTypedArrayHeader(this as this & EncodeCursor, value);
+                    this.writeLargeTypedArrayData(type, value);
                     return;
                 }
-                if (value.byteLength > LARGE_DATA_LENGTH) {
-                    // ARRAY(1) + TYPE_MARKER(1) + TYPE(1) + COUNT_MARKER(1) + COUNT(5)
-                    writeTypedArrayHeader(this as this & EncodeCursor, value);
-                    this.writeLargeTypedArrayData(value);
-                } else {
-                    // ARRAY(1) + TYPE_MARKER(1) + TYPE(1) + COUNT_MARKER(1) + COUNT(MAX5) + DATA
-                    this.ensureCapacity(9 + value.byteLength);
-                    this.data[this.length++] = constants.ARRAY;
-                    this.data[this.length++] = constants.TYPE_MARKER;
-                    if (value instanceof Uint8Array || value instanceof Int8Array) {
-                        // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
-                        this.data[this.length++] = value instanceof Uint8Array ? constants.UINT8 : constants.INT8;
-                        this.data[this.length++] = constants.COUNT_MARKER;
-                        writeLength(this as this & EncodeCursor, value.length);
-                        this.data.set(value, this.length);
-                        this.length += value.byteLength;
-                        return;
-                    }
-
-                    const arrayLength = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array)
-                        .length;
-                    const elementSize = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array)
-                        .BYTES_PER_ELEMENT;
-                    if (value instanceof Float64Array) {
-                        this.data[this.length++] = constants.FLOAT64;
-                        this.data[this.length++] = constants.COUNT_MARKER;
-                        writeLength(this as this & EncodeCursor, arrayLength);
-                        for (let i = 0; i < arrayLength; i++) {
-                            this.view.setFloat64(this.length, value[i]!);
-                            this.length += elementSize;
-                        }
-                    } else if (value instanceof Int32Array) {
-                        this.data[this.length++] = constants.INT32;
-                        this.data[this.length++] = constants.COUNT_MARKER;
-                        writeLength(this as this & EncodeCursor, arrayLength);
-                        for (let i = 0; i < arrayLength; i++) {
-                            this.view.setInt32(this.length, value[i]!);
-                            this.length += elementSize;
-                        }
-                    } else if (value instanceof Int16Array) {
-                        this.data[this.length++] = constants.INT16;
-                        this.data[this.length++] = constants.COUNT_MARKER;
-                        writeLength(this as this & EncodeCursor, arrayLength);
-                        for (let i = 0; i < arrayLength; i++) {
-                            this.view.setInt16(this.length, value[i]!);
-                            this.length += elementSize;
-                        }
-                    } else if (value instanceof Float32Array) {
-                        this.data[this.length++] = constants.FLOAT32;
-                        this.data[this.length++] = constants.COUNT_MARKER;
-                        writeLength(this as this & EncodeCursor, arrayLength);
-                        for (let i = 0; i < arrayLength; i++) {
-                            this.view.setFloat32(this.length, value[i]!);
-                            this.length += elementSize;
-                        }
-                    } else if (value instanceof BigInt64Array) {
-                        this.data[this.length++] = constants.INT64;
-                        this.data[this.length++] = constants.COUNT_MARKER;
-                        writeLength(this as this & EncodeCursor, arrayLength);
-                        for (let i = 0; i < arrayLength; i++) {
-                            this.view.setBigInt64(this.length, value[i]!);
-                            this.length += elementSize;
-                        }
-                    } else {
-                        unsupportedView(value);
-                    }
+                const { toJSON } = value as Record<string, unknown>;
+                if (typeof toJSON == 'function') {
+                    this.write(toJSON.call(value));
+                    return;
+                }
+                // 生成稳定的结果以便 hash 计算
+                const keys = objectKeys(value);
+                const size = keys.length;
+                if (this.sortObjectKeys && size > 1) {
+                    keys.sort();
                 }
+                this.ensureCapacity(2 + size);
+                this.data[this.length++] = constants.OBJECT;
+                for (let index = 0; index < size; index++) {
+                    const key = keys[index]!;
+                    const element = (value as Record<string, unknown>)[key];
+                    if (element === undefined || typeof element == 'function') continue;
+                    this.writeStringData(key);
+                    this.write(element);
+                }
+                this.ensureCapacity(1);
+                this.data[this.length++] = constants.OBJECT_END;
                 return;
             }
             case 'boolean':
@@ -230,27 +153,26 @@ export abstract class EncoderBase {
 
         // 预估头部大小
         const headerSize = strLength < 0x80 ? 2 : strLength < 0x8000 ? 3 : 5;
-        const headerPos = this.length;
-        const bufLength = encodeInto(value, this.data, this.length + headerSize);
+        const { length: headerPos, data, view } = this;
+        const bufLength = encodeInto(value, data, headerPos + headerSize);
         if (bufLength < 0x80) {
-            this.data[this.length++] = constants.INT8;
-            this.data[this.length++] = bufLength;
+            view.setInt16(headerPos, I8_MASK | bufLength);
+            this.length = headerPos + 2 + bufLength;
         } else if (bufLength < 0x8000) {
             if (headerSize < 3) {
-                this.data.copyWithin(headerPos + 3, headerPos + headerSize, headerPos + headerSize + bufLength);
+                data.copyWithin(headerPos + 3, headerPos + headerSize, headerPos + headerSize + bufLength);
             }
-            this.data[this.length++] = constants.INT16;
-            this.data[this.length++] = bufLength >> 8;
-            this.data[this.length++] = bufLength & 0xff;
+            data[headerPos] = constants.INT16;
+            view.setInt16(headerPos + 1, bufLength);
+            this.length = headerPos + 3 + bufLength;
         } else {
             if (headerSize < 5) {
-                this.data.copyWithin(headerPos + 5, headerPos + headerSize, headerPos + headerSize + bufLength);
+                data.copyWithin(headerPos + 5, headerPos + headerSize, headerPos + headerSize + bufLength);
             }
-            this.data[this.length++] = constants.INT32;
-            this.view.setInt32(this.length, bufLength);
-            this.length += 4;
+            data[headerPos] = constants.INT32;
+            view.setInt32(headerPos + 1, bufLength);
+            this.length = headerPos + 5 + bufLength;
         }
-        this.length += bufLength;
     }
 
     /** 写入大字符串 */
@@ -266,45 +188,7 @@ export abstract class EncoderBase {
     }
 
     /** 写入数组 */
-    protected writeLargeTypedArrayData(value: ArrayBufferView): void {
-        this.ensureCapacity(value.byteLength);
-        if (value instanceof Uint8Array || value instanceof Int8Array) {
-            // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
-            this.data.set(value, this.length);
-            this.length += value.byteLength;
-            return;
-        }
-
-        const arrayLength = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array).length;
-        const elementSize = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array)
-            .BYTES_PER_ELEMENT;
-        if (value instanceof Int16Array) {
-            for (let i = 0; i < arrayLength; i++) {
-                this.view.setInt16(this.length, value[i]!);
-                this.length += elementSize;
-            }
-        } else if (value instanceof Int32Array) {
-            for (let i = 0; i < arrayLength; i++) {
-                this.view.setInt32(this.length, value[i]!);
-                this.length += elementSize;
-            }
-        } else if (value instanceof Float32Array) {
-            for (let i = 0; i < arrayLength; i++) {
-                this.view.setFloat32(this.length, value[i]!);
-                this.length += elementSize;
-            }
-        } else if (value instanceof Float64Array) {
-            for (let i = 0; i < arrayLength; i++) {
-                this.view.setFloat64(this.length, value[i]!);
-                this.length += elementSize;
-            }
-        } else if (value instanceof BigInt64Array) {
-            for (let i = 0; i < arrayLength; i++) {
-                this.view.setBigInt64(this.length, value[i]!);
-                this.length += elementSize;
-            }
-        } else {
-            unsupportedView(value);
-        }
+    protected writeLargeTypedArrayData(type: TypedArrayType, value: ArrayBufferView): void {
+        writeTypedArrayData(this as this & EncodeCursor, type, value);
     }
 }

package/src/encoder.ts

@@ -1,6 +1,7 @@
 import { EncoderBase } from './base/encoder.js';
+import type { EncodeOptions } from './options.js';
 
-const BLOCK_SIZE = 1024 * 16; // 16 KiB
+const BLOCK_SIZE = 1024 * 64; // 64 KiB
 const MAX_SIZE = 1024 * 1024 * 128; //128 MiB
 
 /** 编码至 ubjson */
@@ -8,6 +9,8 @@ export class Encoder extends EncoderBase {
     private readonly flushedBuffers: Uint8Array[] = [];
     /** 通过内存池减少分配 */
     private readonly pool = new Uint8Array(BLOCK_SIZE);
+    /** 缓存当前容量，避免对象访问耗时 */
+    private capacity = 0;
     /**
      * 确保 buffer 还有 capacity 的空闲空间
      */
@@ -16,9 +19,15 @@ export class Encoder extends EncoderBase {
             // 超过最大尺寸限制
             throw new Error('Buffer has exceed max size');
         }
-        // 无需扩容
-        if (this.data.byteLength >= this.length + capacity) return;
+        if (this.capacity >= this.length + capacity) {
+            // 无需扩容
+            return;
+        }
+        this.flushBuffer(capacity);
+    }
 
+    /** 提交并扩容 */
+    protected flushBuffer(capacity: number): void {
         // 提交目前的数据
         if (this.data === this.pool) {
             this.flushedBuffers.push(this.data.slice(0, this.length));
@@ -33,16 +42,16 @@ export class Encoder extends EncoderBase {
 
     /** 分配 buffer */
     private allocUnsafe(size: number): void {
-        if (size === this.pool.byteLength) {
-            // 从 pool 中获取
-            this.data = this.pool;
-            this.view = new DataView(this.data.buffer);
-            this.length = 0;
-            return;
-        }
-        this.data = new Uint8Array(size);
-        this.view = new DataView(this.data.buffer);
+        const data =
+            size === BLOCK_SIZE
+                ? // 从 pool 中获取
+                  this.pool
+                : // 新建 buffer
+                  new Uint8Array(size);
+        this.data = data;
+        this.view = new DataView(data.buffer);
         this.length = 0;
+        this.capacity = size;
     }
 
     /** 获取结果 */
@@ -53,15 +62,17 @@ export class Encoder extends EncoderBase {
         }
 
         // 合并缓冲区
+        const { length } = this;
+        const activeBuffer = this.data.subarray(0, length);
         const flushedBuffers = this.flushedBuffers.splice(0);
-        const size = flushedBuffers.reduce((sum, buffer) => sum + buffer.byteLength, this.length);
+        const size = flushedBuffers.reduce((sum, buffer) => sum + buffer.byteLength, length);
         const result = new Uint8Array(size);
         let offset = 0;
         for (const buffer of flushedBuffers) {
             result.set(buffer, offset);
             offset += buffer.byteLength;
         }
-        result.set(this.data.subarray(0, this.length), offset);
+        result.set(activeBuffer, offset);
         return result;
     }
 
@@ -100,10 +111,11 @@ export class Encoder extends EncoderBase {
 let _ENCODER: Encoder | undefined;
 
 /** 获取默认的编码器 */
-export function getEncoder(): Encoder {
+export function getEncoder(options?: EncodeOptions): Encoder {
     if (_ENCODER == null) {
         _ENCODER = new Encoder();
     }
+    _ENCODER.sortObjectKeys = options?.sortObjectKeys ?? false;
     return _ENCODER;
 }