@cloudpss/ubjson 0.4.32 → 0.4.34

package/tests/encode.js

@@ -69,8 +69,8 @@ test('encode char', () => {
     expect(toArray(encode('a'))).toEqual(toArray('C', 'a'));
 });
 
-test('encode char 128', () => {
-    expect(toArray(encode('\u00CC'))).toEqual(toArray('C', '\u00CC'));
+test('encode char 127', () => {
+    expect(toArray(encode('\u007F'))).toEqual(toArray('C', '\u007F'));
 });
 
 test('encode char 257', () => {
@@ -85,15 +85,27 @@ test('encode string', () => {
     expect(toArray(encode('ubjson'))).toEqual(toArray('S', 'i', 6, ...'ubjson'));
 });
 
-test('encode string (u8 len)', () => {
+test('encode string (len = 60)', () => {
     // 不生成 u8
-    expect(toArray(encode('ubjson'.repeat(10)))).toEqual(toArray('S', 'I', 0, 6 * 10, ...'ubjson'.repeat(10)));
+    const str = 'ubjson'.repeat(10);
+    expect(toArray(encode(str))).toEqual(toArray('S', 'i', str.length, ...str));
+});
+
+test('encode string (len = 120)', () => {
+    // 不生成 u8
+    const str = 'ubjson'.repeat(20);
+    expect(toArray(encode(str))).toEqual(toArray('S', 'i', str.length, ...str));
+});
+
+test('encode string (len = 180)', () => {
+    // 不生成 u8
+    const str = 'ubjson'.repeat(30);
+    expect(toArray(encode(str))).toEqual(toArray('S', 'I', 0, str.length, ...str));
 });
 
 test('encode string (no encodeInto)', () => {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const encodeInto = TextEncoder.prototype.encodeInto;
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error 移除 encodeInto 以测试兼容性
     TextEncoder.prototype.encodeInto = undefined;
     expect(toArray(encode('ubjson'))).toEqual(toArray('S', 'i', 6, ...'ubjson'));
@@ -113,6 +125,10 @@ test('encode array (undefined)', () => {
     expect(toArray(encode([undefined]))).toEqual(toArray('[', 'Z', ']'));
 });
 
+test('encode array (function)', () => {
+    expect(toArray(encode([() => 1]))).toEqual(toArray('[', 'Z', ']'));
+});
+
 test('encode array (spares)', () => {
     const array = Array.from({ length: 3 });
     array[1] = true;
@@ -314,13 +330,9 @@ test('encode object (skip undefined)', () => {
     expect(toArray(encode(obj))).toEqual(toArray('{', '}'));
 });
 
-test('encode object (function) [error]', () => {
-    const obj = {
-        a: () => {
-            // noop
-        },
-    };
-    expect(() => encode(obj)).toThrow(/Unsupported type \[object Function\]/);
+test('encode object (skip function)', () => {
+    const obj = { a: 1, b: () => 1 };
+    expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, '}'));
 });
 
 test('encode object (include null)', () => {
@@ -357,31 +369,48 @@ test('encode huge data (~128M)', () => {
     );
 });
 
-test('encode huge data (128M)', () => {
-    const obj = [new Uint8Array(128 * 1024 * 1024)];
+test('encode huge data (128M - 9)', () => {
+    const obj = [new Uint8Array(128 * 1024 * 1024 - 9)];
     obj[0][0] = 0x12;
     obj[0][1] = 0x34;
     const encoded = encode(obj);
-    expect(encoded.length).toBe(128 * 1024 * 1024 + 9 + 2);
-    expect(toArray(encoded.slice(0, 12))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x8, 0, 0, 0, 0x12, 0x34));
+    expect(encoded.length).toBe(128 * 1024 * 1024 + 2);
+    // (128 * 1024 * 1024 - 9) === 0x7fffff7
+    expect(toArray(encoded.slice(0, 12))).toEqual(
+        toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf7, 0x12, 0x34),
+    );
 });
 
-test('encode huge data (128M + 1) [error]', () => {
-    const obj = [new Uint8Array(128 * 1024 * 1024 + 1)];
+test('encode huge data (128M - 8) [error]', () => {
+    const obj = [new Uint8Array(128 * 1024 * 1024 - 8)];
     expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
 });
 
 test('encode huge data (256M)', () => {
-    const obj = [new Uint8Array(128 * 1024 * 1024), new Uint8Array(128 * 1024 * 1024)];
+    const obj = [new Uint8Array(128 * 1024 * 1024 - 9), new Uint8Array(128 * 1024 * 1024 - 9)];
     obj[0][0] = 0x12;
     obj[0][1] = 0x34;
     obj[1][0] = 0x56;
     obj[1][1] = 0x78;
     const encoded = encode(obj);
-    expect(encoded.length).toBe(128 * 1024 * 1024 * 2 + 9 * 2 + 2);
-    expect(toArray(encoded.slice(0, 12))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x8, 0, 0, 0, 0x12, 0x34));
-    expect(toArray(encoded.slice(128 * 1024 * 1024 + 10, 128 * 1024 * 1024 + 10 + 11))).toEqual(
-        toArray('[', '$', 'U', '#', 'l', 0x8, 0, 0, 0, 0x56, 0x78),
+    expect(encoded.length).toBe(128 * 1024 * 1024 * 2 + 2);
+    expect(toArray(encoded.slice(0, 12))).toEqual(
+        toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf7, 0x12, 0x34),
+    );
+    expect(toArray(encoded.slice(128 * 1024 * 1024 + 1, 128 * 1024 * 1024 + 1 + 11))).toEqual(
+        toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf7, 0x56, 0x78),
     );
     expect(toArray(encoded.slice(-1))).toEqual(toArray(']'));
 });
+
+test('encode custom toJSON', () => {
+    const obj = {
+        toJSON: () => ({ a: 1 }),
+    };
+    expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, '}'));
+});
+
+test('encode Date', () => {
+    const obj = new Date(0);
+    expect(toArray(encode(obj))).toEqual(toArray('S', 'i', 24, ...'1970-01-01T00:00:00.000Z'));
+});

package/tests/rxjs/decode.js

@@ -5,6 +5,7 @@ import { jest } from '@jest/globals';
 import { firstValueFrom, of, Subject } from 'rxjs';
 import { decode as decodePipe } from '../../dist/rxjs/index.js';
 import { toBuffer } from '../.utils.js';
+import { UnexpectedEof } from '../../dist/utils.js';
 
 /**
  * 包装为 promise
@@ -109,7 +110,7 @@ test('decode string (bad size) [error]', async () => {
 });
 
 test('decode string (unexpected eof) [error]', async () => {
-    await expect(() => decode(toBuffer('S', 'i', 2, 'x'))).rejects.toThrow(/Unexpected EOF/);
+    await expect(() => decode(toBuffer('S', 'i', 2, 'x'))).rejects.toThrow(UnexpectedEof);
 });
 
 test('decode ascii string', async () => {
@@ -306,7 +307,7 @@ test('decode array of objects of arrays (optimized)', async () => {
 });
 
 test('decode array (strongly typed, unexpected eof, optimized)', async () => {
-    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2))).rejects.toThrow();
+    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2))).rejects.toThrow(UnexpectedEof);
 });
 
 test('decode array (strongly typed, invalid length value, optimized)', async () => {

package/tests/rxjs/encode.js

@@ -85,8 +85,8 @@ test('encode char', async () => {
     expect(toArray(await encodeAsync('a'))).toEqual(toArray('C', 'a'));
 });
 
-test('encode char 128', async () => {
-    expect(toArray(await encodeAsync('\u00CC'))).toEqual(toArray('C', '\u00CC'));
+test('encode char 127', async () => {
+    expect(toArray(await encodeAsync('\u007F'))).toEqual(toArray('C', '\u007F'));
 });
 
 test('encode char 257', async () => {
@@ -109,7 +109,6 @@ test('encode huge string', async () => {
 test('encode string (no encodeInto)', async () => {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const encodeInto = TextEncoder.prototype.encodeInto;
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error 移除 encodeInto 以测试兼容性
     TextEncoder.prototype.encodeInto = undefined;
     expect(toArray(await encodeAsync('ubjson'))).toEqual(toArray('S', 'i', 6, 'u', 'b', 'j', 's', 'o', 'n'));
@@ -330,13 +329,11 @@ test('encode object (skip undefined)', async () => {
     expect(toArray(await encodeAsync(obj))).toEqual(toArray('{', '}'));
 });
 
-test('encode object (function) [error]', async () => {
+test('encode object (skip function)', async () => {
     const obj = {
-        a: () => {
-            // noop
-        },
+        a: () => 1,
     };
-    await expect(() => encodeAsync(obj)).rejects.toThrow(/Unsupported type \[object Function\]/);
+    expect(toArray(await encodeAsync(obj))).toEqual(toArray('{', '}'));
 });
 
 test('encode object (include null)', async () => {

package/tests/stream/decode.js

@@ -5,6 +5,7 @@ import { jest } from '@jest/globals';
 import { Readable } from 'node:stream';
 import { decoder as decodeStream, decode as decodeAsync } from '../../dist/stream/index.js';
 import { toBuffer } from '../.utils.js';
+import { UnexpectedEof } from '../../dist/utils.js';
 
 /**
  * 包装为 promise
@@ -104,7 +105,7 @@ test('decode string (bad size) [error]', async () => {
 });
 
 test('decode string (unexpected eof) [error]', async () => {
-    await expect(() => decode(toBuffer('S', 'i', 2, 'x'))).rejects.toThrow(/Unexpected EOF/);
+    await expect(() => decode(toBuffer('S', 'i', 2, 'x'))).rejects.toThrow(UnexpectedEof);
 });
 
 test('decode ascii string', async () => {

package/tests/stream/encode.js

@@ -80,8 +80,8 @@ test('encode char', async () => {
     expect(toArray(await encodeAsync('a'))).toEqual(toArray('C', 'a'));
 });
 
-test('encode char 128', async () => {
-    expect(toArray(await encodeAsync('\u00CC'))).toEqual(toArray('C', '\u00CC'));
+test('encode char 127', async () => {
+    expect(toArray(await encodeAsync('\u007F'))).toEqual(toArray('C', '\u007F'));
 });
 
 test('encode char 257', async () => {
@@ -104,7 +104,6 @@ test('encode huge string', async () => {
 test('encode string (no encodeInto)', async () => {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const encodeInto = TextEncoder.prototype.encodeInto;
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error 移除 encodeInto 以测试兼容性
     TextEncoder.prototype.encodeInto = undefined;
     expect(toArray(await encodeAsync('ubjson'))).toEqual(toArray('S', 'i', 6, 'u', 'b', 'j', 's', 'o', 'n'));
@@ -325,13 +324,13 @@ test('encode object (skip undefined)', async () => {
     expect(toArray(await encodeAsync(obj))).toEqual(toArray('{', '}'));
 });
 
-test('encode object (function) [error]', async () => {
+test('encode object (skip function)', async () => {
     const obj = {
         a: () => {
             // noop
         },
     };
-    await expect(() => encodeAsync(obj)).rejects.toThrow(/Unsupported type \[object Function\]/);
+    expect(toArray(await encodeAsync(obj))).toEqual(toArray('{', '}'));
 });
 
 test('encode object (include null)', async () => {

package/tests/string-encoding.js

@@ -1,5 +1,6 @@
-import { StringEncoder } from '../dist/common/string-encoder.js';
-import { StringDecoder, decodeJs } from '../dist/common/string-decoder.js';
+import { Encoder } from '../dist/encoder.js';
+import { decode, decodeKey, decodeJs } from '../dist/common/string-decoder.js';
+import '../dist/common/constants.js';
 
 /**
  * 测试编码
@@ -9,25 +10,59 @@ function testEncoding(
     /** @type {Pick<TextDecoder, 'decode'>} */ decoder,
 ) {
     expect(decoder.decode(encoder.encode(''))).toEqual('');
+    expect(decoder.decode(encoder.encode('a'))).toEqual('a');
     expect(decoder.decode(encoder.encode('p4'))).toEqual('p4');
     expect(decoder.decode(encoder.encode('t0'))).toEqual('t0');
-    expect(decoder.decode(encoder.encode('ab'))).toEqual('ab');
-    expect(decoder.decode(encoder.encode('ba'))).toEqual('ba');
+    expect(decoder.decode(encoder.encode('qwe'))).toEqual('qwe');
+    expect(decoder.decode(encoder.encode('1qaz'))).toEqual('1qaz');
     expect(decoder.decode(encoder.encode('123456'))).toEqual('123456');
     expect(decoder.decode(encoder.encode('123465'))).toEqual('123465');
     expect(decoder.decode(encoder.encode('1234651'))).toEqual('1234651');
     expect(decoder.decode(encoder.encode('1234651'))).toEqual('1234651');
+    expect(decoder.decode(encoder.encode('12346511234651'))).toEqual('12346511234651');
+    expect(decoder.decode(encoder.encode('123465112346511234651'))).toEqual('123465112346511234651');
     expect(decoder.decode(encoder.encode('abc 你好 😊🤣'))).toEqual('abc 你好 😊🤣');
+    expect(decoder.decode(encoder.encode('abc 你好abc 你好abc 你好 😊🤣'))).toEqual('abc 你好abc 你好abc 你好 😊🤣');
+    expect(decoder.decode(encoder.encode('水'.repeat(127)))).toEqual('水'.repeat(127));
+    expect(decoder.decode(encoder.encode('水'.repeat(32767)))).toEqual('水'.repeat(32767));
     expect(decoder.decode(encoder.encode('abc 你好 😊🤣'.repeat(1000)))).toEqual('abc 你好 😊🤣'.repeat(1000));
 
+    for (let length = 1; length < 1024; length++) {
+        const expected = 'a'.repeat(length);
+        const actual = decoder.decode(encoder.encode(expected));
+        expect(actual).toEqual(expected);
+
+        const expected2 = '©'.repeat(length);
+        const actual2 = decoder.decode(encoder.encode(expected2));
+        expect(actual2).toEqual(expected2);
+
+        const expected3 = '水'.repeat(length);
+        const actual3 = decoder.decode(encoder.encode(expected3));
+        expect(actual3).toEqual(expected3);
+
+        const expected4 = '😊'.repeat(length);
+        const actual4 = decoder.decode(encoder.encode(expected4));
+        expect(actual4).toEqual(expected4);
+
+        const bad = new Uint8Array(length);
+        bad.fill(0xff);
+        expect(decoder.decode(bad)).toEqual('\uFFFD'.repeat(length));
+
+        bad.fill('a'.charCodeAt(0), 0, length - 1);
+        expect(decoder.decode(bad)).toEqual('a'.repeat(length - 1) + '\uFFFD');
+    }
+
     {
         // 检查所有单字节
         for (let index = 0; index < 0xffff; index++) {
             // 跳过 Surrogate
             if (index >= 0xd800 && index <= 0xdfff) continue;
             const expected = String.fromCharCode(index);
-            const actual = decoder.decode(encoder.encode(expected));
-            if (expected !== actual) expect(actual).toEqual(expected);
+            const encoded = encoder.encode(expected);
+            const actual = decoder.decode(encoded);
+            if (expected !== actual) {
+                expect(actual).toEqual(expected);
+            }
         }
     }
 
@@ -53,32 +88,49 @@ function testEncoding(
 }
 
 test('encode string', () => {
-    testEncoding(new StringEncoder(), new TextDecoder('utf8', { ignoreBOM: true, fatal: false }));
+    testEncoding(
+        {
+            encode(s) {
+                const encoder = new Encoder(s);
+                const buffer = encoder.encode();
+                if (buffer[0] === 67) return buffer.subarray(1);
+                if (buffer[1] === 105) return buffer.subarray(3);
+                if (buffer[1] === 73) return buffer.subarray(4);
+                if (buffer[1] === 108) return buffer.subarray(6);
+                throw new Error('Invalid buffer');
+            },
+        },
+        new TextDecoder('utf8', { ignoreBOM: true, fatal: false }),
+    );
 });
 
 test('decode string', () => {
-    testEncoding(
-        new TextEncoder(),
-        new (class extends StringDecoder {
-            /** @override */ decode(/** @type {Uint8Array} */ buffer) {
-                return super.decode(buffer, 0, buffer.byteLength);
-            }
-        })(),
-    );
+    testEncoding(new TextEncoder(), {
+        decode(buffer) {
+            if (!(buffer instanceof Uint8Array)) return '';
+            return decode(buffer, 0, buffer.byteLength);
+        },
+    });
+});
+
+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(),
-        new (class extends StringDecoder {
-            /** @override */ decode(/** @type {Uint8Array} */ buffer) {
-                return decodeJs(buffer, 0, buffer.byteLength);
-            }
-        })(),
-    );
+    testEncoding(new TextEncoder(), {
+        decode(buffer) {
+            if (!(buffer instanceof Uint8Array)) return '';
+            return decodeJs(buffer, 0, buffer.byteLength);
+        },
+    });
 });
 
 test('decode malformed', () => {
-    const decoder = new StringDecoder();
-    expect(decoder.decode(new Uint8Array([0xff, 'a'.charCodeAt(0)]), 0, 2)).toEqual('\uFFFDa');
+    expect(decode(new Uint8Array([0xff, 'a'.charCodeAt(0)]), 0, 2)).toEqual('\uFFFDa');
 });

package/tsconfig.json

@@ -2,6 +2,8 @@
   "extends": "../../tsconfig",
   "include": ["./src/"],
   "compilerOptions": {
-    "outDir": "./dist"
+    "outDir": "./dist",
+    "isolatedModules": false,
+    "verbatimModuleSyntax": false
   }
 }