@cloudpss/ubjson 0.5.37 → 0.5.38

package/src/helper/decode.ts

@@ -0,0 +1,362 @@
+import { constants } from './constants.js';
+import { UnexpectedEofError, unsupportedType } from './errors.js';
+import { decode, decodeKey } from './string-decoder.js';
+import { toUint8Array } from './utils.js';
+
+const { fromEntries } = Object;
+const { fromCharCode } = String;
+
+/** 数据包装 */
+export interface DecodeCursor {
+    /** 数据 */
+    readonly view: DataView;
+    /** 数据 */
+    readonly data: Uint8Array;
+    /** 当前读指针位置 */
+    offset: number;
+    /** 读取到末尾时调用 */
+    eof(): never;
+}
+
+/** 创建数据包装 */
+export function DecodeCursor(data: BinaryData): DecodeCursor {
+    const d = toUint8Array(data);
+    const v = new DataView(d.buffer, d.byteOffset, d.byteLength);
+    return {
+        data: d,
+        view: v,
+        offset: 0,
+        eof() {
+            throw new UnexpectedEofError();
+        },
+    };
+}
+
+/**
+ * 读取第一个非 NOOP 的字节
+ * @returns 返回读取到的字节，如果读取到末尾则返回 undefined
+ */
+export function readMarkerOrUndefined(cursor: DecodeCursor): number | undefined {
+    let marker: number | undefined;
+    do {
+        marker = cursor.data[cursor.offset++];
+    } while (marker === constants.NO_OP);
+    return marker;
+}
+
+/**
+ * 读取第一个非 NOOP 的字节
+ */
+export function readMarker(cursor: DecodeCursor): number {
+    let marker: number | undefined;
+    do {
+        marker = cursor.data[cursor.offset++];
+    } while (marker === constants.NO_OP);
+    if (marker === undefined) return cursor.eof();
+    return marker;
+}
+
+/** 读取一个大于 0 的整数 */
+export function readLength(cursor: DecodeCursor): number {
+    const marker = readMarker(cursor);
+    let length: number;
+    switch (marker) {
+        case constants.INT8:
+            length = readInt8Data(cursor);
+            break;
+        case constants.UINT8:
+            length = readUint8Data(cursor);
+            break;
+        case constants.INT16:
+            length = readInt16Data(cursor);
+            break;
+        case constants.INT32:
+            length = readInt32Data(cursor);
+            break;
+        case constants.INT64: {
+            const l = readInt64Data(cursor);
+            if (l < 0 || l > Number.MAX_SAFE_INTEGER) {
+                throw new Error('Invalid length');
+            }
+            length = Number(l);
+            break;
+        }
+        default:
+            throw new Error(`Unexpected marker '${String.fromCharCode(marker)}'(${marker}) for int length`);
+    }
+    if (length < 0) {
+        throw new Error('Invalid length');
+    }
+    return length;
+}
+
+/** readInt8Data */
+export function readInt8Data(cursor: DecodeCursor): number {
+    try {
+        return cursor.view.getInt8(cursor.offset++);
+    } catch {
+        return cursor.eof();
+    }
+}
+/** readUint8Data */
+export function readUint8Data(cursor: DecodeCursor): number {
+    const result = cursor.data[cursor.offset++];
+    if (result === undefined) return cursor.eof();
+    return result;
+}
+/** readInt16Data */
+export function readInt16Data(cursor: DecodeCursor): number {
+    try {
+        const result = cursor.view.getInt16(cursor.offset);
+        cursor.offset += 2;
+        return result;
+    } catch {
+        return cursor.eof();
+    }
+}
+/** readInt32Data */
+export function readInt32Data(cursor: DecodeCursor): number {
+    try {
+        const result = cursor.view.getInt32(cursor.offset);
+        cursor.offset += 4;
+        return result;
+    } catch {
+        return cursor.eof();
+    }
+}
+/** readInt64Data */
+export function readInt64Data(cursor: DecodeCursor): bigint {
+    try {
+        const result = cursor.view.getBigInt64(cursor.offset);
+        cursor.offset += 8;
+        return result;
+    } catch {
+        return cursor.eof();
+    }
+}
+/** readFloat32Data */
+export function readFloat32Data(cursor: DecodeCursor): number {
+    try {
+        const result = cursor.view.getFloat32(cursor.offset);
+        cursor.offset += 4;
+        return result;
+    } catch {
+        return cursor.eof();
+    }
+}
+/** readFloat64Data */
+export function readFloat64Data(cursor: DecodeCursor): number {
+    try {
+        const result = cursor.view.getFloat64(cursor.offset);
+        cursor.offset += 8;
+        return result;
+    } catch {
+        return cursor.eof();
+    }
+}
+
+/** 读取数据 */
+export function read(cursor: DecodeCursor): unknown {
+    const marker = readMarker(cursor);
+    return readData(cursor, marker);
+}
+
+/** 根据标签读取后续数据 */
+export function readData(cursor: DecodeCursor, marker: number): unknown {
+    // 按照出现频率排序
+    switch (marker) {
+        case constants.STRING: {
+            const length = readLength(cursor);
+            const begin = cursor.offset;
+            const end = begin + length;
+            cursor.offset = end;
+            const { data } = cursor;
+            if (end > data.length) cursor.eof();
+            return decode(data, begin, end);
+        }
+        case constants.OBJECT: {
+            const markers = readOptimizedFormatMarkers(cursor);
+            if (markers == null) {
+                // 直到 '}'
+                const object: Array<[string, unknown]> = [];
+                while (readMarker(cursor) !== constants.OBJECT_END) {
+                    cursor.offset--;
+                    object.push([readKey(cursor), read(cursor)]);
+                }
+                return fromEntries(object);
+            }
+
+            const { count, type } = markers;
+            const object: Array<[string, unknown]> = [];
+            object.length = count;
+            for (let i = 0; i < count; i++) {
+                const key = readKey(cursor);
+                const value = readData(cursor, type ?? readMarker(cursor));
+                object[i] = [key, value];
+            }
+            return fromEntries(object);
+        }
+        case constants.ARRAY: {
+            const markers = readOptimizedFormatMarkers(cursor);
+            if (markers == null) {
+                const array = [];
+                // 直到 ']'
+                while (readMarker(cursor) !== constants.ARRAY_END) {
+                    cursor.offset--;
+                    array.push(read(cursor));
+                }
+                return array;
+            }
+
+            const { count, type } = markers;
+            switch (type) {
+                case constants.UINT8:
+                    try {
+                        const buf = new Uint8Array(
+                            cursor.data.buffer,
+                            cursor.data.byteOffset + cursor.offset,
+                            count,
+                        ).slice();
+                        cursor.offset += count;
+                        return buf;
+                    } catch {
+                        return cursor.eof();
+                    }
+                case constants.INT8:
+                    try {
+                        const buf = new Int8Array(
+                            cursor.data.buffer,
+                            cursor.data.byteOffset + cursor.offset,
+                            count,
+                        ).slice();
+                        cursor.offset += count;
+                        return buf;
+                    } catch {
+                        return cursor.eof();
+                    }
+                case constants.INT16: {
+                    const result = new Int16Array(count);
+                    for (let i = 0; i < count; i++) {
+                        result[i] = readInt16Data(cursor);
+                    }
+                    return result;
+                }
+                case constants.INT32: {
+                    const result = new Int32Array(count);
+                    for (let i = 0; i < count; i++) {
+                        result[i] = readInt32Data(cursor);
+                    }
+                    return result;
+                }
+                case constants.FLOAT32: {
+                    const result = new Float32Array(count);
+                    for (let i = 0; i < count; i++) {
+                        result[i] = readFloat32Data(cursor);
+                    }
+                    return result;
+                }
+                case constants.FLOAT64: {
+                    const result = new Float64Array(count);
+                    for (let i = 0; i < count; i++) {
+                        result[i] = readFloat64Data(cursor);
+                    }
+                    return result;
+                }
+                case constants.INT64: {
+                    const result = new BigInt64Array(count);
+                    for (let i = 0; i < count; i++) {
+                        result[i] = readInt64Data(cursor);
+                    }
+                    return result;
+                }
+                case constants.NULL:
+                    return Array.from({ length: count }).fill(null);
+                case constants.TRUE:
+                    return Array.from({ length: count }).fill(true);
+                case constants.FALSE:
+                    return Array.from({ length: count }).fill(false);
+                default:
+                    break;
+            }
+            const array: unknown[] = [];
+            array.length = count;
+            for (let i = 0; i < count; i++) {
+                array[i] = type === undefined ? read(cursor) : readData(cursor, type);
+            }
+            return array;
+        }
+        case constants.FLOAT64:
+            return readFloat64Data(cursor);
+        case constants.UINT8:
+            return readUint8Data(cursor);
+        case constants.INT16:
+            return readInt16Data(cursor);
+        case constants.FLOAT32:
+            return readFloat32Data(cursor);
+        case constants.CHAR:
+            return fromCharCode(readUint8Data(cursor));
+        case constants.INT32:
+            return readInt32Data(cursor);
+        case constants.INT8:
+            return readInt8Data(cursor);
+        case constants.NULL:
+            return null;
+        case constants.TRUE:
+            return true;
+        case constants.FALSE:
+            return false;
+        case constants.INT64: {
+            const n = readInt64Data(cursor);
+            if (n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER) {
+                return n;
+            }
+            return Number(n);
+        }
+        case constants.HIGH_PRECISION_NUMBER: {
+            const length = readLength(cursor);
+            try {
+                const _buffer = new Uint8Array(cursor.data.buffer, cursor.offset, length).slice();
+                cursor.offset += length;
+                // return buffer;
+            } catch {
+                return cursor.eof();
+            }
+            unsupportedType('high precision number');
+        }
+    }
+    if (typeof marker != 'number') return marker;
+    throw new Error(`Unexpected marker '${fromCharCode(marker)}'(${marker})`);
+}
+
+/** readKey */
+export function readKey(cursor: DecodeCursor): string {
+    const length = readLength(cursor);
+    const begin = cursor.offset;
+    const end = begin + length;
+    cursor.offset = end;
+    const { data } = cursor;
+    if (end > data.length) cursor.eof();
+    return decodeKey(data, begin, end);
+}
+
+/** 读取 Optimized Format 数据 */
+export function readOptimizedFormatMarkers(cursor: DecodeCursor): { type?: number; count: number } | undefined {
+    let type;
+    let count;
+    switch (readMarker(cursor)) {
+        case constants.TYPE_MARKER:
+            type = readMarker(cursor);
+            if (readMarker(cursor) !== constants.COUNT_MARKER) {
+                throw new Error('Expected count marker');
+            }
+        /* fall through */
+        case constants.COUNT_MARKER:
+            count = readLength(cursor);
+            break;
+        default:
+            // 不是 '$' 或 '#'，回溯
+            cursor.offset--;
+            return undefined;
+    }
+    return { type, count };
+}

package/src/helper/encode.ts

@@ -0,0 +1,89 @@
+import { constants } from './constants.js';
+import { unsupportedView } from './errors.js';
+
+/** 数据包装 */
+export interface EncodeCursor {
+    /** 数据 */
+    readonly view: DataView;
+    /** 数据 */
+    readonly data: Uint8Array;
+    /** 当前写指针位置 */
+    length: number;
+    /** 确保 buffer 还有 capacity 的空闲空间 */
+    ensureCapacity(capacity: number): void;
+}
+
+/** 创建数据包装 */
+export function EncodeCursor(length: number): EncodeCursor {
+    const data = new Uint8Array(length);
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return {
+        data,
+        view,
+        length: 0,
+        ensureCapacity(capacity: number) {
+            if (this.length + capacity > this.data.length) {
+                throw new RangeError('Out of capacity');
+            }
+        },
+    };
+}
+
+/** 写入标签 */
+export function writeMarker(cursor: EncodeCursor, marker: constants): void {
+    cursor.ensureCapacity(1);
+    cursor.data[cursor.length++] = marker;
+}
+
+/** 写入长度 */
+export function writeLength(cursor: EncodeCursor, length: number): void {
+    if (length < 0x80) {
+        cursor.ensureCapacity(2);
+        cursor.data[cursor.length++] = constants.INT8;
+        cursor.data[cursor.length++] = length;
+    } else if (length < 0x8000) {
+        cursor.ensureCapacity(3);
+        cursor.data[cursor.length++] = constants.INT16;
+        cursor.view.setInt16(cursor.length, length);
+        cursor.length += 2;
+    } else if (length < 0x8000_0000) {
+        cursor.ensureCapacity(5);
+        cursor.data[cursor.length++] = constants.INT32;
+        cursor.view.setInt32(cursor.length, length);
+        cursor.length += 4;
+    } else if (length < Number.MAX_SAFE_INTEGER) {
+        cursor.ensureCapacity(9);
+        cursor.data[cursor.length++] = constants.INT64;
+        cursor.view.setBigInt64(cursor.length, BigInt(length));
+        cursor.length += 8;
+    } else {
+        throw new RangeError('Invalid length');
+    }
+}
+
+/** 写入 TypedArray 前导，包括 marker 和长度 */
+export function writeTypedArrayHeader(cursor: EncodeCursor, value: ArrayBufferView): void {
+    // ARRAY(1) + TYPE_MARKER(1) + TYPE(1) + COUNT_MARKER(1) + COUNT(MIN2 MAX5) + DATA
+    cursor.ensureCapacity(9);
+    cursor.data[cursor.length++] = constants.ARRAY;
+    cursor.data[cursor.length++] = constants.TYPE_MARKER;
+    if (value instanceof Uint8Array) {
+        cursor.data[cursor.length++] = constants.UINT8;
+    } else if (value instanceof Float64Array) {
+        cursor.data[cursor.length++] = constants.FLOAT64;
+    } else if (value instanceof Int32Array) {
+        cursor.data[cursor.length++] = constants.INT32;
+    } else if (value instanceof Int8Array) {
+        cursor.data[cursor.length++] = constants.INT8;
+    } else if (value instanceof Int16Array) {
+        cursor.data[cursor.length++] = constants.INT16;
+    } else if (value instanceof Float32Array) {
+        cursor.data[cursor.length++] = constants.FLOAT32;
+    } else if (value instanceof BigInt64Array) {
+        cursor.data[cursor.length++] = constants.INT64;
+    } else {
+        unsupportedView(value);
+    }
+    cursor.data[cursor.length++] = constants.COUNT_MARKER;
+    writeLength(cursor, value.length);
+}

package/src/{common → helper}/errors.ts

@@ -1,6 +1,8 @@
+const getType = (obj: unknown): string => Object.prototype.toString.call(obj).slice(8, -1);
+
 /** unsupported view */
 export function unsupportedView(view: ArrayBufferView): never {
-    const type = Object.prototype.toString.call(view).slice(8, -1);
+    const type = getType(view);
     throw new Error(`Unsupported array buffer view of type ${type}`);
 }
 
@@ -9,6 +11,14 @@ export function unsupportedType(value: unknown): never {
     if (value && typeof value == 'string') {
         throw new Error(`Unsupported type ${value}`);
     }
-    const type = Object.prototype.toString.call(value).slice(8, -1);
+    const type = getType(value);
     throw new Error(`Unsupported type ${type}`);
 }
+
+/** 未结束的流 */
+export class UnexpectedEofError extends Error {
+    constructor() {
+        super('Unexpected EOF');
+        this.name = 'UnexpectedEofError';
+    }
+}

package/src/{common → helper}/string-decoder.ts

@@ -1,7 +1,7 @@
 const CHUNK_SIZE = 0x1000;
 const REPLACE_CHAR = 0xfffd;
 
-const fromCharCode = String.fromCharCode;
+const { fromCharCode } = String;
 
 /** 解码 */
 export function jsDecode(bytes: Uint8Array, begin: number, end: number): string {

package/src/{utils.ts → helper/utils.ts}

@@ -8,10 +8,3 @@ export function toUint8Array(data: BinaryData): Uint8Array {
     }
     return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 }
-
-/** 未结束的流 */
-export class UnexpectedEof extends Error {
-    constructor() {
-        super('Unexpected EOF');
-    }
-}

package/src/index.ts

@@ -1,8 +1,6 @@
 import { getEncoder } from './encoder.js';
-import { Decoder, type DecoderOptions } from './decoder.js';
-export { UnexpectedEof } from './utils.js';
-
-export type { DecoderOptions };
+import { Decoder } from './decoder.js';
+export { UnexpectedEofError as UnexpectedEof } from './helper/errors.js';
 
 /** 编码为 UBJSON */
 export function encode(value: unknown): Uint8Array {
@@ -15,14 +13,14 @@ export function encodeMany(value: Iterable<unknown>): Uint8Array {
 }
 
 /** 解码 UBJSON */
-export function decode(value: BinaryData, options?: DecoderOptions): unknown {
-    const decoder = new Decoder(value, options);
+export function decode(value: BinaryData): unknown {
+    const decoder = new Decoder(value);
     return decoder.decode();
 }
 
 /** 解码 UBJSON */
-export function* decodeMany(value: BinaryData, options?: DecoderOptions): Iterable<unknown> {
-    const decoder = new Decoder(value, options);
+export function* decodeMany(value: BinaryData): Iterable<unknown> {
+    const decoder = new Decoder(value);
     while (!decoder.ended) {
         yield decoder.decode();
     }

package/src/rxjs/decoder.ts

@@ -1,6 +1,6 @@
 import { Observable, type OperatorFunction } from 'rxjs';
 import { StreamDecoderHelper, kEof, UnexpectedEof } from '../stream-helper/decoder.js';
-import { toUint8Array } from '../utils.js';
+import { toUint8Array } from '../helper/utils.js';
 
 const DEFAULT_BUFFER_SIZE = 16 * 1024 * 1024; // 16 MiB
 const EMPTY_BUFFER = new Uint8Array(0);

package/src/rxjs/index.ts

@@ -1,3 +1,3 @@
 export { encode } from './encoder.js';
 export { decode } from './decoder.js';
-export { UnexpectedEof } from '../utils.js';
+export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';

package/src/stream/index.ts

@@ -1,8 +1,8 @@
-import { Readable, Transform } from 'node:stream';
+import { Readable, type Transform } from 'node:stream';
 import { StreamEncoder } from './encoder.js';
 import { StreamDecoder } from './decoder.js';
 
-export { UnexpectedEof } from '../utils.js';
+export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';
 
 /** 编码为 UBJSON */
 export function encode(value: unknown): Readable {
@@ -37,7 +37,7 @@ export function encoder(): Transform {
 }
 
 /** 解码 UBJSON */
-export function decode(stream: NodeJS.ReadableStream): Promise<unknown> {
+export async function decode(stream: NodeJS.ReadableStream): Promise<unknown> {
     return new Promise((resolve, reject) => {
         const decoder = new StreamDecoder();
         decoder.on('error', reject);

package/src/stream-helper/decoder.ts

@@ -1,17 +1,14 @@
-import { DecoderBase } from '../common/decoder.js';
+import { DecoderBase } from '../base/decoder.js';
 
 /** 未结束的流 */
 export const kEof = Symbol('EOF');
 
 /** 流式解码 UBJSON */
 export class StreamDecoderHelper extends DecoderBase {
-    constructor(data: Uint8Array) {
-        super(data);
-    }
     /** @inheritdoc */
     protected override eof(): never {
         // 性能优化，避免 new Error 的开销
-        // eslint-disable-next-line @typescript-eslint/no-throw-literal
+        // eslint-disable-next-line @typescript-eslint/only-throw-error
         throw kEof;
     }
 
@@ -21,4 +18,4 @@ export class StreamDecoderHelper extends DecoderBase {
     }
 }
 
-export { UnexpectedEof } from '../utils.js';
+export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';

package/src/stream-helper/encoder.ts

@@ -1,7 +1,7 @@
-import { constants } from '../common/constants.js';
-import { EncoderBase } from '../common/encoder.js';
-import { unsupportedView } from '../common/errors.js';
-import { encode, stringByteLength } from '../common/string-encoder.js';
+import { constants } from '../helper/constants.js';
+import { unsupportedView } from '../helper/errors.js';
+import { encode, stringByteLength } from '../helper/string-encoder.js';
+import { EncoderBase } from '../base/encoder.js';
 
 const BLOCK_SIZE = 1024 * 64; // 64 KiB
 const MAX_SIZE = 1024 * 1024 * 32; // 32 MiB
@@ -32,14 +32,14 @@ function free(buf: Uint8Array): boolean {
 export class StreamEncoderHelper extends EncoderBase {
     constructor(protected readonly onChunk: (chunk: Uint8Array) => void) {
         super();
-        this.buffer = alloc(BLOCK_SIZE);
-        this.view = new DataView(this.buffer.buffer);
+        this.data = alloc(BLOCK_SIZE);
+        this.view = new DataView(this.data.buffer);
     }
     /**
      * 销毁实例，释放内存池
      */
     destroy(): void {
-        free(this.buffer);
+        free(this.data);
         const self = this as unknown as { view: DataView | null; buffer: Uint8Array | null };
         self.view = null;
         self.buffer = null;
@@ -53,26 +53,26 @@ export class StreamEncoderHelper extends EncoderBase {
             throw new Error('Buffer has exceed max size');
         }
         // 无需扩容
-        if (capacity >= 0 && this.buffer.byteLength >= this.length + capacity) return;
+        if (capacity >= 0 && this.data.byteLength >= this.length + capacity) return;
 
-        const CURRENT_SIZE = this.buffer.byteLength;
+        const CURRENT_SIZE = this.data.byteLength;
         const NEXT_SIZE = capacity < BLOCK_SIZE ? BLOCK_SIZE : capacity;
         const REUSE_BUF =
             CURRENT_SIZE >= NEXT_SIZE && // 满足容量需求
             CURRENT_SIZE - BLOCK_SIZE < NEXT_SIZE; // 不过于浪费
         // 提交目前的数据
         if (REUSE_BUF) {
-            this.onChunk(this.buffer.slice(0, this.length));
+            this.onChunk(this.data.slice(0, this.length));
         } else {
-            if (free(this.buffer)) {
+            if (free(this.data)) {
                 // 归还内存池成功，buffer 可能重用，需要拷贝数据
-                this.onChunk(this.buffer.slice(0, this.length));
+                this.onChunk(this.data.slice(0, this.length));
             } else {
-                this.onChunk(this.buffer.subarray(0, this.length));
+                this.onChunk(this.data.subarray(0, this.length));
             }
             // 重新分配缓冲区
-            this.buffer = alloc(NEXT_SIZE);
-            this.view = new DataView(this.buffer.buffer);
+            this.data = alloc(NEXT_SIZE);
+            this.view = new DataView(this.data.buffer);
         }
         this.length = 0;
     }
@@ -81,7 +81,7 @@ export class StreamEncoderHelper extends EncoderBase {
         const strLen = value.length;
         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(-1);