@pezkuwi/types-codec 16.5.20 → 16.5.21

package/build/native/Struct.js

@@ -1,260 +0,0 @@
-import { isBoolean, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-import { compareMap, decodeU8aStruct, mapToTypeMap, typesToMap } from '../utils/index.js';
-function noopSetDefinition(d) {
-    return d;
-}
-/** @internal */
-function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
-    let jsonObj;
-    const typeofArray = Array.isArray(value);
-    const typeofMap = value instanceof Map;
-    const count = keys.length;
-    if (!typeofArray && !typeofMap && !isObject(value)) {
-        throw new Error(`Struct: Cannot decode value ${stringify(value)} (typeof ${typeof value}), expected an input object, map or array`);
-    }
-    else if (typeofArray && value.length !== count) {
-        throw new Error(`Struct: Unable to map ${stringify(value)} array to object with known keys ${keys.join(', ')}`);
-    }
-    const raw = new Array(count);
-    for (let i = 0; i < count; i++) {
-        const key = keys[i];
-        const jsonKey = jsonMap.get(key) || key;
-        const Type = Types[i];
-        let assign;
-        try {
-            if (typeofArray) {
-                assign = value[i];
-            }
-            else if (typeofMap) {
-                assign = jsonKey && value.get(jsonKey);
-            }
-            else {
-                assign = jsonKey && Object.prototype.hasOwnProperty.call(value, jsonKey) ? value[jsonKey] : undefined;
-                if (isUndefined(assign)) {
-                    if (isUndefined(jsonObj)) {
-                        const entries = Object.entries(value);
-                        jsonObj = {};
-                        for (let e = 0, ecount = entries.length; e < ecount; e++) {
-                            if (Object.prototype.hasOwnProperty.call(value, entries[e][0])) {
-                                jsonObj[stringCamelCase(entries[e][0])] = entries[e][1];
-                            }
-                        }
-                    }
-                    assign = jsonKey && Object.prototype.hasOwnProperty.call(jsonObj, jsonKey) ? jsonObj[jsonKey] : undefined;
-                }
-            }
-            raw[i] = [
-                key,
-                assign instanceof Type
-                    ? assign
-                    : new Type(registry, assign)
-            ];
-        }
-        catch (error) {
-            let type = Type.name;
-            try {
-                type = new Type(registry).toRawType();
-            }
-            catch {
-                // ignore
-            }
-            throw new Error(`Struct: failed on ${jsonKey}: ${type}:: ${error.message}`);
-        }
-    }
-    return [raw, 0];
-}
-/**
- * @name Struct
- * @description
- * A Struct defines an Object with key-value pairs - where the values are Codec values. It removes
- * a lot of repetition from the actual coding, define a structure type, pass it the key/Codec
- * values in the constructor and it manages the decoding. It is important that the constructor
- * values matches 100% to the order in th Rust code, i.e. don't go crazy and make it alphabetical,
- * it needs to decoded in the specific defined order.
- * @noInheritDoc
- */
-export class Struct extends Map {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    #jsonMap;
-    #Types;
-    constructor(registry, Types, value, jsonMap = new Map(), { definition, setDefinition = noopSetDefinition } = {}) {
-        const typeMap = definition || setDefinition(mapToTypeMap(registry, Types));
-        const [decoded, decodedLength] = isU8a(value) || isHex(value)
-            ? decodeU8aStruct(registry, new Array(typeMap[0].length), u8aToU8a(value), typeMap)
-            : value instanceof Struct
-                ? [value, 0]
-                : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
-        super(decoded);
-        this.initialU8aLength = decodedLength;
-        this.registry = registry;
-        this.#jsonMap = jsonMap;
-        this.#Types = typeMap;
-    }
-    static with(Types, jsonMap) {
-        let definition;
-        // eslint-disable-next-line no-return-assign
-        const setDefinition = (d) => definition = d;
-        return class extends Struct {
-            static {
-                const keys = Object.keys(Types);
-                objectProperties(this.prototype, keys, (k, _, self) => self.get(k));
-            }
-            constructor(registry, value) {
-                super(registry, Types, value, jsonMap, { definition, setDefinition });
-            }
-        };
-    }
-    /**
-     * @description The available keys for this struct
-     */
-    get defKeys() {
-        return this.#Types[1];
-    }
-    /**
-     * @description Checks if the value is an empty value '{}'
-     */
-    get isEmpty() {
-        return [...this.keys()].length === 0;
-    }
-    /**
-     * @description The length of the value when encoded as a Uint8Array
-     */
-    get encodedLength() {
-        let total = 0;
-        for (const v of this.values()) {
-            total += v.encodedLength;
-        }
-        return total;
-    }
-    /**
-     * @description returns a hash of the contents
-     */
-    get hash() {
-        return this.registry.hash(this.toU8a());
-    }
-    /**
-     * @description Returns the Type description of the structure
-     */
-    get Type() {
-        const result = {};
-        const [Types, keys] = this.#Types;
-        for (let i = 0, count = keys.length; i < count; i++) {
-            result[keys[i]] = new Types[i](this.registry).toRawType();
-        }
-        return result;
-    }
-    /**
-     * @description Compares the value of the input to see if there is a match
-     */
-    eq(other) {
-        return compareMap(this, other);
-    }
-    /**
-     * @description Returns a specific names entry in the structure
-     * @param key The name of the entry to retrieve
-     */
-    get(key) {
-        return super.get(key);
-    }
-    /**
-     * @description Returns the values of a member at a specific index (Rather use get(name) for performance)
-     */
-    getAtIndex(index) {
-        return this.toArray()[index];
-    }
-    /**
-     * @description Returns the a types value by name
-     */
-    getT(key) {
-        return super.get(key);
-    }
-    /**
-     * @description Returns a breakdown of the hex encoding for this Codec
-     */
-    inspect(isBare) {
-        const inner = [];
-        for (const [k, v] of this.entries()) {
-            inner.push({
-                ...v.inspect(!isBare || isBoolean(isBare)
-                    ? isBare
-                    : isBare[k]),
-                name: stringCamelCase(k)
-            });
-        }
-        return {
-            inner
-        };
-    }
-    /**
-     * @description Converts the Object to an standard JavaScript Array
-     */
-    toArray() {
-        return [...this.values()];
-    }
-    /**
-     * @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) {
-        const json = {};
-        for (const [k, v] of this.entries()) {
-            json[k] = v.toHuman(isExtended, disableAscii);
-        }
-        return json;
-    }
-    /**
-     * @description Converts the Object to JSON, typically used for RPC transfers
-     */
-    toJSON() {
-        const json = {};
-        for (const [k, v] of this.entries()) {
-            // Here we pull out the entry against the JSON mapping (if supplied)
-            // since this representation goes over RPC and needs to be correct
-            json[(this.#jsonMap.get(k) || k)] = v.toJSON();
-        }
-        return json;
-    }
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive(disableAscii) {
-        const json = {};
-        for (const [k, v] of this.entries()) {
-            json[k] = v.toPrimitive(disableAscii);
-        }
-        return json;
-    }
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType() {
-        return stringify(typesToMap(this.registry, this.#Types));
-    }
-    /**
-     * @description Returns the string representation of the value
-     */
-    toString() {
-        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) {
-        const encoded = [];
-        for (const [k, v] of this.entries()) {
-            encoded.push(v.toU8a(!isBare || isBoolean(isBare)
-                ? isBare
-                : isBare[k]));
-        }
-        return u8aConcatStrict(encoded);
-    }
-}

package/build/native/Text.d.ts

@@ -1,77 +0,0 @@
-import type { HexString } from '@pezkuwi/util/types';
-import type { AnyString, AnyU8a, Inspect, IText, IU8a, Registry } from '../types/index.js';
-/**
- * @name Text
- * @description
- * This is a string wrapper, along with the length. It is used both for strings as well
- * as items such as documentation. It simply extends the standard JS `String` built-in
- * object, inheriting all methods exposed from `String`.
- * @noInheritDoc
- */
-export declare class Text extends String implements IText {
-    #private;
-    readonly registry: Registry;
-    createdAtHash?: IU8a;
-    initialU8aLength?: number;
-    isStorageFallback?: boolean;
-    constructor(registry: Registry, value?: null | AnyString | AnyU8a | {
-        toString: () => string;
-    });
-    /**
-     * @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;
-    /**
-     * @description Set an override value for this
-     */
-    setOverride(override: string): void;
-    /**
-     * @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(): string;
-    /**
-     * @description Converts the Object to JSON, typically used for RPC transfers
-     */
-    toJSON(): string;
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive(): string;
-    /**
-     * @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;
-}

package/build/native/Text.js

@@ -1,150 +0,0 @@
-import { compactAddLength, compactFromU8aLim, compactToU8a, hexToU8a, isHex, isString, isU8a, stringToU8a, u8aToHex, u8aToString } from '@pezkuwi/util';
-import { Raw } from './Raw.js';
-const MAX_LENGTH = 128 * 1024;
-/** @internal */
-function decodeText(value) {
-    if (isU8a(value)) {
-        if (!value.length) {
-            return ['', 0];
-        }
-        // for Raw, the internal buffer does not have an internal length
-        // (the same applies in e.g. Bytes, where length is added at encoding-time)
-        if (value instanceof Raw) {
-            return [u8aToString(value), 0];
-        }
-        const [offset, length] = compactFromU8aLim(value);
-        const total = offset + length;
-        if (length > MAX_LENGTH) {
-            throw new Error(`Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
-        }
-        else if (total > value.length) {
-            throw new Error(`Text: required length less than remainder, expected at least ${total}, found ${value.length}`);
-        }
-        return [u8aToString(value.subarray(offset, total)), total];
-    }
-    else if (isHex(value)) {
-        return [u8aToString(hexToU8a(value)), 0];
-    }
-    return [value ? value.toString() : '', 0];
-}
-/**
- * @name Text
- * @description
- * This is a string wrapper, along with the length. It is used both for strings as well
- * as items such as documentation. It simply extends the standard JS `String` built-in
- * object, inheriting all methods exposed from `String`.
- * @noInheritDoc
- */
-export class Text extends String {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    #override = null;
-    constructor(registry, value) {
-        const [str, decodedLength] = decodeText(value);
-        super(str);
-        this.registry = registry;
-        this.initialU8aLength = decodedLength;
-    }
-    /**
-     * @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.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 isString(other)
-            ? this.toString() === other.toString()
-            : false;
-    }
-    /**
-     * @description Returns a breakdown of the hex encoding for this Codec
-     */
-    inspect() {
-        const value = stringToU8a(super.toString());
-        return {
-            outer: value.length
-                ? [compactToU8a(value.length), value]
-                : [compactToU8a(value.length)]
-        };
-    }
-    /**
-     * @description Set an override value for this
-     */
-    setOverride(override) {
-        this.#override = override;
-    }
-    /**
-     * @description Returns a hex string representation of the value
-     */
-    toHex() {
-        // like with Vec<u8>, when we are encoding to hex, we don't actually add
-        // the length prefix (it is already implied by the actual string length)
-        return u8aToHex(this.toU8a(true));
-    }
-    /**
-     * @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 this.toString();
-    }
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive() {
-        return this.toJSON();
-    }
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType() {
-        return 'Text';
-    }
-    /**
-     * @description Returns the string representation of the value
-     */
-    toString() {
-        return this.#override || super.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) {
-        // NOTE Here we use the super toString (we are not taking overrides into account,
-        // rather encoding the original value the string was constructed with)
-        const encoded = stringToU8a(super.toString());
-        return isBare
-            ? encoded
-            : compactAddLength(encoded);
-    }
-}

package/build/native/index.d.ts

@@ -1,8 +0,0 @@
-export { bool as Bool, bool } from './Bool.js';
-export { CodecDate, CodecDate as Date } from './Date.js';
-export { Float } from './Float.js';
-export { Json } from './Json.js';
-export { Raw } from './Raw.js';
-export { CodecSet, CodecSet as Set } from './Set.js';
-export { Struct } from './Struct.js';
-export { Text } from './Text.js';

package/build/native/index.js

@@ -1,8 +0,0 @@
-export { bool as Bool, bool } from './Bool.js';
-export { CodecDate, CodecDate as Date } from './Date.js';
-export { Float } from './Float.js';
-export { Json } from './Json.js';
-export { Raw } from './Raw.js';
-export { CodecSet, CodecSet as Set } from './Set.js';
-export { Struct } from './Struct.js';
-export { Text } from './Text.js';