@polkadot/types-codec 9.14.2 → 10.1.1

package/primitive/U128.js

@@ -1,14 +1,13 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { UInt } from "../base/UInt.js";
-
+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';
+    constructor() {
+        super(...arguments);
+        // NOTE without this, we cannot properly determine extensions
+        this.__UIntType = 'u128';
+    }
 }

package/primitive/U16.d.ts

@@ -1,5 +1,5 @@
-import { UInt } from '../base/UInt';
-declare const u16_base: import("../types").CodecClass<UInt>;
+import { UInt } from '../base/UInt.js';
+declare const u16_base: import("../types/codec.js").CodecClass<UInt>;
 /**
  * @name u16
  * @description

package/primitive/U16.js

@@ -1,14 +1,13 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { UInt } from "../base/UInt.js";
-
+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';
+    constructor() {
+        super(...arguments);
+        // NOTE without this, we cannot properly determine extensions
+        this.__UIntType = 'u16';
+    }
 }

package/primitive/U256.d.ts

@@ -1,5 +1,5 @@
-import { UInt } from '../base/UInt';
-declare const u256_base: import("../types").CodecClass<UInt>;
+import { UInt } from '../base/UInt.js';
+declare const u256_base: import("../types/codec.js").CodecClass<UInt>;
 /**
  * @name u256
  * @description

package/primitive/U256.js

@@ -1,14 +1,13 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { UInt } from "../base/UInt.js";
-
+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';
+    constructor() {
+        super(...arguments);
+        // NOTE without this, we cannot properly determine extensions
+        this.__UIntType = 'u256';
+    }
 }

package/primitive/U32.d.ts

@@ -1,5 +1,5 @@
-import { UInt } from '../base/UInt';
-declare const u32_base: import("../types").CodecClass<UInt>;
+import { UInt } from '../base/UInt.js';
+declare const u32_base: import("../types/codec.js").CodecClass<UInt>;
 /**
  * @name u32
  * @description

package/primitive/U32.js

@@ -1,14 +1,13 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { UInt } from "../base/UInt.js";
-
+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';
+    constructor() {
+        super(...arguments);
+        // NOTE without this, we cannot properly determine extensions
+        this.__UIntType = 'u32';
+    }
 }

package/primitive/U64.d.ts

@@ -1,5 +1,5 @@
-import { UInt } from '../base/UInt';
-declare const u64_base: import("../types").CodecClass<UInt>;
+import { UInt } from '../base/UInt.js';
+declare const u64_base: import("../types/codec.js").CodecClass<UInt>;
 /**
  * @name u64
  * @description

package/primitive/U64.js

@@ -1,14 +1,13 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { UInt } from "../base/UInt.js";
-
+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';
+    constructor() {
+        super(...arguments);
+        // NOTE without this, we cannot properly determine extensions
+        this.__UIntType = 'u64';
+    }
 }

package/primitive/U8.d.ts

@@ -1,5 +1,5 @@
-import { UInt } from '../base/UInt';
-declare const u8_base: import("../types").CodecClass<UInt>;
+import { UInt } from '../base/UInt.js';
+declare const u8_base: import("../types/codec.js").CodecClass<UInt>;
 /**
  * @name u8
  * @description

package/primitive/U8.js

@@ -1,14 +1,13 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { UInt } from "../base/UInt.js";
-
+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';
+    constructor() {
+        super(...arguments);
+        // NOTE without this, we cannot properly determine extensions
+        this.__UIntType = 'u8';
+    }
 }

package/primitive/USize.d.ts

@@ -1,5 +1,5 @@
-import type { Registry } from '../types';
-import { u32 } from './U32';
+import type { Registry } from '../types/index.js';
+import { u32 } from './U32.js';
 /**
  * @name USize
  * @description

package/primitive/USize.js

@@ -1,8 +1,4 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { u32 } from "./U32.js";
-
+import { u32 } from './U32.js';
 /**
  * @name USize
  * @description
@@ -11,8 +7,8 @@ import { u32 } from "./U32.js";
  * 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.');
-  }
+    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.d.ts

@@ -1,15 +1,15 @@
-export { f32, f32 as F32 } from './F32';
-export { f64, f64 as F64 } from './F64';
-export { i8, i8 as I8 } from './I8';
-export { i16, i16 as I16 } from './I16';
-export { i32, i32 as I32 } from './I32';
-export { i64, i64 as I64 } from './I64';
-export { i128, i128 as I128 } from './I128';
-export { i256, i256 as I256 } from './I256';
-export { u8, u8 as U8 } from './U8';
-export { u16, u16 as U16 } from './U16';
-export { u32, u32 as U32 } from './U32';
-export { u64, u64 as U64 } from './U64';
-export { u128, u128 as U128 } from './U128';
-export { u256, u256 as U256 } from './U256';
-export { usize, usize as USize } from './USize';
+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/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/codec.d.ts

@@ -1,7 +1,7 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, ToString } from './helpers';
-import type { IU8a } from './interfaces';
-import type { Registry } from './registry';
+import type { AnyJson, ToString } from './helpers.js';
+import type { IU8a } from './interfaces.js';
+import type { Registry } from './registry.js';
 export type BareOpts = boolean | Record<string, boolean>;
 export interface Inspect {
     inner?: Inspect[];

package/types/helpers.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import type { BN } from '@polkadot/util';
 import type { HexString } from '@polkadot/util/types';
-import type { Codec } from './codec';
+import type { Codec } from './codec.js';
 export type AnyJson = string | number | boolean | null | undefined | AnyJson[] | {
     [index: string]: AnyJson;
 };

package/types/index.d.ts

@@ -1,4 +1,4 @@
-export * from './codec';
-export * from './helpers';
-export * from './interfaces';
-export * from './registry';
+export * from './codec.js';
+export * from './helpers.js';
+export * from './interfaces.js';
+export * from './registry.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/types/interfaces.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import type { BN } from '@polkadot/util';
-import type { ArgsDef, Codec } from './codec';
-import type { AnyTuple } from './helpers';
+import type { ArgsDef, Codec } from './codec.js';
+import type { AnyTuple } from './helpers.js';
 export interface ICompact<T extends INumber = INumber> extends Codec {
     toBigInt(): bigint;
     toBn(): BN;

package/types/registry.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="bn.js" />
 import type { BN } from '@polkadot/util';
-import type { Codec, CodecClass } from './codec';
-import type { AnyTuple, LookupString } from './helpers';
-import type { ICompact, IEnum, IMap, IMethod, INumber, IOption, IResult, ISet, IStruct, ITuple, IU8a, IVec } from './interfaces';
+import type { Codec, CodecClass } from './codec.js';
+import type { AnyTuple, LookupString } from './helpers.js';
+import type { ICompact, IEnum, IMap, IMethod, INumber, IOption, IResult, ISet, IStruct, ITuple, IU8a, IVec } from './interfaces.js';
 export type OnlyCodec<K, T, Types> = K extends keyof Types ? Types[K] : T extends ICompact | IEnum | IMap | IMethod | INumber | IOption | IResult | ISet | IStruct | ITuple | IU8a | IVec ? T : T extends Codec ? T : never;
 export interface RegistryError {
     args: string[];

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.d.ts

@@ -1,4 +1,4 @@
-import type { Codec, CodecClass, Registry } from '../types';
+import type { Codec, CodecClass, Registry } from '../types/index.js';
 /**
  * @internal
  *

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.d.ts

@@ -1,9 +1,9 @@
-export { compareArray } from './compareArray';
-export { compareMap } from './compareMap';
-export { compareSet } from './compareSet';
-export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a';
-export { mapToTypeMap } from './mapToTypeMap';
-export { typeToConstructor } from './typeToConstructor';
-export { sanitize } from './sanitize';
-export { sortAsc, sortSet, sortMap } from './sortValues';
-export { typesToMap } from './typesToMap';
+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';