@cloudpss/ubjson 0.5.37 → 0.5.39

package/src/{common → base}/encoder.ts

@@ -1,6 +1,7 @@
-import { constants } from './constants.js';
-import { unsupportedType, unsupportedView } from './errors.js';
-import { stringByteLength, encodeInto } from './string-encoder.js';
+import { constants } from '../helper/constants.js';
+import { type EncodeCursor, writeLength, writeTypedArrayHeader } from '../helper/encode.js';
+import { unsupportedType, unsupportedView } from '../helper/errors.js';
+import { stringByteLength, encodeInto } from '../helper/string-encoder.js';
 
 const LARGE_DATA_LENGTH = 65536;
 
@@ -9,7 +10,7 @@ export abstract class EncoderBase {
     /** 当前写指针位置 */
     protected length = 0;
     /** 数据 */
-    protected buffer!: Uint8Array;
+    protected data!: Uint8Array;
     /** buffer 的 DataView */
     protected view!: DataView;
     /**
@@ -17,11 +18,11 @@ export abstract class EncoderBase {
      */
     protected abstract ensureCapacity(capacity: number): void;
 
-    /** 编码至 ubjson */
+    /** 编码至 ubjson，对于 `undefined` 写入 NOOP */
     protected writeValue(value: unknown): void {
         if (value === undefined) {
             this.ensureCapacity(1);
-            this.buffer[this.length++] = constants.NO_OP;
+            this.data[this.length++] = constants.NO_OP;
             return;
         }
         this.write(value);
@@ -30,14 +31,14 @@ export abstract class EncoderBase {
     private write(value: unknown): void {
         switch (typeof value) {
             case 'string':
-                if (value.length === 1 && value.charCodeAt(0) < 128) {
+                if (value.length === 1 && value.charCodeAt(0) < 0x80) {
                     // 1 byte ascii char
                     this.ensureCapacity(2);
-                    this.buffer[this.length++] = constants.CHAR;
-                    this.buffer[this.length++] = value.charCodeAt(0);
+                    this.data[this.length++] = constants.CHAR;
+                    this.data[this.length++] = value.charCodeAt(0);
                 } else {
                     this.ensureCapacity(2);
-                    this.buffer[this.length++] = constants.STRING;
+                    this.data[this.length++] = constants.STRING;
                     this.writeStringData(value);
                 }
                 return;
@@ -46,32 +47,32 @@ export abstract class EncoderBase {
                 if ((value | 0) === value) {
                     if (value >= 0 && value <= 255) {
                         this.ensureCapacity(2);
-                        this.buffer[this.length++] = constants.UINT8;
-                        this.buffer[this.length++] = value;
+                        this.data[this.length++] = constants.UINT8;
+                        this.data[this.length++] = value;
                     } else if (value >= -128 && value <= 127) {
                         this.ensureCapacity(2);
-                        this.buffer[this.length++] = constants.INT8;
-                        this.buffer[this.length++] = value;
+                        this.data[this.length++] = constants.INT8;
+                        this.data[this.length++] = value;
                     } else if (value >= -32768 && value <= 32767) {
                         this.ensureCapacity(3);
-                        this.buffer[this.length++] = constants.INT16;
-                        this.buffer[this.length++] = value >> 8;
-                        this.buffer[this.length++] = value & 0xff;
+                        this.data[this.length++] = constants.INT16;
+                        this.data[this.length++] = value >> 8;
+                        this.data[this.length++] = value & 0xff;
                     } else {
                         this.ensureCapacity(5);
-                        this.buffer[this.length++] = constants.INT32;
+                        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.buffer[this.length++] = constants.FLOAT32;
+                    this.data[this.length++] = constants.FLOAT32;
                     this.view.setFloat32(this.length, value);
                     this.length += 4;
                 } else {
                     this.ensureCapacity(9);
-                    this.buffer[this.length++] = constants.FLOAT64;
+                    this.data[this.length++] = constants.FLOAT64;
                     this.view.setFloat64(this.length, value);
                     this.length += 8;
                 }
@@ -79,25 +80,25 @@ export abstract class EncoderBase {
             case 'object': {
                 if (value === null) {
                     this.ensureCapacity(1);
-                    this.buffer[this.length++] = constants.NULL;
+                    this.data[this.length++] = constants.NULL;
                     return;
                 }
                 if (Array.isArray(value)) {
                     this.ensureCapacity(1);
-                    this.buffer[this.length++] = constants.ARRAY;
+                    this.data[this.length++] = constants.ARRAY;
                     const size = value.length;
                     for (let index = 0; index < size; index++) {
                         const element = value[index] as unknown;
                         // 在数组中 undefined 和 function 也被视作 null 进行序列化
                         if (element == null || typeof element == 'function') {
                             this.ensureCapacity(1);
-                            this.buffer[this.length++] = constants.NULL;
+                            this.data[this.length++] = constants.NULL;
                         } else {
                             this.write(element);
                         }
                     }
                     this.ensureCapacity(1);
-                    this.buffer[this.length++] = constants.ARRAY_END;
+                    this.data[this.length++] = constants.ARRAY_END;
                     return;
                 }
                 if (!ArrayBuffer.isView(value)) {
@@ -107,7 +108,7 @@ export abstract class EncoderBase {
                         return;
                     }
                     this.ensureCapacity(1);
-                    this.buffer[this.length++] = constants.OBJECT;
+                    this.data[this.length++] = constants.OBJECT;
                     // 生成稳定的结果以便 hash 计算
                     const keys = Object.keys(value).sort();
                     const size = keys.length;
@@ -119,45 +120,24 @@ export abstract class EncoderBase {
                         this.write(element);
                     }
                     this.ensureCapacity(1);
-                    this.buffer[this.length++] = constants.OBJECT_END;
+                    this.data[this.length++] = constants.OBJECT_END;
                     return;
                 }
                 if (value.byteLength > LARGE_DATA_LENGTH) {
                     // ARRAY(1) + TYPE_MARKER(1) + TYPE(1) + COUNT_MARKER(1) + COUNT(5)
-                    this.ensureCapacity(9);
-                    this.buffer[this.length++] = constants.ARRAY;
-                    this.buffer[this.length++] = constants.TYPE_MARKER;
-                    if (value instanceof Uint8Array) {
-                        this.buffer[this.length++] = constants.UINT8;
-                    } else if (value instanceof Int8Array) {
-                        this.buffer[this.length++] = constants.INT8;
-                    } else if (value instanceof Int16Array) {
-                        this.buffer[this.length++] = constants.INT16;
-                    } else if (value instanceof Int32Array) {
-                        this.buffer[this.length++] = constants.INT32;
-                    } else if (value instanceof Float32Array) {
-                        this.buffer[this.length++] = constants.FLOAT32;
-                    } else if (value instanceof Float64Array) {
-                        this.buffer[this.length++] = constants.FLOAT64;
-                    } else if (value instanceof BigInt64Array) {
-                        this.buffer[this.length++] = constants.INT64;
-                    } else {
-                        unsupportedView(value);
-                    }
-                    this.buffer[this.length++] = constants.COUNT_MARKER;
-                    this.setLength(value.length);
+                    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.buffer[this.length++] = constants.ARRAY;
-                    this.buffer[this.length++] = constants.TYPE_MARKER;
+                    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.buffer[this.length++] = value instanceof Uint8Array ? constants.UINT8 : constants.INT8;
-                        this.buffer[this.length++] = constants.COUNT_MARKER;
-                        this.setLength(value.length);
-                        this.buffer.set(value, this.length);
+                        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;
                     }
@@ -166,42 +146,42 @@ export abstract class EncoderBase {
                         .length;
                     const elementSize = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array)
                         .BYTES_PER_ELEMENT;
-                    if (value instanceof Int16Array) {
-                        this.buffer[this.length++] = constants.INT16;
-                        this.buffer[this.length++] = constants.COUNT_MARKER;
-                        this.setLength(arrayLength);
+                    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.setInt16(this.length, value[i]!);
+                            this.view.setFloat64(this.length, value[i]!);
                             this.length += elementSize;
                         }
                     } else if (value instanceof Int32Array) {
-                        this.buffer[this.length++] = constants.INT32;
-                        this.buffer[this.length++] = constants.COUNT_MARKER;
-                        this.setLength(arrayLength);
+                        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 Float32Array) {
-                        this.buffer[this.length++] = constants.FLOAT32;
-                        this.buffer[this.length++] = constants.COUNT_MARKER;
-                        this.setLength(arrayLength);
+                    } 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.setFloat32(this.length, value[i]!);
+                            this.view.setInt16(this.length, value[i]!);
                             this.length += elementSize;
                         }
-                    } else if (value instanceof Float64Array) {
-                        this.buffer[this.length++] = constants.FLOAT64;
-                        this.buffer[this.length++] = constants.COUNT_MARKER;
-                        this.setLength(arrayLength);
+                    } 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.setFloat64(this.length, value[i]!);
+                            this.view.setFloat32(this.length, value[i]!);
                             this.length += elementSize;
                         }
                     } else if (value instanceof BigInt64Array) {
-                        this.buffer[this.length++] = constants.INT64;
-                        this.buffer[this.length++] = constants.COUNT_MARKER;
-                        this.setLength(arrayLength);
+                        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;
@@ -214,7 +194,7 @@ export abstract class EncoderBase {
             }
             case 'boolean':
                 this.ensureCapacity(1);
-                this.buffer[this.length++] = value ? constants.TRUE : constants.FALSE;
+                this.data[this.length++] = value ? constants.TRUE : constants.FALSE;
                 return;
             case 'bigint':
                 // int32 range
@@ -224,7 +204,7 @@ export abstract class EncoderBase {
                 // int64 range
                 else if (value >= -9_223_372_036_854_775_808n && value <= 9_223_372_036_854_775_807n) {
                     this.ensureCapacity(9);
-                    this.buffer[this.length++] = constants.INT64;
+                    this.data[this.length++] = constants.INT64;
                     this.view.setBigInt64(this.length, value);
                     this.length += 8;
                 } else {
@@ -249,24 +229,24 @@ export abstract class EncoderBase {
         this.ensureCapacity(maxUsage + 5 + 3);
 
         // 预估头部大小
-        const headerSize = strLength < 128 ? 2 : strLength < 32768 ? 3 : 5;
+        const headerSize = strLength < 0x80 ? 2 : strLength < 0x8000 ? 3 : 5;
         const headerPos = this.length;
-        const bufLength = encodeInto(value, this.buffer, this.length + headerSize);
-        if (bufLength < 128) {
-            this.buffer[this.length++] = constants.INT8;
-            this.buffer[this.length++] = bufLength;
-        } else if (bufLength < 32768) {
+        const bufLength = encodeInto(value, this.data, this.length + headerSize);
+        if (bufLength < 0x80) {
+            this.data[this.length++] = constants.INT8;
+            this.data[this.length++] = bufLength;
+        } else if (bufLength < 0x8000) {
             if (headerSize < 3) {
-                this.buffer.copyWithin(headerPos + 3, headerPos + headerSize, headerPos + headerSize + bufLength);
+                this.data.copyWithin(headerPos + 3, headerPos + headerSize, headerPos + headerSize + bufLength);
             }
-            this.buffer[this.length++] = constants.INT16;
-            this.buffer[this.length++] = bufLength >> 8;
-            this.buffer[this.length++] = bufLength & 0xff;
+            this.data[this.length++] = constants.INT16;
+            this.data[this.length++] = bufLength >> 8;
+            this.data[this.length++] = bufLength & 0xff;
         } else {
             if (headerSize < 5) {
-                this.buffer.copyWithin(headerPos + 5, headerPos + headerSize, headerPos + headerSize + bufLength);
+                this.data.copyWithin(headerPos + 5, headerPos + headerSize, headerPos + headerSize + bufLength);
             }
-            this.buffer[this.length++] = constants.INT32;
+            this.data[this.length++] = constants.INT32;
             this.view.setInt32(this.length, bufLength);
             this.length += 4;
         }
@@ -277,11 +257,11 @@ export abstract class EncoderBase {
     protected writeLargeStringData(value: string): void {
         const binLen = stringByteLength(value);
         this.ensureCapacity(5);
-        this.buffer[this.length++] = constants.INT32;
+        this.data[this.length++] = constants.INT32;
         this.view.setInt32(this.length, binLen);
         this.length += 4;
         this.ensureCapacity(binLen);
-        encodeInto(value, this.buffer, this.length);
+        encodeInto(value, this.data, this.length);
         this.length += binLen;
     }
 
@@ -290,7 +270,7 @@ export abstract class EncoderBase {
         this.ensureCapacity(value.byteLength);
         if (value instanceof Uint8Array || value instanceof Int8Array) {
             // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
-            this.buffer.set(value, this.length);
+            this.data.set(value, this.length);
             this.length += value.byteLength;
             return;
         }
@@ -327,28 +307,4 @@ export abstract class EncoderBase {
             unsupportedView(value);
         }
     }
-
-    /**
-     * 写入整形数字，选取合适的大小，需提前分配空间
-     */
-    private setLength(value: number): number {
-        // eslint-disable-next-line unicorn/prefer-math-trunc
-        value = value | 0;
-        if ((value & 0x7f) === value) {
-            this.buffer[this.length++] = constants.INT8;
-            this.buffer[this.length++] = value;
-            return 1;
-        }
-        // 不使用 uint8 以保持兼容
-        if ((value & 0x7fff) === value) {
-            this.buffer[this.length++] = constants.INT16;
-            this.buffer[this.length++] = value >> 8;
-            this.buffer[this.length++] = value & 0xff;
-            return 2;
-        }
-        this.buffer[this.length++] = constants.INT32;
-        this.view.setInt32(this.length, value);
-        this.length += 4;
-        return 4;
-    }
 }

package/src/decoder.ts

@@ -1,5 +1,4 @@
-import { DecoderBase } from './common/decoder.js';
-export type { DecoderOptions } from './common/decoder.js';
+import { DecoderBase } from './base/decoder.js';
 
 /** 解码 UBJSON */
 export class Decoder extends DecoderBase {

package/src/encoder.ts

@@ -1,4 +1,4 @@
-import { EncoderBase } from './common/encoder.js';
+import { EncoderBase } from './base/encoder.js';
 
 const BLOCK_SIZE = 1024 * 16; // 16 KiB
 const MAX_SIZE = 1024 * 1024 * 128; //128 MiB
@@ -17,13 +17,13 @@ export class Encoder extends EncoderBase {
             throw new Error('Buffer has exceed max size');
         }
         // 无需扩容
-        if (this.buffer.byteLength >= this.length + capacity) return;
+        if (this.data.byteLength >= this.length + capacity) return;
 
         // 提交目前的数据
-        if (this.buffer === this.pool) {
-            this.flushedBuffers.push(this.buffer.slice(0, this.length));
+        if (this.data === this.pool) {
+            this.flushedBuffers.push(this.data.slice(0, this.length));
         } else {
-            this.flushedBuffers.push(this.buffer.subarray(0, this.length));
+            this.flushedBuffers.push(this.data.subarray(0, this.length));
         }
 
         // 重新分配缓冲区
@@ -35,13 +35,13 @@ export class Encoder extends EncoderBase {
     private allocUnsafe(size: number): void {
         if (size === this.pool.byteLength) {
             // 从 pool 中获取
-            this.buffer = this.pool;
-            this.view = new DataView(this.buffer.buffer);
+            this.data = this.pool;
+            this.view = new DataView(this.data.buffer);
             this.length = 0;
             return;
         }
-        this.buffer = new Uint8Array(size);
-        this.view = new DataView(this.buffer.buffer);
+        this.data = new Uint8Array(size);
+        this.view = new DataView(this.data.buffer);
         this.length = 0;
     }
 
@@ -49,7 +49,7 @@ export class Encoder extends EncoderBase {
     private getResult(): Uint8Array {
         if (this.flushedBuffers.length === 0) {
             // 缓冲区为空，复制当前 buffer
-            return this.buffer.slice(0, this.length);
+            return this.data.slice(0, this.length);
         }
 
         // 合并缓冲区
@@ -61,7 +61,7 @@ export class Encoder extends EncoderBase {
             result.set(buffer, offset);
             offset += buffer.byteLength;
         }
-        result.set(this.buffer.subarray(0, this.length), offset);
+        result.set(this.data.subarray(0, this.length), offset);
         return result;
     }