@cloudpss/ubjson 0.5.39 → 0.5.41

package/src/stream-helper/encoder.ts

@@ -1,7 +1,8 @@
 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';
+import type { EncodeOptions } from '../options.js';
 
 const BLOCK_SIZE = 1024 * 64; // 64 KiB
 const MAX_SIZE = 1024 * 1024 * 32; // 32 MiB
@@ -30,8 +31,12 @@ function free(buf: Uint8Array): boolean {
 
 /** 流式编码 UBJSON */
 export class StreamEncoderHelper extends EncoderBase {
-    constructor(protected readonly onChunk: (chunk: Uint8Array) => void) {
+    constructor(
+        options: EncodeOptions | null | undefined,
+        protected readonly onChunk: (chunk: Uint8Array) => void,
+    ) {
         super();
+        this.sortObjectKeys = options?.sortObjectKeys ?? false;
         this.data = alloc(BLOCK_SIZE);
         this.view = new DataView(this.data.buffer);
     }
@@ -102,54 +107,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/.utils.js

@@ -2,6 +2,7 @@ import { resetEnv as resetDecoderEnv } from '../dist/helper/string-decoder.js';
 import { resetEnv as resetEncoderEnv } from '../dist/helper/string-encoder.js';
 import { resetEncoder } from '../dist/encoder.js';
 import '../dist/helper/constants.js';
+import '../dist/options.js';
 
 /**
  * 重设所有环境

package/tests/e2e/stream.js

@@ -13,7 +13,19 @@ describe('stream', () => {
                 expect(decoded).toEqual(expected);
             }).rejects.toThrow(expected);
         } else {
-            const decoded = await decodeStream(encodeStream(input));
+            const encoded = await encodeStream(input).toArray();
+            const data = encoded.flatMap((/** @type {Buffer} */ chunk) => {
+                // split to random chunks
+                const chunks = [];
+                let offset = 0;
+                while (offset < chunk.length) {
+                    const size = Math.floor(Math.random() * chunk.length);
+                    chunks.push(chunk.subarray(offset, offset + size));
+                    offset += size;
+                }
+                return chunks;
+            });
+            const decoded = await decodeStream(Readable.from(data));
             expect(decoded).toEqual(expected);
         }
     });

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 }, { sortObjectKeys: true }))).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