@cloudpss/ubjson 0.3.5 → 0.3.8

package/src/encoder.ts

@@ -1,6 +1,4 @@
-/* eslint-disable @typescript-eslint/unbound-method */
-import * as constants from './constants.js';
-import { StringEncoder } from './string-encoder.js';
+import { EncoderBase } from './common/encoder.js';
 
 const INITIAL_SIZE = 1024 * 8; // 8 KiB
 const MAX_SIZE = 1024 * 1024 * 128; //128 MiB
@@ -8,22 +6,11 @@ const RESIZE_FACTOR = 4;
 const RESIZE_FACTOR_2 = 2;
 
 /** 编码至 ubjson */
-class Encoder {
-    /** 字符串编码 */
-    private stringEncoder = new StringEncoder();
-    /** 当前写指针位置 */
-    private length = 0;
-    /** 数据 */
-    private buffer!: Uint8Array;
-    /** buffer 的 DataView */
-    private view!: DataView;
-
-    constructor(readonly value: unknown) {}
-
+export class Encoder extends EncoderBase {
     /**
      * 确保 buffer 还有 capacity 的空闲空间
      */
-    private ensureCapacity(capacity: number): void {
+    protected ensureCapacity(capacity: number): void {
         if (this.buffer == null) {
             if (capacity > MAX_SIZE) {
                 // 超过最大尺寸限制
@@ -62,6 +49,7 @@ class Encoder {
         this.buffer = newBuffer;
         this.view = new DataView(newBuffer.buffer);
     }
+
     /** 获取写入结果 */
     encode(): Uint8Array {
         if (ArrayBuffer.isView(this.value)) {
@@ -87,293 +75,4 @@ class Encoder {
             return this.buffer.slice(0, this.length);
         }
     }
-    /** 写入一个对象 */
-    private write(value: unknown): void {
-        switch (typeof value) {
-            case 'undefined':
-                return this.writeNoOp();
-            case 'boolean':
-                return this.writeBoolean(value);
-            case 'number':
-                return this.writeNumber(value);
-            case 'string':
-                if (value.length === 1 && value.charCodeAt(0) < 255) {
-                    // 1 byte string
-                    return this.writeChar(value);
-                }
-                return this.writeString(value);
-            case 'object': {
-                if (value === null) {
-                    return this.writeNull();
-                }
-                if (Array.isArray(value)) {
-                    return this.writeArray(value);
-                }
-                if (ArrayBuffer.isView(value)) {
-                    return this.writeTypedArray(value);
-                }
-                return this.writeObject(value as Record<string, unknown>);
-            }
-        }
-        throw new Error(`Unsupported type ${Object.prototype.toString.call(value)}`);
-    }
-    /** 写入 marker */
-    private writeMarker(marker: number): void {
-        this.ensureCapacity(1);
-        this.view.setUint8(this.length, marker);
-        this.length += 1;
-    }
-
-    /** 写入 marker */
-    private writeNull(): void {
-        this.writeMarker(constants.NULL);
-    }
-
-    /** writeNoOp */
-    private writeNoOp(): void {
-        this.writeMarker(constants.NO_OP);
-    }
-
-    /** writeBoolean */
-    private writeBoolean(value: boolean): void {
-        this.writeMarker(value ? constants.TRUE : constants.FALSE);
-    }
-
-    /** writeInt8 */
-    private writeInt8(value: number): void {
-        this.writeMarker(constants.INT8);
-        this.writeInt8Data(value);
-    }
-
-    /** writeInt8Data */
-    private writeInt8Data(value: number): void {
-        this.ensureCapacity(1);
-        this.view.setInt8(this.length, value);
-        this.length += 1;
-    }
-
-    /** writeUint8 */
-    private writeUint8(value: number): void {
-        this.writeMarker(constants.UINT8);
-        this.writeUint8Data(value);
-    }
-
-    /** writeUint8Data */
-    private writeUint8Data(value: number): void {
-        this.ensureCapacity(1);
-        this.view.setUint8(this.length, value);
-        this.length += 1;
-    }
-
-    /** writeInt16 */
-    private writeInt16(value: number): void {
-        this.writeMarker(constants.INT16);
-        this.writeInt16Data(value);
-    }
-
-    /** writeInt16Data */
-    private writeInt16Data(value: number): void {
-        this.ensureCapacity(2);
-        this.view.setInt16(this.length, value);
-        this.length += 2;
-    }
-
-    /** writeInt32 */
-    private writeInt32(value: number): void {
-        this.writeMarker(constants.INT32);
-        this.writeInt32Data(value);
-    }
-
-    /** writeInt32Data */
-    private writeInt32Data(value: number): void {
-        this.ensureCapacity(4);
-        this.view.setInt32(this.length, value);
-        this.length += 4;
-    }
-
-    /** writeFloat32 */
-    private writeFloat32(value: number): void {
-        this.writeMarker(constants.FLOAT32);
-        this.writeFloat32Data(value);
-    }
-
-    /** writeFloat32Data */
-    private writeFloat32Data(value: number): void {
-        this.ensureCapacity(4);
-        this.view.setFloat32(this.length, value);
-        this.length += 4;
-    }
-
-    /** writeFloat64 */
-    private writeFloat64(value: number): void {
-        this.writeMarker(constants.FLOAT64);
-        this.writeFloat64Data(value);
-    }
-
-    /** writeFloat64Data */
-    private writeFloat64Data(value: number): void {
-        this.ensureCapacity(8);
-        this.view.setFloat64(this.length, value);
-        this.length += 8;
-    }
-
-    /** writeChar */
-    private writeChar(value: string): void {
-        this.writeMarker(constants.CHAR);
-        this.writeCharData(value);
-    }
-
-    /** writeCharData */
-    private writeCharData(value: string): void {
-        this.ensureCapacity(1);
-        this.view.setUint8(this.length, value.charCodeAt(0));
-        this.length += 1;
-    }
-
-    /** writeString */
-    private writeString(value: string): void {
-        this.writeMarker(constants.STRING);
-        this.writeStringData(value);
-    }
-
-    /** writeStringData */
-    private writeStringData(value: string): void {
-        // 优化小字符串
-        if (value.length < 32) {
-            const buf = this.stringEncoder.encode(value);
-            this.writeInt(buf.length);
-            this.ensureCapacity(buf.length);
-            this.buffer.set(buf, this.length);
-            this.length += buf.length;
-            return;
-        }
-        if (this.stringEncoder.encodeInto != null) {
-            const maxUsage = value.length * 3;
-            const currentPos = this.length;
-            // 先写入最大大小
-            const lengthWriter = this.writeInt(maxUsage);
-            this.ensureCapacity(maxUsage);
-            // 写入文本数据
-            const { written } = this.stringEncoder.encodeInto(value, this.buffer.subarray(this.length));
-            // 回溯，写入实际大小
-            this.length = currentPos;
-            lengthWriter.call(this, written as number);
-            // 移动指针到写入末尾
-            this.length += written as number;
-            return;
-        }
-        const data = this.stringEncoder.encode(value);
-        this.writeInt(data.length);
-        this.ensureCapacity(data.length);
-        this.buffer.set(data, this.length);
-        this.length += data.length;
-    }
-
-    /**
-     * 写入整形数字，选取合适的大小
-     *
-     * @throws 无法在 int32 范围内表示
-     */
-    private writeInt(value: number): (this: this, value: number) => void {
-        value = value | 0;
-        if (value >= -128 && value <= 127) {
-            this.writeInt8(value);
-            return this.writeInt8;
-        }
-        if (value >= -32768 && value <= 32767) {
-            this.writeInt16(value);
-            return this.writeInt16;
-        }
-        if (value >= -2147483648 && value <= 2147483647) {
-            this.writeInt32(value);
-            return this.writeInt32;
-        }
-        /* c8 ignore next 2 */
-        throw new Error(`Unsupported int value ${value}: out of range`);
-    }
-
-    /** 写入数字，选取合适的大小 */
-    private writeNumber(value: number): void {
-        if (Number.isInteger(value) && value >= -2147483648 && value <= 2147483647) {
-            if (value >= 0 && value <= 255) return this.writeUint8(value);
-            this.writeInt(value);
-            return;
-        }
-        if (!(Number.isNaN(value) || Math.fround(value) === value)) {
-            return this.writeFloat64(value);
-        }
-        // 如果不会损失精度，则使用 32 位浮点
-        return this.writeFloat32(value);
-    }
-
-    /** writeObject */
-    private writeObject(value: Record<string, unknown>): void {
-        this.writeMarker(constants.OBJECT);
-        // 生成稳定的结果以便 hash 计算
-        for (const key of Object.keys(value).sort()) {
-            const element = value[key];
-            if (element === undefined) continue;
-            this.writeStringData(key);
-            this.write(element);
-        }
-        this.writeMarker(constants.OBJECT_END);
-    }
-
-    /** writeArray */
-    private writeArray(value: unknown[]): void {
-        this.writeMarker(constants.ARRAY);
-        for (const v of value) {
-            // 在数组中 undefined 也被视作 null 进行序列化
-            if (v == null) this.writeNull();
-            else this.write(v);
-        }
-        this.writeMarker(constants.ARRAY_END);
-    }
-
-    /** writeArray */
-    private writeTypedArray(value: ArrayBufferView): void {
-        this.writeMarker(constants.ARRAY);
-        this.writeMarker(constants.TYPE_MARKER);
-        if (value instanceof Uint8Array || value instanceof Int8Array) {
-            // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
-            this.writeMarker(value instanceof Uint8Array ? constants.UINT8 : constants.INT8);
-            this.writeMarker(constants.COUNT_MARKER);
-            this.writeInt(value.length);
-            this.ensureCapacity(value.byteLength);
-            this.buffer.set(value, this.length);
-            this.length += value.byteLength;
-            return;
-        }
-        /** 用于写入的 setter */
-        let setValue;
-        if (value instanceof Int16Array) {
-            this.writeMarker(constants.INT16);
-            setValue = this.view.setInt16;
-        } else if (value instanceof Int32Array) {
-            this.writeMarker(constants.INT32);
-            setValue = this.view.setInt32;
-        } else if (value instanceof Float32Array) {
-            this.writeMarker(constants.FLOAT32);
-            setValue = this.view.setFloat32;
-        } else if (value instanceof Float64Array) {
-            this.writeMarker(constants.FLOAT64);
-            setValue = this.view.setFloat64;
-        } else {
-            throw new Error(`Unsupported typed array type ${Object.prototype.toString.call(value)}`);
-        }
-        this.writeMarker(constants.COUNT_MARKER);
-        this.writeInt(value.length);
-        this.ensureCapacity(value.byteLength);
-        // 不要在前面 bind，this.ensureCapacity 有可能导致 this.view 指向新的对象
-        for (const v of value) {
-            setValue.call(this.view, this.length, v);
-            this.length += value.BYTES_PER_ELEMENT;
-        }
-    }
-}
-
-/** 编码 */
-export function encode(value: unknown): Uint8Array {
-    const encoder = new Encoder(value);
-    return encoder.encode();
 }

package/src/index.ts

@@ -1,2 +1,14 @@
-export { encode } from './encoder.js';
-export { decode } from './decoder.js';
+import { Encoder } from './encoder.js';
+import { Decoder } from './common/decoder.js';
+
+/** 编码为 UBJSON */
+export function encode(value: unknown): Uint8Array {
+    const encoder = new Encoder(value);
+    return encoder.encode();
+}
+
+/** 解码 UBJSON */
+export function decode(value: Uint8Array): unknown {
+    const decoder = new Decoder(value);
+    return decoder.decode();
+}

package/src/stream/encoder.ts

@@ -0,0 +1,83 @@
+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
+
+/** 流式编码 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;
+    }
+
+    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);
+                    }
+                },
+            });
+        }
+        return this.stream;
+    }
+}

package/src/stream/index.ts

@@ -0,0 +1,8 @@
+import type { Readable } from 'node:stream';
+import { StreamEncoder } from './encoder.js';
+
+/** 编码为 UBJSON */
+export function encode(value: unknown): Readable {
+    const encoder = new StreamEncoder(value);
+    return encoder.encode();
+}