@pezkuwi/types-codec 16.5.8 → 16.5.9

package/build/base/Null.d.ts

@@ -1,56 +0,0 @@
-import type { HexString } from '@pezkuwi/util/types';
-import type { Codec, Inspect, IU8a, Registry } from '../types/index.js';
-/**
- * @name Null
- * @description
- * Implements a type that does not contain anything (apart from `null`)
- */
-export declare class Null implements Codec {
-    readonly encodedLength = 0;
-    readonly isEmpty = true;
-    readonly registry: Registry;
-    createdAtHash?: IU8a;
-    initialU8aLength: number;
-    isStorageFallback?: boolean;
-    constructor(registry: Registry);
-    /**
-     * @description returns a hash of the contents
-     */
-    get hash(): IU8a;
-    /**
-     * @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;
-    /**
-     * @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(): null;
-    /**
-     * @description Converts the Object to JSON, typically used for RPC transfers
-     */
-    toJSON(): null;
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive(): null;
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType(): string;
-    /**
-     * @description Returns the string representation of the value
-     */
-    toString(): string;
-    /**
-     * @description Encodes the value as a Uint8Array as per the SCALE specifications
-     */
-    toU8a(_isBare?: boolean): Uint8Array;
-}

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.d.ts

@@ -1,94 +0,0 @@
-import type { HexString } from '@pezkuwi/util/types';
-import type { AnyJson, Codec, CodecClass, DefinitionSetter, Inspect, IOption, IU8a, Registry } from '../types/index.js';
-/**
- * @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 declare class Option<T extends Codec> implements IOption<T> {
-    #private;
-    readonly registry: Registry;
-    createdAtHash?: IU8a;
-    initialU8aLength?: number;
-    isStorageFallback?: boolean;
-    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: unknown, { definition, setDefinition }?: DefinitionSetter<CodecClass<T>>);
-    static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Option<O>>;
-    /**
-     * @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 Option has no value
-     */
-    get isEmpty(): boolean;
-    /**
-     * @description Checks if the Option has no value
-     */
-    get isNone(): boolean;
-    /**
-     * @description Checks if the Option has a value
-     */
-    get isSome(): boolean;
-    /**
-     * @description The actual value for the Option
-     */
-    get value(): T;
-    /**
-     * @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;
-    /**
-     * @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
-     */
-    toRawType(isBare?: boolean): 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;
-    /**
-     * @description Returns the value that the Option represents (if available), throws if null
-     */
-    unwrap(): T;
-    /**
-     * @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<O>(defaultValue: O): T | O;
-    /**
-     * @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(): T;
-}

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);
-    }
-}

package/build/base/Result.d.ts

@@ -1,38 +0,0 @@
-import type { Codec, CodecClass, IResult, Registry } from '../types/index.js';
-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 declare class Result<O extends Codec, E extends Codec> extends Enum implements IResult<O, E> {
-    constructor(registry: Registry, Ok: CodecClass<O> | string, Err: CodecClass<E> | string, value?: unknown);
-    static with<O extends Codec, E extends Codec>(Types: {
-        Ok: CodecClass<O> | string;
-        Err: CodecClass<E> | string;
-    }): CodecClass<Result<O, E>>;
-    /**
-     * @description Returns the wrapper Err value (if isErr)
-     */
-    get asErr(): E;
-    /**
-     * @description Returns the wrapper Ok value (if isOk)
-     */
-    get asOk(): O;
-    /**
-     * @description Checks if the Result has no value
-     */
-    get isEmpty(): boolean;
-    /**
-     * @description Checks if the Result wraps an Err value
-     */
-    get isErr(): boolean;
-    /**
-     * @description Checks if the Result wraps an Ok value
-     */
-    get isOk(): boolean;
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType(): string;
-}

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.d.ts

@@ -1,42 +0,0 @@
-import type { AnyTupleValue, Codec, CodecClass, DefinitionSetter, Inspect, ITuple, Registry } from '../types/index.js';
-import { AbstractArray } from '../abstract/Array.js';
-type TupleType = (CodecClass | string);
-type TupleTypes = TupleType[] | Record<string, CodecClass | string>;
-type Definition = [CodecClass[], string[]];
-/**
- * @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 declare class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
-    #private;
-    constructor(registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue, { definition, setDefinition }?: DefinitionSetter<Definition>);
-    static with(Types: TupleTypes | TupleType): CodecClass<Tuple>;
-    /**
-     * @description The length of the value when encoded as a Uint8Array
-     */
-    get encodedLength(): number;
-    /**
-     * @description The types definition of the tuple
-     */
-    get Types(): string[];
-    /**
-     * @description Returns a breakdown of the hex encoding for this Codec
-     */
-    inspect(): Inspect;
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    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;
-}
-export {};