@polkadot/types-create 9.14.2 → 10.0.1

package/cjs/util/getTypeDef.js

@@ -1,220 +1,196 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getTypeDef = getTypeDef;
-var _typesCodec = require("@polkadot/types-codec");
-var _util = require("@polkadot/util");
-var _types = require("../types");
-var _typeSplit = require("./typeSplit");
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeDef = void 0;
+const types_codec_1 = require("@polkadot/types-codec");
+const util_1 = require("@polkadot/util");
+const types_1 = require("../types");
+const typeSplit_1 = require("./typeSplit");
 const KNOWN_INTERNALS = ['_alias', '_fallback'];
 function getTypeString(typeOrObj) {
-  return (0, _util.isString)(typeOrObj) ? typeOrObj.toString() : JSON.stringify(typeOrObj);
+    return (0, util_1.isString)(typeOrObj)
+        ? typeOrObj.toString()
+        : JSON.stringify(typeOrObj);
 }
 function isRustEnum(details) {
-  const values = Object.values(details);
-  if (values.some(v => (0, _util.isNumber)(v))) {
-    if (!values.every(v => (0, _util.isNumber)(v) && v >= 0 && v <= 255)) {
-      throw new Error('Invalid number-indexed enum definition');
+    const values = Object.values(details);
+    if (values.some((v) => (0, util_1.isNumber)(v))) {
+        if (!values.every((v) => (0, util_1.isNumber)(v) && v >= 0 && v <= 255)) {
+            throw new Error('Invalid number-indexed enum definition');
+        }
+        return false;
     }
-    return false;
-  }
-  return true;
+    return true;
 }
-
-// decode an enum of either of the following forms
-//  { _enum: ['A', 'B', 'C'] }
-//  { _enum: { A: AccountId, B: Balance, C: u32 } }
-//  { _enum: { A: 1, B: 2 } }
 function _decodeEnum(value, details, count, fallbackType) {
-  value.info = _types.TypeDefInfo.Enum;
-  value.fallbackType = fallbackType;
-
-  // not as pretty, but remain compatible with oo7 for both struct and Array types
-  if (Array.isArray(details)) {
-    value.sub = details.map((name, index) => ({
-      index,
-      info: _types.TypeDefInfo.Plain,
-      name,
-      type: 'Null'
-    }));
-  } else if (isRustEnum(details)) {
-    value.sub = Object.entries(details).map((_ref, index) => {
-      let [name, typeOrObj] = _ref;
-      return (0, _util.objectSpread)({}, getTypeDef(getTypeString(typeOrObj || 'Null'), {
-        name
-      }, count), {
-        index
-      });
-    });
-  } else {
-    value.sub = Object.entries(details).map(_ref2 => {
-      let [name, index] = _ref2;
-      return {
+    value.info = types_1.TypeDefInfo.Enum;
+    value.fallbackType = fallbackType;
+    // not as pretty, but remain compatible with oo7 for both struct and Array types
+    if (Array.isArray(details)) {
+        value.sub = details.map((name, index) => ({
+            index,
+            info: types_1.TypeDefInfo.Plain,
+            name,
+            type: 'Null'
+        }));
+    }
+    else if (isRustEnum(details)) {
+        value.sub = Object.entries(details).map(([name, typeOrObj], index) => (0, util_1.objectSpread)({}, getTypeDef(getTypeString(typeOrObj || 'Null'), { name }, count), { index }));
+    }
+    else {
+        value.sub = Object.entries(details).map(([name, index]) => ({
+            index,
+            info: types_1.TypeDefInfo.Plain,
+            name,
+            type: 'Null'
+        }));
+    }
+    return value;
+}
+function _decodeSet(value, details, fallbackType) {
+    value.info = types_1.TypeDefInfo.Set;
+    value.fallbackType = fallbackType;
+    value.length = details._bitLength;
+    value.sub = Object
+        .entries(details)
+        .filter(([name]) => !name.startsWith('_'))
+        .map(([name, index]) => ({
         index,
-        info: _types.TypeDefInfo.Plain,
+        info: types_1.TypeDefInfo.Plain,
         name,
         type: 'Null'
-      };
-    });
-  }
-  return value;
-}
-
-// decode a set of the form
-//   { _set: { A: 0b0001, B: 0b0010, C: 0b0100 } }
-function _decodeSet(value, details, fallbackType) {
-  value.info = _types.TypeDefInfo.Set;
-  value.fallbackType = fallbackType;
-  value.length = details._bitLength;
-  value.sub = Object.entries(details).filter(_ref3 => {
-    let [name] = _ref3;
-    return !name.startsWith('_');
-  }).map(_ref4 => {
-    let [name, index] = _ref4;
-    return {
-      index,
-      info: _types.TypeDefInfo.Plain,
-      name,
-      type: 'Null'
-    };
-  });
-  return value;
+    }));
+    return value;
 }
-
-// decode a struct, set or enum
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeStruct(value, type, _, count) {
-  const parsed = JSON.parse(type);
-  const keys = Object.keys(parsed);
-  if (keys.includes('_enum')) {
-    return _decodeEnum(value, parsed._enum, count, parsed._fallback);
-  } else if (keys.includes('_set')) {
-    return _decodeSet(value, parsed._set, parsed._fallback);
-  }
-  value.alias = parsed._alias ? new Map(Object.entries(parsed._alias)) : undefined;
-  value.fallbackType = parsed._fallback;
-  value.sub = keys.filter(name => !KNOWN_INTERNALS.includes(name)).map(name => getTypeDef(getTypeString(parsed[name]), {
-    name
-  }, count));
-  return value;
+    const parsed = JSON.parse(type);
+    const keys = Object.keys(parsed);
+    if (keys.includes('_enum')) {
+        return _decodeEnum(value, parsed._enum, count, parsed._fallback);
+    }
+    else if (keys.includes('_set')) {
+        return _decodeSet(value, parsed._set, parsed._fallback);
+    }
+    value.alias = parsed._alias
+        ? new Map(Object.entries(parsed._alias))
+        : undefined;
+    value.fallbackType = parsed._fallback;
+    value.sub = keys
+        .filter((name) => !KNOWN_INTERNALS.includes(name))
+        .map((name) => getTypeDef(getTypeString(parsed[name]), { name }, count));
+    return value;
 }
-
-// decode a fixed vector, e.g. [u8;32]
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeFixedVec(value, type, _, count) {
-  const max = type.length - 1;
-  let index = -1;
-  let inner = 0;
-  for (let i = 1; i < max && index === -1; i++) {
-    switch (type[i]) {
-      case ';':
-        {
-          if (inner === 0) {
-            index = i;
-          }
-          break;
+    const max = type.length - 1;
+    let index = -1;
+    let inner = 0;
+    for (let i = 1; (i < max) && (index === -1); i++) {
+        switch (type[i]) {
+            case ';': {
+                if (inner === 0) {
+                    index = i;
+                }
+                break;
+            }
+            case '[':
+            case '(':
+            case '<':
+                inner++;
+                break;
+            case ']':
+            case ')':
+            case '>':
+                inner--;
+                break;
         }
-      case '[':
-      case '(':
-      case '<':
-        inner++;
-        break;
-      case ']':
-      case ')':
-      case '>':
-        inner--;
-        break;
     }
-  }
-  if (index === -1) {
-    throw new Error(`${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);
-  if (length > 2048) {
-    throw new Error(`${type}: Only support for [Type; <length>], where length <= 2048`);
-  }
-  value.displayName = displayName;
-  value.length = length;
-  value.sub = getTypeDef(vecType, {}, count);
-  return value;
+    if (index === -1) {
+        throw new Error(`${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);
+    if (length > 2048) {
+        throw new Error(`${type}: Only support for [Type; <length>], where length <= 2048`);
+    }
+    value.displayName = displayName;
+    value.length = length;
+    value.sub = getTypeDef(vecType, {}, count);
+    return value;
 }
-
-// decode a tuple
 function _decodeTuple(value, _, subType, count) {
-  value.sub = subType.length === 0 ? [] : (0, _typeSplit.typeSplit)(subType).map(inner => getTypeDef(inner, {}, count));
-  return value;
+    value.sub = subType.length === 0
+        ? []
+        : (0, typeSplit_1.typeSplit)(subType).map((inner) => getTypeDef(inner, {}, count));
+    return value;
 }
-
-// decode a Int/UInt<bitLength[, name]>
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeAnyInt(value, type, _, clazz) {
-  const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(',');
-  const length = parseInt(strLength.trim(), 10);
-  if (length > 8192 || length % 8) {
-    throw new Error(`${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
-  }
-  value.displayName = displayName;
-  value.length = length;
-  return value;
+    const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(',');
+    const length = parseInt(strLength.trim(), 10);
+    if ((length > 8192) || (length % 8)) {
+        throw new Error(`${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
+    }
+    value.displayName = displayName;
+    value.length = length;
+    return value;
 }
 function _decodeInt(value, type, subType) {
-  return _decodeAnyInt(value, type, subType, 'Int');
+    return _decodeAnyInt(value, type, subType, 'Int');
 }
 function _decodeUInt(value, type, subType) {
-  return _decodeAnyInt(value, type, subType, 'UInt');
+    return _decodeAnyInt(value, type, subType, 'UInt');
 }
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeDoNotConstruct(value, type, _) {
-  const NAME_LENGTH = 'DoNotConstruct'.length;
-  value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
-  return value;
+    const NAME_LENGTH = 'DoNotConstruct'.length;
+    value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
+    return value;
 }
-function hasWrapper(type, _ref5) {
-  let [start, end] = _ref5;
-  return type.substring(0, start.length) === start && type.slice(-1 * end.length) === end;
+function hasWrapper(type, [start, end]) {
+    return (type.substring(0, start.length) === start) && (type.slice(-1 * end.length) === end);
 }
-const nestedExtraction = [['[', ']', _types.TypeDefInfo.VecFixed, _decodeFixedVec], ['{', '}', _types.TypeDefInfo.Struct, _decodeStruct], ['(', ')', _types.TypeDefInfo.Tuple, _decodeTuple],
-// the inner for these are the same as tuple, multiple values
-['BTreeMap<', '>', _types.TypeDefInfo.BTreeMap, _decodeTuple], ['HashMap<', '>', _types.TypeDefInfo.HashMap, _decodeTuple], ['Int<', '>', _types.TypeDefInfo.Int, _decodeInt], ['Result<', '>', _types.TypeDefInfo.Result, _decodeTuple], ['UInt<', '>', _types.TypeDefInfo.UInt, _decodeUInt], ['DoNotConstruct<', '>', _types.TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]];
-const wrappedExtraction = [['BTreeSet<', '>', _types.TypeDefInfo.BTreeSet], ['Compact<', '>', _types.TypeDefInfo.Compact], ['Linkage<', '>', _types.TypeDefInfo.Linkage], ['Opaque<', '>', _types.TypeDefInfo.WrapperOpaque], ['Option<', '>', _types.TypeDefInfo.Option], ['Range<', '>', _types.TypeDefInfo.Range], ['RangeInclusive<', '>', _types.TypeDefInfo.RangeInclusive], ['Vec<', '>', _types.TypeDefInfo.Vec], ['WrapperKeepOpaque<', '>', _types.TypeDefInfo.WrapperKeepOpaque], ['WrapperOpaque<', '>', _types.TypeDefInfo.WrapperOpaque]];
-function extractSubType(type, _ref6) {
-  let [start, end] = _ref6;
-  return type.substring(start.length, type.length - end.length);
+const nestedExtraction = [
+    ['[', ']', types_1.TypeDefInfo.VecFixed, _decodeFixedVec],
+    ['{', '}', types_1.TypeDefInfo.Struct, _decodeStruct],
+    ['(', ')', types_1.TypeDefInfo.Tuple, _decodeTuple],
+    // the inner for these are the same as tuple, multiple values
+    ['BTreeMap<', '>', types_1.TypeDefInfo.BTreeMap, _decodeTuple],
+    ['HashMap<', '>', types_1.TypeDefInfo.HashMap, _decodeTuple],
+    ['Int<', '>', types_1.TypeDefInfo.Int, _decodeInt],
+    ['Result<', '>', types_1.TypeDefInfo.Result, _decodeTuple],
+    ['UInt<', '>', types_1.TypeDefInfo.UInt, _decodeUInt],
+    ['DoNotConstruct<', '>', types_1.TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]
+];
+const wrappedExtraction = [
+    ['BTreeSet<', '>', types_1.TypeDefInfo.BTreeSet],
+    ['Compact<', '>', types_1.TypeDefInfo.Compact],
+    ['Linkage<', '>', types_1.TypeDefInfo.Linkage],
+    ['Opaque<', '>', types_1.TypeDefInfo.WrapperOpaque],
+    ['Option<', '>', types_1.TypeDefInfo.Option],
+    ['Range<', '>', types_1.TypeDefInfo.Range],
+    ['RangeInclusive<', '>', types_1.TypeDefInfo.RangeInclusive],
+    ['Vec<', '>', types_1.TypeDefInfo.Vec],
+    ['WrapperKeepOpaque<', '>', types_1.TypeDefInfo.WrapperKeepOpaque],
+    ['WrapperOpaque<', '>', types_1.TypeDefInfo.WrapperOpaque]
+];
+function extractSubType(type, [start, end]) {
+    return type.substring(start.length, type.length - end.length);
+}
+function getTypeDef(_type, { displayName, name } = {}, count = 0) {
+    // create the type via Type, allowing types to be sanitized
+    const type = (0, types_codec_1.sanitize)(_type);
+    const value = { displayName, info: types_1.TypeDefInfo.Plain, name, type };
+    if (++count > 64) {
+        throw new Error('getTypeDef: Maximum nested limit reached');
+    }
+    const nested = nestedExtraction.find((nested) => hasWrapper(type, nested));
+    if (nested) {
+        value.info = nested[2];
+        return nested[3](value, type, extractSubType(type, nested), count);
+    }
+    const wrapped = wrappedExtraction.find((wrapped) => hasWrapper(type, wrapped));
+    if (wrapped) {
+        value.info = wrapped[2];
+        value.sub = getTypeDef(extractSubType(type, wrapped), {}, count);
+    }
+    return value;
 }
-function getTypeDef(_type) {
-  let {
-    displayName,
-    name
-  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  let count = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  // create the type via Type, allowing types to be sanitized
-  const type = (0, _typesCodec.sanitize)(_type);
-  const value = {
-    displayName,
-    info: _types.TypeDefInfo.Plain,
-    name,
-    type
-  };
-  if (++count > 64) {
-    throw new Error('getTypeDef: Maximum nested limit reached');
-  }
-  const nested = nestedExtraction.find(nested => hasWrapper(type, nested));
-  if (nested) {
-    value.info = nested[2];
-    return nested[3](value, type, extractSubType(type, nested), count);
-  }
-  const wrapped = wrappedExtraction.find(wrapped => hasWrapper(type, wrapped));
-  if (wrapped) {
-    value.info = wrapped[2];
-    value.sub = getTypeDef(extractSubType(type, wrapped), {}, count);
-  }
-  return value;
-}
+exports.getTypeDef = getTypeDef;

package/cjs/util/index.js

@@ -1,49 +1,7 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _encodeTypes = require("./encodeTypes");
-Object.keys(_encodeTypes).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _encodeTypes[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _encodeTypes[key];
-    }
-  });
-});
-var _getTypeDef = require("./getTypeDef");
-Object.keys(_getTypeDef).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _getTypeDef[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _getTypeDef[key];
-    }
-  });
-});
-var _typeSplit = require("./typeSplit");
-Object.keys(_typeSplit).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _typeSplit[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _typeSplit[key];
-    }
-  });
-});
-var _xcm = require("./xcm");
-Object.keys(_xcm).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _xcm[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _xcm[key];
-    }
-  });
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./encodeTypes"), exports);
+tslib_1.__exportStar(require("./getTypeDef"), exports);
+tslib_1.__exportStar(require("./typeSplit"), exports);
+tslib_1.__exportStar(require("./xcm"), exports);

package/cjs/util/typeSplit.js

@@ -1,76 +1,61 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.typeSplit = typeSplit;
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// safely split a string on ', ' while taking care of any nested occurences
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeSplit = void 0;
 function typeSplit(type) {
-  const result = [];
-
-  // these are the depths of the various tokens: <, [, {, (
-  let c = 0;
-  let f = 0;
-  let s = 0;
-  let t = 0;
-
-  // current start position
-  let start = 0;
-  for (let i = 0; i < type.length; i++) {
-    switch (type[i]) {
-      // if we are not nested, add the type
-      case ',':
-        {
-          if (!(c || f || s || t)) {
-            result.push(type.substring(start, i).trim());
-            start = i + 1;
-          }
-          break;
+    const result = [];
+    // these are the depths of the various tokens: <, [, {, (
+    let c = 0;
+    let f = 0;
+    let s = 0;
+    let t = 0;
+    // current start position
+    let start = 0;
+    for (let i = 0; i < type.length; i++) {
+        switch (type[i]) {
+            // if we are not nested, add the type
+            case ',': {
+                if (!(c || f || s || t)) {
+                    result.push(type.substring(start, i).trim());
+                    start = i + 1;
+                }
+                break;
+            }
+            // adjust compact/vec (and friends) depth
+            case '<':
+                c++;
+                break;
+            case '>':
+                c--;
+                break;
+            // adjust fixed vec depths
+            case '[':
+                f++;
+                break;
+            case ']':
+                f--;
+                break;
+            // adjust struct depth
+            case '{':
+                s++;
+                break;
+            case '}':
+                s--;
+                break;
+            // adjust tuple depth
+            case '(':
+                t++;
+                break;
+            case ')':
+                t--;
+                break;
         }
-
-      // adjust compact/vec (and friends) depth
-      case '<':
-        c++;
-        break;
-      case '>':
-        c--;
-        break;
-
-      // adjust fixed vec depths
-      case '[':
-        f++;
-        break;
-      case ']':
-        f--;
-        break;
-
-      // adjust struct depth
-      case '{':
-        s++;
-        break;
-      case '}':
-        s--;
-        break;
-
-      // adjust tuple depth
-      case '(':
-        t++;
-        break;
-      case ')':
-        t--;
-        break;
     }
-  }
-
-  // ensure we have all the terminators taken care of
-  if (c || f || s || t) {
-    throw new Error(`Invalid definition (missing terminators) found in ${type}`);
-  }
-
-  // the final leg of the journey
-  result.push(type.substring(start, type.length).trim());
-  return result;
-}
+    // ensure we have all the terminators taken care of
+    if (c || f || s || t) {
+        throw new Error(`Invalid definition (missing terminators) found in ${type}`);
+    }
+    // the final leg of the journey
+    result.push(type.substring(start, type.length).trim());
+    return result;
+}
+exports.typeSplit = typeSplit;

package/cjs/util/xcm.js

@@ -1,18 +1,9 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.XCM_MAPPINGS = void 0;
-exports.mapXcmTypes = mapXcmTypes;
-var _util = require("@polkadot/util");
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-const XCM_MAPPINGS = ['AssetInstance', 'Fungibility', 'Junction', 'Junctions', 'MultiAsset', 'MultiAssetFilter', 'MultiLocation', 'Response', 'WildFungibility', 'WildMultiAsset', 'Xcm', 'XcmError', 'XcmOrder'];
-exports.XCM_MAPPINGS = XCM_MAPPINGS;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapXcmTypes = exports.XCM_MAPPINGS = void 0;
+const util_1 = require("@polkadot/util");
+exports.XCM_MAPPINGS = ['AssetInstance', 'Fungibility', 'Junction', 'Junctions', 'MultiAsset', 'MultiAssetFilter', 'MultiLocation', 'Response', 'WildFungibility', 'WildMultiAsset', 'Xcm', 'XcmError', 'XcmOrder'];
 function mapXcmTypes(version) {
-  return XCM_MAPPINGS.reduce((all, key) => (0, _util.objectSpread)(all, {
-    [key]: `${key}${version}`
-  }), {});
-}
+    return exports.XCM_MAPPINGS.reduce((all, key) => (0, util_1.objectSpread)(all, { [key]: `${key}${version}` }), {});
+}
+exports.mapXcmTypes = mapXcmTypes;