@cloudpss/ubjson 0.3.11 → 0.4.1

package/src/stream/encoder.ts

@@ -1,83 +1,23 @@
-import { Readable } from 'node:stream';
-import { EncoderBase } from '../common/encoder.js';
-
-const BLOCK_SIZE = 1024 * 8; // 8 KiB
-const MAX_SIZE = 1024 * 1024 * 256; //256 MiB
+import { Transform, TransformCallback } from 'node:stream';
+import { StreamEncoderHelper } from '../stream-helper/encoder.js';
 
 /** 流式编码 UBJSON */
-export class StreamEncoder extends EncoderBase {
-    protected stream!: Readable;
-    /**
-     * 确保 buffer 还有 capacity 的空闲空间
-     */
-    protected ensureCapacity(capacity: number): void {
-        if (capacity > MAX_SIZE) {
-            // 超过最大尺寸限制
-            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.stream.push(this.buffer.subarray(0, this.length));
-            this.buffer = new Uint8Array(0);
-            this.view = new DataView(this.buffer.buffer);
-            this.length = 0;
-            this.stream.push(null);
-            return;
-        }
-        // 无需扩容
-        if (this.buffer.byteLength >= this.length + capacity) return;
-
-        // 提交目前的数据
-        this.stream.push(this.buffer.subarray(0, this.length));
-
-        // 重新分配缓冲区
-        if (capacity < BLOCK_SIZE) capacity = BLOCK_SIZE;
-        this.buffer = new Uint8Array(capacity);
-        this.view = new DataView(this.buffer.buffer);
-        this.length = 0;
+export class StreamEncoder extends Transform {
+    constructor() {
+        super({
+            readableObjectMode: false,
+            writableObjectMode: true,
+        });
     }
 
-    protected currentPos: Array<string | number> = [];
-    /** 获取写入结果 */
-    encode(): Readable {
-        if (typeof this.value != 'object' || this.value == null || ArrayBuffer.isView(this.value)) {
-            this.stream = new Readable({
-                objectMode: false,
-                construct: (callback) => {
-                    this.ensureCapacity(20);
-                    callback();
-                },
-                read: () => {
-                    try {
-                        this.write(this.value);
-                        this.ensureCapacity(-1);
-                    } catch (ex) {
-                        this.stream.destroy(ex as Error);
-                    }
-                },
-            });
-        } else {
-            this.stream = new Readable({
-                objectMode: false,
-                construct: (callback) => {
-                    this.ensureCapacity(BLOCK_SIZE);
-                    callback();
-                },
-                read: () => {
-                    try {
-                        this.write(this.value);
-                        this.ensureCapacity(-1);
-                    } catch (ex) {
-                        this.stream.destroy(ex as Error);
-                    }
-                },
-            });
+    /** @inheritdoc */
+    override _transform(obj: unknown, _encoding: BufferEncoding, callback: TransformCallback): void {
+        const helper = new StreamEncoderHelper(obj, (binary) => this.push(binary));
+        try {
+            helper.encode();
+            callback();
+        } catch (ex) {
+            callback(ex as Error);
         }
-        return this.stream;
     }
 }

package/src/stream/index.ts

@@ -1,8 +1,35 @@
-import type { Readable } from 'node:stream';
+import { Readable, Transform } from 'node:stream';
 import { StreamEncoder } from './encoder.js';
+import { StreamDecoder } from './decoder.js';
 
 /** 编码为 UBJSON */
 export function encode(value: unknown): Readable {
-    const encoder = new StreamEncoder(value);
-    return encoder.encode();
+    if (value == null) {
+        return Readable.from([value === null ? 'Z' : 'N'], { objectMode: false });
+    }
+    const encoder = new StreamEncoder();
+    encoder.write(value);
+    encoder.end();
+    return encoder;
+}
+
+/** 编码为 UBJSON */
+export function encoder(): Transform {
+    return new StreamEncoder();
+}
+
+/** 解码 UBJSON */
+export function decode(stream: NodeJS.ReadableStream): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+        const decoder = new StreamDecoder();
+        decoder.on('error', reject);
+        decoder.on('end', resolve);
+        decoder.on('data', resolve);
+        stream.pipe(decoder);
+    });
+}
+
+/** 解码 UBJSON */
+export function decoder(): Transform {
+    return new StreamDecoder();
 }

package/src/stream-helper/decoder.ts

@@ -0,0 +1,15 @@
+import { Decoder, UnexpectedEof } from '../common/decoder.js';
+
+export { UnexpectedEof };
+
+/** 流式解码 UBJSON */
+export class StreamDecoderHelper extends Decoder {
+    constructor(data: Uint8Array) {
+        super(data);
+    }
+
+    /** 读取的字节数 */
+    get readLength(): number {
+        return this.offset;
+    }
+}

package/src/stream-helper/encoder.ts

@@ -0,0 +1,56 @@
+import { EncoderBase } from '../common/encoder.js';
+
+const BLOCK_SIZE = 1024 * 8; // 8 KiB
+const MAX_SIZE = 1024 * 1024 * 256; // 256 MiB
+
+/** 流式编码 UBJSON */
+export class StreamEncoderHelper extends EncoderBase {
+    constructor(value: unknown, protected readonly onChunk: (chunk: Uint8Array) => void) {
+        super(value);
+    }
+    /**
+     * 确保 buffer 还有 capacity 的空闲空间
+     */
+    protected ensureCapacity(capacity: number): void {
+        if (capacity > MAX_SIZE) {
+            // 超过最大尺寸限制
+            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;
+            return;
+        }
+        // 无需扩容
+        if (this.buffer.byteLength >= this.length + capacity) return;
+
+        // 提交目前的数据
+        this.onChunk(this.buffer.subarray(0, this.length));
+
+        // 重新分配缓冲区
+        if (capacity < BLOCK_SIZE) capacity = BLOCK_SIZE;
+        this.buffer = new Uint8Array(capacity);
+        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.write(this.value);
+            this.ensureCapacity(-1);
+        } else {
+            this.ensureCapacity(BLOCK_SIZE);
+            this.write(this.value);
+            this.ensureCapacity(-1);
+        }
+    }
+}

package/tests/encode.js

@@ -345,10 +345,21 @@ test('encode huge typed array (3G) [error]', () => {
 
 test('encode huge data (~128M)', () => {
     const obj = [new Uint8Array(128 * 1024 * 1024 - 20)];
-    expect(toArray(encode(obj).slice(0, 11))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0));
+    obj[0][0] = 0x12;
+    obj[0][1] = 0x34;
+    expect(toArray(encode(obj).slice(0, 12))).toEqual(
+        toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0x12, 0x34),
+    );
 });
 
-test('encode huge data (128M) [error]', () => {
+test('encode huge data (128M)', () => {
     const obj = [new Uint8Array(128 * 1024 * 1024)];
+    obj[0][0] = 0x12;
+    obj[0][1] = 0x34;
+    expect(toArray(encode(obj).slice(0, 12))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x8, 0, 0, 0, 0x12, 0x34));
+});
+
+test('encode huge data (128M + 1) [error]', () => {
+    const obj = [new Uint8Array(128 * 1024 * 1024 + 1)];
     expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
 });