@polkadot/types-create 8.8.2 → 8.8.3-10

package/cjs/packageInfo.js

@@ -11,6 +11,6 @@ const packageInfo = {
   name: '@polkadot/types-create',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '8.8.2'
+  version: '8.8.3-10'
 };
 exports.packageInfo = packageInfo;

package/cjs/util/getTypeDef.js

@@ -16,6 +16,8 @@ var _typeSplit = require("./typeSplit");
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 const MAX_NESTED = 64;
+const MAX_FIX_LEN = 2048;
+const MAX_BIT_LEN = 8192;
 const KNOWN_INTERNALS = ['_alias', '_fallback'];
 
 function getTypeString(typeOrObj) {
@@ -121,21 +123,35 @@ function _decodeFixedVec(value, type, _, count) {
   let inner = 0;
 
   for (let i = 1; i < max && index === -1; i++) {
-    if (type[i] === ';' && inner === 0) {
-      index = i;
-    } else if (['[', '(', '<'].includes(type[i])) {
-      inner++;
-    } else if ([']', ')', '>'].includes(type[i])) {
-      inner--;
+    switch (type[i]) {
+      case ';':
+        {
+          if (inner === 0) {
+            index = i;
+          }
+
+          break;
+        }
+
+      case '[':
+      case '(':
+      case '<':
+        inner++;
+        break;
+
+      case ']':
+      case ')':
+      case '>':
+        inner--;
+        break;
     }
   }
 
   (0, _util.assert)(index !== -1, () => `${type}: Unable to extract location of ';'`);
   const vecType = type.substring(1, index);
   const [strLength, displayName] = type.substring(index + 1, max).split(';');
-  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
-
-  (0, _util.assert)(length <= 256, () => `${type}: Only support for [Type; <length>], where length <= 256`);
+  const length = parseInt(strLength.trim(), 10);
+  (0, _util.assert)(length <= MAX_FIX_LEN, () => `${type}: Only support for [Type; <length>], where length <= ${MAX_FIX_LEN}`);
   value.displayName = displayName;
   value.length = length;
   value.sub = getTypeDef(vecType, {}, count);
@@ -152,9 +168,8 @@ function _decodeTuple(value, _, subType, count) {
 
 function _decodeAnyInt(value, type, _, clazz) {
   const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(',');
-  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
-
-  (0, _util.assert)(length <= 8192 && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
+  const length = parseInt(strLength.trim(), 10);
+  (0, _util.assert)(length <= MAX_BIT_LEN && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= ${MAX_BIT_LEN} and a power of 8, found ${length}`);
   value.displayName = displayName;
   value.length = length;
   return value;
@@ -187,8 +202,7 @@ const wrappedExtraction = [['BTreeSet<', '>', _types.TypeDefInfo.BTreeSet], ['Co
 function extractSubType(type, _ref6) {
   let [start, end] = _ref6;
   return type.substring(start.length, type.length - end.length);
-} // eslint-disable-next-line @typescript-eslint/ban-types
-
+}
 
 function getTypeDef(_type) {
   let {

package/cjs/util/typeSplit.js

@@ -9,72 +9,70 @@ var _util = require("@polkadot/util");
 
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-function isNotNested() {
-  for (var _len = arguments.length, counters = new Array(_len), _key = 0; _key < _len; _key++) {
-    counters[_key] = arguments[_key];
-  }
-
-  return !counters.some(counter => counter !== 0);
-} // safely split a string on ', ' while taking care of any nested occurences
-
-
+// safely split a string on ', ' while taking care of any nested occurences
 function typeSplit(type) {
-  let [cDepth, fDepth, sDepth, tDepth, start] = [0, 0, 0, 0, 0];
-  const result = [];
+  const result = []; // these are the depths of the various tokens: <, [, {, (
 
-  const extract = index => {
-    if (isNotNested(cDepth, fDepth, sDepth, tDepth)) {
-      result.push(type.substring(start, index).trim());
-      start = index + 1;
-    }
-  };
+  let c = 0;
+  let f = 0;
+  let s = 0;
+  let t = 0; // current start position
 
-  for (let index = 0; index < type.length; index++) {
-    switch (type[index]) {
+  let start = 0;
+
+  for (let i = 0; i < type.length; i++) {
+    switch (type[i]) {
       // if we are not nested, add the type
       case ',':
-        extract(index);
-        break;
+        {
+          if (!(c || f || s || t)) {
+            result.push(type.substring(start, i).trim());
+            start = i + 1;
+          }
+
+          break;
+        }
       // adjust compact/vec (and friends) depth
 
       case '<':
-        cDepth++;
+        c++;
         break;
 
       case '>':
-        cDepth--;
+        c--;
         break;
       // adjust fixed vec depths
 
       case '[':
-        fDepth++;
+        f++;
         break;
 
       case ']':
-        fDepth--;
+        f--;
         break;
       // adjust struct depth
 
       case '{':
-        sDepth++;
+        s++;
         break;
 
       case '}':
-        sDepth--;
+        s--;
         break;
       // adjust tuple depth
 
       case '(':
-        tDepth++;
+        t++;
         break;
 
       case ')':
-        tDepth--;
+        t--;
         break;
     }
-  }
+  } // ensure we have all the terminators taken care of
+
 
-  (0, _util.assert)(isNotNested(cDepth, fDepth, sDepth, tDepth), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
+  (0, _util.assert)(!(c || f || s || t), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
 
   result.push(type.substring(start, type.length).trim());
   return result;

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "8.8.2",
+  "version": "8.8.3-10",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -121,7 +121,7 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.18.3",
-    "@polkadot/types-codec": "8.8.2",
-    "@polkadot/util": "^9.4.1"
+    "@polkadot/types-codec": "8.8.3-10",
+    "@polkadot/util": "^9.4.2-22"
   }
 }

package/packageInfo.js

@@ -5,5 +5,5 @@ export const packageInfo = {
   name: '@polkadot/types-create',
   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.8.2'
+  version: '8.8.3-10'
 };

package/util/getTypeDef.d.ts

@@ -1,7 +1,8 @@
+import type { AnyString } from '@polkadot/types-codec/types';
 import type { TypeDef } from '@polkadot/types-create/types';
 interface TypeDefOptions {
     name?: string;
     displayName?: string;
 }
-export declare function getTypeDef(_type: String | string, { displayName, name }?: TypeDefOptions, count?: number): TypeDef;
+export declare function getTypeDef(_type: AnyString, { displayName, name }?: TypeDefOptions, count?: number): TypeDef;
 export {};

package/util/getTypeDef.js

@@ -5,6 +5,8 @@ import { assert, isNumber, isString, objectSpread } from '@polkadot/util';
 import { TypeDefInfo } from "../types/index.js";
 import { typeSplit } from "./typeSplit.js";
 const MAX_NESTED = 64;
+const MAX_FIX_LEN = 2048;
+const MAX_BIT_LEN = 8192;
 const KNOWN_INTERNALS = ['_alias', '_fallback'];
 
 function getTypeString(typeOrObj) {
@@ -98,21 +100,35 @@ function _decodeFixedVec(value, type, _, count) {
   let inner = 0;
 
   for (let i = 1; i < max && index === -1; i++) {
-    if (type[i] === ';' && inner === 0) {
-      index = i;
-    } else if (['[', '(', '<'].includes(type[i])) {
-      inner++;
-    } else if ([']', ')', '>'].includes(type[i])) {
-      inner--;
+    switch (type[i]) {
+      case ';':
+        {
+          if (inner === 0) {
+            index = i;
+          }
+
+          break;
+        }
+
+      case '[':
+      case '(':
+      case '<':
+        inner++;
+        break;
+
+      case ']':
+      case ')':
+      case '>':
+        inner--;
+        break;
     }
   }
 
   assert(index !== -1, () => `${type}: Unable to extract location of ';'`);
   const vecType = type.substring(1, index);
   const [strLength, displayName] = type.substring(index + 1, max).split(';');
-  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
-
-  assert(length <= 256, () => `${type}: Only support for [Type; <length>], where length <= 256`);
+  const length = parseInt(strLength.trim(), 10);
+  assert(length <= MAX_FIX_LEN, () => `${type}: Only support for [Type; <length>], where length <= ${MAX_FIX_LEN}`);
   value.displayName = displayName;
   value.length = length;
   value.sub = getTypeDef(vecType, {}, count);
@@ -129,9 +145,8 @@ function _decodeTuple(value, _, subType, count) {
 
 function _decodeAnyInt(value, type, _, clazz) {
   const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(',');
-  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
-
-  assert(length <= 8192 && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
+  const length = parseInt(strLength.trim(), 10);
+  assert(length <= MAX_BIT_LEN && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= ${MAX_BIT_LEN} and a power of 8, found ${length}`);
   value.displayName = displayName;
   value.length = length;
   return value;
@@ -162,8 +177,7 @@ const wrappedExtraction = [['BTreeSet<', '>', TypeDefInfo.BTreeSet], ['Compact<'
 
 function extractSubType(type, [start, end]) {
   return type.substring(start.length, type.length - end.length);
-} // eslint-disable-next-line @typescript-eslint/ban-types
-
+}
 
 export function getTypeDef(_type, {
   displayName,

package/util/typeSplit.js

@@ -1,69 +1,70 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert } from '@polkadot/util';
-
-function isNotNested(...counters) {
-  return !counters.some(counter => counter !== 0);
-} // safely split a string on ', ' while taking care of any nested occurences
-
+import { assert } from '@polkadot/util'; // safely split a string on ', ' while taking care of any nested occurences
 
 export function typeSplit(type) {
-  let [cDepth, fDepth, sDepth, tDepth, start] = [0, 0, 0, 0, 0];
-  const result = [];
+  const result = []; // these are the depths of the various tokens: <, [, {, (
 
-  const extract = index => {
-    if (isNotNested(cDepth, fDepth, sDepth, tDepth)) {
-      result.push(type.substring(start, index).trim());
-      start = index + 1;
-    }
-  };
+  let c = 0;
+  let f = 0;
+  let s = 0;
+  let t = 0; // current start position
+
+  let start = 0;
 
-  for (let index = 0; index < type.length; index++) {
-    switch (type[index]) {
+  for (let i = 0; i < type.length; i++) {
+    switch (type[i]) {
       // if we are not nested, add the type
       case ',':
-        extract(index);
-        break;
+        {
+          if (!(c || f || s || t)) {
+            result.push(type.substring(start, i).trim());
+            start = i + 1;
+          }
+
+          break;
+        }
       // adjust compact/vec (and friends) depth
 
       case '<':
-        cDepth++;
+        c++;
         break;
 
       case '>':
-        cDepth--;
+        c--;
         break;
       // adjust fixed vec depths
 
       case '[':
-        fDepth++;
+        f++;
         break;
 
       case ']':
-        fDepth--;
+        f--;
         break;
       // adjust struct depth
 
       case '{':
-        sDepth++;
+        s++;
         break;
 
       case '}':
-        sDepth--;
+        s--;
         break;
       // adjust tuple depth
 
       case '(':
-        tDepth++;
+        t++;
         break;
 
       case ')':
-        tDepth--;
+        t--;
         break;
     }
-  }
+  } // ensure we have all the terminators taken care of
+
 
-  assert(isNotNested(cDepth, fDepth, sDepth, tDepth), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
+  assert(!(c || f || s || t), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
 
   result.push(type.substring(start, type.length).trim());
   return result;