@cloudpss/ubjson 0.5.10 → 0.5.12

package/src/rxjs/encoder.ts

@@ -5,12 +5,11 @@ import { StreamEncoderHelper } from '../stream-helper/encoder.js';
 export function encode(): OperatorFunction<unknown, Uint8Array> {
     return (observable) => {
         return new Observable<Uint8Array>((subscriber) => {
-            const onChunk = (chunk: Uint8Array): void => subscriber.next(chunk);
-            return observable.subscribe({
+            const helper = new StreamEncoderHelper((chunk: Uint8Array): void => subscriber.next(chunk));
+            const sub = observable.subscribe({
                 next(value) {
                     try {
-                        const helper = new StreamEncoderHelper(value, onChunk);
-                        helper.encode();
+                        helper.encode(value);
                     } catch (ex) {
                         subscriber.error(ex as Error);
                     }
@@ -22,6 +21,8 @@ export function encode(): OperatorFunction<unknown, Uint8Array> {
                     subscriber.complete();
                 },
             });
+            sub.add(() => helper.destroy());
+            return sub;
         });
     };
 }

package/src/stream/encoder.ts

@@ -8,16 +8,24 @@ export class StreamEncoder extends Transform {
             readableObjectMode: false,
             writableObjectMode: true,
         });
+        this.helper = new StreamEncoderHelper((binary) => this.push(binary));
     }
 
+    private readonly helper;
+
     /** @inheritdoc */
     override _transform(obj: unknown, _encoding: BufferEncoding, callback: TransformCallback): void {
-        const helper = new StreamEncoderHelper(obj, (binary) => this.push(binary));
         try {
-            helper.encode();
+            this.helper.encode(obj);
             callback();
         } catch (ex) {
             callback(ex as Error);
         }
     }
+
+    /** @inheritdoc */
+    override _destroy(error: Error | null, callback: (error?: Error | null | undefined) => void): void {
+        this.helper.destroy();
+        super._destroy(error, callback);
+    }
 }

package/src/stream-helper/encoder.ts

@@ -3,14 +3,31 @@ import { EncoderBase } from '../common/encoder.js';
 const BLOCK_SIZE = 1024 * 8; // 8 KiB
 const MAX_SIZE = 1024 * 1024 * 256; // 256 MiB
 
+/** 保存一个内存池以减少重复分配 */
+let POOL: Uint8Array | null = null;
+
 /** 流式编码 UBJSON */
 export class StreamEncoderHelper extends EncoderBase {
-    constructor(
-        value: unknown,
-        protected readonly onChunk: (chunk: Uint8Array) => void,
-    ) {
-        super(value);
+    constructor(protected readonly onChunk: (chunk: Uint8Array) => void) {
+        super();
+        if (POOL != null) {
+            this.pool = POOL;
+            POOL = null;
+        } else {
+            this.pool = new Uint8Array(BLOCK_SIZE);
+        }
+    }
+    /**
+     * 销毁实例，释放内存池
+     */
+    destroy(): void {
+        POOL ??= this.pool;
+        const self = this as unknown as { pool: Uint8Array | null; buffer: Uint8Array | null };
+        self.pool = null;
+        self.buffer = null;
     }
+    /** 通过内存池减少分配 */
+    private readonly pool;
     /**
      * 确保 buffer 还有 capacity 的空闲空间
      */
@@ -19,41 +36,46 @@ export class StreamEncoderHelper extends EncoderBase {
             // 超过最大尺寸限制
             throw new Error('Buffer has exceed max size');
         }
-        if (this.buffer == null) {
-            this.buffer = new Uint8Array(capacity);
-            this.view = new DataView(this.buffer.buffer);
-            return;
-        }
         if (capacity < 0) {
             // 结束流
-            this.onChunk(this.buffer.subarray(0, this.length));
-            this.buffer = new Uint8Array(0);
-            this.view = new DataView(this.buffer.buffer);
-            this.length = 0;
+            if (this.buffer === this.pool) {
+                this.onChunk(this.buffer.slice(0, this.length));
+            } else {
+                this.onChunk(this.buffer.subarray(0, this.length));
+            }
             return;
         }
         // 无需扩容
         if (this.buffer.byteLength >= this.length + capacity) return;
 
         // 提交目前的数据
-        this.onChunk(this.buffer.subarray(0, this.length));
+        if (this.buffer === this.pool) {
+            this.onChunk(this.buffer.slice(0, this.length));
+        } else {
+            this.onChunk(this.buffer.subarray(0, this.length));
+        }
 
         // 重新分配缓冲区
         if (capacity < BLOCK_SIZE) capacity = BLOCK_SIZE;
-        this.buffer = new Uint8Array(capacity);
+        this.allocUnsafe(capacity);
+    }
+    /** 分配 buffer */
+    private allocUnsafe(size: number): void {
+        if (size === this.pool.byteLength) {
+            // 从 pool 中获取
+            this.buffer = this.pool;
+            this.view = new DataView(this.buffer.buffer);
+            this.length = 0;
+            return;
+        }
+        this.buffer = new Uint8Array(size);
         this.view = new DataView(this.buffer.buffer);
         this.length = 0;
     }
     /** 获取写入结果 */
-    encode(): void {
-        if (typeof this.value != 'object' || this.value == null || ArrayBuffer.isView(this.value)) {
-            this.ensureCapacity(20);
-            this.writeValue();
-            this.ensureCapacity(-1);
-        } else {
-            this.ensureCapacity(BLOCK_SIZE);
-            this.writeValue();
-            this.ensureCapacity(-1);
-        }
+    encode(value: unknown): void {
+        this.allocUnsafe(BLOCK_SIZE);
+        this.writeValue(value);
+        this.ensureCapacity(-1);
     }
 }

package/src/utils.ts

@@ -1,14 +1,11 @@
 /** 支持的数据转为 Uint8Array */
-export function toUint8Array(data: BinaryData, exact: boolean): Uint8Array {
+export function toUint8Array(data: BinaryData): Uint8Array {
     if (data == null || typeof data != 'object' || typeof data.byteLength != 'number') {
         throw new TypeError('Invalid data');
     }
     if (!ArrayBuffer.isView(data)) {
         return new Uint8Array(data);
     }
-    if (exact && (data.byteOffset !== 0 || data.buffer.byteLength !== data.byteLength)) {
-        return new Uint8Array(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
-    }
     return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 }
 

package/tests/decode.js

@@ -54,8 +54,9 @@ test('decode int32', () => {
     expect(decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x1234_5678);
 });
 
-test('decode int64 [error]', () => {
-    expect(() => decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toThrow();
+test('decode int64', () => {
+    expect(decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toBe(0x1234_5678_9abc_def0n);
+    expect(decode(toBuffer('L', 0x00, 0x04, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toBe(0x04_5678_9abc_def0);
 });
 
 test('decode float32', () => {
@@ -156,9 +157,10 @@ test('decode huge string', () => {
     expect(decode(toBuffer('S', 'l', 0x00, 0x00, 0x00, 6, 'u', 'b', 'j', 's', 'o', 'n'))).toBe('ubjson');
 });
 
-test('decode huge string [error]', () => {
-    expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toThrow(
-        /Unsupported type int64/,
+test('decode huge string [int64 length]', () => {
+    expect(decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toBe('x');
+    expect(() => decode(toBuffer('S', 'L', 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toThrow(
+        /Invalid length/,
     );
 });
 
@@ -200,6 +202,24 @@ test('decode N-D array (strongly typed, optimized)', () => {
     ).toEqual([new Int8Array([1, 2, 3]), new Int8Array([4, 5, 6])]);
 });
 
+test('decode N-D array (strongly typed, optimized, no alloc buffer)', () => {
+    const buf = toBuffer('[', '$', '[', '#', 'i', 2, '$', 'i', '#', 'i', 3, 1, 2, 3, '$', 'U', '#', 'U', 3, 4, 5, 6);
+
+    const decoded1 = /** @type {[Int8Array, Uint8Array]} */ (decode(buf));
+    const decoded2 = /** @type {[Int8Array, Uint8Array]} */ (decode(buf, { noAllocBuffer: true }));
+    // @ts-expect-error Falsy value
+    const decoded3 = /** @type {[Int8Array, Uint8Array]} */ (decode(buf, { noAllocBuffer: 0 }));
+    expect(decoded1).toEqual([new Int8Array([1, 2, 3]), new Uint8Array([4, 5, 6])]);
+    expect(decoded2).toEqual([new Int8Array([1, 2, 3]), new Uint8Array([4, 5, 6])]);
+    expect(decoded3).toEqual([new Int8Array([1, 2, 3]), new Uint8Array([4, 5, 6])]);
+    expect(decoded1[0].buffer).not.toBe(buf.buffer);
+    expect(decoded1[1].buffer).not.toBe(buf.buffer);
+    expect(decoded2[0].buffer).not.toBe(buf.buffer);
+    expect(decoded2[1].buffer).toBe(buf.buffer);
+    expect(decoded3[0].buffer).not.toBe(buf.buffer);
+    expect(decoded3[1].buffer).not.toBe(buf.buffer);
+});
+
 test('decode array of objects (optimized)', () => {
     expect(
         decode(
@@ -389,13 +409,13 @@ test('decode array (int32, strongly typed, optimized) [use typed array]', () =>
 });
 
 test('decode array (int64, strongly typed, optimized) [use typed array]', () => {
-    expect(() =>
-        decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98)),
-    ).toThrow();
+    expect(decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98))).toEqual(
+        new BigInt64Array([0x1234_5678_fedc_ba98n]),
+    );
 });
 
 test('decode array (int64, strongly typed, optimized, empty) [use typed array]', () => {
-    expect(() => decode(toBuffer('[', '$', 'L', '#', 'i', 0))).toThrow();
+    expect(decode(toBuffer('[', '$', 'L', '#', 'i', 0))).toEqual(new BigInt64Array([]));
 });
 
 test('decode array (float32, strongly typed, optimized) [use typed array]', () => {

package/tests/e2e.js

@@ -2,6 +2,7 @@
  * Tests from https://bitbucket.org/shelacek/ubjson
  */
 import { encode, decode } from '../dist/index.js';
+import { resetEncoder } from '../dist/encoder.js';
 
 test('encode/decode complex object', () => {
     const expected = {
@@ -301,6 +302,7 @@ test('encode/decode complex object (no encodeInto)', () => {
     const encodeInto = TextEncoder.prototype.encodeInto;
     // @ts-expect-error 移除 encodeInto 以测试兼容性
     TextEncoder.prototype.encodeInto = undefined;
+    resetEncoder();
     const expected = {
         hello: 'world',
         from: ['UBJSON'],
@@ -372,6 +374,7 @@ test('encode/decode complex object (no encodeInto)', () => {
     const actual = decode(encoded);
     expect(actual).toEqual(expected);
     TextEncoder.prototype.encodeInto = encodeInto;
+    resetEncoder();
 });
 
 test('encode/decode large array', () => {