@polkadot/types-codec 9.5.2 → 9.6.1

package/cjs/utils/decodeU8a.js

@@ -6,9 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.decodeU8a = decodeU8a;
 exports.decodeU8aStruct = decodeU8aStruct;
 exports.decodeU8aVec = decodeU8aVec;
-
 var _util = require("@polkadot/util");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -18,15 +16,17 @@ function formatFailure(registry, result, _ref, u8a, i, count, Type, key) {
     message
   } = _ref;
   let type = '';
-
   try {
     type = `: ${new Type(registry).toRawType()}`;
-  } catch {// ignore
-  } // console.error(JSON.stringify(result, null, 2));
+  } catch {
+    // ignore
+  }
 
+  // console.error(JSON.stringify(result, null, 2));
 
   return `decodeU8a: failed at ${(0, _util.u8aToHex)(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ''} (index ${i}/${count})${type}:: ${message}`;
 }
+
 /**
  * @internal
  *
@@ -37,14 +37,11 @@ function formatFailure(registry, result, _ref, u8a, i, count, Type, key) {
  * @param result - The result array (will be returned with values pushed)
  * @param types - The array of CodecClass to decode the U8a against.
  */
-
-
 function decodeU8a(registry, result, u8a, _ref2) {
   let [Types, keys] = _ref2;
   const count = result.length;
   let offset = 0;
   let i = 0;
-
   try {
     while (i < count) {
       const value = new Types[i](registry, u8a.subarray(offset));
@@ -55,23 +52,20 @@ function decodeU8a(registry, result, u8a, _ref2) {
   } catch (error) {
     throw new Error(formatFailure(registry, result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
   }
-
   return [result, offset];
 }
+
 /**
  * @internal
  *
  * Split from decodeU8a since this is specialized to zip returns ... while we duplicate, this
  * is all on the hot-path, so it is not great, however there is (some) method behind the madness
  */
-
-
 function decodeU8aStruct(registry, result, u8a, _ref3) {
   let [Types, keys] = _ref3;
   const count = result.length;
   let offset = 0;
   let i = 0;
-
   try {
     while (i < count) {
       const value = new Types[i](registry, u8a.subarray(offset));
@@ -82,22 +76,19 @@ function decodeU8aStruct(registry, result, u8a, _ref3) {
   } catch (error) {
     throw new Error(formatFailure(registry, result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
   }
-
   return [result, offset];
 }
+
 /**
  * @internal
  *
  * Split from decodeU8a since this is specialized to 1 instance ... while we duplicate, this
  * is all on the hot-path, so it is not great, however there is (some) method behind the madness
  */
-
-
 function decodeU8aVec(registry, result, u8a, startAt, Type) {
   const count = result.length;
   let offset = startAt;
   let i = 0;
-
   try {
     while (i < count) {
       const value = new Type(registry, u8a.subarray(offset));
@@ -108,6 +99,5 @@ function decodeU8aVec(registry, result, u8a, startAt, Type) {
   } catch (error) {
     throw new Error(formatFailure(registry, result, error, u8a.subarray(offset), i, count, Type));
   }
-
   return [offset, offset - startAt];
 }

package/cjs/utils/index.js

@@ -81,21 +81,12 @@ Object.defineProperty(exports, "typesToMap", {
     return _typesToMap.typesToMap;
   }
 });
-
 var _compareArray = require("./compareArray");
-
 var _compareMap = require("./compareMap");
-
 var _compareSet = require("./compareSet");
-
 var _decodeU8a = require("./decodeU8a");
-
 var _mapToTypeMap = require("./mapToTypeMap");
-
 var _typeToConstructor = require("./typeToConstructor");
-
 var _sanitize = require("./sanitize");
-
 var _sortValues = require("./sortValues");
-
 var _typesToMap = require("./typesToMap");

package/cjs/utils/mapToTypeMap.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.mapToTypeMap = mapToTypeMap;
-
 var _typeToConstructor = require("./typeToConstructor");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -17,11 +15,9 @@ 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.typeToConstructor)(registry, entries[i][1]);
   }
-
   return output;
 }

package/cjs/utils/sanitize.js

@@ -17,152 +17,148 @@ exports.sanitize = sanitize;
 exports.trim = trim;
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 const BOUNDED = ['BTreeMap', 'BTreeSet', 'HashMap', 'Vec'];
 const ALLOWED_BOXES = BOUNDED.concat(['Compact', 'DoNotConstruct', 'Int', 'Linkage', 'Range', 'RangeInclusive', 'Result', 'Opaque', 'Option', 'UInt', 'WrapperKeepOpaque', 'WrapperOpaque']);
 const BOX_PRECEDING = ['<', '(', '[', '"', ',', ' ']; // start of vec, tuple, fixed array, part of struct def or in tuple
 
-const mappings = [// alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
-alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false), alias('VecDeque<', 'Vec<', false), // <T::Balance as HasCompact>
-cleanupCompact(), // Change BoundedVec<Type, Size> to Vec<Type>
-removeExtensions('Bounded', true), // Change WeakVec<Type> to Vec<Type>
-removeExtensions('Weak', false), // Remove all the trait prefixes
-removeTraits(), // remove PairOf<T> -> (T, T)
-removePairOf(), // remove boxing, `Box<Proposal>` -> `Proposal`
-removeWrap('Box<'), // remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
-removeGenerics(), // alias String -> Text (compat with jsonrpc methods)
-alias('String', 'Text'), // alias Vec<u8> -> Bytes
-alias('Vec<u8>', 'Bytes'), alias('&\\[u8\\]', 'Bytes'), alias("&'static\\[u8\\]", 'Bytes'), // alias RawAddress -> Address
-alias('RawAddress', 'Address'), // lookups, mapped to Address/AccountId as appropriate in runtime
-alias('Lookup::Source', 'LookupSource'), alias('Lookup::Target', 'LookupTarget'), // HACK duplication between contracts & primitives, however contracts prefixed with exec
-alias('exec::StorageKey', 'ContractStorageKey'), // flattens tuples with one value, `(AccountId)` -> `AccountId`
-flattenSingleTuple(), // converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
-removeColons(), // remove all trailing spaces - this should always be the last
-trim()]; // given a string, trim it
-
+const mappings = [
+// alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
+alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false), alias('VecDeque<', 'Vec<', false),
+// <T::Balance as HasCompact>
+cleanupCompact(),
+// Change BoundedVec<Type, Size> to Vec<Type>
+removeExtensions('Bounded', true),
+// Change WeakVec<Type> to Vec<Type>
+removeExtensions('Weak', false),
+// Remove all the trait prefixes
+removeTraits(),
+// remove PairOf<T> -> (T, T)
+removePairOf(),
+// remove boxing, `Box<Proposal>` -> `Proposal`
+removeWrap('Box<'),
+// remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
+removeGenerics(),
+// alias String -> Text (compat with jsonrpc methods)
+alias('String', 'Text'),
+// alias Vec<u8> -> Bytes
+alias('Vec<u8>', 'Bytes'), alias('&\\[u8\\]', 'Bytes'), alias("&'static\\[u8\\]", 'Bytes'),
+// alias RawAddress -> Address
+alias('RawAddress', 'Address'),
+// lookups, mapped to Address/AccountId as appropriate in runtime
+alias('Lookup::Source', 'LookupSource'), alias('Lookup::Target', 'LookupTarget'),
+// HACK duplication between contracts & primitives, however contracts prefixed with exec
+alias('exec::StorageKey', 'ContractStorageKey'),
+// flattens tuples with one value, `(AccountId)` -> `AccountId`
+flattenSingleTuple(),
+// converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
+removeColons(),
+// remove all trailing spaces - this should always be the last
+trim()];
+
+// given a string, trim it
 function trim() {
   return value => value.trim();
-} // given a starting index, find the closing >
-
+}
 
+// given a starting index, find the closing >
 function findClosing(value, start) {
   let depth = 0;
-
   for (let index = start; index < value.length; index++) {
     if (value[index] === '>') {
       if (!depth) {
         return index;
       }
-
       depth--;
     } else if (value[index] === '<') {
       depth++;
     }
   }
-
   throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
 }
-
 function alias(src, dest) {
   let withChecks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
   const from = new RegExp(`(^${src}|${BOX_PRECEDING.map(box => `\\${box}${src}`).join('|')})`, 'g');
-
   const to = src => {
     from.lastIndex = 0;
     return withChecks && BOX_PRECEDING.includes(src[0]) ? `${src[0]}${dest}` : dest;
   };
-
   return value => value.replace(from, to);
 }
-
 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;
-
           if (value.substring(end, end + 14) === ' as HasCompact') {
             value = `Compact<${value.substring(index + 1, end)}>`;
           }
         }
       }
     }
-
     return value;
   };
 }
-
 function flattenSingleTuple() {
   const from1 = /,\)/g;
   const from2 = /\(([^,]+)\)/;
   return value => {
     from1.lastIndex = 0;
-    return value // tuples may have trailing commas, e.g. (u32, BlockNumber, )
-    .replace(from1, ')') // change (u32) -> u32
+    return value
+    // tuples may have trailing commas, e.g. (u32, BlockNumber, )
+    .replace(from1, ')')
+    // change (u32) -> u32
     .replace(from2, '$1');
   };
 }
-
 function replaceTagWith(value, matcher, replacer) {
   let index = -1;
-
   while (true) {
     index = value.indexOf(matcher, index + 1);
-
     if (index === -1) {
       return value;
     }
-
     const start = index + matcher.length;
     const end = findClosing(value, start);
     value = `${value.substring(0, index)}${replacer(value.substring(start, end))}${value.substring(end + 1)}`;
   }
-} // remove the Bounded* or Weak* wrappers
-
+}
 
+// remove the Bounded* or Weak* wrappers
 function removeExtensions(type, isSized) {
   return value => {
     for (let i = 0; i < BOUNDED.length; i++) {
       const tag = BOUNDED[i];
       value = replaceTagWith(value, `${type}${tag}<`, v => {
         const parts = v.split(',').map(s => s.trim()).filter(s => s);
-
         if (isSized) {
           parts.pop();
         }
-
         return `${tag}<${parts.join(',')}>`;
       });
     }
-
     return value;
   };
 }
-
 function removeColons() {
   return value => {
     let index = 0;
-
     while (index !== -1) {
       index = value.indexOf('::');
-
       if (index === 0) {
         value = value.substring(2);
       } else if (index !== -1) {
         let start = index;
-
         while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
           start--;
         }
-
         value = `${value.substring(0, start + 1)}${value.substring(index + 2)}`;
       }
     }
-
     return value;
   };
 }
-
 function removeGenerics() {
   return value => {
     for (let index = 0; index < value.length; index++) {
@@ -170,29 +166,29 @@ function removeGenerics() {
         // check against the allowed wrappers, be it Vec<..>, Option<...> ...
         const box = ALLOWED_BOXES.find(box => {
           const start = index - box.length;
-          return start >= 0 && value.substring(start, index) === box && ( // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
+          return start >= 0 && value.substring(start, index) === 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
+        });
 
+        // 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)}`;
         }
       }
     }
-
     return value;
   };
-} // remove the PairOf wrappers
-
+}
 
+// remove the PairOf wrappers
 function removePairOf() {
   const replacer = v => `(${v},${v})`;
-
   return value => replaceTagWith(value, 'PairOf<', replacer);
-} // remove the type traits
-
+}
 
+// remove the type traits
 function removeTraits() {
   const from1 = /\s/g;
   const from2 = /(T|Self)::/g;
@@ -207,39 +203,38 @@ function removeTraits() {
     from4.lastIndex = 0;
     from5.lastIndex = 0;
     from6.lastIndex = 0;
-    return value // remove all whitespaces
-    .replace(from1, '') // anything `T::<type>` to end up as `<type>`
-    .replace(from2, '') // replace `<T as Trait>::` (whitespaces were removed above)
-    .replace(from3, '') // replace `<T as something::Trait>::` (whitespaces were removed above)
-    .replace(from4, '') // replace <Lookup as StaticLookup>
-    .replace(from5, 'Lookup') // replace `<...>::Type`
+    return value
+    // remove all whitespaces
+    .replace(from1, '')
+    // anything `T::<type>` to end up as `<type>`
+    .replace(from2, '')
+    // replace `<T as Trait>::` (whitespaces were removed above)
+    .replace(from3, '')
+    // replace `<T as something::Trait>::` (whitespaces were removed above)
+    .replace(from4, '')
+    // replace <Lookup as StaticLookup>
+    .replace(from5, 'Lookup')
+    // replace `<...>::Type`
     .replace(from6, '');
   };
-} // remove wrapping values, i.e. Box<Proposal> -> Proposal
-
+}
 
+// remove wrapping values, i.e. Box<Proposal> -> Proposal
 function removeWrap(check) {
   const replacer = v => v;
-
   return value => replaceTagWith(value, check, replacer);
 }
-
 const sanitizeMap = new Map();
-
 function sanitize(value) {
   const startValue = value.toString();
   const memoized = sanitizeMap.get(startValue);
-
   if (memoized) {
     return memoized;
   }
-
   let result = startValue;
-
   for (let i = 0; i < mappings.length; i++) {
     result = mappings[i](result);
   }
-
   sanitizeMap.set(startValue, result);
   return result;
 }

package/cjs/utils/sortValues.js

@@ -6,9 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.sortAsc = sortAsc;
 exports.sortMap = sortMap;
 exports.sortSet = sortSet;
-
 var _util = require("@polkadot/util");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -16,49 +14,41 @@ var _util = require("@polkadot/util");
 function isArrayLike(arg) {
   return arg instanceof Uint8Array || Array.isArray(arg);
 }
-/** @internal **/
-
 
+/** @internal **/
 function isCodec(arg) {
   return (0, _util.isFunction)(arg && arg.toU8a);
 }
-/** @internal **/
-
 
+/** @internal **/
 function isEnum(arg) {
   return isCodec(arg) && (0, _util.isNumber)(arg.index) && isCodec(arg.value);
 }
-/** @internal */
-
 
+/** @internal */
 function isNumberLike(arg) {
   return (0, _util.isNumber)(arg) || (0, _util.isBn)(arg) || (0, _util.isBigInt)(arg);
 }
-/** @internal */
-
 
+/** @internal */
 function sortArray(a, b) {
   // Vec, Tuple, Bytes etc.
   let sortRes = 0;
   const minLen = Math.min(a.length, b.length);
-
   for (let i = 0; i < minLen; ++i) {
     sortRes = sortAsc(a[i], b[i]);
-
     if (sortRes !== 0) {
       return sortRes;
     }
   }
-
   return a.length - b.length;
 }
+
 /**
 * Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap
 * (https://doc.rust-lang.org/stable/std/collections/struct.BTreeSet.html)
 * (https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html)
 */
-
-
 function sortAsc(a, b) {
   if (isNumberLike(a) && isNumberLike(b)) {
     return (0, _util.bnToBn)(a).cmp((0, _util.bnToBn)(b));
@@ -72,14 +62,11 @@ function sortAsc(a, b) {
     // Text, Bool etc.
     return sortAsc(a.toU8a(true), b.toU8a(true));
   }
-
   throw new Error(`Attempting to sort unrecognized values: ${(0, _util.stringify)(a)} (typeof ${typeof a}) <-> ${(0, _util.stringify)(b)} (typeof ${typeof b})`);
 }
-
 function sortSet(set) {
   return new Set(Array.from(set).sort(sortAsc));
 }
-
 function sortMap(map) {
   return new Map(Array.from(map.entries()).sort((_ref, _ref2) => {
     let [keyA] = _ref;

package/cjs/utils/typeToConstructor.js

@@ -4,11 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.typeToConstructor = typeToConstructor;
-
 var _util = require("@polkadot/util");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 function typeToConstructor(registry, type) {
   return (0, _util.isString)(type) ? registry.createClassUnsafe(type) : type;
 }

package/cjs/utils/typesToMap.js

@@ -4,16 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.typesToMap = typesToMap;
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 function typesToMap(registry, _ref) {
   let [Types, keys] = _ref;
   const result = {};
-
   for (let i = 0; i < keys.length; i++) {
     result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
   }
-
   return result;
 }

package/cjs/utils/util.js

@@ -4,11 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.hasEq = hasEq;
-
 var _util = require("@polkadot/util");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 function hasEq(o) {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
   return (0, _util.isFunction)(o.eq);

package/detectOther.js

@@ -1,4 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 // Empty template, auto-generated by @polkadot/dev
+
 export default [];

package/detectPackage.js

@@ -1,6 +1,8 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 // Do not edit, auto-generated by @polkadot/dev
+
 import { detectPackage } from '@polkadot/util';
 import others from "./detectOther.js";
 import { packageInfo } from "./packageInfo.js";

package/extended/BTreeMap.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { CodecMap } from "./Map.js";
 export class BTreeMap extends CodecMap {
   static with(keyType, valType) {
@@ -7,8 +8,6 @@ export class BTreeMap extends CodecMap {
       constructor(registry, value) {
         super(registry, keyType, valType, value, 'BTreeMap');
       }
-
     };
   }
-
 }