@polkadot/types-codec 10.4.1 → 10.6.1

package/native/Struct.js

@@ -1,5 +1,3 @@
-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';
 function noopSetDefinition(d) {
@@ -10,14 +8,15 @@ 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 !== keys.length) {
+    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(keys.length);
-    for (let i = 0; i < keys.length; i++) {
+    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];
@@ -35,7 +34,7 @@ function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
                     if (isUndefined(jsonObj)) {
                         const entries = Object.entries(value);
                         jsonObj = {};
-                        for (let e = 0; e < entries.length; e++) {
+                        for (let e = 0, ecount = entries.length; e < ecount; e++) {
                             jsonObj[stringCamelCase(entries[e][0])] = entries[e][1];
                         }
                     }
@@ -81,12 +80,10 @@ export class Struct extends Map {
                 ? [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");
+        this.__internal__jsonMap = jsonMap;
+        this.__internal__Types = typeMap;
     }
     static with(Types, jsonMap) {
         var _a;
@@ -108,7 +105,7 @@ export class Struct extends Map {
      * @description The available keys for this struct
      */
     get defKeys() {
-        return __classPrivateFieldGet(this, _Struct_Types, "f")[1];
+        return this.__internal__Types[1];
     }
     /**
      * @description Checks if the value is an empty value
@@ -142,8 +139,8 @@ export class Struct extends Map {
      */
     get Type() {
         const result = {};
-        const [Types, keys] = __classPrivateFieldGet(this, _Struct_Types, "f");
-        for (let i = 0; i < keys.length; i++) {
+        const [Types, keys] = this.__internal__Types;
+        for (let i = 0, count = keys.length; i < count; i++) {
             result[keys[i]] = new Types[i](this.registry).toRawType();
         }
         return result;
@@ -220,7 +217,7 @@ export class Struct extends Map {
         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();
+            json[(this.__internal__jsonMap.get(k) || k)] = v.toJSON();
         }
         return json;
     }
@@ -238,7 +235,7 @@ export class Struct extends Map {
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        return stringify(typesToMap(this.registry, __classPrivateFieldGet(this, _Struct_Types, "f")));
+        return stringify(typesToMap(this.registry, this.__internal__Types));
     }
     /**
      * @description Returns the string representation of the value
@@ -260,4 +257,3 @@ export class Struct extends Map {
         return u8aConcatStrict(encoded);
     }
 }
-_Struct_jsonMap = new WeakMap(), _Struct_Types = new WeakMap();

package/native/Text.js

@@ -1,5 +1,3 @@
-var _Text_override;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { compactAddLength, compactFromU8aLim, compactToU8a, hexToU8a, isHex, isString, isU8a, stringToU8a, u8aToHex, u8aToString } from '@polkadot/util';
 import { Raw } from './Raw.js';
 const MAX_LENGTH = 128 * 1024;
@@ -41,7 +39,7 @@ export class Text extends String {
     constructor(registry, value) {
         const [str, decodedLength] = decodeText(value);
         super(str);
-        _Text_override.set(this, null);
+        this.__internal__override = null;
         this.registry = registry;
         this.initialU8aLength = decodedLength;
     }
@@ -93,7 +91,7 @@ export class Text extends String {
      * @description Set an override value for this
      */
     setOverride(override) {
-        __classPrivateFieldSet(this, _Text_override, override, "f");
+        this.__internal__override = override;
     }
     /**
      * @description Returns a hex string representation of the value
@@ -131,7 +129,7 @@ export class Text extends String {
      * @description Returns the string representation of the value
      */
     toString() {
-        return __classPrivateFieldGet(this, _Text_override, "f") || super.toString();
+        return this.__internal__override || super.toString();
     }
     /**
      * @description Encodes the value as a Uint8Array as per the SCALE specifications
@@ -146,4 +144,3 @@ export class Text extends String {
             : compactAddLength(encoded);
     }
 }
-_Text_override = new WeakMap();

package/native/index.d.ts

@@ -1,4 +1,4 @@
-export { bool, bool as Bool } from './Bool.js';
+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';

package/native/index.js

@@ -1,4 +1,4 @@
-export { bool, bool as Bool } from './Bool.js';
+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';

package/package.json

@@ -18,7 +18,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "10.4.1",
+  "version": "10.6.1",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -408,11 +408,6 @@
       "require": "./cjs/utils/decodeU8a.js",
       "default": "./utils/decodeU8a.js"
     },
-    "./utils/mapToTypeMap": {
-      "types": "./utils/mapToTypeMap.d.ts",
-      "require": "./cjs/utils/mapToTypeMap.js",
-      "default": "./utils/mapToTypeMap.js"
-    },
     "./utils/sanitize": {
       "types": "./utils/sanitize.d.ts",
       "require": "./cjs/utils/sanitize.js",
@@ -423,16 +418,16 @@
       "require": "./cjs/utils/sortValues.js",
       "default": "./utils/sortValues.js"
     },
+    "./utils/toConstructors": {
+      "types": "./utils/toConstructors.d.ts",
+      "require": "./cjs/utils/toConstructors.js",
+      "default": "./utils/toConstructors.js"
+    },
     "./utils/typesToMap": {
       "types": "./utils/typesToMap.d.ts",
       "require": "./cjs/utils/typesToMap.js",
       "default": "./utils/typesToMap.js"
     },
-    "./utils/typeToConstructor": {
-      "types": "./utils/typeToConstructor.d.ts",
-      "require": "./cjs/utils/typeToConstructor.js",
-      "default": "./utils/typeToConstructor.js"
-    },
     "./utils/util": {
       "types": "./utils/util.d.ts",
       "require": "./cjs/utils/util.js",
@@ -440,8 +435,8 @@
     }
   },
   "dependencies": {
-    "@polkadot/util": "^12.0.1",
-    "@polkadot/x-bigint": "^12.0.1",
+    "@polkadot/util": "^12.1.2",
+    "@polkadot/x-bigint": "^12.1.2",
     "tslib": "^2.5.0"
   }
 }

package/packageInfo.js

@@ -1 +1 @@
-export const packageInfo = { name: '@polkadot/types-codec', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '10.4.1' };
+export const packageInfo = { name: '@polkadot/types-codec', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '10.6.1' };

package/primitive/index.d.ts

@@ -1,16 +1,16 @@
-export { f32, f32 as F32 } from './F32.js';
-export { f64, f64 as F64 } from './F64.js';
-export { i8, i8 as I8 } from './I8.js';
-export { i16, i16 as I16 } from './I16.js';
-export { i32, i32 as I32 } from './I32.js';
-export { i64, i64 as I64 } from './I64.js';
-export { i128, i128 as I128 } from './I128.js';
-export { i256, i256 as I256 } from './I256.js';
-export { isize, isize as ISize } from './ISize.js';
-export { u8, u8 as U8 } from './U8.js';
-export { u16, u16 as U16 } from './U16.js';
-export { u32, u32 as U32 } from './U32.js';
-export { u64, u64 as U64 } from './U64.js';
-export { u128, u128 as U128 } from './U128.js';
-export { u256, u256 as U256 } from './U256.js';
-export { usize, usize as USize } from './USize.js';
+export { f32 as F32, f32 } from './F32.js';
+export { f64 as F64, f64 } from './F64.js';
+export { i8 as I8, i8 } from './I8.js';
+export { i16 as I16, i16 } from './I16.js';
+export { i32 as I32, i32 } from './I32.js';
+export { i64 as I64, i64 } from './I64.js';
+export { i128 as I128, i128 } from './I128.js';
+export { i256 as I256, i256 } from './I256.js';
+export { isize as ISize, isize } from './ISize.js';
+export { u8 as U8, u8 } from './U8.js';
+export { u16 as U16, u16 } from './U16.js';
+export { u32 as U32, u32 } from './U32.js';
+export { u64 as U64, u64 } from './U64.js';
+export { u128 as U128, u128 } from './U128.js';
+export { u256 as U256, u256 } from './U256.js';
+export { usize as USize, usize } from './USize.js';

package/primitive/index.js

@@ -1,16 +1,16 @@
-export { f32, f32 as F32 } from './F32.js';
-export { f64, f64 as F64 } from './F64.js';
-export { i8, i8 as I8 } from './I8.js';
-export { i16, i16 as I16 } from './I16.js';
-export { i32, i32 as I32 } from './I32.js';
-export { i64, i64 as I64 } from './I64.js';
-export { i128, i128 as I128 } from './I128.js';
-export { i256, i256 as I256 } from './I256.js';
-export { isize, isize as ISize } from './ISize.js';
-export { u8, u8 as U8 } from './U8.js';
-export { u16, u16 as U16 } from './U16.js';
-export { u32, u32 as U32 } from './U32.js';
-export { u64, u64 as U64 } from './U64.js';
-export { u128, u128 as U128 } from './U128.js';
-export { u256, u256 as U256 } from './U256.js';
-export { usize, usize as USize } from './USize.js';
+export { f32 as F32, f32 } from './F32.js';
+export { f64 as F64, f64 } from './F64.js';
+export { i8 as I8, i8 } from './I8.js';
+export { i16 as I16, i16 } from './I16.js';
+export { i32 as I32, i32 } from './I32.js';
+export { i64 as I64, i64 } from './I64.js';
+export { i128 as I128, i128 } from './I128.js';
+export { i256 as I256, i256 } from './I256.js';
+export { isize as ISize, isize } from './ISize.js';
+export { u8 as U8, u8 } from './U8.js';
+export { u16 as U16, u16 } from './U16.js';
+export { u32 as U32, u32 } from './U32.js';
+export { u64 as U64, u64 } from './U64.js';
+export { u128 as U128, u128 } from './U128.js';
+export { u256 as U256, u256 } from './U256.js';
+export { usize as USize, usize } from './USize.js';

package/types/registry.d.ts

@@ -49,6 +49,7 @@ export interface Registry {
     createLookupType(lookupId: ICompact<INumber> | number): LookupString;
     createClassUnsafe<T extends Codec = Codec, K extends string = string>(type: K): CodecClass<T>;
     createTypeUnsafe<T extends Codec = Codec, K extends string = string>(type: K, params: unknown[], options?: CodecCreateOptions): T;
+    get(...params: never[]): any;
     getClassName(clazz: CodecClass): string | undefined;
     getOrThrow<T extends Codec = Codec, K extends string = string>(name: K, msg?: string): CodecClass<T>;
     getOrUnknown<T extends Codec = Codec, K extends string = string>(name: K): CodecClass<T>;

package/utils/index.d.ts

@@ -2,8 +2,7 @@ export { compareArray } from './compareArray.js';
 export { compareMap } from './compareMap.js';
 export { compareSet } from './compareSet.js';
 export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a.js';
-export { mapToTypeMap } from './mapToTypeMap.js';
-export { typeToConstructor } from './typeToConstructor.js';
 export { sanitize } from './sanitize.js';
-export { sortAsc, sortSet, sortMap } from './sortValues.js';
+export { sortAsc, sortMap, sortSet } from './sortValues.js';
+export { mapToTypeMap, typesToConstructors, typeToConstructor } from './toConstructors.js';
 export { typesToMap } from './typesToMap.js';

package/utils/index.js

@@ -2,8 +2,7 @@ export { compareArray } from './compareArray.js';
 export { compareMap } from './compareMap.js';
 export { compareSet } from './compareSet.js';
 export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a.js';
-export { mapToTypeMap } from './mapToTypeMap.js';
-export { typeToConstructor } from './typeToConstructor.js';
 export { sanitize } from './sanitize.js';
-export { sortAsc, sortSet, sortMap } from './sortValues.js';
+export { sortAsc, sortMap, sortSet } from './sortValues.js';
+export { mapToTypeMap, typesToConstructors, typeToConstructor } from './toConstructors.js';
 export { typesToMap } from './typesToMap.js';

package/utils/sanitize.js

@@ -44,14 +44,14 @@ export function trim() {
 }
 export function findClosing(value, start) {
     let depth = 0;
-    for (let index = start; index < value.length; index++) {
-        if (value[index] === '>') {
+    for (let i = start, count = value.length; i < count; i++) {
+        if (value[i] === '>') {
             if (!depth) {
-                return index;
+                return i;
             }
             depth--;
         }
-        else if (value[index] === '<') {
+        else if (value[i] === '<') {
             depth++;
         }
     }
@@ -70,11 +70,11 @@ export function alias(src, dest, withChecks = true) {
 export function cleanupCompact() {
     return (value) => {
         if (value.includes(' as HasCompact')) {
-            for (let index = 0; index < value.length; index++) {
-                if (value[index] === '<') {
-                    const end = findClosing(value, index + 1) - 14;
+            for (let i = 0, count = value.length; i < count; i++) {
+                if (value[i] === '<') {
+                    const end = findClosing(value, i + 1) - 14;
                     if (value.substring(end, end + 14) === ' as HasCompact') {
-                        value = `Compact<${value.substring(index + 1, end)}>`;
+                        value = `Compact<${value.substring(i + 1, end)}>`;
                     }
                 }
             }
@@ -108,7 +108,7 @@ function replaceTagWith(value, matcher, replacer) {
 }
 export function removeExtensions(type, isSized) {
     return (value) => {
-        for (let i = 0; i < BOUNDED.length; i++) {
+        for (let i = 0, count = BOUNDED.length; i < count; i++) {
             const tag = BOUNDED[i];
             value = replaceTagWith(value, `${type}${tag}<`, (v) => {
                 const parts = v
@@ -145,21 +145,21 @@ export function removeColons() {
 }
 export function removeGenerics() {
     return (value) => {
-        for (let index = 0; index < value.length; index++) {
-            if (value[index] === '<') {
+        for (let i = 0, count = value.length; i < count; i++) {
+            if (value[i] === '<') {
                 // check against the allowed wrappers, be it Vec<..>, Option<...> ...
                 const box = ALLOWED_BOXES.find((box) => {
-                    const start = index - box.length;
+                    const start = i - box.length;
                     return ((start >= 0 &&
-                        value.substring(start, index) === box) && (
+                        value.substring(start, i) === box) && (
                     // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
                     start === 0 ||
                         BOX_PRECEDING.includes(value[start - 1])));
                 });
                 // we have not found anything, unwrap generic innards
                 if (!box) {
-                    const end = findClosing(value, index + 1);
-                    value = `${value.substring(0, index)}${value.substring(end + 1)}`;
+                    const end = findClosing(value, i + 1);
+                    value = `${value.substring(0, i)}${value.substring(end + 1)}`;
                 }
             }
         }
@@ -211,7 +211,7 @@ export function sanitize(value) {
         return memoized;
     }
     let result = startValue;
-    for (let i = 0; i < mappings.length; i++) {
+    for (let i = 0, count = mappings.length; i < count; i++) {
         result = mappings[i](result);
     }
     sanitizeMap.set(startValue, result);

package/utils/sortValues.js

@@ -1,13 +1,9 @@
-import { bnToBn, isBigInt, isBn, isFunction, isNumber, stringify } from '@polkadot/util';
+import { bnToBn, isBigInt, isBn, isCodec, isNumber, stringify } from '@polkadot/util';
 /** @internal **/
 function isArrayLike(arg) {
     return arg instanceof Uint8Array || Array.isArray(arg);
 }
 /** @internal **/
-function isCodec(arg) {
-    return isFunction(arg && arg.toU8a);
-}
-/** @internal **/
 function isEnum(arg) {
     return isCodec(arg) && isNumber(arg.index) && isCodec(arg.value);
 }

package/utils/toConstructors.d.ts

@@ -0,0 +1,16 @@
+import type { Codec, CodecClass, Registry } from '../types/index.js';
+/**
+ * @internal
+ * From a type string or class, return the associated type class
+ */
+export declare function typeToConstructor<T extends Codec = Codec>(registry: Registry, type: string | CodecClass<T>): CodecClass<T>;
+/**
+ * @internal
+ * Takes an input array of types and returns the associated classes for it
+*/
+export declare function typesToConstructors<T extends Codec = Codec>(registry: Registry, types: (string | CodecClass<T>)[]): CodecClass<T>[];
+/**
+ * @internal
+ * Takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
+ */
+export declare function mapToTypeMap(registry: Registry, input: Record<string, string | CodecClass>): [CodecClass[], string[]];

package/utils/toConstructors.js

@@ -0,0 +1,35 @@
+/**
+ * @internal
+ * From a type string or class, return the associated type class
+ */
+export function typeToConstructor(registry, type) {
+    return typeof type === 'function'
+        ? type
+        : registry.createClassUnsafe(type);
+}
+/**
+ * @internal
+ * Takes an input array of types and returns the associated classes for it
+*/
+export function typesToConstructors(registry, types) {
+    const count = types.length;
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+        result[i] = typeToConstructor(registry, types[i]);
+    }
+    return result;
+}
+/**
+ * @internal
+ * Takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
+ */
+export function mapToTypeMap(registry, input) {
+    const entries = Object.entries(input);
+    const count = entries.length;
+    const output = [new Array(count), new Array(count)];
+    for (let i = 0; i < count; i++) {
+        output[1][i] = entries[i][0];
+        output[0][i] = typeToConstructor(registry, entries[i][1]);
+    }
+    return output;
+}

package/utils/typesToMap.js

@@ -1,6 +1,6 @@
 export function typesToMap(registry, [Types, keys]) {
     const result = {};
-    for (let i = 0; i < keys.length; i++) {
+    for (let i = 0, count = keys.length; i < count; i++) {
         result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
     }
     return result;

package/cjs/utils/mapToTypeMap.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapToTypeMap = void 0;
-const typeToConstructor_js_1 = require("./typeToConstructor.js");
-/**
- * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
- */
-function mapToTypeMap(registry, input) {
-    const entries = Object.entries(input);
-    const count = entries.length;
-    const output = [new Array(count), new Array(count)];
-    for (let i = 0; i < count; i++) {
-        output[1][i] = entries[i][0];
-        output[0][i] = (0, typeToConstructor_js_1.typeToConstructor)(registry, entries[i][1]);
-    }
-    return output;
-}
-exports.mapToTypeMap = mapToTypeMap;

package/cjs/utils/typeToConstructor.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeToConstructor = void 0;
-const util_1 = require("@polkadot/util");
-function typeToConstructor(registry, type) {
-    return ((0, util_1.isString)(type)
-        ? registry.createClassUnsafe(type)
-        : type);
-}
-exports.typeToConstructor = typeToConstructor;

package/utils/mapToTypeMap.d.ts

@@ -1,5 +0,0 @@
-import type { CodecClass, Registry } from '../types/index.js';
-/**
- * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
- */
-export declare function mapToTypeMap(registry: Registry, input: Record<string, string | CodecClass>): [CodecClass[], string[]];

package/utils/mapToTypeMap.js

@@ -1,14 +0,0 @@
-import { typeToConstructor } from './typeToConstructor.js';
-/**
- * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
- */
-export function mapToTypeMap(registry, input) {
-    const entries = Object.entries(input);
-    const count = entries.length;
-    const output = [new Array(count), new Array(count)];
-    for (let i = 0; i < count; i++) {
-        output[1][i] = entries[i][0];
-        output[0][i] = typeToConstructor(registry, entries[i][1]);
-    }
-    return output;
-}

package/utils/typeToConstructor.d.ts

@@ -1,2 +0,0 @@
-import type { Codec, CodecClass, Registry } from '../types/index.js';
-export declare function typeToConstructor<T extends Codec = Codec>(registry: Registry, type: string | CodecClass<T>): CodecClass<T>;

package/utils/typeToConstructor.js

@@ -1,6 +0,0 @@
-import { isString } from '@polkadot/util';
-export function typeToConstructor(registry, type) {
-    return (isString(type)
-        ? registry.createClassUnsafe(type)
-        : type);
-}