@pezkuwi/types-codec 16.5.8 → 16.5.9

package/src/extended/BTreeMap.spec.ts

@@ -1,245 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import type { CodecClass, ITuple } from '@pezkuwi/types-codec/types';
-
-import { TypeRegistry } from '@pezkuwi/types';
-import { BTreeMap, Enum, I32, Option, Struct, Text, Tuple, U32 } from '@pezkuwi/types-codec';
-import { stringToU8a } from '@pezkuwi/util';
-
-const registry = new TypeRegistry();
-
-class U32TextTuple extends (Tuple.with([U32, Text]) as unknown as CodecClass<ITuple<[U32, Text]>>) {}
-// Reason: We purposefully want `text` to be the first key of the struct and take priority during sorting
-// eslint-disable-next-line sort-keys
-class MockStruct extends Struct.with({ text: Text, int: I32 }) {}
-class MockEnum extends Enum.with({
-  Key1: MockStruct,
-  Key2: MockStruct,
-  Key3: U32TextTuple
-}) {}
-class MockOptionEnum extends Option.with(MockEnum) {}
-
-const mockU32TextMap = new Map<Text, U32>();
-const mockU32DuplicateTextMap = new Map<Text, U32>();
-const mockU32TupleMap = new Map<ITuple<[U32, Text]>, U32>();
-const mockU32I32Map = new Map<I32, U32>();
-const mockU32StructMap = new Map<MockStruct, U32>();
-const mockU32EnumMap = new Map<MockEnum, U32>();
-const mockU32OptionEnumMap = new Map<MockOptionEnum, U32>();
-
-mockU32TextMap.set(new Text(registry, 'bazzing'), new U32(registry, 69));
-
-mockU32DuplicateTextMap.set(new Text(registry, 'bazzing'), new U32(registry, 42));
-mockU32DuplicateTextMap.set(new Text(registry, 'bazzing'), new U32(registry, 43));
-
-mockU32TupleMap.set((new U32TextTuple(registry, [2, 'ba'])), new U32(registry, 42));
-mockU32TupleMap.set((new U32TextTuple(registry, [2, 'b'])), new U32(registry, 7));
-mockU32TupleMap.set((new U32TextTuple(registry, [1, 'baz'])), new U32(registry, 13));
-
-mockU32I32Map.set(new I32(registry, 255), new U32(registry, 69));
-mockU32I32Map.set(new I32(registry, -255), new U32(registry, 42));
-mockU32I32Map.set(new I32(registry, 1000), new U32(registry, 7));
-mockU32I32Map.set(new I32(registry, -1000), new U32(registry, 25));
-mockU32I32Map.set(new I32(registry, 0), new U32(registry, 13));
-
-mockU32StructMap.set(new MockStruct(registry, { int: 1, text: 'b' }), new U32(registry, 42));
-mockU32StructMap.set(new MockStruct(registry, { int: -1, text: 'b' }), new U32(registry, 7));
-mockU32StructMap.set(new MockStruct(registry, { int: -1, text: 'ba' }), new U32(registry, 25));
-mockU32StructMap.set(new MockStruct(registry, { int: -2, text: 'baz' }), new U32(registry, 13));
-
-mockU32EnumMap.set(new MockEnum(registry, { Key3: new U32TextTuple(registry, [2, 'ba']) }), new U32(registry, 13));
-mockU32EnumMap.set(new MockEnum(registry, { Key3: new U32TextTuple(registry, [2, 'b']) }), new U32(registry, 42));
-mockU32EnumMap.set(new MockEnum(registry, { Key2: new MockStruct(registry, { int: -1, text: 'b' }) }), new U32(registry, 7));
-mockU32EnumMap.set(new MockEnum(registry, { Key1: new MockStruct(registry, { int: 1, text: 'b' }) }), new U32(registry, 25));
-mockU32EnumMap.set(new MockEnum(registry, { Key1: new MockStruct(registry, { int: -1, text: 'b' }) }), new U32(registry, 69));
-
-mockU32OptionEnumMap.set(new Option(registry, MockEnum, null), new U32(registry, 13));
-mockU32OptionEnumMap.set(new Option(registry, MockEnum, { Key3: new U32TextTuple(registry, [2, 'ba']) }), new U32(registry, 13));
-mockU32OptionEnumMap.set(new Option(registry, MockEnum, { Key3: new U32TextTuple(registry, [2, 'b']) }), new U32(registry, 42));
-mockU32OptionEnumMap.set(new Option(registry, MockEnum, { Key2: new MockStruct(registry, { int: -1, text: 'b' }) }), new U32(registry, 7));
-mockU32OptionEnumMap.set(new Option(registry, MockEnum, { Key1: new MockStruct(registry, { int: 1, text: 'b' }) }), new U32(registry, 25));
-mockU32OptionEnumMap.set(new Option(registry, MockEnum, { Key1: new MockStruct(registry, { int: -1, text: 'b' }) }), new U32(registry, 69));
-
-describe('BTreeMap', (): void => {
-  it('decodes null', (): void => {
-    expect(
-      new (
-        BTreeMap.with(Text, U32)
-      )(registry, null).toString()
-    ).toEqual('{}');
-  });
-
-  it('decodes reusing instantiated inputs', (): void => {
-    const key = new Text(registry, 'foo');
-    const val = new Text(registry, 'bar');
-
-    expect(
-      (new (BTreeMap.with(Text, Text))(registry, new Map([[key, val]]))).eq(new Map([[key, val]]))
-    ).toBe(true);
-  });
-
-  it('decodes within more complicated types', (): void => {
-    const s = new Struct(registry, {
-      placeholder: U32,
-      value: 'BTreeMap<Text, U32>'
-    });
-
-    s.set('value', new (BTreeMap.with(Text, U32))(registry, mockU32TextMap));
-    expect(s.toString()).toBe('{"placeholder":0,"value":{"bazzing":69}}');
-  });
-
-  it('throws on duplicate keys', (): void => {
-    expect(
-      () => new (BTreeMap.with(Text, U32))(registry, mockU32DuplicateTextMap)
-    ).toThrow(/Duplicate value in BTreeMap/);
-  });
-
-  it('throws when it cannot decode', (): void => {
-    expect(
-      (): BTreeMap<Text, U32> => new (
-        BTreeMap.with(Text, U32)
-      )(registry, 'ABC')
-    ).toThrow(/Map: cannot decode type/);
-  });
-
-  it('correctly encodes length', (): void => {
-    expect(
-      new (
-        BTreeMap.with(Text, U32))(registry, mockU32TextMap).encodedLength
-    ).toEqual(13);
-  });
-
-  it('correctly sorts simple keys', (): void => {
-    expect(
-      Array.from(new (BTreeMap.with(I32, U32))(registry, mockU32I32Map).keys()).map((k) => k.toNumber())
-    ).toEqual([-1000, -255, 0, 255, 1000]);
-  });
-
-  it('correctly sorts tuple keys', (): void => {
-    expect(
-      Array.from(new (BTreeMap.with(U32TextTuple, U32))(registry, mockU32TupleMap).keys()).map((k) => k.toJSON())
-    ).toEqual([[1, 'baz'], [2, 'b'], [2, 'ba']]);
-  });
-
-  it('correctly sorts struct keys', (): void => {
-    expect(
-      Array.from(new (BTreeMap.with(MockStruct, U32))(registry, mockU32StructMap).keys()).map((k) => k.toJSON())
-    ).toEqual([
-      { int: -1, text: 'b' },
-      { int: 1, text: 'b' },
-      { int: -1, text: 'ba' },
-      { int: -2, text: 'baz' }
-    ]);
-  });
-
-  it('correctly sorts Option(Enum) keys', (): void => {
-    expect(
-      Array.from(new (BTreeMap.with(MockOptionEnum, U32))(registry, mockU32OptionEnumMap).keys()).map((k) => k.value.toJSON())
-    ).toEqual([
-      null,
-      { key1: { int: -1, text: 'b' } },
-      { key1: { int: 1, text: 'b' } },
-      { key2: { int: -1, text: 'b' } },
-      { key3: [2, 'b'] },
-      { key3: [2, 'ba'] }
-    ]);
-  });
-
-  it('correctly sorts enum keys', (): void => {
-    expect(
-      Array.from(new (BTreeMap.with(MockEnum, U32))(registry, mockU32EnumMap).keys()).map((k) => k.toJSON())
-    ).toEqual([
-      { key1: { int: -1, text: 'b' } },
-      { key1: { int: 1, text: 'b' } },
-      { key2: { int: -1, text: 'b' } },
-      { key3: [2, 'b'] },
-      { key3: [2, 'ba'] }
-    ]);
-  });
-
-  it('correctly serializes/deserializes to/from json with numeric keys', (): void => {
-    expect(
-      new (BTreeMap.with(I32, U32))(
-        registry,
-        new (BTreeMap.with(I32, U32))(registry, mockU32I32Map).toJSON()
-      ).toJSON()
-    ).toEqual({ '-1000': 25, '-255': 42, 0: 13, 1000: 7, 255: 69 });
-  });
-
-  it('correctly serializes/deserializes to/from json with text keys', (): void => {
-    expect(
-      new (BTreeMap.with(Text, U32))(
-        registry,
-        new (BTreeMap.with(Text, U32))(registry, mockU32TextMap).toJSON()
-      ).toJSON()
-    ).toEqual({ bazzing: 69 });
-  });
-
-  it('correctly serializes/deserializes to/from json with tuple keys', (): void => {
-    expect(
-      new (BTreeMap.with(U32TextTuple, U32))(
-        registry,
-        new (BTreeMap.with(U32TextTuple, U32))(registry, mockU32TupleMap).toJSON()
-      ).toJSON()
-    ).toEqual({ '[1,"baz"]': 13, '[2,"b"]': 7, '[2,"ba"]': 42 });
-  });
-
-  it('correctly serializes/deserializes to/from json with struct keys', (): void => {
-    expect(
-      new (BTreeMap.with(MockStruct, U32))(
-        registry,
-        new (BTreeMap.with(MockStruct, U32))(registry, mockU32StructMap).toJSON()
-      ).toJSON()
-    ).toEqual({
-      '{"text":"b","int":-1}': 7,
-      '{"text":"b","int":1}': 42,
-      '{"text":"ba","int":-1}': 25,
-      '{"text":"baz","int":-2}': 13
-    });
-  });
-
-  it('correctly serializes/deserializes to/from json with enum keys', (): void => {
-    expect(
-      new (BTreeMap.with(MockEnum, U32))(
-        registry,
-        new (BTreeMap.with(MockEnum, U32))(registry, mockU32EnumMap).toJSON()
-      ).toJSON()
-    ).toEqual({
-      '{"key1":{"text":"b","int":-1}}': 69,
-      '{"key1":{"text":"b","int":1}}': 25,
-      '{"key2":{"text":"b","int":-1}}': 7,
-      '{"key3":[2,"b"]}': 42,
-      '{"key3":[2,"ba"]}': 13
-    });
-  });
-
-  it('generates sane toRawTypes', (): void => {
-    expect(new (BTreeMap.with(Text, U32))(registry).toRawType()).toBe('BTreeMap<Text,u32>');
-    expect(new (BTreeMap.with(Text, Text))(registry).toRawType()).toBe('BTreeMap<Text,Text>');
-    expect(new (BTreeMap.with(Text, Struct.with({ a: U32, b: Text })))(registry).toRawType())
-      .toBe('BTreeMap<Text,{"a":"u32","b":"Text"}>');
-  });
-
-  it('has a sane inspect', (): void => {
-    expect(
-      new (BTreeMap.with(Text, Text))(registry, new Map([
-        [new Text(registry, '1'), new Text(registry, 'foo')],
-        [new Text(registry, '2'), new Text(registry, 'bar')],
-        [new Text(registry, '3'), new Text(registry, 'baz')]
-      ])).inspect()
-    ).toEqual({
-      inner: [
-        { outer: [new Uint8Array([1 << 2]), stringToU8a('1')] },
-        { outer: [new Uint8Array([3 << 2]), stringToU8a('foo')] },
-        { outer: [new Uint8Array([1 << 2]), stringToU8a('2')] },
-        { outer: [new Uint8Array([3 << 2]), stringToU8a('bar')] },
-        { outer: [new Uint8Array([1 << 2]), stringToU8a('3')] },
-        { outer: [new Uint8Array([3 << 2]), stringToU8a('baz')] }
-      ],
-      outer: [new Uint8Array([3 << 2])]
-    });
-  });
-});

package/src/extended/BTreeMap.ts

@@ -1,16 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Codec, CodecClass, Registry } from '../types/index.js';
-
-import { CodecMap } from './Map.js';
-
-export class BTreeMap<K extends Codec = Codec, V extends Codec = Codec> extends CodecMap<K, V> {
-  public static with<K extends Codec, V extends Codec> (keyType: CodecClass<K> | string, valType: CodecClass<V> | string): CodecClass<CodecMap<K, V>> {
-    return class extends BTreeMap<K, V> {
-      constructor (registry: Registry, value?: Uint8Array | string | Map<any, any>) {
-        super(registry, keyType, valType, value, 'BTreeMap');
-      }
-    };
-  }
-}

package/src/extended/BTreeSet.spec.ts

@@ -1,260 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import type { CodecClass, CodecTo } from '@pezkuwi/types-codec/types';
-import type { ITuple } from '../types/interfaces.js';
-
-import { TypeRegistry } from '@pezkuwi/types';
-import { BTreeSet, Enum, I32, Option, Struct, Text, Tuple, U32 } from '@pezkuwi/types-codec';
-
-const registry = new TypeRegistry();
-
-class U32TextTuple extends (Tuple.with([U32, Text]) as unknown as CodecClass<ITuple<[U32, Text]>>) {}
-// Reason: We purposefully want `text` to be the first key of the struct and take priority during sorting
-// eslint-disable-next-line sort-keys
-class MockStruct extends Struct.with({ text: Text, int: I32 }) {}
-class MockEnum extends Enum.with({
-  Key1: MockStruct,
-  Key2: MockStruct,
-  Key3: U32TextTuple
-}) {}
-class MockOptionEnum extends Option.with(MockEnum) {}
-
-const mockU32Set = new Set<U32>();
-
-mockU32Set.add(new U32(registry, 2));
-mockU32Set.add(new U32(registry, 24));
-mockU32Set.add(new U32(registry, 30));
-mockU32Set.add(new U32(registry, 80));
-
-const mockU32SetString = '[2,24,30,80]';
-const mockU32SetObject = [2, 24, 30, 80];
-const mockU32SetHexString = '0x1002000000180000001e00000050000000';
-const mockU32SetUint8Array = Uint8Array.from([16, 2, 0, 0, 0, 24, 0, 0, 0, 30, 0, 0, 0, 80, 0, 0, 0]);
-
-const mockI32SetObj = [1000, 0, 255, -255, -1000];
-const mockTextSetObj = [
-  new Text(registry, 'baz'),
-  new Text(registry, 'b'),
-  new Text(registry, 'bb'),
-  new Text(registry, 'ba'),
-  new Text(registry, 'c')
-];
-const mockTupleSetObj = [
-  new U32TextTuple(registry, [2, 'ba']),
-  new U32TextTuple(registry, [2, 'bb']),
-  new U32TextTuple(registry, [2, 'b']),
-  new U32TextTuple(registry, [1, 'baz'])
-];
-const mockStructSetObj = [
-  new MockStruct(registry, { int: 1, text: 'b' }),
-  new MockStruct(registry, { int: -1, text: 'b' }),
-  new MockStruct(registry, { int: -1, text: 'ba' }),
-  new MockStruct(registry, { int: -2, text: 'baz' })
-];
-const mockEnumSetObj = [
-  new MockEnum(registry, { Key3: new U32TextTuple(registry, [2, 'ba']) }),
-  new MockEnum(registry, { Key3: new U32TextTuple(registry, [2, 'b']) }),
-  new MockEnum(registry, { Key2: new MockStruct(registry, { int: -1, text: 'b' }) }),
-  new MockEnum(registry, { Key1: new MockStruct(registry, { int: 1, text: 'b' }) }),
-  new MockEnum(registry, { Key1: new MockStruct(registry, { int: -1, text: 'b' }) })
-];
-
-const mockOptionEnumSetObj = [
-  new Option(registry, MockEnum, null),
-  new Option(registry, MockEnum, { Key3: new U32TextTuple(registry, [2, 'ba']) }),
-  new Option(registry, MockEnum, { Key3: new U32TextTuple(registry, [2, 'b']) }),
-  new Option(registry, MockEnum, { Key2: new MockStruct(registry, { int: -1, text: 'b' }) }),
-  new Option(registry, MockEnum, { Key1: new MockStruct(registry, { int: 1, text: 'b' }) }),
-  new Option(registry, MockEnum, { Key1: new MockStruct(registry, { int: -1, text: 'b' }) })
-];
-const mockDuplicateTextSetObj = [
-  new Text(registry, 'baz'),
-  new Text(registry, 'bb'),
-  new Text(registry, 'bb'), // duplicate.
-  new Text(registry, 'ba'),
-  new Text(registry, 'c')
-];
-
-describe('BTreeSet', (): void => {
-  describe('decoding', (): void => {
-    const testDecode = (type: string, input: unknown, output: string): void =>
-      it(`can decode from ${type}`, (): void => {
-        const s = new BTreeSet(registry, U32, input as string);
-
-        expect(s.toString()).toBe(output);
-      });
-
-    testDecode('Set', mockU32Set, mockU32SetString);
-    testDecode('hex', mockU32SetHexString, mockU32SetString);
-    testDecode('Uint8Array', mockU32SetUint8Array, mockU32SetString);
-
-    testDecode('Set', mockU32Set, mockU32SetString);
-    testDecode('hex', mockU32SetHexString, mockU32SetString);
-    testDecode('Uint8Array', mockU32SetUint8Array, mockU32SetString);
-  });
-
-  describe('encoding multiple values', (): void => {
-    const testEncode = (to: CodecTo, expected: any): void =>
-      it(`can encode ${to}`, (): void => {
-        const s = new BTreeSet(registry, U32, mockU32Set);
-
-        expect(s[to]()).toEqual(expected);
-      });
-
-    testEncode('toHex', mockU32SetHexString);
-    testEncode('toJSON', mockU32SetObject);
-    testEncode('toU8a', mockU32SetUint8Array);
-    testEncode('toString', mockU32SetString);
-  });
-
-  it('decodes null', (): void => {
-    expect(
-      new (
-        BTreeSet.with(U32)
-      )(registry, null).toString()
-    ).toEqual('[]');
-  });
-
-  it('decodes reusing instantiated inputs', (): void => {
-    const foo = new Text(registry, 'bar');
-
-    expect(
-      (new BTreeSet(registry, Text, new Set([foo]))).eq(new Set([foo]))
-    ).toBe(true);
-  });
-
-  it('decodes within more complicated types', (): void => {
-    const s = new Struct(registry, {
-      placeholder: U32,
-      value: BTreeSet.with(U32)
-    });
-
-    s.set('value', new BTreeSet(registry, U32, mockU32Set));
-    expect(s.toString()).toBe('{"placeholder":0,"value":[2,24,30,80]}');
-  });
-
-  it('throws when it cannot decode', (): void => {
-    expect(
-      (): BTreeSet<U32> => new (
-        BTreeSet.with(U32)
-      )(registry, 'ABC')
-    ).toThrow(/BTreeSet: cannot decode type/);
-  });
-
-  describe('enocodedLength & initialU8aLength', (): void => {
-    it('correctly encodes length', (): void => {
-      expect(
-        new (
-          BTreeSet.with(U32))(registry, mockU32Set).encodedLength
-      ).toEqual(17);
-    });
-
-    it('correctly encodes/decodes empty', (): void => {
-      const none = new (BTreeSet.with(U32))(registry, []);
-
-      // only the length byte
-      expect(none.toHex()).toEqual('0x00');
-      expect(none.encodedLength).toEqual(1);
-      expect(
-        (new (BTreeSet.with(U32))(registry, none.toHex())).initialU8aLength
-      ).toEqual(none.encodedLength);
-    });
-
-    it('correctly encodes/decodes filled', (): void => {
-      const some = new (BTreeSet.with(U32))(registry, [1, 2]);
-
-      // length byte + 2 values, 2 << 2 with u32 values
-      expect(some.toHex()).toEqual('0x080100000002000000');
-      expect(some.encodedLength).toEqual(1 + (4 * 2));
-      expect(
-        (new (BTreeSet.with(U32))(registry, some.toHex())).initialU8aLength
-      ).toEqual(some.encodedLength);
-    });
-  });
-
-  describe('sorting', (): void => {
-    it('correctly sorts numeric values', (): void => {
-      expect(
-        Array.from(new (BTreeSet.with(I32))(registry, mockI32SetObj)).map((k) => k.toNumber())
-      ).toEqual([-1000, -255, 0, 255, 1000]);
-    });
-
-    it('correctly sorts text values', (): void => {
-      expect(
-        Array.from(new (BTreeSet.with(Text))(registry, mockTextSetObj)).map((k) => k.toString())
-      ).toEqual(['b', 'ba', 'baz', 'bb', 'c']);
-    });
-
-    it('Reject duplicate values', (): void => {
-      expect(
-        () => new (BTreeSet.with(Text))(registry, mockDuplicateTextSetObj)
-      ).toThrow(/Duplicate value in BTreeSet/);
-    });
-
-    it('correctly sorts complex tuple values', (): void => {
-      expect(
-        Array.from(new (BTreeSet.with(U32TextTuple))(registry, mockTupleSetObj)).map((k) => k.toJSON())
-      ).toEqual([[1, 'baz'], [2, 'b'], [2, 'ba'], [2, 'bb']]);
-    });
-
-    it('correctly sorts complex struct values', (): void => {
-      expect(
-        Array.from(new (BTreeSet.with(MockStruct))(registry, mockStructSetObj)).map((k) => k.toJSON())
-      ).toEqual([
-        { int: -1, text: 'b' },
-        { int: 1, text: 'b' },
-        { int: -1, text: 'ba' },
-        { int: -2, text: 'baz' }
-      ]);
-    });
-
-    it('correctly sorts complex Option(enum) values', (): void => {
-      expect(
-        Array.from(new (BTreeSet.with(MockOptionEnum))(registry, mockOptionEnumSetObj)).map((k) => k.value.toJSON())
-      ).toEqual([
-        null,
-        { key1: { int: -1, text: 'b' } },
-        { key1: { int: 1, text: 'b' } },
-        { key2: { int: -1, text: 'b' } },
-        { key3: [2, 'b'] },
-        { key3: [2, 'ba'] }
-      ]);
-    });
-
-    it('correctly sorts complex enum values', (): void => {
-      expect(
-        Array.from(new (BTreeSet.with(MockEnum))(registry, mockEnumSetObj)).map((k) => k.toJSON())
-      ).toEqual([
-        { key1: { int: -1, text: 'b' } },
-        { key1: { int: 1, text: 'b' } },
-        { key2: { int: -1, text: 'b' } },
-        { key3: [2, 'b'] },
-        { key3: [2, 'ba'] }
-      ]);
-    });
-  });
-
-  it('generates sane toRawTypes', (): void => {
-    expect(new (BTreeSet.with(U32))(registry).toRawType()).toBe('BTreeSet<u32>');
-    expect(new (BTreeSet.with(Text))(registry).toRawType()).toBe('BTreeSet<Text>');
-    expect(new (BTreeSet.with(Struct.with({ a: U32, b: Text })))(registry).toRawType())
-      .toBe('BTreeSet<{"a":"u32","b":"Text"}>');
-  });
-
-  it('has a sane inspect', (): void => {
-    expect(
-      new (BTreeSet.with(U32))(registry, [1, 2, 3, 4]).inspect()
-    ).toEqual({
-      inner: [
-        { outer: [new Uint8Array([1, 0, 0, 0])] },
-        { outer: [new Uint8Array([2, 0, 0, 0])] },
-        { outer: [new Uint8Array([3, 0, 0, 0])] },
-        { outer: [new Uint8Array([4, 0, 0, 0])] }
-      ],
-      outer: [new Uint8Array([4 << 2])]
-    });
-  });
-});