@pezkuwi/types-codec 16.5.6 → 16.5.8

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

@@ -0,0 +1,67 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, BareOpts, CodecObject, Inspect, IU8a, Registry, ToString } from '../types/index.js';
+/**
+ * @name Object
+ * @description A type extends the Base class, when it holds a value
+ */
+export declare abstract class AbstractObject<T extends ToString> implements CodecObject<T> {
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number | undefined;
+    isStorageFallback?: boolean;
+    readonly $: T;
+    protected constructor(registry: Registry, value: T, initialU8aLength?: 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
+     */
+    abstract get isEmpty(): boolean;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    abstract eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    abstract inspect(): Inspect;
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    abstract toHex(isLe?: boolean): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    abstract toHuman(isExtended?: boolean, disableAscii?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    abstract toJSON(): AnyJson;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    abstract toPrimitive(disableAscii?: boolean): AnyJson;
+    /**
+     * @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)
+     */
+    abstract toU8a(isBare?: BareOpts): Uint8Array;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    abstract toRawType(): string;
+    /**
+     * @description Return the internal value (JS-aligned, same result as $)
+     */
+    valueOf(): T;
+}

package/build/cjs/abstract/Object.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractObject = void 0;
+/**
+ * @name Object
+ * @description A type extends the Base class, when it holds a value
+ */
+class AbstractObject {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    $;
+    constructor(registry, value, initialU8aLength) {
+        this.$ = value;
+        this.initialU8aLength = initialU8aLength;
+        this.registry = registry;
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        return this.toU8a().length;
+    }
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash() {
+        return this.registry.hash(this.toU8a());
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        return this.$.toString();
+    }
+    /**
+     * @description Return the internal value (JS-aligned, same result as $)
+     */
+    valueOf() {
+        return this.$;
+    }
+}
+exports.AbstractObject = AbstractObject;

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

@@ -0,0 +1,3 @@
+export { AbstractArray } from './Array.js';
+export { AbstractBase } from './Base.js';
+export { AbstractInt } from './Int.js';

package/build/cjs/abstract/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractInt = exports.AbstractBase = exports.AbstractArray = void 0;
+var Array_js_1 = require("./Array.js");
+Object.defineProperty(exports, "AbstractArray", { enumerable: true, get: function () { return Array_js_1.AbstractArray; } });
+var Base_js_1 = require("./Base.js");
+Object.defineProperty(exports, "AbstractBase", { enumerable: true, get: function () { return Base_js_1.AbstractBase; } });
+var Int_js_1 = require("./Int.js");
+Object.defineProperty(exports, "AbstractInt", { enumerable: true, get: function () { return Int_js_1.AbstractInt; } });

package/build/cjs/base/Compact.d.ts

@@ -0,0 +1,88 @@
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, AnyNumber, CodecClass, DefinitionSetter, ICompact, Inspect, INumber, IU8a, Registry } from '../types/index.js';
+/**
+ * @name Compact
+ * @description
+ * A compact length-encoding codec wrapper. It performs the same function as Length, however
+ * differs in that it uses a variable number of bytes to do the actual encoding. This is mostly
+ * used by other types to add length-prefixed encoding, or in the case of wrapped types, taking
+ * a number and making the compact representation thereof
+ */
+export declare class Compact<T extends INumber> implements ICompact<T> {
+    #private;
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Compact<T> | AnyNumber, { definition, setDefinition }?: DefinitionSetter<CodecClass<T>>);
+    static with<O extends INumber>(Type: CodecClass<O> | string): CodecClass<Compact<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 value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Returns the number of bits in the value
+     */
+    bitLength(): 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;
+    /**
+     * @description Returns a BigInt representation of the number
+     */
+    toBigInt(): bigint;
+    /**
+     * @description Returns the BN representation of the number
+     */
+    toBn(): BN;
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    toHex(isLe?: boolean): 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 Returns the number representation for the value
+     */
+    toNumber(): number;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii?: boolean): string | number;
+    /**
+     * @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;
+    /**
+     * @description Returns the embedded [[UInt]] or [[Moment]] value
+     */
+    unwrap(): T;
+}

package/build/cjs/base/Compact.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compact = void 0;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../utils/index.js");
+function decodeCompact(registry, Type, value) {
+    if ((0, util_1.isU8a)(value)) {
+        const [decodedLength, bn] = (value[0] & 0b11) < 0b11
+            ? (0, util_1.compactFromU8aLim)(value)
+            : (0, util_1.compactFromU8a)(value);
+        return [new Type(registry, bn), decodedLength];
+    }
+    else if (value instanceof Compact) {
+        const raw = value.unwrap();
+        return raw instanceof Type
+            ? [raw, 0]
+            : [new Type(registry, raw), 0];
+    }
+    else if (value instanceof Type) {
+        return [value, 0];
+    }
+    return [new Type(registry, value), 0];
+}
+/**
+ * @name Compact
+ * @description
+ * A compact length-encoding codec wrapper. It performs the same function as Length, however
+ * differs in that it uses a variable number of bytes to do the actual encoding. This is mostly
+ * used by other types to add length-prefixed encoding, or in the case of wrapped types, taking
+ * a number and making the compact representation thereof
+ */
+class Compact {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    #Type;
+    #raw;
+    constructor(registry, Type, value = 0, { definition, setDefinition = util_1.identity } = {}) {
+        this.registry = registry;
+        this.#Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, Type));
+        const [raw, decodedLength] = decodeCompact(registry, this.#Type, value);
+        this.initialU8aLength = decodedLength;
+        this.#raw = raw;
+    }
+    static with(Type) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => (definition = d);
+        return class extends Compact {
+            constructor(registry, value) {
+                super(registry, Type, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        return this.toU8a().length;
+    }
+    /**
+     * @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.#raw.isEmpty;
+    }
+    /**
+     * @description Returns the number of bits in the value
+     */
+    bitLength() {
+        return this.#raw.bitLength();
+    }
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other) {
+        return this.#raw.eq(other instanceof Compact
+            ? other.#raw
+            : other);
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            outer: [this.toU8a()]
+        };
+    }
+    /**
+     * @description Returns a BigInt representation of the number
+     */
+    toBigInt() {
+        return this.#raw.toBigInt();
+    }
+    /**
+     * @description Returns the BN representation of the number
+     */
+    toBn() {
+        return this.#raw.toBn();
+    }
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    toHex(isLe) {
+        return this.#raw.toHex(isLe);
+    }
+    /**
+     * @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.#raw.toJSON();
+    }
+    /**
+     * @description Returns the number representation for the value
+     */
+    toNumber() {
+        return this.#raw.toNumber();
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii) {
+        return this.#raw.toPrimitive(disableAscii);
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return `Compact<${this.registry.getClassName(this.#Type) || this.#raw.toRawType()}>`;
+    }
+    /**
+     * @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
+     */
+    toU8a(_isBare) {
+        return (0, util_1.compactToU8a)(this.#raw.toBn());
+    }
+    /**
+     * @description Returns the embedded [[UInt]] or [[Moment]] value
+     */
+    unwrap() {
+        return this.#raw;
+    }
+}
+exports.Compact = Compact;

package/build/cjs/base/DoNotConstruct.d.ts

@@ -0,0 +1,63 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, Codec, CodecClass, Inspect, IU8a, Registry } from '../types/index.js';
+/**
+ * @name DoNotConstruct
+ * @description
+ * An unknown type that fails on construction with the type info
+ */
+export declare class DoNotConstruct implements Codec {
+    #private;
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    isStorageFallback?: boolean;
+    constructor(registry: Registry, typeName?: string);
+    static with(typeName?: string): CodecClass;
+    /**
+     * @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 (always true)
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Unimplemented
+     */
+    eq(): boolean;
+    /**
+     * @description Unimplemented
+     */
+    inspect(): Inspect;
+    /**
+     * @description Unimplemented
+     */
+    toHex(): HexString;
+    /**
+     * @description Unimplemented
+     */
+    toHuman(): AnyJson;
+    /**
+     * @description Unimplemented
+     */
+    toJSON(): AnyJson;
+    /**
+     * @description Unimplemented
+     */
+    toPrimitive(): AnyJson;
+    /**
+     * @description Unimplemented
+     */
+    toRawType(): string;
+    /**
+     * @description Unimplemented
+     */
+    toString(): string;
+    /**
+     * @description Unimplemented
+     */
+    toU8a(): Uint8Array;
+}

package/build/cjs/base/DoNotConstruct.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoNotConstruct = void 0;
+/**
+ * @name DoNotConstruct
+ * @description
+ * An unknown type that fails on construction with the type info
+ */
+class DoNotConstruct {
+    registry;
+    createdAtHash;
+    isStorageFallback;
+    #neverError;
+    constructor(registry, typeName = 'DoNotConstruct') {
+        this.registry = registry;
+        this.#neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
+        throw this.#neverError;
+    }
+    static with(typeName) {
+        return class extends DoNotConstruct {
+            constructor(registry) {
+                super(registry, typeName);
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        throw this.#neverError;
+    }
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Checks if the value is an empty value (always true)
+     */
+    get isEmpty() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    eq() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    inspect() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toHex() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toHuman() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toJSON() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toPrimitive() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toRawType() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toString() {
+        throw this.#neverError;
+    }
+    /**
+     * @description Unimplemented
+     */
+    toU8a() {
+        throw this.#neverError;
+    }
+}
+exports.DoNotConstruct = DoNotConstruct;

package/build/cjs/base/Enum.d.ts

@@ -0,0 +1,118 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, Codec, CodecClass, DefinitionSetter, IEnum, Inspect, IU8a, Registry } from '../types/index.js';
+export type EnumCodecClass<T = Codec> = new (registry: Registry, value?: any, index?: number) => T;
+interface Definition {
+    def: TypesDef;
+    isBasic: boolean;
+    isIndexed: boolean;
+}
+interface EntryDef {
+    Type: CodecClass;
+    index: number;
+}
+type TypesDef = Record<string, EntryDef>;
+/**
+ * @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 declare class Enum implements IEnum {
+    #private;
+    readonly registry: Registry;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
+    constructor(registry: Registry, Types: Record<string, string | CodecClass> | Record<string, number> | string[], value?: unknown, index?: number, { definition, setDefinition }?: DefinitionSetter<Definition>);
+    static with(Types: Record<string, string | CodecClass> | Record<string, number> | string[]): EnumCodecClass<Enum>;
+    /**
+     * @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 The index of the enum value
+     */
+    get index(): number;
+    /**
+     * @description The value of the enum
+     */
+    get inner(): Codec;
+    /**
+     * @description true if this is a basic enum (no values)
+     */
+    get isBasic(): boolean;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Checks if the Enum points to a [[Null]] type
+     */
+    get isNone(): boolean;
+    /**
+     * @description The available keys for this enum
+     */
+    get defIndexes(): number[];
+    /**
+     * @description The available keys for this enum
+     */
+    get defKeys(): string[];
+    /**
+     * @description The name of the type this enum value represents
+     */
+    get type(): string;
+    /**
+     * @description The value of the enum
+     */
+    get value(): Codec;
+    /**
+     * @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 Returns the number representation for the value
+     */
+    toNumber(): number;
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii?: boolean): AnyJson;
+    /**
+     * @description Returns a raw struct representation of the enum types
+     */
+    protected _toRawStruct(): string[] | Record<string, string | number>;
+    /**
+     * @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 {};