@cloudpss/ubjson 0.5.38 → 0.5.40

package/src/helper/encode.ts

@@ -35,12 +35,14 @@ export function writeMarker(cursor: EncodeCursor, marker: constants): void {
     cursor.data[cursor.length++] = marker;
 }
 
+export const I8_MASK = constants.INT8 << 8;
+export const U8_MASK = constants.UINT8 << 8;
 /** 写入长度 */
 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;
+        cursor.view.setUint16(cursor.length, I8_MASK | length);
+        cursor.length += 2;
     } else if (length < 0x8000) {
         cursor.ensureCapacity(3);
         cursor.data[cursor.length++] = constants.INT16;
@@ -61,29 +63,153 @@ export function writeLength(cursor: EncodeCursor, length: number): void {
     }
 }
 
+/** 写入数字 */
+export function writeNumber(cursor: EncodeCursor, value: number): void {
+    // eslint-disable-next-line unicorn/prefer-math-trunc
+    if (value >> 0 === value) {
+        if (value >= 0 && value <= 0xff) {
+            cursor.ensureCapacity(2);
+            const { length } = cursor;
+            cursor.view.setUint16(length, U8_MASK | value);
+            cursor.length = length + 2;
+        } else if (value < 0x80 && value >= -0x80) {
+            cursor.ensureCapacity(2);
+            const { length } = cursor;
+            cursor.view.setUint16(length, I8_MASK | (value & 0xff));
+            cursor.length = length + 2;
+        } else if (value < 0x8000 && value >= -0x8000) {
+            cursor.ensureCapacity(3);
+            const { length } = cursor;
+            cursor.data[length] = constants.INT16;
+            cursor.view.setInt16(length + 1, value);
+            cursor.length = length + 3;
+        } else {
+            // must be 32 bit
+            cursor.ensureCapacity(5);
+            const { length } = cursor;
+            cursor.data[length] = constants.INT32;
+            cursor.view.setInt32(length + 1, value);
+            cursor.length = length + 5;
+        }
+    } else if (Number.isNaN(value) || Math.fround(value) === value) {
+        // 如果不会损失精度，使用 32 位浮点
+        cursor.ensureCapacity(5);
+        const { length } = cursor;
+        cursor.data[length] = constants.FLOAT32;
+        cursor.view.setFloat32(length + 1, value);
+        cursor.length = length + 5;
+    } else {
+        cursor.ensureCapacity(9);
+        const { length } = cursor;
+        cursor.data[length] = constants.FLOAT64;
+        cursor.view.setFloat64(length + 1, value);
+        cursor.length = length + 9;
+    }
+    return;
+}
+
+/** TypedArray 类型 */
+export type TypedArrayType =
+    | constants.UINT8
+    | constants.INT8
+    | constants.INT16
+    | constants.INT32
+    | constants.INT64
+    | constants.FLOAT32
+    | constants.FLOAT64;
+const T_ARR_HEADER = (type: TypedArrayType): number =>
+    (constants.ARRAY << 24) | (constants.TYPE_MARKER << 16) | (type << 8) | constants.COUNT_MARKER;
+export const U8_ARR_HEADER = T_ARR_HEADER(constants.UINT8);
+export const I8_ARR_HEADER = T_ARR_HEADER(constants.INT8);
+export const I16_ARR_HEADER = T_ARR_HEADER(constants.INT16);
+export const I32_ARR_HEADER = T_ARR_HEADER(constants.INT32);
+export const I64_ARR_HEADER = T_ARR_HEADER(constants.INT64);
+export const F32_ARR_HEADER = T_ARR_HEADER(constants.FLOAT32);
+export const F64_ARR_HEADER = T_ARR_HEADER(constants.FLOAT64);
+
 /** 写入 TypedArray 前导，包括 marker 和长度 */
-export function writeTypedArrayHeader(cursor: EncodeCursor, value: ArrayBufferView): void {
+export function writeTypedArrayHeader(cursor: EncodeCursor, value: ArrayBufferView): TypedArrayType {
     // 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;
+    let type: TypedArrayType;
+    const { length } = cursor;
     if (value instanceof Uint8Array) {
-        cursor.data[cursor.length++] = constants.UINT8;
+        cursor.view.setUint32(length, U8_ARR_HEADER);
+        type = constants.UINT8;
     } else if (value instanceof Float64Array) {
-        cursor.data[cursor.length++] = constants.FLOAT64;
+        cursor.view.setUint32(length, F64_ARR_HEADER);
+        type = constants.FLOAT64;
     } else if (value instanceof Int32Array) {
-        cursor.data[cursor.length++] = constants.INT32;
+        cursor.view.setUint32(length, I32_ARR_HEADER);
+        type = constants.INT32;
+    } else if (value instanceof BigInt64Array) {
+        cursor.view.setUint32(length, I64_ARR_HEADER);
+        type = constants.INT64;
+    } else if (value instanceof Float32Array) {
+        cursor.view.setUint32(length, F32_ARR_HEADER);
+        type = constants.FLOAT32;
     } else if (value instanceof Int8Array) {
-        cursor.data[cursor.length++] = constants.INT8;
+        cursor.view.setUint32(length, I8_ARR_HEADER);
+        type = 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;
+        cursor.view.setUint32(length, I16_ARR_HEADER);
+        type = constants.INT16;
     } else {
         unsupportedView(value);
     }
-    cursor.data[cursor.length++] = constants.COUNT_MARKER;
+    cursor.length = length + 4;
     writeLength(cursor, value.length);
+    return type;
+}
+/** 写入 TypedArray */
+export function writeTypedArray(cursor: EncodeCursor, value: ArrayBufferView): void {
+    cursor.ensureCapacity(9 + value.byteLength);
+    const type = writeTypedArrayHeader(cursor, value);
+    writeTypedArrayData(cursor, type, value);
+}
+/** 写入 TypedArray 数据 */
+export function writeTypedArrayData(cursor: EncodeCursor, type: TypedArrayType, value: ArrayBufferView): void {
+    const { byteLength } = value;
+    cursor.ensureCapacity(byteLength);
+    let pointer = cursor.length;
+    cursor.length = pointer + byteLength;
+    if (type === constants.UINT8 || type === constants.INT8) {
+        // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
+        cursor.data.set(value as Uint8Array | Int8Array, pointer);
+        return;
+    }
+
+    const { view } = cursor;
+    if (type === constants.FLOAT64) {
+        const arrayLength = byteLength / 8;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setFloat64(pointer, (value as Float64Array)[i]!);
+            pointer += 8;
+        }
+    } else if (type === constants.INT32) {
+        const arrayLength = byteLength / 4;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setInt32(pointer, (value as Int32Array)[i]!);
+            pointer += 4;
+        }
+    } else if (type === constants.INT64) {
+        const arrayLength = byteLength / 8;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setBigInt64(pointer, (value as BigInt64Array)[i]!);
+            pointer += 8;
+        }
+    } else if (type === constants.FLOAT32) {
+        const arrayLength = byteLength / 4;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setFloat32(pointer, (value as Float32Array)[i]!);
+            pointer += 4;
+        }
+    } else {
+        (type) satisfies constants.INT16;
+        const arrayLength = byteLength / 2;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setInt16(pointer, (value as Int16Array)[i]!);
+            pointer += 2;
+        }
+    }
 }

package/src/helper/string-decoder.ts

@@ -53,19 +53,19 @@ export function jsDecode(bytes: Uint8Array, begin: number, end: number): string
 }
 
 /** 解码 Ascii */
-function longStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
-    const bytes = Array.from<number>({ length });
+export function longStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
+    const bytes = [];
     for (let i = 0; i < length; i++) {
         const byte = buf[begin++]!;
-        if ((byte & 0x80) > 0) {
+        if (byte & 0x80) {
             return;
         }
-        bytes[i] = byte;
+        bytes.push(byte);
     }
     return fromCharCode(...bytes);
 }
 /** 解码 Ascii */
-function shortStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
+export function shortStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
     if (length < 4) {
         if (length < 2) {
             if (length === 0) return '';
@@ -198,8 +198,12 @@ export function decode(data: Uint8Array, begin: number, end: number): string {
         const result = shortStringInJS(data, begin, length);
         if (result != null) return result;
     }
-    // 只有小字符串有优化价值，见 benchmark-string.js
+    // 只有小字符串有优化价值
     if (length < TEXT_DECODER_THRESHOLD) {
+        // if (length < 32) {
+        //     const result = longStringInJS(data, begin, length);
+        //     if (result != null) return result;
+        // }
         // 为小字符串优化
         return jsDecode(data, begin, end);
     }
@@ -207,42 +211,9 @@ export function decode(data: Uint8Array, begin: number, end: number): string {
     return nativeDecode(data, begin, end);
 }
 
-const KEY_CACHE = Array.from<{ value: string; buffer: Uint8Array } | undefined>({ length: 4096 });
-
-/** 字符串解码，使用缓存 */
-export function decodeKey(data: Uint8Array, begin: number, end: number): string {
-    const length = end - begin;
-    const cacheKey =
-        ((length << 5) ^ (length > 1 ? data[begin]! & (data[begin + 1]! << 8) : length > 0 ? data[begin]! : 0)) & 0xfff;
-    let entry = KEY_CACHE[cacheKey];
-    if (entry != null && entry.buffer.byteLength === length) {
-        let i = 0;
-        for (; i < length; i++) {
-            if (entry.buffer[i] !== data[begin + i]) break;
-        }
-        if (i === length) return entry.value;
-    }
-
-    let str = length < 16 ? shortStringInJS(data, begin, length) : longStringInJS(data, begin, length);
-    if (str == null) {
-        // 只有小字符串有优化价值，见 benchmark-string.js
-        if (length < TEXT_DECODER_THRESHOLD) {
-            // 为小字符串优化
-            str = jsDecode(data, begin, end);
-        } else {
-            // 使用系统解码
-            str = nativeDecode(data, begin, end);
-        }
-    }
-    entry = { value: str, buffer: data.slice(begin, end) };
-    KEY_CACHE[cacheKey] = entry;
-    return str;
-}
-
 /** 重设环境 */
 export function resetEnv(): void {
     TEXT_DECODER = typeof TextDecoder == 'function' ? new TextDecoder('utf8', { ignoreBOM: true, fatal: false }) : null;
     TEXT_DECODER_THRESHOLD = TEXT_DECODER == null ? 0xffff_ffff : 16;
-    KEY_CACHE.fill(undefined);
 }
 resetEnv();

package/src/stream-helper/encoder.ts

@@ -1,7 +1,7 @@
 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';
+import type { TypedArrayType } from '../helper/encode.js';
 
 const BLOCK_SIZE = 1024 * 64; // 64 KiB
 const MAX_SIZE = 1024 * 1024 * 32; // 32 MiB
@@ -102,54 +102,54 @@ export class StreamEncoderHelper extends EncoderBase {
         }
     }
     /** @inheritdoc */
-    protected override writeLargeTypedArrayData(value: ArrayBufferView): void {
+    protected override writeLargeTypedArrayData(type: TypedArrayType, value: ArrayBufferView): void {
         this.ensureCapacity(-1);
-        if (value instanceof Uint8Array || value instanceof Int8Array) {
+        const { byteLength } = value;
+        if (type === constants.UINT8 || type === constants.INT8) {
             // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
             // divide buffer to 64k chunks
-            for (let i = 0; i < value.byteLength; i += BLOCK_SIZE) {
-                this.onChunk(
-                    new Uint8Array(value.buffer.slice(value.byteOffset + i, value.byteOffset + i + BLOCK_SIZE)),
-                );
+            const { buffer, byteOffset } = value;
+            for (let i = 0; i < byteLength; i += BLOCK_SIZE) {
+                this.onChunk(new Uint8Array(buffer.slice(byteOffset + i, byteOffset + i + BLOCK_SIZE)));
             }
             return;
         }
-
-        const arrayLength = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array).length;
-        const elementSize = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array)
-            .BYTES_PER_ELEMENT;
-        if (value instanceof Int16Array) {
+        if (type === constants.FLOAT64) {
+            const arrayLength = byteLength / 8;
             for (let i = 0; i < arrayLength; i++) {
-                this.ensureCapacity(elementSize);
-                this.view.setInt16(this.length, value[i]!);
-                this.length += elementSize;
+                this.ensureCapacity(8);
+                this.view.setFloat64(this.length, (value as Float64Array)[i]!);
+                this.length += 8;
             }
-        } else if (value instanceof Int32Array) {
+        } else if (type === constants.INT32) {
+            const arrayLength = byteLength / 4;
             for (let i = 0; i < arrayLength; i++) {
-                this.ensureCapacity(elementSize);
-                this.view.setInt32(this.length, value[i]!);
-                this.length += elementSize;
+                this.ensureCapacity(4);
+                this.view.setInt32(this.length, (value as Int32Array)[i]!);
+                this.length += 4;
             }
-        } else if (value instanceof Float32Array) {
+        } else if (type === constants.INT64) {
+            const arrayLength = byteLength / 8;
             for (let i = 0; i < arrayLength; i++) {
-                this.ensureCapacity(elementSize);
-                this.view.setFloat32(this.length, value[i]!);
-                this.length += elementSize;
+                this.ensureCapacity(8);
+                this.view.setBigInt64(this.length, (value as BigInt64Array)[i]!);
+                this.length += 8;
             }
-        } else if (value instanceof Float64Array) {
+        } else if (type === constants.FLOAT32) {
+            const arrayLength = byteLength / 4;
             for (let i = 0; i < arrayLength; i++) {
-                this.ensureCapacity(elementSize);
-                this.view.setFloat64(this.length, value[i]!);
-                this.length += elementSize;
+                this.ensureCapacity(4);
+                this.view.setFloat32(this.length, (value as Float32Array)[i]!);
+                this.length += 4;
             }
-        } else if (value instanceof BigInt64Array) {
+        } else {
+            (type) satisfies constants.INT16;
+            const arrayLength = byteLength / 2;
             for (let i = 0; i < arrayLength; i++) {
-                this.ensureCapacity(elementSize);
-                this.view.setBigInt64(this.length, value[i]!);
-                this.length += elementSize;
+                this.ensureCapacity(2);
+                this.view.setInt16(this.length, (value as Int16Array)[i]!);
+                this.length += 2;
             }
-        } else {
-            unsupportedView(value);
         }
     }
     /** 获取写入结果 */

package/tests/encode.js

@@ -407,6 +407,14 @@ test('encode object', () => {
     expect(getEncoder().pool).toBe(poolInit);
 });
 
+test('encode object (keep order)', () => {
+    expect(toArray(encode({ b: 2, a: 1, c: 3 }))).toEqual(
+        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'U', 2, 'i', 1, 'c', 'U', 3, '}'),
+    );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
+});
+
 test('encode object (empty)', () => {
     expect(toArray(encode({}))).toEqual(toArray('{', '}'));
     // @ts-expect-error Access private property

package/tests/string-encoding.js

@@ -1,5 +1,5 @@
 import { Encoder } from '../dist/encoder.js';
-import { decode, decodeKey, jsDecode } from '../dist/helper/string-decoder.js';
+import { decode, jsDecode } from '../dist/helper/string-decoder.js';
 
 /**
  * 测试编码
@@ -111,15 +111,6 @@ test('decode string', () => {
     });
 });
 
-test('decode string key', () => {
-    testEncoding(new TextEncoder(), {
-        decode(buffer) {
-            if (!(buffer instanceof Uint8Array)) return '';
-            return decodeKey(buffer, 0, buffer.byteLength);
-        },
-    });
-});
-
 test('decode string js', () => {
     testEncoding(new TextEncoder(), {
         decode(buffer) {

package/tests/tsconfig.json

@@ -1,9 +1,3 @@
 {
-  "extends": "../tsconfig",
-  "include": ["./"],
-  "compilerOptions": {
-    "checkJs": true,
-    "noEmit": true,
-    "noUncheckedIndexedAccess": false
-  }
+  "extends": "../../tsconfig.test"
 }

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "../../tsconfig",
+  "extends": "../tsconfig.build",
   "compilerOptions": {
     "isolatedModules": false,
     "verbatimModuleSyntax": false