@pezkuwi/types-codec 16.5.6 → 16.5.8

package/build/base/Tuple.js

@@ -0,0 +1,110 @@
+import { identity, isFunction, isHex, isString, isU8a, stringify, u8aConcatStrict, u8aToU8a } from '@pezkuwi/util';
+import { AbstractArray } from '../abstract/Array.js';
+import { decodeU8a, mapToTypeMap, typesToConstructors, typeToConstructor } from '../utils/index.js';
+/** @internal */
+function decodeTuple(registry, result, value, Classes) {
+    if (Array.isArray(value)) {
+        const Types = Classes[0];
+        for (let i = 0, count = Types.length; i < count; i++) {
+            try {
+                const entry = value?.[i];
+                result[i] = entry instanceof Types[i]
+                    ? entry
+                    : new Types[i](registry, entry);
+            }
+            catch (error) {
+                throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
+            }
+        }
+        return [result, 0];
+    }
+    else if (isHex(value)) {
+        return decodeU8a(registry, result, u8aToU8a(value), Classes);
+    }
+    else if (!value || !result.length) {
+        const Types = Classes[0];
+        for (let i = 0, count = Types.length; i < count; i++) {
+            result[i] = new Types[i](registry);
+        }
+        return [result, 0];
+    }
+    throw new Error(`Expected array input to Tuple decoding, found ${typeof value}: ${stringify(value)}`);
+}
+/**
+ * @name Tuple
+ * @description
+ * A Tuple defines an anonymous fixed-length array, where each element has its
+ * own type. It extends the base JS `Array` object.
+ */
+export class Tuple extends AbstractArray {
+    #Types;
+    constructor(registry, Types, value, { definition, setDefinition = identity } = {}) {
+        const Classes = definition || setDefinition(Array.isArray(Types)
+            ? [typesToConstructors(registry, Types), []]
+            : isFunction(Types) || isString(Types)
+                ? [[typeToConstructor(registry, Types)], []]
+                : mapToTypeMap(registry, Types));
+        super(registry, Classes[0].length);
+        this.initialU8aLength = (isU8a(value)
+            ? decodeU8a(registry, this, value, Classes)
+            : decodeTuple(registry, this, value, Classes))[1];
+        this.#Types = Classes;
+    }
+    static with(Types) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => definition = d;
+        return class extends Tuple {
+            constructor(registry, value) {
+                super(registry, Types, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        let total = 0;
+        for (let i = 0, count = this.length; i < count; i++) {
+            total += this[i].encodedLength;
+        }
+        return total;
+    }
+    /**
+     * @description The types definition of the tuple
+     */
+    get Types() {
+        return this.#Types[1].length
+            ? this.#Types[1]
+            : this.#Types[0].map((T) => new T(this.registry).toRawType());
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            inner: this.inspectInner()
+        };
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        const types = this.#Types[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
+        return `(${types.join(',')})`;
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        // Overwrite the default toString representation of Array.
+        return stringify(this.toJSON());
+    }
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare) {
+        return u8aConcatStrict(this.toU8aInner(isBare));
+    }
+}

package/build/base/UInt.d.ts

@@ -0,0 +1,15 @@
+import type { CodecClass, UIntBitLength } from '../types/index.js';
+import { AbstractInt } from '../abstract/Int.js';
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Bizinikiwi all numbers are Little Endian encoded,
+ * this handles the encoding and decoding of those numbers. Upon construction
+ * the bitLength is provided and any additional use keeps the number to this
+ * length. This extends `BN`, so all methods available on a normal `BN` object
+ * is available here.
+ * @noInheritDoc
+ */
+export declare class UInt extends AbstractInt {
+    static with(bitLength: UIntBitLength, typeName?: string): CodecClass<UInt>;
+}

package/build/base/UInt.js

@@ -0,0 +1,23 @@
+import { AbstractInt } from '../abstract/Int.js';
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Bizinikiwi all numbers are Little Endian encoded,
+ * this handles the encoding and decoding of those numbers. Upon construction
+ * the bitLength is provided and any additional use keeps the number to this
+ * length. This extends `BN`, so all methods available on a normal `BN` object
+ * is available here.
+ * @noInheritDoc
+ */
+export class UInt extends AbstractInt {
+    static with(bitLength, typeName) {
+        return class extends UInt {
+            constructor(registry, value) {
+                super(registry, value, bitLength);
+            }
+            toRawType() {
+                return typeName || super.toRawType();
+            }
+        };
+    }
+}

package/build/base/Vec.d.ts

@@ -0,0 +1,28 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { Codec, CodecClass, DefinitionSetter, Registry } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
+export declare function decodeVec<T extends Codec>(registry: Registry, result: T[], value: Uint8Array | HexString | unknown[] | null, startAt: number, Type: CodecClass<T>): [number, number];
+/**
+ * @name Vec
+ * @description
+ * This manages codec arrays. Internally it keeps track of the length (as decoded) and allows
+ * construction with the passed `Type` in the constructor. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ */
+export declare class Vec<T extends Codec> extends AbstractArray<T> {
+    #private;
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: DefinitionSetter<CodecClass<T>>);
+    static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Vec<O>>;
+    /**
+     * @description The type for the items
+     */
+    get Type(): string;
+    /**
+     * @description Finds the index of the value in the array
+     */
+    indexOf(other?: unknown): number;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build/base/Vec.js

@@ -0,0 +1,102 @@
+import { compactFromU8aLim, identity, isHex, isU8a, logger, stringify, u8aToU8a } from '@pezkuwi/util';
+import { AbstractArray } from '../abstract/Array.js';
+import { decodeU8aVec, typeToConstructor } from '../utils/index.js';
+const MAX_LENGTH = 512 * 1024;
+const l = logger('Vec');
+function decodeVecLength(value) {
+    if (Array.isArray(value)) {
+        return [value, value.length, 0];
+    }
+    else if (isU8a(value) || isHex(value)) {
+        const u8a = u8aToU8a(value);
+        const [startAt, length] = compactFromU8aLim(u8a);
+        if (length > MAX_LENGTH) {
+            throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+        }
+        return [u8a, length, startAt];
+    }
+    else if (!value) {
+        return [null, 0, 0];
+    }
+    throw new Error(`Expected array/hex input to Vec<*> decoding, found ${typeof value}: ${stringify(value)}`);
+}
+export function decodeVec(registry, result, value, startAt, Type) {
+    if (Array.isArray(value)) {
+        const count = result.length;
+        for (let i = 0; i < count; i++) {
+            // 26/08/2022 this is actually a false positive - after recent eslint upgdates
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const entry = value[i];
+            try {
+                result[i] = entry instanceof Type
+                    ? entry
+                    : new Type(registry, entry);
+            }
+            catch (error) {
+                l.error(`Unable to decode on index ${i}`, error.message);
+                throw error;
+            }
+        }
+        return [0, 0];
+    }
+    else if (!value) {
+        return [0, 0];
+    }
+    // we don't need more checks, we already limited it via the length decoding
+    return decodeU8aVec(registry, result, u8aToU8a(value), startAt, Type);
+}
+/**
+ * @name Vec
+ * @description
+ * This manages codec arrays. Internally it keeps track of the length (as decoded) and allows
+ * construction with the passed `Type` in the constructor. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ */
+export class Vec extends AbstractArray {
+    #Type;
+    constructor(registry, Type, value = [], { definition, setDefinition = identity } = {}) {
+        const [decodeFrom, length, startAt] = decodeVecLength(value);
+        super(registry, length);
+        this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
+        this.initialU8aLength = (isU8a(decodeFrom)
+            ? decodeU8aVec(registry, this, decodeFrom, startAt, this.#Type)
+            : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
+    }
+    static with(Type) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => (definition = d);
+        return class extends Vec {
+            constructor(registry, value) {
+                super(registry, Type, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The type for the items
+     */
+    get Type() {
+        return this.#Type.name;
+    }
+    /**
+     * @description Finds the index of the value in the array
+     */
+    indexOf(other) {
+        // convert type first, this removes overhead from the eq
+        const check = other instanceof this.#Type
+            ? other
+            : new this.#Type(this.registry, other);
+        for (let i = 0, count = this.length; i < count; i++) {
+            if (check.eq(this[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return `Vec<${this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType()}>`;
+    }
+}

package/build/base/VecAny.d.ts

@@ -0,0 +1,15 @@
+import type { Codec } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
+/**
+ * @name VecAny
+ * @description
+ * This manages codec arrays, assuming that the inputs are already of type Codec. Unlike
+ * a vector, this can be used to manage array-like structures with variable arguments of
+ * any types
+ */
+export declare class VecAny<T extends Codec> extends AbstractArray<T> {
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build/base/VecAny.js

@@ -0,0 +1,17 @@
+import { AbstractArray } from '../abstract/Array.js';
+/**
+ * @name VecAny
+ * @description
+ * This manages codec arrays, assuming that the inputs are already of type Codec. Unlike
+ * a vector, this can be used to manage array-like structures with variable arguments of
+ * any types
+ */
+export class VecAny extends AbstractArray {
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        // FIXME This is basically an any type, cannot instantiate via createType
+        return 'Vec<Codec>';
+    }
+}

package/build/base/VecFixed.d.ts

@@ -0,0 +1,30 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { Codec, CodecClass, DefinitionSetter, Inspect, Registry } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
+/**
+ * @name VecFixed
+ * @description
+ * This manages codec arrays of a fixed length
+ */
+export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
+    #private;
+    constructor(registry: Registry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: DefinitionSetter<CodecClass<T>>);
+    static with<O extends Codec>(Type: CodecClass<O> | string, length: number): CodecClass<VecFixed<O>>;
+    /**
+     * @description The type for the items
+     */
+    get Type(): string;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    toU8a(): Uint8Array;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/build/base/VecFixed.js

@@ -0,0 +1,67 @@
+import { identity, isU8a, u8aConcatStrict } from '@pezkuwi/util';
+import { AbstractArray } from '../abstract/Array.js';
+import { decodeU8aVec, typeToConstructor } from '../utils/index.js';
+import { decodeVec } from './Vec.js';
+/**
+ * @name VecFixed
+ * @description
+ * This manages codec arrays of a fixed length
+ */
+export class VecFixed extends AbstractArray {
+    #Type;
+    constructor(registry, Type, length, value = [], { definition, setDefinition = identity } = {}) {
+        super(registry, length);
+        this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
+        this.initialU8aLength = (isU8a(value)
+            ? decodeU8aVec(registry, this, value, 0, this.#Type)
+            : decodeVec(registry, this, value, 0, this.#Type))[1];
+    }
+    static with(Type, length) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => (definition = d);
+        return class extends VecFixed {
+            constructor(registry, value) {
+                super(registry, Type, length, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The type for the items
+     */
+    get Type() {
+        return new this.#Type(this.registry).toRawType();
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        let total = 0;
+        for (let i = 0, count = this.length; i < count; i++) {
+            total += this[i].encodedLength;
+        }
+        return total;
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            inner: this.inspectInner()
+        };
+    }
+    toU8a() {
+        // we override, we don't add the length prefix for ourselves, and at the same time we
+        // ignore isBare on entries, since they should be properly encoded at all times
+        const encoded = this.toU8aInner();
+        return encoded.length
+            ? u8aConcatStrict(encoded)
+            : new Uint8Array([]);
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return `[${this.Type};${this.length}]`;
+    }
+}

package/build/base/index.d.ts

@@ -0,0 +1,12 @@
+export { Compact } from './Compact.js';
+export { DoNotConstruct } from './DoNotConstruct.js';
+export { Enum } from './Enum.js';
+export { Int } from './Int.js';
+export { Null } from './Null.js';
+export { Option } from './Option.js';
+export { Result } from './Result.js';
+export { Tuple } from './Tuple.js';
+export { UInt } from './UInt.js';
+export { Vec } from './Vec.js';
+export { VecAny } from './VecAny.js';
+export { VecFixed } from './VecFixed.js';

package/build/base/index.js

@@ -0,0 +1,12 @@
+export { Compact } from './Compact.js';
+export { DoNotConstruct } from './DoNotConstruct.js';
+export { Enum } from './Enum.js';
+export { Int } from './Int.js';
+export { Null } from './Null.js';
+export { Option } from './Option.js';
+export { Result } from './Result.js';
+export { Tuple } from './Tuple.js';
+export { UInt } from './UInt.js';
+export { Vec } from './Vec.js';
+export { VecAny } from './VecAny.js';
+export { VecFixed } from './VecFixed.js';

package/build/bundle.d.ts

@@ -0,0 +1,7 @@
+export { packageInfo } from './packageInfo.js';
+export * from './abstract/index.js';
+export * from './base/index.js';
+export * from './extended/index.js';
+export * from './native/index.js';
+export * from './primitive/index.js';
+export * from './utils/index.js';

package/build/bundle.js

@@ -0,0 +1,7 @@
+export { packageInfo } from './packageInfo.js';
+export * from './abstract/index.js';
+export * from './base/index.js';
+export * from './extended/index.js';
+export * from './native/index.js';
+export * from './primitive/index.js';
+export * from './utils/index.js';

package/build/cjs/abstract/Array.d.ts

@@ -0,0 +1,89 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, Codec, Inspect, IU8a, IVec, Registry } from '../types/index.js';
+/**
+ * @name AbstractArray
+ * @description
+ * This manages codec arrays. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ * @noInheritDoc
+ */
+export declare abstract class AbstractArray<T extends Codec> extends Array<T> implements IVec<T> {
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
+    /**
+     * @description This ensures that operators such as clice, filter, map, etc. return
+     * new Array instances (without this we need to apply overrides)
+     */
+    static get [Symbol.species](): typeof Array;
+    protected constructor(registry: Registry, length: number);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description The length of the value
+     */
+    get length(): number;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @internal
+     * @description Internal per-item inspection of internal values
+     */
+    inspectInner(): Inspect[];
+    /**
+     * @description Converts the Object to an standard JavaScript Array
+     */
+    toArray(): T[];
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean, disableAscii?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): AnyJson;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii?: boolean): AnyJson;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    abstract toRawType(): string;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+    /**
+     * @internal
+     * @description Internal per-item SCALE encoding of contained values
+     * @param isBare true when the value has none of the type-specific prefixes (internal)
+     */
+    toU8aInner(isBare?: boolean): Uint8Array[];
+}