@polkadot/types-codec 9.14.2 → 10.0.1

package/primitive/index.js

@@ -1,18 +1,15 @@
-// Copyright 2017-2023 @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";
-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 { 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, 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 { 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';

package/types/index.js

@@ -1,7 +1,4 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export * from "./codec.js";
-export * from "./helpers.js";
-export * from "./interfaces.js";
-export * from "./registry.js";
+export * from './codec.js';
+export * from './helpers.js';
+export * from './interfaces.js';
+export * from './registry.js';

package/utils/compareArray.js

@@ -1,14 +1,10 @@
-// Copyright 2017-2023 @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';
 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;
+    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,28 +1,27 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { isObject, isUndefined } from '@polkadot/util';
-import { hasEq } from "./util.js";
+import { hasEq } from './util.js';
 function hasMismatch(a, b) {
-  return isUndefined(a) || (hasEq(a) ? !a.eq(b) : a !== b);
+    return isUndefined(a) || (hasEq(a)
+        ? !a.eq(b)
+        : a !== b);
 }
 function notEntry(value) {
-  return !Array.isArray(value) || value.length !== 2;
+    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]));
+    // 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
 export function compareMap(a, b) {
-  if (Array.isArray(b)) {
-    return compareMapArray(a, b);
-  } else if (b instanceof Map) {
-    return compareMapArray(a, [...b.entries()]);
-  } else if (isObject(b)) {
-    return compareMapArray(a, Object.entries(b));
-  }
-  return false;
+    if (Array.isArray(b)) {
+        return compareMapArray(a, b);
+    }
+    else if (b instanceof Map) {
+        return compareMapArray(a, [...b.entries()]);
+    }
+    else if (isObject(b)) {
+        return compareMapArray(a, Object.entries(b));
+    }
+    return false;
 }

package/utils/compareSet.js

@@ -1,21 +1,17 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 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));
+    // 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
 export function compareSet(a, b) {
-  if (Array.isArray(b)) {
-    return compareSetArray(a, b);
-  } else if (b instanceof Set) {
-    return compareSetArray(a, [...b.values()]);
-  } else if (isObject(b)) {
-    return compareSetArray(a, Object.values(b));
-  }
-  return false;
+    if (Array.isArray(b)) {
+        return compareSetArray(a, b);
+    }
+    else if (b instanceof Set) {
+        return compareSetArray(a, [...b.values()]);
+    }
+    else if (isObject(b)) {
+        return compareSetArray(a, Object.values(b));
+    }
+    return false;
 }

package/utils/decodeU8a.js

@@ -1,26 +1,18 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { u8aToHex } from '@polkadot/util';
-
 /** @internal */
-function formatFailure(registry, fn, result, {
-  message
-}, u8a, i, count, Type, key) {
-  let type = '';
-  try {
-    type = `: ${new Type(registry).toRawType()}`;
-  } 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 `${fn}: failed at ${u8aToHex(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ''} (index ${i + 1}/${count})${type}:: ${message}`;
+function formatFailure(registry, fn, result, { message }, u8a, i, count, Type, key) {
+    let type = '';
+    try {
+        type = `: ${new Type(registry).toRawType()}`;
+    }
+    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 `${fn}: failed at ${u8aToHex(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ''} (index ${i + 1}/${count})${type}:: ${message}`;
 }
-
 /**
  * @internal
  *
@@ -32,22 +24,22 @@ function formatFailure(registry, fn, result, {
  * @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));
-      offset += value.initialU8aLength || value.encodedLength;
-      result[i] = value;
-      i++;
+    const count = result.length;
+    let offset = 0;
+    let i = 0;
+    try {
+        while (i < count) {
+            const value = new Types[i](registry, u8a.subarray(offset));
+            offset += value.initialU8aLength || value.encodedLength;
+            result[i] = value;
+            i++;
+        }
+    }
+    catch (error) {
+        throw new Error(formatFailure(registry, 'decodeU8a', result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
     }
-  } catch (error) {
-    throw new Error(formatFailure(registry, 'decodeU8a', result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
-  }
-  return [result, offset];
+    return [result, offset];
 }
-
 /**
  * @internal
  *
@@ -55,22 +47,22 @@ export function decodeU8a(registry, result, u8a, [Types, keys]) {
  * 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));
-      offset += value.initialU8aLength || value.encodedLength;
-      result[i] = [keys[i], value];
-      i++;
+    const count = result.length;
+    let offset = 0;
+    let i = 0;
+    try {
+        while (i < count) {
+            const value = new Types[i](registry, u8a.subarray(offset));
+            offset += value.initialU8aLength || value.encodedLength;
+            result[i] = [keys[i], value];
+            i++;
+        }
     }
-  } catch (error) {
-    throw new Error(formatFailure(registry, 'decodeU8aStruct', result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
-  }
-  return [result, offset];
+    catch (error) {
+        throw new Error(formatFailure(registry, 'decodeU8aStruct', result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
+    }
+    return [result, offset];
 }
-
 /**
  * @internal
  *
@@ -78,18 +70,19 @@ export function decodeU8aStruct(registry, result, u8a, [Types, keys]) {
  * 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));
-      offset += value.initialU8aLength || value.encodedLength;
-      result[i] = value;
-      i++;
+    const count = result.length;
+    let offset = startAt;
+    let i = 0;
+    try {
+        while (i < count) {
+            const value = new Type(registry, u8a.subarray(offset));
+            offset += value.initialU8aLength || value.encodedLength;
+            result[i] = value;
+            i++;
+        }
+    }
+    catch (error) {
+        throw new Error(formatFailure(registry, 'decodeU8aVec', result, error, u8a.subarray(offset), i, count, Type));
     }
-  } catch (error) {
-    throw new Error(formatFailure(registry, 'decodeU8aVec', result, error, u8a.subarray(offset), i, count, Type));
-  }
-  return [offset, offset - startAt];
+    return [offset, offset - startAt];
 }

package/utils/index.js

@@ -1,12 +1,9 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-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 { typesToMap } from "./typesToMap.js";
+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 { typesToMap } from './typesToMap.js';

package/utils/mapToTypeMap.js

@@ -1,18 +1,14 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { typeToConstructor } from "./typeToConstructor.js";
-
+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;
+    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;
 }