@polkadot/types-codec 9.5.2 → 9.6.2

package/native/Text.js

@@ -1,38 +1,36 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { compactAddLength, compactFromU8aLim, compactToU8a, hexToU8a, isHex, isString, isU8a, stringToU8a, u8aToHex, u8aToString } from '@polkadot/util';
 import { Raw } from "./Raw.js";
 const MAX_LENGTH = 128 * 1024;
-/** @internal */
 
+/** @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)
-
+    }
 
+    // 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
@@ -41,138 +39,120 @@ function decodeText(value) {
  * object, inheriting all methods exposed from `String`.
  * @noInheritDoc
  */
-
-
 export class Text extends String {
   #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/native/index.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 export { bool, bool as Bool } from "./Bool.js";
 export { CodecDate, CodecDate as Date } from "./Date.js";
 export { Float } from "./Float.js";

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "9.5.2",
+  "version": "9.6.2",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -434,7 +434,7 @@
     }
   },
   "dependencies": {
-    "@babel/runtime": "^7.19.4",
+    "@babel/runtime": "^7.20.0",
     "@polkadot/util": "^10.1.11",
     "@polkadot/x-bigint": "^10.1.11"
   }

package/packageInfo.js

@@ -1,9 +1,11 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 // Do not edit, auto-generated by @polkadot/dev
+
 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: '9.5.2'
+  version: '9.6.2'
 };

package/primitive/F32.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Float } from "../native/Float.js";
+
 /**
  * @name f32
  * @description
  * A 32-bit float
  */
-
 export class f32 extends Float.with(32) {
   // NOTE without this, we cannot properly determine extensions
   __FloatType = 'f32';

package/primitive/F64.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Float } from "../native/Float.js";
+
 /**
  * @name f64
  * @description
  * A 64-bit float
  */
-
 export class f64 extends Float.with(64) {
   // NOTE without this, we cannot properly determine extensions
   __FloatType = 'f64';

package/primitive/I128.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Int } from "../base/Int.js";
+
 /**
  * @name i128
  * @description
  * A 128-bit signed integer
  */
-
 export class i128 extends Int.with(128) {
   // NOTE without this, we cannot properly determine extensions
   __IntType = 'i128';

package/primitive/I16.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Int } from "../base/Int.js";
+
 /**
  * @name i16
  * @description
  * A 16-bit signed integer
  */
-
 export class i16 extends Int.with(16) {
   // NOTE without this, we cannot properly determine extensions
   __IntType = 'i16';

package/primitive/I256.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Int } from "../base/Int.js";
+
 /**
  * @name i256
  * @description
  * A 256-bit signed integer
  */
-
 export class i256 extends Int.with(256) {
   // NOTE without this, we cannot properly determine extensions
   __IntType = 'i256';

package/primitive/I32.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Int } from "../base/Int.js";
+
 /**
  * @name i32
  * @description
  * A 32-bit signed integer
  */
-
 export class i32 extends Int.with(32) {
   // NOTE without this, we cannot properly determine extensions
   __IntType = 'i32';

package/primitive/I64.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Int } from "../base/Int.js";
+
 /**
  * @name i64
  * @description
  * A 64-bit signed integer
  */
-
 export class i64 extends Int.with(64) {
   // NOTE without this, we cannot properly determine extensions
   __IntType = 'i64';

package/primitive/I8.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Int } from "../base/Int.js";
+
 /**
  * @name i8
  * @description
  * An 8-bit signed integer
  */
-
 export class i8 extends Int.with(8) {
   // NOTE without this, we cannot properly determine extensions
   __IntType = 'i8';

package/primitive/U128.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { UInt } from "../base/UInt.js";
+
 /**
  * @name u128
  * @description
  * A 128-bit unsigned integer
  */
-
 export class u128 extends UInt.with(128) {
   // NOTE without this, we cannot properly determine extensions
   __UIntType = 'u128';

package/primitive/U16.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { UInt } from "../base/UInt.js";
+
 /**
  * @name u16
  * @description
  * A 16-bit unsigned integer
  */
-
 export class u16 extends UInt.with(16) {
   // NOTE without this, we cannot properly determine extensions
   __UIntType = 'u16';

package/primitive/U256.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { UInt } from "../base/UInt.js";
+
 /**
  * @name u256
  * @description
  * A 256-bit unsigned integer
  */
-
 export class u256 extends UInt.with(256) {
   // NOTE without this, we cannot properly determine extensions
   __UIntType = 'u256';

package/primitive/U32.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { UInt } from "../base/UInt.js";
+
 /**
  * @name u32
  * @description
  * A 32-bit unsigned integer
  */
-
 export class u32 extends UInt.with(32) {
   // NOTE without this, we cannot properly determine extensions
   __UIntType = 'u32';

package/primitive/U64.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { UInt } from "../base/UInt.js";
+
 /**
  * @name u64
  * @description
  * A 64-bit unsigned integer
  */
-
 export class u64 extends UInt.with(64) {
   // NOTE without this, we cannot properly determine extensions
   __UIntType = 'u64';

package/primitive/U8.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { UInt } from "../base/UInt.js";
+
 /**
  * @name u8
  * @description
  * An 8-bit unsigned integer
  */
-
 export class u8 extends UInt.with(8) {
   // NOTE without this, we cannot properly determine extensions
   __UIntType = 'u8';

package/primitive/USize.js

@@ -1,6 +1,8 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { u32 } from "./U32.js";
+
 /**
  * @name USize
  * @description
@@ -8,11 +10,9 @@ import { u32 } from "./U32.js";
  * data. It is a wrapper for [[U32]] as a WASM default (as generated by Rust bindings).
  * It is not to be used, since it created consensus mismatches.
  */
-
 export class usize extends u32 {
   constructor(registry, value) {
     super(registry, value);
     throw new Error('The `usize` type should not be used. Since it is platform-specific, it creates incompatibilities between native (generally u64) and WASM (always u32) code. Use one of the `u32` or `u64` types explicitly.');
   }
-
 }

package/primitive/index.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 export { f32, f32 as F32 } from "./F32.js";
 export { f64, f64 as F64 } from "./F64.js";
 export { i8, i8 as I8 } from "./I8.js";

package/types/index.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 export * from "./codec.js";
 export * from "./helpers.js";
 export * from "./interfaces.js";

package/utils/compareArray.js

@@ -1,13 +1,14 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { isUndefined } from '@polkadot/util';
-import { hasEq } from "./util.js"; // NOTE These are used internally and when comparing objects, expects that
-// when the second is an Codec[] that the first has to be as well
+import { hasEq } from "./util.js";
 
+// NOTE These are used internally and when comparing objects, expects that
+// when the second is an Codec[] that the first has to be as well
 export function compareArray(a, b) {
   if (Array.isArray(b)) {
     return a.length === b.length && isUndefined(a.find((v, index) => hasEq(v) ? !v.eq(b[index]) : v !== b[index]));
   }
-
   return false;
 }

package/utils/compareMap.js

@@ -1,23 +1,21 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { isObject, isUndefined } from '@polkadot/util';
 import { hasEq } from "./util.js";
-
 function hasMismatch(a, b) {
   return isUndefined(a) || (hasEq(a) ? !a.eq(b) : a !== b);
 }
-
 function notEntry(value) {
   return !Array.isArray(value) || value.length !== 2;
 }
-
 function compareMapArray(a, b) {
   // equal number of entries and each entry in the array should match
   return a.size === b.length && !b.some(e => notEntry(e) || hasMismatch(a.get(e[0]), e[1]));
-} // NOTE These are used internally and when comparing objects, expects that
-// when the second is an Map<string, Codec> that the first has to be as well
-
+}
 
+// NOTE These are used internally and when comparing objects, expects that
+// when the second is an Map<string, Codec> that the first has to be as well
 export function compareMap(a, b) {
   if (Array.isArray(b)) {
     return compareMapArray(a, b);
@@ -26,6 +24,5 @@ export function compareMap(a, b) {
   } else if (isObject(b)) {
     return compareMapArray(a, Object.entries(b));
   }
-
   return false;
 }

package/utils/compareSet.js

@@ -1,14 +1,14 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { isObject } from '@polkadot/util';
 
+import { isObject } from '@polkadot/util';
 function compareSetArray(a, b) {
   // equal number of entries and each entry in the array should match
   return a.size === b.length && !b.some(e => !a.has(e));
-} // NOTE These are used internally and when comparing objects, expects that
-// when the second is an Set<string, Codec> that the first has to be as well
-
+}
 
+// NOTE These are used internally and when comparing objects, expects that
+// when the second is an Set<string, Codec> that the first has to be as well
 export function compareSet(a, b) {
   if (Array.isArray(b)) {
     return compareSetArray(a, b);
@@ -17,6 +17,5 @@ export function compareSet(a, b) {
   } else if (isObject(b)) {
     return compareSetArray(a, Object.values(b));
   }
-
   return false;
 }

package/utils/decodeU8a.js

@@ -1,21 +1,26 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { u8aToHex } from '@polkadot/util';
-/** @internal */
 
+/** @internal */
 function formatFailure(registry, result, {
   message
 }, u8a, i, count, Type, key) {
   let type = '';
-
   try {
     type = `: ${new Type(registry).toRawType()}`;
-  } catch {// ignore
-  } // console.error(JSON.stringify(result, null, 2));
+  } catch {
+    // ignore
+  }
 
+  // This is extra debugging info (we most-probably want this in in some way, shape or form,
+  // but at this point not quite sure how to include and format it (it can be quite massive)
+  // console.error(JSON.stringify(result, null, 2));
 
-  return `decodeU8a: failed at ${u8aToHex(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ''} (index ${i}/${count})${type}:: ${message}`;
+  return `decodeU8a: failed at ${u8aToHex(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ''} (index ${i + 1}/${count})${type}:: ${message}`;
 }
+
 /**
  * @internal
  *
@@ -26,13 +31,10 @@ function formatFailure(registry, result, {
  * @param result - The result array (will be returned with values pushed)
  * @param types - The array of CodecClass to decode the U8a against.
  */
-
-
 export function decodeU8a(registry, result, u8a, [Types, keys]) {
   const count = result.length;
   let offset = 0;
   let i = 0;
-
   try {
     while (i < count) {
       const value = new Types[i](registry, u8a.subarray(offset));
@@ -43,21 +45,19 @@ export function decodeU8a(registry, result, u8a, [Types, keys]) {
   } 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
  */
-
 export function decodeU8aStruct(registry, result, u8a, [Types, keys]) {
   const count = result.length;
   let offset = 0;
   let i = 0;
-
   try {
     while (i < count) {
       const value = new Types[i](registry, u8a.subarray(offset));
@@ -68,21 +68,19 @@ export function decodeU8aStruct(registry, result, u8a, [Types, keys]) {
   } 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
  */
-
 export 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));
@@ -93,6 +91,5 @@ export 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];
 }