@pezkuwi/types-codec 16.5.5 → 16.5.8

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[];
+}

package/build/cjs/abstract/Array.js

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

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

@@ -0,0 +1,75 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyJson, BareOpts, Codec, Inspect, IU8a, Registry } from '../types/index.js';
+/**
+ * @name Base
+ * @description A type extends the Base class, when it holds a value
+ */
+export declare abstract class AbstractBase<T extends Codec> implements Codec {
+    #private;
+    readonly registry: Registry;
+    createdAtHash?: IU8a | undefined;
+    initialU8aLength?: number | undefined;
+    isStorageFallback?: boolean;
+    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 returns the inner (wrapped value)
+     */
+    get inner(): T;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @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. 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 Converts the value in a best-fit primitive form
+     */
+    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)
+     */
+    toU8a(isBare?: BareOpts): Uint8Array;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    abstract toRawType(): string;
+    /**
+     * @description Returns the inner wrapped value (equivalent to valueOf)
+     */
+    unwrap(): T;
+    /**
+     * @description Returns the inner wrapped value
+     */
+    valueOf(): T;
+}

package/build/cjs/abstract/Base.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractBase = void 0;
+/**
+ * @name Base
+ * @description A type extends the Base class, when it holds a value
+ */
+class AbstractBase {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    #raw;
+    constructor(registry, value, initialU8aLength) {
+        this.initialU8aLength = initialU8aLength;
+        this.#raw = value;
+        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 inner (wrapped value)
+     */
+    get inner() {
+        return this.#raw;
+    }
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty() {
+        return this.#raw.isEmpty;
+    }
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other) {
+        return this.#raw.eq(other);
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return this.#raw.inspect();
+    }
+    /**
+     * @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 Converts the value in a best-fit primitive form
+     */
+    toPrimitive(disableAscii) {
+        return this.#raw.toPrimitive(disableAscii);
+    }
+    /**
+     * @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) {
+        return this.#raw.toU8a(isBare);
+    }
+    /**
+     * @description Returns the inner wrapped value (equivalent to valueOf)
+     */
+    unwrap() {
+        return this.#raw;
+    }
+    /**
+     * @description Returns the inner wrapped value
+     */
+    valueOf() {
+        return this.#raw;
+    }
+}
+exports.AbstractBase = AbstractBase;

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

@@ -0,0 +1,80 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { AnyNumber, Inspect, INumber, IU8a, Registry, UIntBitLength } from '../types/index.js';
+import { BN } from '@pezkuwi/util';
+export declare const DEFAULT_UINT_BITS = 64;
+/**
+ * @name AbstractInt
+ * @ignore
+ * @noInheritDoc
+ */
+export declare abstract class AbstractInt extends BN implements INumber {
+    #private;
+    readonly registry: Registry;
+    readonly encodedLength: number;
+    readonly isUnsigned: boolean;
+    createdAtHash?: IU8a;
+    initialU8aLength?: number;
+    isStorageFallback?: boolean;
+    constructor(registry: Registry, value?: AnyNumber | null, bitLength?: UIntBitLength, isSigned?: boolean);
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is a zero value (align elsewhere)
+     */
+    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 True if this value is the max of the type
+     */
+    isMax(): boolean;
+    /**
+     * @description Returns a BigInt representation of the number
+     */
+    toBigInt(): bigint;
+    /**
+     * @description Returns the BN representation of the number. (Compatibility)
+     */
+    toBn(): BN;
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(isLe?: boolean): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(_isExpanded?: boolean): string;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(onlyHex?: boolean): any;
+    /**
+     * @description Returns the value in a primitive form, either number when <= 52 bits, or string otherwise
+     */
+    toPrimitive(): number | string;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Returns the string representation of the value
+     * @param base The base to use for the conversion
+     */
+    toString(base?: number): string;
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     */
+    toU8a(_isBare?: boolean): Uint8Array;
+}