@pezkuwi/types-codec 16.5.19 → 16.5.21

package/build/base/Enum.js

@@ -1,369 +0,0 @@
-import { identity, isHex, isNumber, isObject, isString, isU8a, objectProperties, stringCamelCase, stringify, stringPascalCase, u8aConcatStrict, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-import { mapToTypeMap, typesToMap } from '../utils/index.js';
-import { Null } from './Null.js';
-function isRustEnum(def) {
-    const defValues = Object.values(def);
-    if (defValues.some((v) => isNumber(v))) {
-        if (!defValues.every((v) => isNumber(v) && v >= 0 && v <= 255)) {
-            throw new Error('Invalid number-indexed enum definition');
-        }
-        return false;
-    }
-    return true;
-}
-function extractDef(registry, _def) {
-    const def = {};
-    let isBasic;
-    let isIndexed;
-    if (Array.isArray(_def)) {
-        for (let i = 0, count = _def.length; i < count; i++) {
-            def[_def[i]] = { Type: Null, index: i };
-        }
-        isBasic = true;
-        isIndexed = false;
-    }
-    else if (isRustEnum(_def)) {
-        const [Types, keys] = mapToTypeMap(registry, _def);
-        for (let i = 0, count = keys.length; i < count; i++) {
-            def[keys[i]] = { Type: Types[i], index: i };
-        }
-        isBasic = !Object.values(def).some(({ Type }) => Type !== Null);
-        isIndexed = false;
-    }
-    else {
-        const entries = Object.entries(_def);
-        for (let i = 0, count = entries.length; i < count; i++) {
-            const [key, index] = entries[i];
-            def[key] = { Type: Null, index };
-        }
-        isBasic = true;
-        isIndexed = true;
-    }
-    return {
-        def,
-        isBasic,
-        isIndexed
-    };
-}
-function getEntryType(def, checkIdx) {
-    const values = Object.values(def);
-    for (let i = 0, count = values.length; i < count; i++) {
-        const { Type, index } = values[i];
-        if (index === checkIdx) {
-            return Type;
-        }
-    }
-    throw new Error(`Unable to create Enum via index ${checkIdx}, in ${Object.keys(def).join(', ')}`);
-}
-function createFromU8a(registry, def, index, value) {
-    const Type = getEntryType(def, index);
-    return {
-        index,
-        value: new Type(registry, value)
-    };
-}
-function createFromValue(registry, def, index = 0, value) {
-    const Type = getEntryType(def, index);
-    return {
-        index,
-        value: value instanceof Type
-            ? value
-            : new Type(registry, value)
-    };
-}
-function decodeFromJSON(registry, def, key, value) {
-    // JSON comes in the form of { "<type (camelCase)>": "<value for type>" }, here we
-    // additionally force to lower to ensure forward compat
-    const keys = Object.keys(def).map((k) => k.toLowerCase());
-    const keyLower = key.toLowerCase();
-    const index = keys.indexOf(keyLower);
-    if (index === -1) {
-        throw new Error(`Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`);
-    }
-    try {
-        return createFromValue(registry, def, Object.values(def)[index].index, value);
-    }
-    catch (error) {
-        throw new Error(`Enum(${key}):: ${error.message}`);
-    }
-}
-function decodeEnum(registry, def, value, index) {
-    // NOTE We check the index path first, before looking at values - this allows treating
-    // the optional indexes before anything else, more-specific > less-specific
-    if (isNumber(index)) {
-        return createFromValue(registry, def, index, value);
-    }
-    else if (isU8a(value) || isHex(value)) {
-        const u8a = u8aToU8a(value);
-        // nested, we don't want to match isObject below
-        if (u8a.length) {
-            return createFromU8a(registry, def, u8a[0], u8a.subarray(1));
-        }
-    }
-    else if (value instanceof Enum) {
-        return createFromValue(registry, def, value.index, value.value);
-    }
-    else if (isNumber(value)) {
-        return createFromValue(registry, def, value);
-    }
-    else if (isString(value)) {
-        return decodeFromJSON(registry, def, value.toString());
-    }
-    else if (isObject(value)) {
-        const key = Object.keys(value)[0];
-        return decodeFromJSON(registry, def, key, value[key]);
-    }
-    // Worst-case scenario, return the first with default
-    return createFromValue(registry, def, Object.values(def)[0].index);
-}
-/**
- * @name Enum
- * @description
- * This implements an enum, that based on the value wraps a different type. It is effectively
- * an extension to enum where the value type is determined by the actual index.
- */
-export class Enum {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    #def;
-    #entryIndex;
-    #indexes;
-    #isBasic;
-    #isIndexed;
-    #raw;
-    constructor(registry, Types, value, index, { definition, setDefinition = identity } = {}) {
-        const { def, isBasic, isIndexed } = definition || setDefinition(extractDef(registry, Types));
-        // shortcut isU8a as used in SCALE decoding
-        const decoded = isU8a(value) && value.length && !isNumber(index)
-            ? createFromU8a(registry, def, value[0], value.subarray(1))
-            : decodeEnum(registry, def, value, index);
-        this.registry = registry;
-        this.#def = def;
-        this.#isBasic = isBasic;
-        this.#isIndexed = isIndexed;
-        this.#indexes = Object.values(def).map(({ index }) => index);
-        this.#entryIndex = this.#indexes.indexOf(decoded.index);
-        this.#raw = decoded.value;
-        if (this.#raw.initialU8aLength) {
-            this.initialU8aLength = 1 + this.#raw.initialU8aLength;
-        }
-    }
-    static with(Types) {
-        let definition;
-        // eslint-disable-next-line no-return-assign
-        const setDefinition = (d) => definition = d;
-        return class extends Enum {
-            static {
-                const keys = Array.isArray(Types)
-                    ? Types
-                    : Object.keys(Types);
-                const count = keys.length;
-                const asKeys = new Array(count);
-                const isKeys = new Array(count);
-                for (let i = 0; i < count; i++) {
-                    const name = stringPascalCase(keys[i]);
-                    asKeys[i] = `as${name}`;
-                    isKeys[i] = `is${name}`;
-                }
-                objectProperties(this.prototype, isKeys, (_, i, self) => self.type === keys[i]);
-                objectProperties(this.prototype, asKeys, (k, i, self) => {
-                    if (self.type !== keys[i]) {
-                        throw new Error(`Cannot convert '${self.type}' via ${k}`);
-                    }
-                    return self.value;
-                });
-            }
-            constructor(registry, value, index) {
-                super(registry, Types, value, index, { definition, setDefinition });
-            }
-        };
-    }
-    /**
-     * @description The length of the value when encoded as a Uint8Array
-     */
-    get encodedLength() {
-        return 1 + this.#raw.encodedLength;
-    }
-    /**
-     * @description returns a hash of the contents
-     */
-    get hash() {
-        return this.registry.hash(this.toU8a());
-    }
-    /**
-     * @description The index of the enum value
-     */
-    get index() {
-        return this.#indexes[this.#entryIndex];
-    }
-    /**
-     * @description The value of the enum
-     */
-    get inner() {
-        return this.#raw;
-    }
-    /**
-     * @description true if this is a basic enum (no values)
-     */
-    get isBasic() {
-        return this.#isBasic;
-    }
-    /**
-     * @description Checks if the value is an empty value
-     */
-    get isEmpty() {
-        return this.#raw.isEmpty;
-    }
-    /**
-     * @description Checks if the Enum points to a [[Null]] type
-     */
-    get isNone() {
-        return this.#raw instanceof Null;
-    }
-    /**
-     * @description The available keys for this enum
-     */
-    get defIndexes() {
-        return this.#indexes;
-    }
-    /**
-     * @description The available keys for this enum
-     */
-    get defKeys() {
-        return Object.keys(this.#def);
-    }
-    /**
-     * @description The name of the type this enum value represents
-     */
-    get type() {
-        return this.defKeys[this.#entryIndex];
-    }
-    /**
-     * @description The value of the enum
-     */
-    get value() {
-        return this.#raw;
-    }
-    /**
-     * @description Compares the value of the input to see if there is a match
-     */
-    eq(other) {
-        // cater for the case where we only pass the enum index
-        if (isU8a(other)) {
-            return !this.toU8a().some((entry, index) => entry !== other[index]);
-        }
-        else if (isNumber(other)) {
-            return this.toNumber() === other;
-        }
-        else if (this.#isBasic && isString(other)) {
-            return this.type === other;
-        }
-        else if (isHex(other)) {
-            return this.toHex() === other;
-        }
-        else if (other instanceof Enum) {
-            return this.index === other.index && this.value.eq(other.value);
-        }
-        else if (isObject(other)) {
-            return this.value.eq(other[this.type]);
-        }
-        // compare the actual wrapper value
-        return this.value.eq(other);
-    }
-    /**
-     * @description Returns a breakdown of the hex encoding for this Codec
-     */
-    inspect() {
-        if (this.#isBasic) {
-            return { outer: [new Uint8Array([this.index])] };
-        }
-        const { inner, outer = [] } = this.#raw.inspect();
-        return {
-            inner,
-            outer: [new Uint8Array([this.index]), ...outer]
-        };
-    }
-    /**
-     * @description Returns a hex string representation of the value
-     */
-    toHex() {
-        return u8aToHex(this.toU8a());
-    }
-    /**
-     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-     */
-    toHuman(isExtended, disableAscii) {
-        return this.#isBasic || this.isNone
-            ? this.type
-            : { [this.type]: this.#raw.toHuman(isExtended, disableAscii) };
-    }
-    /**
-     * @description Converts the Object to JSON, typically used for RPC transfers
-     */
-    toJSON() {
-        return this.#isBasic
-            ? this.type
-            : { [stringCamelCase(this.type)]: this.#raw.toJSON() };
-    }
-    /**
-     * @description Returns the number representation for the value
-     */
-    toNumber() {
-        return this.index;
-    }
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive(disableAscii) {
-        return this.#isBasic
-            ? this.type
-            : { [stringCamelCase(this.type)]: this.#raw.toPrimitive(disableAscii) };
-    }
-    /**
-     * @description Returns a raw struct representation of the enum types
-     */
-    _toRawStruct() {
-        if (this.#isBasic) {
-            return this.#isIndexed
-                ? this.defKeys.reduce((out, key, index) => {
-                    out[key] = this.#indexes[index];
-                    return out;
-                }, {})
-                : this.defKeys;
-        }
-        const entries = Object.entries(this.#def);
-        return typesToMap(this.registry, entries.reduce((out, [key, { Type }], i) => {
-            out[0][i] = Type;
-            out[1][i] = key;
-            return out;
-        }, [new Array(entries.length), new Array(entries.length)]));
-    }
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType() {
-        return stringify({ _enum: this._toRawStruct() });
-    }
-    /**
-     * @description Returns the string representation of the value
-     */
-    toString() {
-        return this.isNone
-            ? this.type
-            : 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 isBare
-            ? this.#raw.toU8a(isBare)
-            : u8aConcatStrict([
-                new Uint8Array([this.index]),
-                this.#raw.toU8a(isBare)
-            ]);
-    }
-}

package/build/base/Int.js

@@ -1,26 +0,0 @@
-import { AbstractInt } from '../abstract/Int.js';
-/**
- * @name Int
- * @description
- * A generic signed 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 Int extends AbstractInt {
-    constructor(registry, value = 0, bitLength) {
-        super(registry, value, bitLength, true);
-    }
-    static with(bitLength, typeName) {
-        return class extends Int {
-            constructor(registry, value) {
-                super(registry, value, bitLength);
-            }
-            toRawType() {
-                return typeName || super.toRawType();
-            }
-        };
-    }
-}

package/build/base/Null.js

@@ -1,77 +0,0 @@
-import { isNull } from '@pezkuwi/util';
-/**
- * @name Null
- * @description
- * Implements a type that does not contain anything (apart from `null`)
- */
-export class Null {
-    encodedLength = 0;
-    isEmpty = true;
-    registry;
-    createdAtHash;
-    initialU8aLength = 0;
-    isStorageFallback;
-    constructor(registry) {
-        this.registry = registry;
-    }
-    /**
-     * @description returns a hash of the contents
-     */
-    get hash() {
-        throw new Error('.hash is not implemented on Null');
-    }
-    /**
-     * @description Compares the value of the input to see if there is a match
-     */
-    eq(other) {
-        return other instanceof Null || isNull(other);
-    }
-    /**
-     * @description Returns a breakdown of the hex encoding for this Codec
-     */
-    inspect() {
-        return {};
-    }
-    /**
-     * @description Returns a hex string representation of the value
-     */
-    toHex() {
-        return '0x';
-    }
-    /**
-     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-     */
-    toHuman() {
-        return this.toJSON();
-    }
-    /**
-     * @description Converts the Object to JSON, typically used for RPC transfers
-     */
-    toJSON() {
-        return null;
-    }
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive() {
-        return null;
-    }
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType() {
-        return 'Null';
-    }
-    /**
-     * @description Returns the string representation of the value
-     */
-    toString() {
-        return '';
-    }
-    /**
-     * @description Encodes the value as a Uint8Array as per the SCALE specifications
-     */
-    toU8a(_isBare) {
-        return new Uint8Array();
-    }
-}

package/build/base/Option.js

@@ -1,232 +0,0 @@
-import { identity, isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@pezkuwi/util';
-import { typeToConstructor } from '../utils/index.js';
-import { Null } from './Null.js';
-class None extends Null {
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType() {
-        return 'None';
-    }
-}
-/** @internal */
-function decodeOption(registry, Type, value) {
-    if (value instanceof Type) {
-        // don't re-create, use as it (which also caters for derived types)
-        return value;
-    }
-    else if (value instanceof Option) {
-        if (value.value instanceof Type) {
-            // same instance, return it
-            return value.value;
-        }
-        else if (value.isNone) {
-            // internal is None, we are also none
-            return new None(registry);
-        }
-        // convert the actual value into known
-        return new Type(registry, value.value);
-    }
-    else if (isNull(value) || isUndefined(value) || value === '0x' || value instanceof None) {
-        // anything empty we pass as-is
-        return new None(registry);
-    }
-    else if (isU8a(value)) {
-        // the isU8a check happens last in the if-tree - since the wrapped value
-        // may be an instance of it, so Type and Option checks go in first
-        return !value.length || value[0] === 0
-            ? new None(registry)
-            : new Type(registry, value.subarray(1));
-    }
-    return new Type(registry, value);
-}
-/**
- * @name Option
- * @description
- * An Option is an optional field. Basically the first byte indicates that there is
- * is value to follow. If the byte is `1` there is an actual value. So the Option
- * implements that - decodes, checks for optionality and wraps the required structure
- * with a value if/as required/found.
- */
-export class Option {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    #Type;
-    #raw;
-    constructor(registry, typeName, value, { definition, setDefinition = identity } = {}) {
-        const Type = definition || setDefinition(typeToConstructor(registry, typeName));
-        const decoded = isU8a(value) && value.length && !isCodec(value)
-            ? value[0] === 0
-                ? new None(registry)
-                : new Type(registry, value.subarray(1))
-            : decodeOption(registry, Type, value);
-        this.registry = registry;
-        this.#Type = Type;
-        this.#raw = decoded;
-        if (decoded?.initialU8aLength) {
-            this.initialU8aLength = 1 + decoded.initialU8aLength;
-        }
-    }
-    static with(Type) {
-        let definition;
-        const setDefinition = (d) => {
-            definition = d;
-            return d;
-        };
-        return class extends Option {
-            constructor(registry, value) {
-                super(registry, Type, value, { definition, setDefinition });
-            }
-        };
-    }
-    /**
-     * @description The length of the value when encoded as a Uint8Array
-     */
-    get encodedLength() {
-        // boolean byte (has value, doesn't have) along with wrapped length
-        return 1 + this.#raw.encodedLength;
-    }
-    /**
-     * @description returns a hash of the contents
-     */
-    get hash() {
-        return this.registry.hash(this.toU8a());
-    }
-    /**
-     * @description Checks if the Option has no value
-     */
-    get isEmpty() {
-        return this.isNone;
-    }
-    /**
-     * @description Checks if the Option has no value
-     */
-    get isNone() {
-        return this.#raw instanceof None;
-    }
-    /**
-     * @description Checks if the Option has a value
-     */
-    get isSome() {
-        return !this.isNone;
-    }
-    /**
-     * @description The actual value for the Option
-     */
-    get value() {
-        return this.#raw;
-    }
-    /**
-     * @description Compares the value of the input to see if there is a match
-     */
-    eq(other) {
-        if (other instanceof Option) {
-            return (this.isSome === other.isSome) && this.value.eq(other.value);
-        }
-        return this.value.eq(other);
-    }
-    /**
-     * @description Returns a breakdown of the hex encoding for this Codec
-     */
-    inspect() {
-        if (this.isNone) {
-            return { outer: [new Uint8Array([0])] };
-        }
-        const { inner, outer = [] } = this.#raw.inspect();
-        return {
-            inner,
-            outer: [new Uint8Array([1]), ...outer]
-        };
-    }
-    /**
-     * @description Returns a hex string representation of the value
-     */
-    toHex() {
-        // This attempts to align with the JSON encoding - actually in this case
-        // the isSome value is correct, however the `isNone` may be problematic
-        return this.isNone
-            ? '0x'
-            : u8aToHex(this.toU8a().subarray(1));
-    }
-    /**
-     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-     */
-    toHuman(isExtended, disableAscii) {
-        return this.#raw.toHuman(isExtended, disableAscii);
-    }
-    /**
-     * @description Converts the Object to JSON, typically used for RPC transfers
-     */
-    toJSON() {
-        return this.isNone
-            ? null
-            : this.#raw.toJSON();
-    }
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive(disableAscii) {
-        return this.isNone
-            ? null
-            : this.#raw.toPrimitive(disableAscii);
-    }
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType(isBare) {
-        const wrapped = this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType();
-        return isBare
-            ? wrapped
-            : `Option<${wrapped}>`;
-    }
-    /**
-     * @description Returns the string representation of the value
-     */
-    toString() {
-        return this.#raw.toString();
-    }
-    /**
-     * @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) {
-        if (isBare) {
-            return this.#raw.toU8a(true);
-        }
-        const u8a = new Uint8Array(this.encodedLength);
-        if (this.isSome) {
-            u8a.set([1]);
-            u8a.set(this.#raw.toU8a(), 1);
-        }
-        return u8a;
-    }
-    /**
-     * @description Returns the value that the Option represents (if available), throws if null
-     */
-    unwrap() {
-        if (this.isNone) {
-            throw new Error('Option: unwrapping a None value');
-        }
-        return this.#raw;
-    }
-    /**
-     * @description Returns the value that the Option represents (if available) or defaultValue if none
-     * @param defaultValue The value to return if the option isNone
-     */
-    unwrapOr(defaultValue) {
-        return this.isSome
-            ? this.unwrap()
-            : defaultValue;
-    }
-    /**
-     * @description Returns the value that the Option represents (if available) or defaultValue if none
-     * @param defaultValue The value to return if the option isNone
-     */
-    unwrapOrDefault() {
-        return this.isSome
-            ? this.unwrap()
-            : new this.#Type(this.registry);
-    }
-}