@polkadot/types-codec 8.5.1 → 8.5.2-10

package/native/Struct.js

@@ -1,22 +1,26 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isBoolean, isFunction, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { assert, isBoolean, isFunction, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { compareMap, decodeU8a, mapToTypeMap, typesToMap } from "../utils/index.js";
 
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
-function decodeStructFromObject(registry, Types, value, jsonMap) {
+
+
+function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
   let jsonObj;
-  const inputKeys = Object.keys(Types);
   const typeofArray = Array.isArray(value);
   const typeofMap = value instanceof Map;
   assert(typeofArray || typeofMap || isObject(value), () => `Struct: Cannot decode value ${stringify(value)} (typeof ${typeof value}), expected an input object, map or array`);
-  assert(!typeofArray || value.length === inputKeys.length, () => `Struct: Unable to map ${stringify(value)} array to object with known keys ${inputKeys.join(', ')}`);
-  const raw = new Array(inputKeys.length);
+  assert(!typeofArray || value.length === keys.length, () => `Struct: Unable to map ${stringify(value)} array to object with known keys ${keys.join(', ')}`);
+  const raw = new Array(keys.length);
 
-  for (let i = 0; i < inputKeys.length; i++) {
-    const key = inputKeys[i];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
     const jsonKey = jsonMap.get(key) || key;
-    const Type = Types[key];
+    const Type = Types[i];
     let assign;
 
     try {
@@ -73,9 +77,12 @@ export class Struct extends Map {
   #jsonMap;
   #Types;
 
-  constructor(registry, Types, value, jsonMap = new Map()) {
-    const typeMap = mapToTypeMap(registry, Types);
-    const [decoded, decodedLength] = isU8a(value) ? decodeU8a(registry, value, typeMap, true) : isHex(value) ? decodeU8a(registry, u8aToU8a(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
+  constructor(registry, Types, value, jsonMap = new Map(), {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    const typeMap = definition || setDefinition(mapToTypeMap(registry, Types));
+    const [decoded, decodedLength] = isU8a(value) || isHex(value) ? decodeU8a(registry, new Array(typeMap[0].length), u8aToU8a(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
     super(decoded);
     this.#registry = registry;
     this.initialU8aLength = decodedLength;
@@ -85,9 +92,16 @@ export class Struct extends Map {
 
   static with(Types, jsonMap) {
     const keys = Object.keys(Types);
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Struct {
       constructor(registry, value) {
-        super(registry, Types, value, jsonMap);
+        super(registry, Types, value, jsonMap, {
+          definition,
+          setDefinition
+        });
         objectProperties(this, keys, k => this.get(k));
       }
 
@@ -99,7 +113,7 @@ export class Struct extends Map {
 
 
   get defKeys() {
-    return Object.keys(this.#Types);
+    return this.#Types[1];
   }
 
   getT(key) {
@@ -126,11 +140,10 @@ export class Struct extends Map {
 
   get Type() {
     const result = {};
-    const defs = Object.entries(this.#Types);
+    const [Types, keys] = this.#Types;
 
-    for (let i = 0; i < defs.length; i++) {
-      const [key, Type] = defs[i];
-      result[key] = new Type(this.registry).toRawType();
+    for (let i = 0; i < keys.length; i++) {
+      result[keys[i]] = new Types[i](this.registry).toRawType();
     }
 
     return result;
@@ -191,11 +204,11 @@ export class Struct extends Map {
    */
 
 
-  inspect() {
+  inspect(isBare) {
     const inner = new Array();
 
     for (const [k, v] of this.entries()) {
-      inner.push({ ...v.inspect(),
+      inner.push({ ...v.inspect(!isBare || isBoolean(isBare) ? isBare : isBare[k]),
         name: stringCamelCase(k)
       });
     }
@@ -280,7 +293,7 @@ export class Struct extends Map {
       }
     }
 
-    return u8aConcat(...encoded);
+    return u8aConcatStrict(encoded);
   }
 
 }

package/native/Text.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyU8a, Inspect, IText, IU8a, Registry } from '../types';
+import type { AnyString, AnyU8a, Inspect, IText, IU8a, Registry } from '../types';
 /**
  * @name Text
  * @description
@@ -12,7 +12,7 @@ export declare class Text extends String implements IText {
     #private;
     readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: Registry, value?: null | Text | string | AnyU8a | {
+    constructor(registry: Registry, value?: null | AnyString | AnyU8a | {
         toString: () => string;
     });
     /**

package/native/Text.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactAddLength, compactFromU8a, compactToU8a, hexToU8a, isHex, isString, isU8a, stringToU8a, u8aToHex, u8aToString } from '@polkadot/util';
+import { assert, compactAddLength, compactFromU8aLim, compactToU8a, hexToU8a, isHex, isString, isU8a, stringToU8a, u8aToHex, u8aToString } from '@polkadot/util';
 import { Raw } from "./Raw.js";
 const MAX_LENGTH = 128 * 1024;
 /** @internal */
@@ -17,9 +17,9 @@ function decodeText(value) {
       return [u8aToString(value), 0];
     }
 
-    const [offset, length] = compactFromU8a(value);
-    const total = offset + length.toNumber();
-    assert(length.lten(MAX_LENGTH), () => `Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    const [offset, length] = compactFromU8aLim(value);
+    const total = offset + length;
+    assert(length <= MAX_LENGTH, () => `Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
     assert(total <= value.length, () => `Text: required length less than remainder, expected at least ${total}, found ${value.length}`);
     return [u8aToString(value.subarray(offset, total)), total];
   } else if (isHex(value)) {

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "8.5.1",
+  "version": "8.5.2-10",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -172,6 +172,11 @@
       "require": "./cjs/extended/Map.js",
       "default": "./extended/Map.js"
     },
+    "./extended/OptionBool": {
+      "types": "./extended/OptionBool.d.ts",
+      "require": "./cjs/extended/OptionBool.js",
+      "default": "./extended/OptionBool.js"
+    },
     "./extended/Range": {
       "types": "./extended/Range.d.ts",
       "require": "./cjs/extended/Range.js",
@@ -410,6 +415,6 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.18.0",
-    "@polkadot/util": "^9.2.1"
+    "@polkadot/util": "^9.2.2-15"
   }
 }

package/packageInfo.js

@@ -5,5 +5,5 @@ 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: '8.5.1'
+  version: '8.5.2-10'
 };

package/types/codec.d.ts

@@ -47,7 +47,7 @@ export interface Codec {
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
      */
-    inspect(): Inspect;
+    inspect(isBare?: BareOpts): Inspect;
     /**
      * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
      */
@@ -81,6 +81,5 @@ export interface CodecClass<T = Codec> {
     readonly __fallbackType?: string;
     new (registry: Registry, ...args: any[]): T;
 }
-export declare type CodecClassDef<T = Codec> = Record<string, CodecClass<T>>;
 export declare type CodecTo = 'toHex' | 'toJSON' | 'toString' | 'toU8a';
 export declare type ArgsDef = Record<string, CodecClass | string>;

package/types/helpers.d.ts

@@ -6,7 +6,8 @@ export declare type AnyJson = string | number | boolean | null | undefined | Any
 };
 export declare type AnyFunction = (...args: any[]) => any;
 export declare type AnyNumber = BN | bigint | Uint8Array | number | string;
-export declare type AnyString = string | string;
+export declare type AnyString = String | string;
+export declare type AnyBool = Boolean | boolean;
 export declare type AnyTuple = Codec[];
 export declare type AnyU8a = Uint8Array | number[] | string;
 export declare type UIntBitLength = 8 | 16 | 32 | 64 | 128 | 256;

package/utils/decodeU8a.d.ts

@@ -7,7 +7,5 @@ import type { Codec, CodecClass, Registry } from '../types';
  * @param result - The result array (will be returned with values pushed)
  * @param types - The array of CodecClass to decode the U8a against.
  */
-export declare function decodeU8a<T extends Codec = Codec, E = T>(registry: Registry, u8a: Uint8Array, types: CodecClass[] | {
-    [index: string]: CodecClass;
-}, withZip?: boolean): [E[], number];
-export declare function decodeU8aVec<T extends Codec = Codec>(registry: Registry, u8a: Uint8Array, start: number, Type: CodecClass<T>, count: number): [T[], number, number];
+export declare function decodeU8a<T extends Codec = Codec, E = T>(registry: Registry, result: unknown[], u8a: Uint8Array, [Types, keys]: [CodecClass[], string[]], withZip?: boolean): [E[], number];
+export declare function decodeU8aVec<T extends Codec = Codec>(registry: Registry, result: unknown[], u8a: Uint8Array, startAt: number, Type: CodecClass<T>): [number, number];

package/utils/decodeU8a.js

@@ -23,12 +23,11 @@ function getRawType(registry, Type) {
  */
 
 
-export function decodeU8a(registry, u8a, types, withZip) {
-  const [Types, keys] = Array.isArray(types) ? [types, []] : [Object.values(types), Object.keys(types)];
-  const result = new Array(Types.length);
+export function decodeU8a(registry, result, u8a, [Types, keys], withZip) {
+  const count = result.length;
   let offset = 0;
 
-  for (let i = 0; i < Types.length; i++) {
+  for (let i = 0; i < count; i++) {
     try {
       const value = new Types[i](registry, u8a.subarray(offset));
       offset += value.initialU8aLength || value.encodedLength;
@@ -42,9 +41,9 @@ export function decodeU8a(registry, u8a, types, withZip) {
 } // Split from decodeU8a since this is specialized to 1 instance ... yes duplication, but
 // since we have to do less checks (and these are intensive anyway), much faster
 
-export function decodeU8aVec(registry, u8a, start, Type, count) {
-  const result = new Array(count);
-  let offset = start;
+export function decodeU8aVec(registry, result, u8a, startAt, Type) {
+  const count = result.length;
+  let offset = startAt;
 
   for (let i = 0; i < count; i++) {
     try {
@@ -56,5 +55,5 @@ export function decodeU8aVec(registry, u8a, start, Type, count) {
     }
   }
 
-  return [result, offset, offset - start];
+  return [offset, offset - startAt];
 }

package/utils/mapToTypeMap.d.ts

@@ -2,4 +2,4 @@ import type { CodecClass, Registry } from '../types';
 /**
  * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
  */
-export declare function mapToTypeMap(registry: Registry, input: Record<string, string | CodecClass>): Record<string, CodecClass>;
+export declare function mapToTypeMap(registry: Registry, input: Record<string, string | CodecClass>): [CodecClass[], string[]];

package/utils/mapToTypeMap.js

@@ -7,10 +7,12 @@ import { typeToConstructor } from "./typeToConstructor.js";
 
 export function mapToTypeMap(registry, input) {
   const entries = Object.entries(input);
-  const output = {};
+  const count = entries.length;
+  const output = [new Array(count), new Array(count)];
 
   for (let i = 0; i < entries.length; i++) {
-    output[entries[i][0]] = typeToConstructor(registry, entries[i][1]);
+    output[1][i] = entries[i][0];
+    output[0][i] = typeToConstructor(registry, entries[i][1]);
   }
 
   return output;

package/utils/sanitize.d.ts

@@ -2,6 +2,7 @@ interface SanitizeOptions {
     allowNamespaces?: boolean;
 }
 declare type Mapper = (value: string, options?: SanitizeOptions) => string;
+export declare function trim(): Mapper;
 export declare function findClosing(value: string, start: number): number;
 export declare function alias(src: string, dest: string, withChecks?: boolean): Mapper;
 export declare function cleanupCompact(): Mapper;

package/utils/sanitize.js

@@ -19,7 +19,12 @@ alias('RawAddress', 'Address'), // lookups, mapped to Address/AccountId as appro
 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()]; // given a starting index, find the closing >
+removeColons(), // remove all trailing spaces - this should always be the last
+trim()]; // given a string, trim it
+
+export function trim() {
+  return value => value.trim();
+} // given a starting index, find the closing >
 
 export function findClosing(value, start) {
   let depth = 0;
@@ -191,10 +196,11 @@ export function removeWrap(check) {
 const sanitizeMap = new Map(); // eslint-disable-next-line @typescript-eslint/ban-types
 
 export function sanitize(value, options) {
-  let result = value.toString();
+  const startValue = value.toString();
+  let result = startValue;
 
   if (!options) {
-    const memoized = sanitizeMap.get(result);
+    const memoized = sanitizeMap.get(startValue);
 
     if (memoized) {
       return memoized;
@@ -205,10 +211,8 @@ export function sanitize(value, options) {
     result = mappings[i](result, options);
   }
 
-  result = result.trim();
-
   if (!options) {
-    sanitizeMap.set(value.toString(), result);
+    sanitizeMap.set(startValue, result);
   }
 
   return result;

package/utils/typesToMap.d.ts

@@ -1,2 +1,2 @@
 import type { CodecClass, Registry } from '../types';
-export declare function typesToMap(registry: Registry, Types: Record<string, CodecClass>): Record<string, string>;
+export declare function typesToMap(registry: Registry, [Types, keys]: [CodecClass[], string[]]): Record<string, string>;

package/utils/typesToMap.js

@@ -1,12 +1,10 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-export function typesToMap(registry, Types) {
-  const entries = Object.entries(Types);
+export function typesToMap(registry, [Types, keys]) {
   const result = {};
 
-  for (let i = 0; i < entries.length; i++) {
-    const [key, Type] = entries[i];
-    result[key] = registry.getClassName(Type) || new Type(registry).toRawType();
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
   }
 
   return result;