@polkadot/types-codec 9.14.2 → 10.1.1

package/extended/Bytes.js

@@ -1,29 +1,22 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { compactAddLength, compactFromU8aLim, compactToU8a, isString, isU8a, u8aToU8a } from '@polkadot/util';
-import { Raw } from "../native/Raw.js";
-
-// Bytes are used for things like on-chain code, so it has a healthy limit
+import { Raw } from '../native/Raw.js';
 const MAX_LENGTH = 10 * 1024 * 1024;
-
 /** @internal */
 function decodeBytesU8a(value) {
-  if (!value.length) {
-    return [new Uint8Array(), 0];
-  }
-
-  // handle all other Uint8Array inputs, these do have a length prefix
-  const [offset, length] = compactFromU8aLim(value);
-  const total = offset + length;
-  if (length > MAX_LENGTH) {
-    throw new Error(`Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
-  } else if (total > value.length) {
-    throw new Error(`Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
-  }
-  return [value.subarray(offset, total), total];
+    if (!value.length) {
+        return [new Uint8Array(), 0];
+    }
+    // handle all other Uint8Array inputs, these do have a length prefix
+    const [offset, length] = compactFromU8aLim(value);
+    const total = offset + length;
+    if (length > MAX_LENGTH) {
+        throw new Error(`Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    }
+    else if (total > value.length) {
+        throw new Error(`Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
+    }
+    return [value.subarray(offset, total), total];
 }
-
 /**
  * @name Bytes
  * @description
@@ -32,40 +25,46 @@ function decodeBytesU8a(value) {
  * as what is found in [[Text]] and [[Vec]])
  */
 export class Bytes extends Raw {
-  constructor(registry, value) {
-    const [u8a, decodedLength] = isU8a(value) && !(value instanceof Raw) ? decodeBytesU8a(value) : Array.isArray(value) || isString(value) ? [u8aToU8a(value), 0] : [value, 0];
-    super(registry, u8a, decodedLength);
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  get encodedLength() {
-    return this.length + compactToU8a(this.length).length;
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  inspect(isBare) {
-    const clength = compactToU8a(this.length);
-    return {
-      outer: isBare ? [super.toU8a()] : this.length ? [clength, super.toU8a()] : [clength]
-    };
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    return 'Bytes';
-  }
-
-  /**
-   * @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) {
-    return isBare ? super.toU8a(isBare) : compactAddLength(this);
-  }
+    constructor(registry, value) {
+        const [u8a, decodedLength] = isU8a(value) && !(value instanceof Raw)
+            ? decodeBytesU8a(value)
+            : Array.isArray(value) || isString(value)
+                ? [u8aToU8a(value), 0]
+                : [value, 0];
+        super(registry, u8a, decodedLength);
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        return this.length + compactToU8a(this.length).length;
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(isBare) {
+        const clength = compactToU8a(this.length);
+        return {
+            outer: isBare
+                ? [super.toU8a()]
+                : this.length
+                    ? [clength, super.toU8a()]
+                    : [clength]
+        };
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return 'Bytes';
+    }
+    /**
+     * @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) {
+        return isBare
+            ? super.toU8a(isBare)
+            : compactAddLength(this);
+    }
 }

package/extended/HashMap.d.ts

@@ -1,5 +1,5 @@
-import type { Codec, CodecClass } from '../types';
-import { CodecMap } from './Map';
+import type { Codec, CodecClass } from '../types/index.js';
+import { CodecMap } from './Map.js';
 export declare class HashMap<K extends Codec = Codec, V extends Codec = Codec> extends CodecMap<K, V> {
     static with<K extends Codec, V extends Codec>(keyType: CodecClass<K> | string, valType: CodecClass<V> | string): CodecClass<CodecMap<K, V>>;
 }

package/extended/HashMap.js

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

package/extended/Linkage.d.ts

@@ -1,7 +1,7 @@
-import type { Codec, CodecClass, Registry } from '../types';
-import { Option } from '../base/Option';
-import { Tuple } from '../base/Tuple';
-import { Struct } from '../native/Struct';
+import type { Codec, CodecClass, Registry } from '../types/index.js';
+import { Option } from '../base/Option.js';
+import { Tuple } from '../base/Tuple.js';
+import { Struct } from '../native/Struct.js';
 type TypeWithValues = [CodecClass, any[]];
 /**
  * @name Linkage

package/extended/Linkage.js

@@ -1,64 +1,59 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { Option } from "../base/Option.js";
-import { Tuple } from "../base/Tuple.js";
-import { Vec } from "../base/Vec.js";
-import { Struct } from "../native/Struct.js";
+import { Option } from '../base/Option.js';
+import { Tuple } from '../base/Tuple.js';
+import { Vec } from '../base/Vec.js';
+import { Struct } from '../native/Struct.js';
 const EMPTY = new Uint8Array();
-
 /**
  * @name Linkage
  * @description The wrapper for the result from a LinkedMap
  */
 export class Linkage extends Struct {
-  constructor(registry, Type, value) {
-    super(registry, {
-      previous: Option.with(Type),
-      // eslint-disable-next-line sort-keys
-      next: Option.with(Type)
-    }, value);
-  }
-  static withKey(Type) {
-    return class extends Linkage {
-      constructor(registry, value) {
-        super(registry, Type, value);
-      }
-    };
-  }
-  get previous() {
-    return this.get('previous');
-  }
-  get next() {
-    return this.get('next');
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    return `Linkage<${this.next.toRawType(true)}>`;
-  }
-
-  /**
-   * @description Custom toU8a which with bare mode does not return the linkage if empty
-   */
-  toU8a() {
-    // As part of a storage query (where these appear), in the case of empty, the values
-    // are NOT populated by the node - follow the same logic, leaving it empty
-    return this.isEmpty ? EMPTY : super.toU8a();
-  }
+    constructor(registry, Type, value) {
+        super(registry, {
+            previous: Option.with(Type),
+            // eslint-disable-next-line sort-keys
+            next: Option.with(Type)
+        }, value);
+    }
+    static withKey(Type) {
+        return class extends Linkage {
+            constructor(registry, value) {
+                super(registry, Type, value);
+            }
+        };
+    }
+    get previous() {
+        return this.get('previous');
+    }
+    get next() {
+        return this.get('next');
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return `Linkage<${this.next.toRawType(true)}>`;
+    }
+    /**
+     * @description Custom toU8a which with bare mode does not return the linkage if empty
+     */
+    toU8a() {
+        // As part of a storage query (where these appear), in the case of empty, the values
+        // are NOT populated by the node - follow the same logic, leaving it empty
+        return this.isEmpty
+            ? EMPTY
+            : super.toU8a();
+    }
 }
-
 /**
  * @name LinkageResult
  * @description A Linkage keys/Values tuple
  */
 export class LinkageResult extends Tuple {
-  constructor(registry, [TypeKey, keys], [TypeValue, values]) {
-    super(registry, {
-      Keys: Vec.with(TypeKey),
-      Values: Vec.with(TypeValue)
-    }, [keys, values]);
-  }
+    constructor(registry, [TypeKey, keys], [TypeValue, values]) {
+        super(registry, {
+            Keys: Vec.with(TypeKey),
+            Values: Vec.with(TypeValue)
+        }, [keys, values]);
+    }
 }

package/extended/Map.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, IMap, Inspect, IU8a, Registry } from '../types';
+import type { AnyJson, Codec, CodecClass, IMap, Inspect, IU8a, Registry } from '../types/index.js';
 export declare class CodecMap<K extends Codec = Codec, V extends Codec = Codec> extends Map<K, V> implements IMap<K, V> {
     #private;
     readonly registry: Registry;