@pezkuwi/types-codec 16.5.5 → 16.5.6

package/cjs/native/Struct.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Struct = void 0;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../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 && !(0, util_1.isObject)(value)) {
+        throw new Error(`Struct: Cannot decode value ${(0, util_1.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 ${(0, util_1.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 ((0, util_1.isUndefined)(assign)) {
+                    if ((0, util_1.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[(0, util_1.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
+ */
+class Struct extends Map {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    #jsonMap;
+    #Types;
+    constructor(registry, Types, value, jsonMap = new Map(), { definition, setDefinition = noopSetDefinition } = {}) {
+        const typeMap = definition || setDefinition((0, index_js_1.mapToTypeMap)(registry, Types));
+        const [decoded, decodedLength] = (0, util_1.isU8a)(value) || (0, util_1.isHex)(value)
+            ? (0, index_js_1.decodeU8aStruct)(registry, new Array(typeMap[0].length), (0, util_1.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);
+                (0, util_1.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 (0, index_js_1.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 || (0, util_1.isBoolean)(isBare)
+                    ? isBare
+                    : isBare[k]),
+                name: (0, util_1.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 (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 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 (0, util_1.stringify)((0, index_js_1.typesToMap)(this.registry, this.#Types));
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        return (0, util_1.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 || (0, util_1.isBoolean)(isBare)
+                ? isBare
+                : isBare[k]));
+        }
+        return (0, util_1.u8aConcatStrict)(encoded);
+    }
+}
+exports.Struct = Struct;

package/cjs/native/Text.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Text = void 0;
+const util_1 = require("@pezkuwi/util");
+const Raw_js_1 = require("./Raw.js");
+const MAX_LENGTH = 128 * 1024;
+/** @internal */
+function decodeText(value) {
+    if ((0, util_1.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_js_1.Raw) {
+            return [(0, util_1.u8aToString)(value), 0];
+        }
+        const [offset, length] = (0, util_1.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 [(0, util_1.u8aToString)(value.subarray(offset, total)), total];
+    }
+    else if ((0, util_1.isHex)(value)) {
+        return [(0, util_1.u8aToString)((0, util_1.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
+ */
+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 (0, util_1.isString)(other)
+            ? this.toString() === other.toString()
+            : false;
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        const value = (0, util_1.stringToU8a)(super.toString());
+        return {
+            outer: value.length
+                ? [(0, util_1.compactToU8a)(value.length), value]
+                : [(0, util_1.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 (0, util_1.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 = (0, util_1.stringToU8a)(super.toString());
+        return isBare
+            ? encoded
+            : (0, util_1.compactAddLength)(encoded);
+    }
+}
+exports.Text = Text;

package/cjs/native/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Text = exports.Struct = exports.Set = exports.CodecSet = exports.Raw = exports.Json = exports.Float = exports.Date = exports.CodecDate = exports.bool = exports.Bool = void 0;
+var Bool_js_1 = require("./Bool.js");
+Object.defineProperty(exports, "Bool", { enumerable: true, get: function () { return Bool_js_1.bool; } });
+Object.defineProperty(exports, "bool", { enumerable: true, get: function () { return Bool_js_1.bool; } });
+var Date_js_1 = require("./Date.js");
+Object.defineProperty(exports, "CodecDate", { enumerable: true, get: function () { return Date_js_1.CodecDate; } });
+Object.defineProperty(exports, "Date", { enumerable: true, get: function () { return Date_js_1.CodecDate; } });
+var Float_js_1 = require("./Float.js");
+Object.defineProperty(exports, "Float", { enumerable: true, get: function () { return Float_js_1.Float; } });
+var Json_js_1 = require("./Json.js");
+Object.defineProperty(exports, "Json", { enumerable: true, get: function () { return Json_js_1.Json; } });
+var Raw_js_1 = require("./Raw.js");
+Object.defineProperty(exports, "Raw", { enumerable: true, get: function () { return Raw_js_1.Raw; } });
+var Set_js_1 = require("./Set.js");
+Object.defineProperty(exports, "CodecSet", { enumerable: true, get: function () { return Set_js_1.CodecSet; } });
+Object.defineProperty(exports, "Set", { enumerable: true, get: function () { return Set_js_1.CodecSet; } });
+var Struct_js_1 = require("./Struct.js");
+Object.defineProperty(exports, "Struct", { enumerable: true, get: function () { return Struct_js_1.Struct; } });
+var Text_js_1 = require("./Text.js");
+Object.defineProperty(exports, "Text", { enumerable: true, get: function () { return Text_js_1.Text; } });

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/packageDetect.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("@pezkuwi/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, []);

package/cjs/packageInfo.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@pezkuwi/types-codec', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.4' };

package/cjs/primitive/F32.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.f32 = void 0;
+const Float_js_1 = require("../native/Float.js");
+/**
+ * @name f32
+ * @description
+ * A 32-bit float
+ */
+class f32 extends Float_js_1.Float.with(32) {
+    // NOTE without this, we cannot properly determine extensions
+    __FloatType = 'f32';
+}
+exports.f32 = f32;

package/cjs/primitive/F64.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.f64 = void 0;
+const Float_js_1 = require("../native/Float.js");
+/**
+ * @name f64
+ * @description
+ * A 64-bit float
+ */
+class f64 extends Float_js_1.Float.with(64) {
+    // NOTE without this, we cannot properly determine extensions
+    __FloatType = 'f64';
+}
+exports.f64 = f64;

package/cjs/primitive/I128.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i128 = void 0;
+const Int_js_1 = require("../base/Int.js");
+/**
+ * @name i128
+ * @description
+ * A 128-bit signed integer
+ */
+class i128 extends Int_js_1.Int.with(128) {
+    // NOTE without this, we cannot properly determine extensions
+    __IntType = 'i128';
+}
+exports.i128 = i128;

package/cjs/primitive/I16.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i16 = void 0;
+const Int_js_1 = require("../base/Int.js");
+/**
+ * @name i16
+ * @description
+ * A 16-bit signed integer
+ */
+class i16 extends Int_js_1.Int.with(16) {
+    // NOTE without this, we cannot properly determine extensions
+    __IntType = 'i16';
+}
+exports.i16 = i16;

package/cjs/primitive/I256.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i256 = void 0;
+const Int_js_1 = require("../base/Int.js");
+/**
+ * @name i256
+ * @description
+ * A 256-bit signed integer
+ */
+class i256 extends Int_js_1.Int.with(256) {
+    // NOTE without this, we cannot properly determine extensions
+    __IntType = 'i256';
+}
+exports.i256 = i256;

package/cjs/primitive/I32.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i32 = void 0;
+const Int_js_1 = require("../base/Int.js");
+/**
+ * @name i32
+ * @description
+ * A 32-bit signed integer
+ */
+class i32 extends Int_js_1.Int.with(32) {
+    // NOTE without this, we cannot properly determine extensions
+    __IntType = 'i32';
+}
+exports.i32 = i32;

package/cjs/primitive/I64.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i64 = void 0;
+const Int_js_1 = require("../base/Int.js");
+/**
+ * @name i64
+ * @description
+ * A 64-bit signed integer
+ */
+class i64 extends Int_js_1.Int.with(64) {
+    // NOTE without this, we cannot properly determine extensions
+    __IntType = 'i64';
+}
+exports.i64 = i64;

package/cjs/primitive/I8.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i8 = void 0;
+const Int_js_1 = require("../base/Int.js");
+/**
+ * @name i8
+ * @description
+ * An 8-bit signed integer
+ */
+class i8 extends Int_js_1.Int.with(8) {
+    // NOTE without this, we cannot properly determine extensions
+    __IntType = 'i8';
+}
+exports.i8 = i8;

package/cjs/primitive/ISize.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isize = void 0;
+const I32_js_1 = require("./I32.js");
+/**
+ * @name ISize
+ * @description
+ * A System default signed number, typically used in RPC to report non-consensus
+ * data. It is a wrapper for [[I32]] as a WASM default (as generated by Rust bindings).
+ * It is not to be used, since it creates consensus mismatches.
+ */
+class isize extends I32_js_1.i32 {
+    constructor(registry, value) {
+        super(registry, value);
+        throw new Error('The `isize` type should not be used. Since it is platform-specific, it creates incompatibilities between native (generally i64) and WASM (always i32) code. Use one of the `i32` or `i64` types explicitly.');
+    }
+}
+exports.isize = isize;

package/cjs/primitive/U128.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u128 = void 0;
+const UInt_js_1 = require("../base/UInt.js");
+/**
+ * @name u128
+ * @description
+ * A 128-bit unsigned integer
+ */
+class u128 extends UInt_js_1.UInt.with(128) {
+    // NOTE without this, we cannot properly determine extensions
+    __UIntType = 'u128';
+}
+exports.u128 = u128;

package/cjs/primitive/U16.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u16 = void 0;
+const UInt_js_1 = require("../base/UInt.js");
+/**
+ * @name u16
+ * @description
+ * A 16-bit unsigned integer
+ */
+class u16 extends UInt_js_1.UInt.with(16) {
+    // NOTE without this, we cannot properly determine extensions
+    __UIntType = 'u16';
+}
+exports.u16 = u16;

package/cjs/primitive/U256.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u256 = void 0;
+const UInt_js_1 = require("../base/UInt.js");
+/**
+ * @name u256
+ * @description
+ * A 256-bit unsigned integer
+ */
+class u256 extends UInt_js_1.UInt.with(256) {
+    // NOTE without this, we cannot properly determine extensions
+    __UIntType = 'u256';
+}
+exports.u256 = u256;

package/cjs/primitive/U32.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u32 = void 0;
+const UInt_js_1 = require("../base/UInt.js");
+/**
+ * @name u32
+ * @description
+ * A 32-bit unsigned integer
+ */
+class u32 extends UInt_js_1.UInt.with(32) {
+    // NOTE without this, we cannot properly determine extensions
+    __UIntType = 'u32';
+}
+exports.u32 = u32;

package/cjs/primitive/U64.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u64 = void 0;
+const UInt_js_1 = require("../base/UInt.js");
+/**
+ * @name u64
+ * @description
+ * A 64-bit unsigned integer
+ */
+class u64 extends UInt_js_1.UInt.with(64) {
+    // NOTE without this, we cannot properly determine extensions
+    __UIntType = 'u64';
+}
+exports.u64 = u64;