@polkadot/types-codec 9.14.2 → 10.1.1

package/native/Struct.js

@@ -1,60 +1,67 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+var _Struct_jsonMap, _Struct_Types;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { isBoolean, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
-import { compareMap, decodeU8aStruct, mapToTypeMap, typesToMap } from "../utils/index.js";
+import { compareMap, decodeU8aStruct, mapToTypeMap, typesToMap } from '../utils/index.js';
 function noopSetDefinition(d) {
-  return d;
+    return d;
 }
-
 /** @internal */
 function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
-  let jsonObj;
-  const typeofArray = Array.isArray(value);
-  const typeofMap = value instanceof Map;
-  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 !== keys.length) {
-    throw new Error(`Struct: Unable to map ${stringify(value)} array to object with known keys ${keys.join(', ')}`);
-  }
-  const raw = new Array(keys.length);
-  for (let i = 0; i < keys.length; 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 && value[jsonKey];
-        if (isUndefined(assign)) {
-          if (isUndefined(jsonObj)) {
-            const entries = Object.entries(value);
-            jsonObj = {};
-            for (let e = 0; e < entries.length; e++) {
-              jsonObj[stringCamelCase(entries[e][0])] = entries[e][1];
+    let jsonObj;
+    const typeofArray = Array.isArray(value);
+    const typeofMap = value instanceof Map;
+    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 !== keys.length) {
+        throw new Error(`Struct: Unable to map ${stringify(value)} array to object with known keys ${keys.join(', ')}`);
+    }
+    const raw = new Array(keys.length);
+    for (let i = 0; i < keys.length; 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 && value[jsonKey];
+                if (isUndefined(assign)) {
+                    if (isUndefined(jsonObj)) {
+                        const entries = Object.entries(value);
+                        jsonObj = {};
+                        for (let e = 0; e < entries.length; e++) {
+                            jsonObj[stringCamelCase(entries[e][0])] = entries[e][1];
+                        }
+                    }
+                    assign = jsonKey && jsonObj[jsonKey];
+                }
+            }
+            raw[i] = [
+                key,
+                assign instanceof Type
+                    ? assign
+                    : new Type(registry, assign)
+            ];
+        }
+        catch (error) {
+            let type = Type.name;
+            try {
+                type = new Type(registry).toRawType();
+            }
+            catch (error) {
+                // ignore
             }
-          }
-          assign = jsonKey && jsonObj[jsonKey];
+            throw new Error(`Struct: failed on ${jsonKey}: ${type}:: ${error.message}`);
         }
-      }
-      raw[i] = [key, assign instanceof Type ? assign : new Type(registry, assign)];
-    } catch (error) {
-      let type = Type.name;
-      try {
-        type = new Type(registry).toRawType();
-      } catch (error) {
-        // ignore
-      }
-      throw new Error(`Struct: failed on ${jsonKey}: ${type}:: ${error.message}`);
     }
-  }
-  return [raw, 0];
+    return [raw, 0];
 }
-
 /**
  * @name Struct
  * @description
@@ -66,205 +73,191 @@ function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
  * @noInheritDoc
  */
 export class Struct extends Map {
-  #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) {
-    var _class;
-    let definition;
-
-    // eslint-disable-next-line no-return-assign
-    const setDefinition = d => definition = d;
-    return _class = class extends Struct {
-      constructor(registry, value) {
-        super(registry, Types, value, jsonMap, {
-          definition,
-          setDefinition
-        });
-      }
-    }, (() => {
-      const keys = Object.keys(Types);
-      objectProperties(_class.prototype, keys, (k, _, self) => self.get(k));
-    })(), _class;
-  }
-
-  /**
-   * @description The available keys for this struct
-   */
-  get defKeys() {
-    return this.#Types[1];
-  }
-
-  /**
-   * @description Checks if the value is an empty value
-   */
-  get isEmpty() {
-    for (const v of this.values()) {
-      if (!v.isEmpty) {
-        return false;
-      }
+    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);
+        _Struct_jsonMap.set(this, void 0);
+        _Struct_Types.set(this, void 0);
+        this.initialU8aLength = decodedLength;
+        this.registry = registry;
+        __classPrivateFieldSet(this, _Struct_jsonMap, jsonMap, "f");
+        __classPrivateFieldSet(this, _Struct_Types, typeMap, "f");
     }
-    return true;
-  }
-
-  /**
-   * @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;
+    static with(Types, jsonMap) {
+        var _a;
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => definition = d;
+        return _a = class extends Struct {
+                constructor(registry, value) {
+                    super(registry, Types, value, jsonMap, { definition, setDefinition });
+                }
+            },
+            (() => {
+                const keys = Object.keys(Types);
+                objectProperties(_a.prototype, keys, (k, _, self) => self.get(k));
+            })(),
+            _a;
     }
-    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; i < keys.length; i++) {
-      result[keys[i]] = new Types[i](this.registry).toRawType();
+    /**
+     * @description The available keys for this struct
+     */
+    get defKeys() {
+        return __classPrivateFieldGet(this, _Struct_Types, "f")[1];
+    }
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty() {
+        for (const v of this.values()) {
+            if (!v.isEmpty) {
+                return false;
+            }
+        }
+        return true;
     }
-    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 = new Array();
-    for (const [k, v] of this.entries()) {
-      inner.push({
-        ...v.inspect(!isBare || isBoolean(isBare) ? isBare : isBare[k]),
-        name: stringCamelCase(k)
-      });
+    /**
+     * @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] = __classPrivateFieldGet(this, _Struct_Types, "f");
+        for (let i = 0; i < keys.length; i++) {
+            result[keys[i]] = new Types[i](this.registry).toRawType();
+        }
+        return result;
     }
-    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) {
-    const json = {};
-    for (const [k, v] of this.entries()) {
-      json[k] = v.toHuman(isExtended);
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other) {
+        return compareMap(this, other);
     }
-    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();
+    /**
+     * @description Returns a specific names entry in the structure
+     * @param key The name of the entry to retrieve
+     */
+    get(key) {
+        return super.get(key);
     }
-    return json;
-  }
-
-  /**
-   * @description Converts the value in a best-fit primitive form
-   */
-  toPrimitive() {
-    const json = {};
-    for (const [k, v] of this.entries()) {
-      json[k] = v.toPrimitive();
+    /**
+     * @description Returns the values of a member at a specific index (Rather use get(name) for performance)
+     */
+    getAtIndex(index) {
+        return this.toArray()[index];
     }
-    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]));
+    /**
+     * @description Returns the a types value by name
+     */
+    getT(key) {
+        return super.get(key);
     }
-    return u8aConcatStrict(encoded);
-  }
-}
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(isBare) {
+        const inner = new Array();
+        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) {
+        const json = {};
+        for (const [k, v] of this.entries()) {
+            json[k] = v.toHuman(isExtended);
+        }
+        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[(__classPrivateFieldGet(this, _Struct_jsonMap, "f").get(k) || k)] = v.toJSON();
+        }
+        return json;
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive() {
+        const json = {};
+        for (const [k, v] of this.entries()) {
+            json[k] = v.toPrimitive();
+        }
+        return json;
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return stringify(typesToMap(this.registry, __classPrivateFieldGet(this, _Struct_Types, "f")));
+    }
+    /**
+     * @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);
+    }
+}
+_Struct_jsonMap = new WeakMap(), _Struct_Types = new WeakMap();

package/native/Text.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyString, AnyU8a, Inspect, IText, IU8a, Registry } from '../types';
+import type { AnyString, AnyU8a, Inspect, IText, IU8a, Registry } from '../types/index.js';
 /**
  * @name Text
  * @description