@cloudpss/ubjson 0.6.0-alpha.8 → 0.6.0-alpha.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudpss/ubjson",
-  "version": "0.6.0-alpha.8",
+  "version": "0.6.0-alpha.9",
   "author": "CloudPSS",
   "license": "MIT",
   "keywords": [

package/tests/.utils.ts

@@ -7,7 +7,7 @@ import '../dist/options.js';
 /**
  * 重设所有环境
  */
-export function resetEnv() {
+export function resetEnv(): void {
     resetDecoderEnv();
     resetEncoderEnv();
     resetEncoder();
@@ -15,25 +15,26 @@ export function resetEnv() {
 
 /**
  * 输入转为数字数组以便比较
- * @param {[ArrayBuffer] | [Uint8Array] | (number | string)[]} args 输入
- * @returns {number[]} 数字数组
+ * @param args 输入
+ * @returns 数字数组
  */
-export function toArray(...args) {
+export function toArray(...args: [ArrayBuffer] | [Uint8Array] | Array<number | string>): number[] {
     if (args[0] instanceof ArrayBuffer) {
         return Array.from(new Uint8Array(args[0]));
     }
     if (args[0] instanceof Uint8Array) {
         return Array.from(args[0]);
     }
-    return args.map((x) => (typeof x == 'number' ? x : /** @type {string} */ (x).charCodeAt(0)));
+    // eslint-disable-next-line unicorn/prefer-code-point
+    return args.map((x) => (typeof x == 'number' ? x : (x as string).charCodeAt(0)));
 }
 
 /**
  * 将数字或字符串转换为 Uint8Array
- * @param  {...string | number} args 数字或 char 的数组
- * @returns {Uint8Array} Uint8Array
+ * @param args 数字或 char 的数组
+ * @returns Uint8Array
  */
-export function toBuffer(...args) {
+export function toBuffer(...args: Array<string | number>): Uint8Array<ArrayBuffer> {
     const data = [];
     for (const x of args) {
         if (typeof x == 'number') {

package/tests/decode.ts

@@ -141,6 +141,7 @@ test('decode huge string (unexpected eof) [error]', () => {
 
 test('decode ascii string', () => {
     const header = toBuffer('S', 'I', 0x3f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x3fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(decode(payload)).toBe('a'.repeat(0x3fff));
@@ -148,6 +149,7 @@ test('decode ascii string', () => {
 
 test('decode ascii string [huge]', () => {
     const header = toBuffer('S', 'I', 0x7f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x7fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(decode(payload)).toBe('a'.repeat(0x7fff));
@@ -507,19 +509,16 @@ test('decode (eof at key)', () => {
 
 describe('proto poisoning attack', () => {
     it('should remove __proto__ key', () => {
-        const obj = /** @type {Record<string, unknown>} */ decode(
+        const obj = decode(
             toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
-        );
+        ) as Record<string, unknown>;
         expect(Object.hasOwn(obj, '__proto__')).toBe(false);
         expect(obj['__proto__']).toBe(Object.prototype);
     });
     it('should allow __proto__ key', () => {
-        const obj = /** @type {Record<string, unknown>} */ decode(
-            toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
-            {
-                protoAction: 'allow',
-            },
-        );
+        const obj = decode(toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+            protoAction: 'allow',
+        }) as Record<string, unknown>;
         expect(Object.hasOwn(obj, '__proto__')).toBe(true);
         expect(obj['__proto__']).toEqual({ a: 'abc' });
     });
@@ -534,19 +533,16 @@ describe('proto poisoning attack', () => {
 
 describe('constructor poisoning attack', () => {
     it('should remove constructor key', () => {
-        const obj = /** @type {Record<string, unknown>} */ decode(
-            toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
-            {
-                constructorAction: 'remove',
-            },
-        );
+        const obj = decode(toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+            constructorAction: 'remove',
+        }) as Record<string, unknown>;
         expect(Object.hasOwn(obj, 'constructor')).toBe(false);
         expect(obj.constructor).toBe(Object);
     });
     it('should allow constructor key', () => {
-        const obj = /** @type {Record<string, unknown>} */ decode(
+        const obj = decode(
             toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
-        );
+        ) as Record<string, unknown>;
         expect(Object.hasOwn(obj, 'constructor')).toBe(true);
         expect(obj.constructor).toEqual({ a: 'abc' });
     });

package/tests/e2e/stream.ts

@@ -8,15 +8,15 @@ describe('stream', () => {
         const expected = EXPECTED[name] ?? input;
         if (expected instanceof Error) {
             await expect(async () => {
-                const encoded = await Readable.fromWeb(/** @type {any} */ encodeStream(input)).toArray();
+                const encoded = await Readable.fromWeb(encodeStream(input) as never).toArray();
                 const decoded = await decodeStream(
-                    /** @type {ReadableStream<Uint8Array>} */ Readable.toWeb(Readable.from(encoded)),
+                    Readable.toWeb(Readable.from(encoded)) as ReadableStream<Uint8Array<ArrayBuffer>>,
                 );
                 expect(decoded).toEqual(expected);
             }).rejects.toThrow(expected);
         } else {
-            const encoded = await Readable.fromWeb(/** @type {any} */ encodeStream(input)).toArray();
-            const data = encoded.flatMap((/** @type {Buffer} */ chunk) => {
+            const encoded = await Readable.fromWeb(encodeStream(input) as never).toArray();
+            const data = encoded.flatMap((chunk: Buffer<ArrayBuffer>) => {
                 if (chunk.length < 2) return [chunk];
                 // split to random chunks
                 const chunks = [];
@@ -29,7 +29,7 @@ describe('stream', () => {
                 return chunks;
             });
             const decoded = await decodeStream(
-                /** @type {ReadableStream<Uint8Array>} */ Readable.toWeb(Readable.from(data)),
+                Readable.toWeb(Readable.from(data)) as ReadableStream<Uint8Array<ArrayBuffer>>,
             );
             expect(decoded).toEqual(expected);
         }

package/tests/encode.ts

@@ -7,7 +7,7 @@ import { getEncoder } from '../dist/encoder.js';
 import { toArray } from './.utils.ts';
 
 // @ts-expect-error Access private property
-const poolInit = getEncoder().pool;
+const poolInit = getEncoder().pool as Uint8Array<ArrayBuffer>;
 
 test('encode function', () => {
     expect(() =>
@@ -444,10 +444,10 @@ test('encode object (only null values)', () => {
 });
 
 test('encode object (skip prototype)', () => {
-    const obj = Object.create({ a: 2, x: 'xx' });
-    obj.a = 1;
-    obj.b = 'a';
-    obj.c = true;
+    const obj = Object.create({ a: 2, x: 'xx' }) as Record<string, unknown>;
+    obj['a'] = 1;
+    obj['b'] = 'a';
+    obj['c'] = true;
     expect(toArray(encode(obj))).toEqual(
         toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
     );

package/tests/huge-string.ts

@@ -6,11 +6,8 @@ const STR_BYTE_LENGTH = 128 * 1024 * 1024 - 20;
 
 /**
  * 构造测试字符串
- * @param {string} char 使用的字符
- * @param {number} byteLength 需要的长度
- * @returns {[Uint8Array, string]}
  */
-function makeString(char, byteLength) {
+function makeString(char: string, byteLength: number): [Uint8Array<ArrayBuffer>, string] {
     const encoded = new TextEncoder().encode(char);
     return [encoded, char.repeat(byteLength / encoded.byteLength)];
 }

package/tests/rxjs/decode.ts

@@ -2,28 +2,24 @@
  * Tests from https://bitbucket.org/shelacek/ubjson
  */
 import { jest } from '@jest/globals';
-import { firstValueFrom, of, Subject } from 'rxjs';
+import { firstValueFrom, type Observable, of, Subject } from 'rxjs';
 import { decode as decodePipe } from '../../dist/rxjs/index.js';
 import { toBuffer } from '../.utils.ts';
 import { UnexpectedEofError as UnexpectedEof } from '../../dist/helper/errors.js';
 
 /**
  * 包装为 promise
- * @param {Uint8Array} data ubjson 数据
- * @returns {Promise<unknown>}
  */
-async function decode(data) {
+async function decode(data: BufferSource): Promise<unknown> {
     const readable = of(data);
     return firstValueFrom(readable.pipe(decodePipe()), { defaultValue: undefined });
 }
 
 /**
  * 包装为 promise
- * @param {import("rxjs").Observable<Uint8Array>} observable ubjson 数据流
- * @param {(data: unknown) => void} onData 数据回调
  */
-async function decodeStream(observable, onData) {
-    return /** @type {Promise<void>} */ new Promise((resolve, reject) => {
+async function decodeStream(observable: Observable<BufferSource>, onData: (data: unknown) => void) {
+    return new Promise<void>((resolve, reject) => {
         observable.pipe(decodePipe()).subscribe({
             next: onData,
             error: reject,
@@ -115,6 +111,7 @@ test('decode string (unexpected eof) [error]', async () => {
 
 test('decode ascii string', async () => {
     const header = toBuffer('S', 'I', 0x3f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x3fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(0x3fff));
@@ -123,6 +120,7 @@ test('decode ascii string', async () => {
 test('decode ascii string 32kiB [huge]', async () => {
     const size = 0x7fff;
     const header = toBuffer('S', 'I', 0x7f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(size + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(size));
@@ -131,6 +129,7 @@ test('decode ascii string 32kiB [huge]', async () => {
 test('decode ascii string 64MB [huge]', async () => {
     const size = 0x03d0_9000;
     const header = toBuffer('S', 'l', 0x03, 0xd0, 0x90, 0x00);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(size + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(size));
@@ -467,7 +466,7 @@ test('decode object (empty key, optimized)', async () => {
 });
 
 test('decode stream', async () => {
-    const stream = new Subject();
+    const stream = new Subject<BufferSource>();
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     const result = decodeStream(stream, onData);
@@ -485,7 +484,7 @@ test('decode stream', async () => {
 });
 
 test('decode bad stream [error]', async () => {
-    const stream = new Subject();
+    const stream = new Subject<BufferSource>();
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     const result = decodeStream(stream, onData);
@@ -504,7 +503,7 @@ test('decode bad stream [error]', async () => {
 });
 
 test('decode partial stream [error]', async () => {
-    const stream = new Subject();
+    const stream = new Subject<BufferSource>();
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     const result = decodeStream(stream, onData);
@@ -520,7 +519,7 @@ test('decode partial stream [error]', async () => {
 });
 
 test('decode error stream [error]', async () => {
-    const stream = new Subject();
+    const stream = new Subject<BufferSource>();
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     const result = decodeStream(stream, onData);

package/tests/rxjs/encode.ts

@@ -8,10 +8,8 @@ import { toArray } from '../.utils.ts';
 
 /**
  * 包装为 promise
- * @param {unknown} value 要编码的值
- * @returns {Promise<Buffer>}
  */
-async function encodeAsync(value) {
+async function encodeAsync(value: unknown): Promise<Buffer<ArrayBuffer>> {
     return firstValueFrom(
         of(value).pipe(
             encode(),
@@ -304,7 +302,7 @@ test('encode object (only null values)', async () => {
 });
 
 test('encode object (skip prototype)', async () => {
-    const obj = /** @type {Record<string, unknown>} */ Object.create({ a: 2, x: 'xx' });
+    const obj = Object.create({ a: 2, x: 'xx' }) as Record<string, unknown>;
     obj['a'] = 1;
     obj['b'] = 'a';
     obj['c'] = true;

package/tests/stream/decode.ts

@@ -9,20 +9,16 @@ import { UnexpectedEofError as UnexpectedEof } from '../../dist/helper/errors.js
 
 /**
  * 包装为 promise
- * @param {Uint8Array} data ubjson 数据
- * @returns {Promise<unknown>}
  */
-async function decode(data) {
+async function decode(data: Uint8Array<ArrayBuffer>): Promise<unknown> {
     const readable = Readable.from([data], { objectMode: false });
-    return decodeAsync(/** @type {ReadableStream<Uint8Array>} */ Readable.toWeb(readable));
+    return decodeAsync(Readable.toWeb(readable) as ReadableStream<Uint8Array<ArrayBuffer>>);
 }
 
 /**
  * 包装为 promise
- * @param {import("stream").Readable} stream ubjson 流
- * @returns {Promise<void>}
  */
-async function eos(stream) {
+async function eos(stream: Readable): Promise<void> {
     return new Promise((resolve, reject) => {
         stream.on('error', reject);
         stream.on('end', resolve);
@@ -113,6 +109,7 @@ test('decode string (unexpected eof) [error]', async () => {
 
 test('decode ascii string', async () => {
     const header = toBuffer('S', 'I', 0x3f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x3fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(0x3fff));
@@ -120,6 +117,7 @@ test('decode ascii string', async () => {
 
 test('decode ascii string [huge]', async () => {
     const header = toBuffer('S', 'I', 0x7f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x7fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(0x7fff));
@@ -456,7 +454,7 @@ test('decode object (empty key, optimized)', async () => {
 });
 
 test('decode stream', async () => {
-    const stream = Transform.fromWeb(/** @type {any} */ decodeStream(), { objectMode: true });
+    const stream = Transform.fromWeb(decodeStream() as never, { objectMode: true });
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     stream.on('data', onData);
@@ -499,7 +497,7 @@ test('decode bad stream [error]', async () => {
 });
 
 test('decode partial stream [error]', async () => {
-    const stream = Transform.fromWeb(/** @type {any} */ decodeStream(), { objectMode: true });
+    const stream = Transform.fromWeb(decodeStream() as never, { objectMode: true });
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     stream.on('data', onData);

package/tests/stream/encode.ts

@@ -9,11 +9,9 @@ import { Transform } from 'node:stream';
 
 /**
  * 包装为 promise
- * @param {unknown} value 值
- * @returns {Promise<Buffer>} 返回值
  */
-async function encodeAsync(value) {
-    return buffer(encode(value));
+async function encodeAsync(value: unknown): Promise<Buffer<ArrayBuffer>> {
+    return (await buffer(encode(value))) as Buffer<ArrayBuffer>;
 }
 
 test('encode function', async () => {
@@ -299,10 +297,10 @@ test('encode object (only null values)', async () => {
 });
 
 test('encode object (skip prototype)', async () => {
-    const obj = Object.create({ a: 2, x: 'xx' });
-    obj.a = 1;
-    obj.b = 'a';
-    obj.c = true;
+    const obj = Object.create({ a: 2, x: 'xx' }) as Record<string, unknown>;
+    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', '}'),
     );
@@ -364,7 +362,7 @@ test('encode huge data (~128M)', async () => {
 });
 
 test('encode stream', async () => {
-    const stream = Transform.fromWeb(/** @type {any} */ encoder(), { objectMode: true });
+    const stream = Transform.fromWeb(encoder() as never, { objectMode: true });
     stream.write(undefined);
     stream.write(true);
     stream.write(false);

package/tests/stream/many.ts

@@ -1,15 +1,13 @@
 import { Readable } from 'node:stream';
+import type { ReadableStream as ReadableStream2 } from 'node:stream/web';
 import { encodeMany, decodeMany } from '../../dist/stream/index.js';
 import { buffer } from 'node:stream/consumers';
 import { finished } from 'node:stream/promises';
 
 /**
  * iterableToAsyncIterable
- * @template T
- * @param {Iterable<T>} iterable - iterable
- * @returns {AsyncIterable<T>} async iterable
  */
-function iterableToAsyncIterable(iterable) {
+function iterableToAsyncIterable<T>(iterable: Iterable<T>): AsyncIterable<T> {
     return {
         [Symbol.asyncIterator]: () => {
             const iterator = iterable[Symbol.iterator]();
@@ -23,12 +21,9 @@ function iterableToAsyncIterable(iterable) {
 
 /**
  * asyncIterableToArray
- * @template T
- * @param {AsyncIterable<T>} asyncIterable - async iterable
- * @returns {Promise<Array<T>>} array
  */
-async function asyncIterableToArray(asyncIterable) {
-    const array = [];
+async function asyncIterableToArray<T>(asyncIterable: AsyncIterable<T>): Promise<T[]> {
+    const array: T[] = [];
     for await (const item of asyncIterable) {
         array.push(item);
     }
@@ -53,7 +48,7 @@ test('encode/decode many', async () => {
     ];
     const encoded = await buffer(encodeMany(iterableToAsyncIterable(data)));
     const decoded = await asyncIterableToArray(
-        decodeMany(/** @type {ReadableStream<Uint8Array>} */ (Readable.toWeb(Readable.from([encoded])))),
+        decodeMany(Readable.toWeb(Readable.from([encoded])) as ReadableStream<Uint8Array<ArrayBuffer>>),
     );
     expect(decoded).toEqual([
         {
@@ -74,7 +69,7 @@ test('encode/decode many', async () => {
 
 test('encode/decode many with invalid value', async () => {
     await expect(async () => {
-        const readable = Readable.fromWeb(/** @type {any} */ (encodeMany(iterableToAsyncIterable([1, () => 1]))));
+        const readable = Readable.fromWeb(encodeMany(iterableToAsyncIterable([1, () => 1])) as ReadableStream2);
         const f = finished(readable);
         readable.resume();
         await f;
@@ -82,31 +77,25 @@ test('encode/decode many with invalid value', async () => {
 });
 
 test('encode/decode many with error', async () => {
-    // await expect(async () => {
-    //     try {
-    //         const stream = encodeMany(
-    //             (async function* () {
-    //                 yield 1;
-    //                 await Promise.resolve();
-    //                 // throw new Error('xx');
-    //             })(),
-    //         );
-    //         const f = finished(/** @type {any} */ (stream));
-    //         for await (const _ of stream) {
-    //             //
-    //         }
-    //         await f;
-    //     } catch (ex) {
-    //         console.log(ex);
-    //     }
-    // }).rejects.toThrow('xx');
+    await expect(async () => {
+        const stream = encodeMany(
+            (async function* () {
+                yield 1;
+                await Promise.resolve();
+                throw new Error('test error');
+            })(),
+        );
+        for await (const _ of stream) {
+            //
+        }
+    }).rejects.toThrow('test error');
 });
 
 test('encode/decode many with undefined', async () => {
     const data = [1, null, undefined, [undefined]];
     const encoded = await buffer(encodeMany(iterableToAsyncIterable(data)));
     const decoded = await asyncIterableToArray(
-        decodeMany(/** @type {ReadableStream<Uint8Array>} */ (Readable.toWeb(Readable.from([encoded])))),
+        decodeMany(Readable.toWeb(Readable.from([encoded])) as ReadableStream<Uint8Array<ArrayBuffer>>),
     );
     expect(decoded).toEqual([
         1,

package/tests/string-encoding.ts

@@ -2,11 +2,9 @@ import { Encoder } from '../dist/encoder.js';
 import { decode, jsDecode } from '../dist/helper/string-decoder.js';
 
 /**
- * 测试编码
- * @param {Pick<TextEncoder, 'encode'>} encoder encoder
- * @param {Pick<TextDecoder, 'decode'>} decoder decoder
+ * 测试编码器和解码器
  */
-function testEncoding(encoder, decoder) {
+function testEncoding(encoder: Pick<TextEncoder, 'encode'>, decoder: Pick<TextDecoder, 'decode'>) {
     expect(decoder.decode(encoder.encode(''))).toEqual('');
     expect(decoder.decode(encoder.encode('a'))).toEqual('a');
     expect(decoder.decode(encoder.encode('p4'))).toEqual('p4');
@@ -46,6 +44,7 @@ function testEncoding(encoder, decoder) {
         bad.fill(0xff);
         expect(decoder.decode(bad)).toEqual('\uFFFD'.repeat(length));
 
+        // eslint-disable-next-line unicorn/prefer-code-point
         bad.fill('a'.charCodeAt(0), 0, length - 1);
         expect(decoder.decode(bad)).toEqual('a'.repeat(length - 1) + '\uFFFD');
     }
@@ -55,6 +54,7 @@ function testEncoding(encoder, decoder) {
         for (let index = 0; index < 0xffff; index++) {
             // 跳过 Surrogate
             if (index >= 0xd800 && index <= 0xdfff) continue;
+            // eslint-disable-next-line unicorn/prefer-code-point
             const expected = String.fromCharCode(index);
             const encoded = encoder.encode(expected);
             const actual = decoder.decode(encoded);
@@ -77,6 +77,7 @@ function testEncoding(encoder, decoder) {
         // 检查所有 2 字节 ASCII
         for (let index = 0; index < 0x80; index++) {
             for (let index2 = 0; index2 < 0x80; index2++) {
+                // eslint-disable-next-line unicorn/prefer-code-point
                 const expected = String.fromCharCode(index, index2);
                 const actual = decoder.decode(encoder.encode(expected));
                 if (expected !== actual) expect(actual).toEqual(expected);
@@ -121,6 +122,8 @@ test('decode string js', () => {
 });
 
 test('decode malformed', () => {
+    // eslint-disable-next-line unicorn/prefer-code-point
     expect(decode(new Uint8Array([0xff, 'a'.charCodeAt(0)]), 0, 2)).toEqual('\uFFFDa');
+    // eslint-disable-next-line unicorn/prefer-code-point
     expect(jsDecode(new Uint8Array([0xff, 'a'.charCodeAt(0)]), 0, 2)).toEqual('\uFFFDa');
 });