@cloudpss/ubjson 0.4.14 → 0.4.16

package/tests/stream/encode.js

@@ -8,7 +8,6 @@ import { toArray } from '../.utils.js';
 
 /**
  * 包装为 promise
- *
  * @param {unknown} value 值
  */
 function encodeAsync(value) {
@@ -60,21 +59,19 @@ test('encode int16', async () => {
 });
 
 test('encode int32', async () => {
-    expect(toArray(await encodeAsync(0x12345678))).toEqual(toArray('l', 0x12, 0x34, 0x56, 0x78));
+    expect(toArray(await encodeAsync(0x1234_5678))).toEqual(toArray('l', 0x12, 0x34, 0x56, 0x78));
 });
 
 test('encode float32', async () => {
-    expect(toArray(await encodeAsync(1.00390625))).toEqual(toArray('d', 0x3f, 0x80, 0x80, 0x00));
+    expect(toArray(await encodeAsync(1.003_906_25))).toEqual(toArray('d', 0x3f, 0x80, 0x80, 0x00));
 });
 
 test('encode float32 (too large integer)', async () => {
-    expect(toArray(await encodeAsync(2147483648))).toEqual(toArray('d', 0x4f, 0x00, 0x00, 0x00));
+    expect(toArray(await encodeAsync(2_147_483_648))).toEqual(toArray('d', 0x4f, 0x00, 0x00, 0x00));
 });
 
 test('encode float64', async () => {
-    expect(toArray(await encodeAsync(100000.00390625))).toEqual(
-        toArray('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00),
-    );
+    expect(toArray(await encodeAsync(100_000.003_906_25))).toEqual(toArray('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00));
 });
 
 test('encode char', async () => {
@@ -82,7 +79,7 @@ test('encode char', async () => {
 });
 
 test('encode char 128', async () => {
-    expect(toArray(await encodeAsync('\xcc'))).toEqual(toArray('C', '\xcc'));
+    expect(toArray(await encodeAsync('\u00CC'))).toEqual(toArray('C', '\u00CC'));
 });
 
 test('encode char 257', async () => {
@@ -126,7 +123,7 @@ test('encode array (undefined)', async () => {
 });
 
 test('encode array (spares)', async () => {
-    const array = new Array(3);
+    const array = Array.from({ length: 3 });
     array[1] = true;
     expect(toArray(await encodeAsync(array))).toEqual(toArray('[', 'Z', 'T', 'Z', ']'));
 });
@@ -190,25 +187,19 @@ test('encode array of objects of arrays', async () => {
 });
 
 test('encode array (int8 typed array)', async () => {
-    expect(toArray(await encodeAsync(Int8Array.from([18, -2])))).toEqual(
-        toArray('[', '$', 'i', '#', 'i', 2, 0x12, 0xfe),
-    );
+    expect(toArray(await encodeAsync(Int8Array.from([18, -2])))).toEqual(toArray('[', '$', 'i', '#', 'i', 2, 0x12, 0xfe));
 });
 
 test('encode array (uint8 typed array)', async () => {
-    expect(toArray(await encodeAsync(Uint8Array.from([18, 254])))).toEqual(
-        toArray('[', '$', 'U', '#', 'i', 2, 0x12, 0xfe),
-    );
+    expect(toArray(await encodeAsync(Uint8Array.from([18, 254])))).toEqual(toArray('[', '$', 'U', '#', 'i', 2, 0x12, 0xfe));
 });
 
 test('encode array (int16 typed array)', async () => {
-    expect(toArray(await encodeAsync(Int16Array.from([4660, -292])))).toEqual(
-        toArray('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc),
-    );
+    expect(toArray(await encodeAsync(Int16Array.from([4660, -292])))).toEqual(toArray('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc));
 });
 
 test('encode array (int32 typed array)', async () => {
-    expect(toArray(await encodeAsync(Int32Array.from([305419896, -19088744])))).toEqual(
+    expect(toArray(await encodeAsync(Int32Array.from([305_419_896, -19_088_744])))).toEqual(
         toArray('[', '$', 'l', '#', 'i', 2, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98),
     );
 });
@@ -221,30 +212,7 @@ test('encode array (float32 typed array)', async () => {
 
 test('encode array (float64 typed array)', async () => {
     expect(toArray(await encodeAsync(Float64Array.from([0.25, 0.125])))).toEqual(
-        toArray(
-            '[',
-            '$',
-            'D',
-            '#',
-            'i',
-            2,
-            0x3f,
-            0xd0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x3f,
-            0xc0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-        ),
+        toArray('[', '$', 'D', '#', 'i', 2, 0x3f, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
     );
 });
 
@@ -269,9 +237,7 @@ test('encode array (int64 typed array)', async () => {
 });
 
 test('encode object', async () => {
-    expect(toArray(await encodeAsync({ a: 1, b: 2, c: 3 }))).toEqual(
-        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'U', 2, 'i', 1, 'c', 'U', 3, '}'),
-    );
+    expect(toArray(await encodeAsync({ a: 1, b: 2, c: 3 }))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'U', 2, 'i', 1, 'c', 'U', 3, '}'));
 });
 
 test('encode object (empty)', async () => {
@@ -283,15 +249,11 @@ test('encode object (empty key)', async () => {
 });
 
 test('encode object (mixed)', async () => {
-    expect(toArray(await encodeAsync({ a: 1, b: 'a', c: true }))).toEqual(
-        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
-    );
+    expect(toArray(await encodeAsync({ a: 1, b: 'a', c: true }))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'));
 });
 
 test('encode object (only null values)', async () => {
-    expect(toArray(await encodeAsync({ a: null, b: null, c: null }))).toEqual(
-        toArray('{', 'i', 1, 'a', 'Z', 'i', 1, 'b', 'Z', 'i', 1, 'c', 'Z', '}'),
-    );
+    expect(toArray(await encodeAsync({ a: null, b: null, c: null }))).toEqual(toArray('{', 'i', 1, 'a', 'Z', 'i', 1, 'b', 'Z', 'i', 1, 'c', 'Z', '}'));
 });
 
 test('encode object (skip prototype)', async () => {
@@ -299,9 +261,7 @@ test('encode object (skip prototype)', async () => {
     obj.a = 1;
     obj.b = 'a';
     obj.c = true;
-    expect(toArray(await encodeAsync(obj))).toEqual(
-        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
-    );
+    expect(toArray(await encodeAsync(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'));
 });
 
 test('encode object (skip symbol)', async () => {
@@ -347,9 +307,7 @@ test('encode huge typed array (16K)', async () => {
 
 test('encode huge typed array (~128M)', async () => {
     const obj = new Uint8Array(128 * 1024 * 1024 - 10);
-    expect(toArray((await encodeAsync(obj)).slice(0, 10))).toEqual(
-        toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf6, 0),
-    );
+    expect(toArray((await encodeAsync(obj)).slice(0, 10))).toEqual(toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf6, 0));
 });
 
 test('encode huge typed array (256M + 1) [error]', async () => {
@@ -364,9 +322,7 @@ test('encode huge typed array (3G) [error]', async () => {
 
 test('encode huge data (~128M)', async () => {
     const obj = [new Uint8Array(128 * 1024 * 1024 - 20)];
-    expect(toArray((await encodeAsync(obj)).slice(0, 11))).toEqual(
-        toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0),
-    );
+    expect(toArray((await encodeAsync(obj)).subarray(0, 11))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0));
 });
 
 test('encode huge data (256M + 1) [error]', async () => {

package/tests/string-encoding.js

@@ -4,10 +4,7 @@ import { StringDecoder, decodeJs } from '../dist/common/string-decoder.js';
 /**
  * 测试编码
  */
-function testEncoding(
-    /** @type {Pick<TextEncoder, 'encode'>} */ encoder,
-    /** @type {Pick<TextDecoder, 'decode'>} */ decoder,
-) {
+function testEncoding(/** @type {Pick<TextEncoder, 'encode'>} */ encoder, /** @type {Pick<TextDecoder, 'decode'>} */ decoder) {
     expect(decoder.decode(encoder.encode(''))).toEqual('');
     expect(decoder.decode(encoder.encode('p4'))).toEqual('p4');
     expect(decoder.decode(encoder.encode('t0'))).toEqual('t0');
@@ -33,7 +30,7 @@ function testEncoding(
 
     {
         // 检查所有代理项
-        for (let index = 0x10000; index < 0x10ffff; index++) {
+        for (let index = 0x1_0000; index < 0x10_ffff; index++) {
             const expected = String.fromCodePoint(index);
             const actual = decoder.decode(encoder.encode(expected));
             if (expected !== actual) expect(actual).toEqual(expected);
@@ -53,7 +50,7 @@ function testEncoding(
 }
 
 test('encode string', () => {
-    testEncoding(new StringEncoder(), new TextDecoder('utf-8', { ignoreBOM: true, fatal: false }));
+    testEncoding(new StringEncoder(), new TextDecoder('utf8', { ignoreBOM: true, fatal: false }));
 });
 
 test('decode string', () => {
@@ -80,5 +77,5 @@ test('decode string js', () => {
 
 test('decode malformed', () => {
     const decoder = new StringDecoder();
-    expect(decoder.decode(new Uint8Array([0xff, 'a'.charCodeAt(0)]), 0, 2)).toEqual('\ufffda');
+    expect(decoder.decode(new Uint8Array([0xff, 'a'.charCodeAt(0)]), 0, 2)).toEqual('\uFFFDa');
 });