@pezkuwi/types-codec 16.5.20 → 16.5.21

package/build/base/Result.js

@@ -1,63 +0,0 @@
-import { Enum } from './Enum.js';
-/**
- * @name Result
- * @description
- * A Result maps to the Rust Result type, that can either wrap a success or error value
- */
-export class Result extends Enum {
-    constructor(registry, Ok, Err, value) {
-        // NOTE This is order-dependent, Ok (with index 0) needs to be first
-        // eslint-disable-next-line sort-keys
-        super(registry, { Ok, Err }, value);
-    }
-    static with(Types) {
-        return class extends Result {
-            constructor(registry, value) {
-                super(registry, Types.Ok, Types.Err, value);
-            }
-        };
-    }
-    /**
-     * @description Returns the wrapper Err value (if isErr)
-     */
-    get asErr() {
-        if (!this.isErr) {
-            throw new Error('Cannot extract Err value from Ok result, check isErr first');
-        }
-        return this.value;
-    }
-    /**
-     * @description Returns the wrapper Ok value (if isOk)
-     */
-    get asOk() {
-        if (!this.isOk) {
-            throw new Error('Cannot extract Ok value from Err result, check isOk first');
-        }
-        return this.value;
-    }
-    /**
-     * @description Checks if the Result has no value
-     */
-    get isEmpty() {
-        return this.isOk && this.value.isEmpty;
-    }
-    /**
-     * @description Checks if the Result wraps an Err value
-     */
-    get isErr() {
-        return !this.isOk;
-    }
-    /**
-     * @description Checks if the Result wraps an Ok value
-     */
-    get isOk() {
-        return this.index === 0;
-    }
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType() {
-        const Types = this._toRawStruct();
-        return `Result<${Types.Ok},${Types.Err}>`;
-    }
-}

package/build/base/Tuple.js

@@ -1,110 +0,0 @@
-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.js

@@ -1,23 +0,0 @@
-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.js

@@ -1,102 +0,0 @@
-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.js

@@ -1,17 +0,0 @@
-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.js

@@ -1,67 +0,0 @@
-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.js

@@ -1,12 +0,0 @@
-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.js

@@ -1,7 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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[];
-}

package/build/cjs/abstract/Array.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractArray = void 0;
-const util_1 = require("@pezkuwi/util");
-const compareArray_js_1 = require("../utils/compareArray.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
- */
-class AbstractArray extends Array {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    /**
-     * @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]() {
-        return Array;
-    }
-    constructor(registry, length) {
-        super(length);
-        this.registry = registry;
-    }
-    /**
-     * @description The length of the value when encoded as a Uint8Array
-     */
-    get encodedLength() {
-        // We need to loop through all entries since they may have a variable length themselves,
-        // e.g. when a Vec or Compact is contained withing, it has a variable length based on data
-        const count = this.length;
-        let total = (0, util_1.compactToU8a)(count).length;
-        for (let i = 0; i < count; i++) {
-            total += this[i].encodedLength;
-        }
-        return total;
-    }
-    /**
-     * @description returns a hash of the contents
-     */
-    get hash() {
-        return this.registry.hash(this.toU8a());
-    }
-    /**
-     * @description Checks if the value is an empty value
-     */
-    get isEmpty() {
-        return this.length === 0;
-    }
-    /**
-     * @description The length of the value
-     */
-    get length() {
-        // only included here since we ignore inherited docs
-        return super.length;
-    }
-    /**
-     * @description Compares the value of the input to see if there is a match
-     */
-    eq(other) {
-        return (0, compareArray_js_1.compareArray)(this, other);
-    }
-    /**
-     * @description Returns a breakdown of the hex encoding for this Codec
-     */
-    inspect() {
-        return {
-            inner: this.inspectInner(),
-            outer: [(0, util_1.compactToU8a)(this.length)]
-        };
-    }
-    /**
-     * @internal
-     * @description Internal per-item inspection of internal values
-     */
-    inspectInner() {
-        const count = this.length;
-        const inner = new Array(count);
-        for (let i = 0; i < count; i++) {
-            inner[i] = this[i].inspect();
-        }
-        return inner;
-    }
-    /**
-     * @description Converts the Object to an standard JavaScript Array
-     */
-    toArray() {
-        return Array.from(this);
-    }
-    /**
-     * @description Returns a hex string representation of the value
-     */
-    toHex() {
-        return (0, util_1.u8aToHex)(this.toU8a());
-    }
-    /**
-     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-     */
-    toHuman(isExtended, disableAscii) {
-        const count = this.length;
-        const result = new Array(count);
-        for (let i = 0; i < count; i++) {
-            result[i] = this[i] && this[i].toHuman(isExtended, disableAscii);
-        }
-        return result;
-    }
-    /**
-     * @description Converts the Object to JSON, typically used for RPC transfers
-     */
-    toJSON() {
-        const count = this.length;
-        const result = new Array(count);
-        for (let i = 0; i < count; i++) {
-            // We actually log inside the U8a decoding and use JSON.stringify(...), which
-            // means that the Vec may be partially populated (same applies to toHuman, same check)
-            result[i] = this[i] && this[i].toJSON();
-        }
-        return result;
-    }
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive(disableAscii) {
-        const count = this.length;
-        const result = new Array(count);
-        for (let i = 0; i < count; i++) {
-            result[i] = this[i] && this[i].toPrimitive(disableAscii);
-        }
-        return result;
-    }
-    /**
-     * @description Returns the string representation of the value
-     */
-    toString() {
-        const count = this.length;
-        const result = new Array(count);
-        for (let i = 0; i < count; i++) {
-            result[i] = this[i].toString();
-        }
-        return `[${result.join(', ')}]`;
-    }
-    /**
-     * @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) {
-        const encoded = this.toU8aInner();
-        return isBare
-            ? (0, util_1.u8aConcatStrict)(encoded)
-            : (0, util_1.u8aConcatStrict)([(0, util_1.compactToU8a)(this.length), ...encoded]);
-    }
-    /**
-     * @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) {
-        const count = this.length;
-        const encoded = new Array(count);
-        for (let i = 0; i < count; i++) {
-            encoded[i] = this[i].toU8a(isBare);
-        }
-        return encoded;
-    }
-}
-exports.AbstractArray = AbstractArray;