@cloudpss/ubjson 0.4.32 → 0.4.33

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'));

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'));

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
   }
 }