@cloudpss/ubjson 0.5.35 → 0.5.36

package/tests/encode.js

@@ -500,20 +500,22 @@ test('encode huge typed array (16K)', () => {
 
 test('encode huge typed array (~128M)', () => {
     const obj = new Uint8Array(128 * 1024 * 1024 - 10);
-    expect(toArray(encode(obj).slice(0, 10))).toEqual(toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf6, 0));
+    obj[0] = 0x58;
+    expect(toArray(encode(obj).slice(0, 10))).toEqual(toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf6, 0x58));
     // @ts-expect-error Access private property
     expect(getEncoder().pool).toBe(poolInit);
 });
 
-test('encode huge typed array (128M) [error]', () => {
+test('encode huge typed array (128M)', () => {
     const obj = new Uint8Array(128 * 1024 * 1024);
-    expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
+    obj[0] = 0x58;
+    expect(toArray(encode(obj).slice(0, 10))).toEqual(toArray('[', '$', 'U', '#', 'l', 0x8, 0x00, 0x00, 0x00, 0x58));
     // @ts-expect-error Access private property
     expect(getEncoder().pool).toBe(poolInit);
 });
 
-test('encode huge typed array (3G) [error]', () => {
-    const obj = new Uint8Array(3 * 1024 * 1024 * 1024);
+test('encode huge typed array (1G) [error]', () => {
+    const obj = new Uint8Array(1 * 1024 * 1024 * 1024);
     expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
     // @ts-expect-error Access private property
     expect(getEncoder().pool).toBe(poolInit);
@@ -530,27 +532,17 @@ test('encode huge data (~128M)', () => {
     expect(getEncoder().pool).toBe(poolInit);
 });
 
-test('encode huge data (128M - 9)', () => {
-    const obj = [new Uint8Array(128 * 1024 * 1024 - 9)];
+test('encode huge data (128M)', () => {
+    const obj = [new Uint8Array(128 * 1024 * 1024)];
     obj[0][0] = 0x12;
     obj[0][1] = 0x34;
-    const encoded = encode(obj);
-    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),
+    expect(toArray(encode(obj).slice(0, 12))).toEqual(
+        toArray('[', '[', '$', 'U', '#', 'l', 0x8, 0x00, 0x00, 0x00, 0x12, 0x34),
     );
     // @ts-expect-error Access private property
     expect(getEncoder().pool).toBe(poolInit);
 });
 
-test('encode huge data (128M - 8) [error]', () => {
-    const obj = [new Uint8Array(128 * 1024 * 1024 - 8)];
-    expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
-    // @ts-expect-error Access private property
-    expect(getEncoder().pool).toBe(poolInit);
-});
-
 test('encode huge data (256M)', () => {
     const obj = [new Uint8Array(128 * 1024 * 1024 - 9), new Uint8Array(128 * 1024 * 1024 - 9)];
     obj[0][0] = 0x12;

package/tests/huge-string.js

@@ -1,6 +1,6 @@
+import { Buffer } from 'node:buffer';
 import { encode } from '../dist/index.js';
-import { resetEncoder } from '../dist/encoder.js';
-import { toArray } from './.utils.js';
+import { toArray, resetEnv } from './.utils.js';
 
 const STR_BYTE_LENGTH = 128 * 1024 * 1024 - 20;
 
@@ -24,7 +24,7 @@ const [str4Data, str4] = makeString('😀', STR_BYTE_LENGTH);
 // bad surrogate pair
 const [strXData, strX] = makeString('😀'[0], STR_BYTE_LENGTH);
 
-const strErr = 'a'.repeat(128 * 1024 * 1024);
+const strErr = 'a'.repeat(128 * 1024 * 1024 + 1);
 
 const ENCODED_PREFIX_LENGTH = 6;
 
@@ -70,17 +70,15 @@ describe(`encode huge string`, () => {
         });
     });
     describe(`without node buffer`, () => {
-        let buffer = Buffer;
         beforeAll(() => {
-            buffer = global.Buffer;
             // @ts-expect-error remove buffer
-            delete global.Buffer;
-            resetEncoder();
+            global.Buffer = undefined;
+            resetEnv();
         });
 
         afterAll(() => {
-            global.Buffer = buffer;
-            resetEncoder();
+            global.Buffer = Buffer;
+            resetEnv();
         });
 
         it(`~128M [1]`, () => {

package/tests/rxjs/encode.js

@@ -1,7 +1,7 @@
 /**
  * Tests from https://bitbucket.org/shelacek/ubjson
  */
-import { firstValueFrom, of, reduce, Subject } from 'rxjs';
+import { firstValueFrom, of, map, reduce, Subject, toArray as rxjsToArray } from 'rxjs';
 import { encode } from '../../dist/rxjs/index.js';
 import { decode, encode as encodeRef } from '../../dist/index.js';
 import { toArray } from '../.utils.js';
@@ -14,7 +14,8 @@ function encodeAsync(value) {
     return firstValueFrom(
         of(value).pipe(
             encode(),
-            reduce((a, b) => Buffer.concat([a, b])),
+            rxjsToArray(),
+            map((data) => Buffer.concat(data)),
         ),
     );
 }
@@ -357,28 +358,13 @@ test('encode huge typed array (~128M)', async () => {
     );
 });
 
-test('encode huge typed array (256M + 1) [error]', async () => {
-    const obj = new Uint8Array(256 * 1024 * 1024 + 1);
-    await expect(() => encodeAsync(obj)).rejects.toThrow(/Buffer has exceed max size/);
-});
-
-test('encode huge typed array (3G) [error]', async () => {
-    const obj = new Uint8Array(3 * 1024 * 1024 * 1024);
-    await expect(() => encodeAsync(obj)).rejects.toThrow(/Buffer has exceed max size/);
-});
-
 test('encode huge data (~128M)', async () => {
     const obj = [new Uint8Array(128 * 1024 * 1024 - 20)];
-    expect(toArray((await encodeAsync(obj)).slice(0, 11))).toEqual(
+    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 () => {
-    const obj = [new Uint8Array(256 * 1024 * 1024 + 1)];
-    await expect(() => encodeAsync(obj)).rejects.toThrow(/Buffer has exceed max size/);
-});
-
 test('encode stream', async () => {
     const stream = new Subject();
     const result = firstValueFrom(

package/tests/stream/encode.js

@@ -354,16 +354,6 @@ test('encode huge typed array (~128M)', async () => {
     );
 });
 
-test('encode huge typed array (256M + 1) [error]', async () => {
-    const obj = new Uint8Array(256 * 1024 * 1024 + 1);
-    await expect(() => encodeAsync(obj)).rejects.toThrow(/Buffer has exceed max size/);
-});
-
-test('encode huge typed array (3G) [error]', async () => {
-    const obj = new Uint8Array(3 * 1024 * 1024 * 1024);
-    await expect(() => encodeAsync(obj)).rejects.toThrow(/Buffer has exceed max size/);
-});
-
 test('encode huge data (~128M)', async () => {
     const obj = [new Uint8Array(128 * 1024 * 1024 - 20)];
     expect(toArray((await encodeAsync(obj)).subarray(0, 11))).toEqual(
@@ -371,11 +361,6 @@ test('encode huge data (~128M)', async () => {
     );
 });
 
-test('encode huge data (256M + 1) [error]', async () => {
-    const obj = [new Uint8Array(256 * 1024 * 1024 + 1)];
-    await expect(() => encodeAsync(obj)).rejects.toThrow(/Buffer has exceed max size/);
-});
-
 test('encode stream', async () => {
     const stream = encoder();
     stream.write(undefined);

package/tests/string-encoding.js

@@ -1,5 +1,5 @@
 import { Encoder } from '../dist/encoder.js';
-import { decode, decodeKey, decodeJs } from '../dist/common/string-decoder.js';
+import { decode, decodeKey, jsDecode } from '../dist/common/string-decoder.js';
 import '../dist/common/constants.js';
 
 /**
@@ -126,11 +126,12 @@ test('decode string js', () => {
     testEncoding(new TextEncoder(), {
         decode(buffer) {
             if (!(buffer instanceof Uint8Array)) return '';
-            return decodeJs(buffer, 0, buffer.byteLength);
+            return jsDecode(buffer, 0, buffer.byteLength);
         },
     });
 });
 
 test('decode malformed', () => {
     expect(decode(new Uint8Array([0xff, 'a'.charCodeAt(0)]), 0, 2)).toEqual('\uFFFDa');
+    expect(jsDecode(new Uint8Array([0xff, 'a'.charCodeAt(0)]), 0, 2)).toEqual('\uFFFDa');
 });

package/tests/tsconfig.json

@@ -3,6 +3,7 @@
   "include": ["./"],
   "compilerOptions": {
     "checkJs": true,
-    "noEmit": true
+    "noEmit": true,
+    "noUncheckedIndexedAccess": false
   }
 }

package/tests/e2e.js

@@ -1,415 +0,0 @@
-/**
- * Tests from https://bitbucket.org/shelacek/ubjson
- */
-import { encode, decode } from '../dist/index.js';
-import { resetEncoder } from '../dist/encoder.js';
-
-test('encode/decode complex object', () => {
-    const expected = {
-        hello: 'world',
-        from: ['UBJSON'],
-        colors: [[255, 255, 255], [0, 0, 0], [64, 64, 96], new Uint8Array([255, 0, 1, 2, 3, 127])],
-        domains: {
-            '': '',
-            com: 'commercial',
-            org: 'organization',
-            net: 'network',
-        },
-        entires: [
-            {
-                id: 1,
-                name: 'test',
-                content: null,
-                timestamp: 1_532_432_408.008,
-                published: false,
-            },
-            {
-                id: 2,
-                name: 'lorem',
-                content: 'Lorem ipsum...',
-                timestamp: 1_532_432_416.346,
-                published: true,
-            },
-        ],
-        plots: {
-            traces: [
-                {
-                    name: 'test',
-                    x: new Float64Array([
-                        1,
-                        2,
-                        3,
-                        Number.NEGATIVE_INFINITY,
-                        Number.POSITIVE_INFINITY,
-                        Number.NaN,
-                        Number.MAX_VALUE,
-                        Number.MIN_VALUE,
-                    ]),
-                    y: new Int8Array([0, 4, 5, 6, -128, -1, 127]),
-                },
-                {
-                    name: 'test2',
-                    x: new Float32Array([
-                        1,
-                        2,
-                        3,
-                        Number.NEGATIVE_INFINITY,
-                        Number.POSITIVE_INFINITY,
-                        Number.NaN,
-                        Number.MAX_VALUE,
-                        Number.MIN_VALUE,
-                    ]),
-                    y: new Int16Array([4, 5, 6, -32768, 32767]),
-                },
-                {
-                    name: 'test233',
-                    x: new Int32Array([1, 2, 3, 0, -1]),
-                    y: new Int32Array([4, 5, 6, -(2 ** 31), 2 ** 31 - 1]),
-                },
-            ],
-        },
-        description1: 'medium text'.repeat(100),
-        description2: 'medium text'.repeat(1000),
-        document1: 'long text'.repeat(10000),
-        document2: 'long text'.repeat(100_000),
-    };
-    const encoded = encode(expected);
-    const actual = decode(Buffer.from(encoded));
-    expect(actual).toEqual(expected);
-});
-
-test('encode/decode model', () => {
-    const expected = {
-        rid: 'project/CloudPSS/_SubSysPort',
-        name: '模块端口',
-        description: '',
-        tags: [
-            'project:component',
-            'type:30000',
-            'project-group:模块-基础:101',
-            'project-category:component',
-            'project-support:job-definition/cloudpss/emtp',
-            'project-support:job-definition/cloudpss/sfemt',
-            'project-support:job-definition/cloudpss/power-flow',
-        ],
-        revision: {
-            graphic: {
-                pins: {
-                    input: {
-                        position: {
-                            x: 0.999_999_9,
-                            y: 0.5,
-                        },
-                    },
-                    output: {
-                        position: {
-                            x: 0,
-                            y: 0.5,
-                        },
-                    },
-                    electrical: {
-                        position: {
-                            x: 0.999_999_9,
-                            y: 0.5,
-                        },
-                    },
-                },
-                attrs: {
-                    p0: {
-                        fill: 'var(--fill)',
-                        stroke: 'var(--stroke)',
-                        refPath: {
-                            d: 'm90000 0h-60000a10000 10000 0 0 0 0 20000h60000zm0 10000h20000',
-                            h: 20000,
-                            w: 110_000,
-                        },
-                        fillOpacity: 'var(--fill-opacity)',
-                        strokeWidth: 'var(--stroke-width)',
-                        strokeOpacity: 'var(--stroke-opacity)',
-                    },
-                    p1: {
-                        fill: 'var(--fill)',
-                        stroke: 'var(--stroke)',
-                        refPath: {
-                            d: 'm90000 0h-60000a10000 10000 0 0 0 0 20000h60000zm0 10000h20000',
-                            h: 20000,
-                            w: 110_000,
-                        },
-                        fillOpacity: 'var(--fill-opacity)',
-                        strokeWidth: 'var(--stroke-width)',
-                        strokeOpacity: 'var(--stroke-opacity)',
-                    },
-                    p2: {
-                        fill: 'transparent',
-                        stroke: 'var(--stroke)',
-                        refPath: {
-                            d: 'm20000 10000m-5000 -5000l5000 5000l-5000 5000',
-                            h: 20000,
-                            w: 110_000,
-                        },
-                        fillOpacity: 'var(--fill-opacity)',
-                        strokeWidth: 'var(--stroke-width)',
-                        strokeOpacity: 'var(--stroke-opacity)',
-                    },
-                    p3: {
-                        fill: 'var(--fill)',
-                        stroke: 'var(--stroke)',
-                        refPath: {
-                            d: 'm20000 0h60000a10000 10000 0 0 1 0 20000h-60000zm0 10000h-20000',
-                            h: 20000,
-                            w: 110_000,
-                        },
-                        fillOpacity: 'var(--fill-opacity)',
-                        strokeWidth: 'var(--stroke-width)',
-                        strokeOpacity: 'var(--stroke-opacity)',
-                    },
-                    p4: {
-                        fill: 'transparent',
-                        stroke: 'var(--stroke)',
-                        refPath: {
-                            d: 'm110000 10000m-5000 -5000l5000 5000l-5000 5000',
-                            h: 20000,
-                            w: 110_000,
-                        },
-                        fillOpacity: 'var(--fill-opacity)',
-                        strokeWidth: 'var(--stroke-width)',
-                        strokeOpacity: 'var(--stroke-opacity)',
-                    },
-                    t0: {
-                        fill: 'var(--spectrum-global-color-orange-600)',
-                        refX: 0.5,
-                        refY: 0.5,
-                        stroke: 'transparent',
-                        fontSize: 12,
-                        textAnchor: 'middle',
-                    },
-                },
-                width: 110,
-                height: 20,
-                markup: [
-                    {
-                        tagName: 'path',
-                        selector: 'p0',
-                        condition:
-                            "=finder(p, index, array)= equalText(p.key, Key);\n              p = $$.revision.pins.find(finder);\n              p == undefined ? true : (not equalText(p.connection, 'input') and not equalText(p.connection, 'output'))",
-                    },
-                    {
-                        tagName: 'path',
-                        selector: 'p1',
-                        condition:
-                            "=finder(p, index, array) = equalText(p.key, Key);\n              p = $$.revision.pins.find(finder);\n              p != undefined ? equalText(p.connection, 'input') :false",
-                    },
-                    {
-                        tagName: 'path',
-                        selector: 'p2',
-                        condition:
-                            "=finder(p, index, array) = equalText(p.key, Key);\n              p = $$.revision.pins.find(finder);\n              p != undefined ? equalText(p.connection, 'output') : false",
-                    },
-                    {
-                        tagName: 'path',
-                        selector: 'p3',
-                        condition:
-                            "=finder(p, index, array) = equalText(p.key, Key);\n              p = $$.revision.pins.find(finder);\n              p != undefined ? equalText(p.connection, 'output') : false",
-                    },
-                    {
-                        tagName: 'path',
-                        selector: 'p4',
-                        condition:
-                            "=finder(p, index, array) = equalText(p.key, Key);\n              p = $$.revision.pins.find(finder);\n              p != undefined ? equalText(p.connection, 'input') :false",
-                    },
-                    {
-                        attrs: {
-                            y: '0.35em',
-                        },
-                        tagName: 'text',
-                        selector: 't0',
-                        condition: '',
-                        textContent: 'Port: $Key',
-                    },
-                ],
-                generator: 'x6',
-            },
-            parameters: [
-                {
-                    name: 'Configuration',
-                    items: [
-                        {
-                            key: 'Key',
-                            name: 'Pin Key',
-                            type: 'choice',
-                            value: '',
-                            choices:
-                                '=mapper(p,index,array) = {key: p.key, name: p.key, description: p.description};\n$$.revision.pins.map(mapper)',
-                            condition: 'true',
-                            description: '绑定端口',
-                        },
-                    ],
-                    condition: 'true',
-                    description: 'Configuration',
-                },
-            ],
-            pins: [
-                {
-                    dim: [
-                        "=finder(p, index, array) = equalText(p.key, 'a');\np = $$.revision.pins.find(finder);\np!=undefined?p.dim[1]:''",
-                        "=finder(p, index, array) = equalText(p.key, 'a');\np = $$.revision.pins.find(finder);\np!=undefined?p.dim[2]:''",
-                    ],
-                    key: 'input',
-                    data: 'real',
-                    name: 'Port',
-                    visible: true,
-                    condition:
-                        "=finder(p, index, array) = equalText(p.key, Key);\np = $$.revision.pins.find(finder);\np != undefined ? equalText(p.connection, 'input') :false",
-                    connection: 'output',
-                },
-                {
-                    dim: [
-                        "=finder(p, index, array) = equalText(p.key, 'a');\np = $$.revision.pins.find(finder);\np!=undefined?p.dim[2]:''",
-                        "=finder(p, index, array) = equalText(p.key, 'a');\np = $$.revision.pins.find(finder);\np!=undefined?p.dim[2]:''",
-                    ],
-                    key: 'output',
-                    data: 'real',
-                    name: 'Port',
-                    visible: true,
-                    condition:
-                        "=finder(p, index, array) = equalText(p.key, Key);\np = $$.revision.pins.find(finder);\np != undefined ? equalText(p.connection, 'output') :false",
-                    connection: 'input',
-                },
-                {
-                    dim: [
-                        "=finder(p, index, array) = equalText(p.key, 'a');\np = $$.revision.pins.find(finder);\np!=undefined?p.dim[2]:''",
-                        "=finder(p, index, array) = equalText(p.key, 'a');\np = $$.revision.pins.find(finder);\np!=undefined?p.dim[2]:''",
-                    ],
-                    key: 'electrical',
-                    data: 'real',
-                    name: 'Port',
-                    visible: true,
-                    condition:
-                        "=finder(p, index, array)= equalText(p.key, Key);\np = $$.revision.pins.find(finder);\np == undefined ? true : (not equalText(p.connection, 'input') and not equalText(p.connection, 'output'))",
-                    connection: 'electrical',
-                },
-            ],
-            documentation: '@[docs](http://docs.cloudpss.net/components/comp_PSS/comp_PSSSystem/BasicComp/SystemPort)',
-        },
-    };
-    const encoded = encode(expected);
-    const actual = decode(encoded);
-    expect(actual).toEqual(expected);
-});
-
-test('encode/decode complex object (no encodeInto)', () => {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const encodeInto = TextEncoder.prototype.encodeInto;
-    // @ts-expect-error 移除 encodeInto 以测试兼容性
-    TextEncoder.prototype.encodeInto = undefined;
-    resetEncoder();
-    const expected = {
-        hello: 'world',
-        from: ['UBJSON'],
-        colors: [[255, 255, 255], [0, 0, 0], [64, 64, 96], new Uint8Array([255, 0, 1, 2, 3, 127])],
-        domains: {
-            com: 'commercial',
-            org: 'organization',
-            net: 'network',
-        },
-        entires: [
-            {
-                id: 1,
-                name: 'test',
-                content: null,
-                timestamp: 1_532_432_408.008,
-                published: false,
-            },
-            {
-                id: 2,
-                name: 'lorem',
-                content: 'Lorem ipsum...',
-                timestamp: 1_532_432_416.346,
-                published: true,
-            },
-        ],
-        plots: {
-            traces: [
-                {
-                    name: 'test',
-                    x: new Float64Array([
-                        1,
-                        2,
-                        3,
-                        Number.NEGATIVE_INFINITY,
-                        Number.POSITIVE_INFINITY,
-                        Number.NaN,
-                        Number.MAX_VALUE,
-                        Number.MIN_VALUE,
-                    ]),
-                    y: new Int8Array([0, 4, 5, 6, -128, -1, 127]),
-                },
-                {
-                    name: 'test2',
-                    x: new Float32Array([
-                        1,
-                        2,
-                        3,
-                        Number.NEGATIVE_INFINITY,
-                        Number.POSITIVE_INFINITY,
-                        Number.NaN,
-                        Number.MAX_VALUE,
-                        Number.MIN_VALUE,
-                    ]),
-                    y: new Int16Array([4, 5, 6, -32768, 32767]),
-                },
-                {
-                    name: 'test233',
-                    x: new Int32Array([1, 2, 3, 0, -1]),
-                    y: new Int32Array([4, 5, 6, -(2 ** 31), 2 ** 31 - 1]),
-                },
-            ],
-        },
-        description1: 'medium text'.repeat(100),
-        description2: 'medium text'.repeat(1000),
-        document1: 'long text'.repeat(10000),
-        document2: 'long text'.repeat(100_000),
-    };
-    const encoded = encode(expected);
-    const actual = decode(encoded);
-    expect(actual).toEqual(expected);
-    TextEncoder.prototype.encodeInto = encodeInto;
-    resetEncoder();
-});
-
-test('encode/decode large array', () => {
-    const array = Array.from({ length: 100_000 });
-    array[12345] = 'item';
-
-    const expected = Array.from({ length: 100_000 }).fill(null);
-    expected[12345] = 'item';
-
-    expect(decode(encode(array))).toEqual(expected);
-});
-
-test('encode/decode object with undefined values', () => {
-    const obj = { a: 1, b: undefined, c: { d: 2, e: undefined, f: null } };
-    expect(decode(encode(obj))).toEqual(obj);
-});
-
-test('decode ArrayBuffer', () => {
-    const obj = { a: 1, b: undefined, c: { d: 2, e: undefined, f: null } };
-    expect(decode(encode(obj).buffer)).toEqual(obj);
-});
-
-test('decode Int8Array', () => {
-    const obj = { a: 1, b: undefined, c: { d: 2, e: undefined, f: null } };
-    expect(decode(new Int8Array(encode(obj).buffer))).toEqual(obj);
-});
-
-test('decode invalid __proto__', () => {
-    const obj = decode(encode(JSON.parse('{"__proto__":"xxx"}')));
-    expect(obj).toEqual(JSON.parse('{"__proto__":"xxx"}'));
-    expect(Object.getPrototypeOf(obj)).toBe(Object.prototype);
-});
-
-test('decode null __proto__', () => {
-    const obj = decode(encode(JSON.parse('{"__proto__":null}')));
-    expect(obj).toEqual(JSON.parse('{"__proto__":null}'));
-    expect(Object.getPrototypeOf(obj)).toBe(Object.prototype);
-});