@pezkuwi/types-create 16.5.8 → 16.5.10

package/build-tsc-esm/create/class.js

@@ -1,160 +0,0 @@
-import { BTreeMap, BTreeSet, Bytes, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Null, Option, Range, RangeInclusive, Result, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@pezkuwi/types-codec';
-import { isNumber, stringify } from '@pezkuwi/util';
-import { TypeDefInfo } from '../types/index.js';
-import { getTypeDef } from '../util/getTypeDef.js';
-function getTypeDefType({ lookupName, type }) {
-    return lookupName || type;
-}
-function getSubDefArray(value) {
-    if (!Array.isArray(value.sub)) {
-        throw new Error(`Expected subtype as TypeDef[] in ${stringify(value)}`);
-    }
-    return value.sub;
-}
-function getSubDef(value) {
-    if (!value.sub || Array.isArray(value.sub)) {
-        throw new Error(`Expected subtype as TypeDef in ${stringify(value)}`);
-    }
-    return value.sub;
-}
-function getSubType(value) {
-    return getTypeDefType(getSubDef(value));
-}
-function getTypeClassMap(value) {
-    const subs = getSubDefArray(value);
-    const map = {};
-    for (let i = 0, count = subs.length; i < count; i++) {
-        const sub = subs[i];
-        if (!sub.name) {
-            throw new Error(`No name found in definition ${stringify(sub)}`);
-        }
-        map[sub.name] = getTypeDefType(sub);
-    }
-    return map;
-}
-function getTypeClassArray(value) {
-    return getSubDefArray(value).map(getTypeDefType);
-}
-function createInt(Clazz, { displayName, length }) {
-    if (!isNumber(length)) {
-        throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
-    }
-    return Clazz.with(length, displayName);
-}
-function createHashMap(Clazz, value) {
-    const [keyType, valueType] = getTypeClassArray(value);
-    return Clazz.with(keyType, valueType);
-}
-function createWithSub(Clazz, value) {
-    return Clazz.with(getSubType(value));
-}
-const infoMapping = {
-    [TypeDefInfo.BTreeMap]: (_registry, value) => createHashMap(BTreeMap, value),
-    [TypeDefInfo.BTreeSet]: (_registry, value) => createWithSub(BTreeSet, value),
-    [TypeDefInfo.Compact]: (_registry, value) => createWithSub(Compact, value),
-    [TypeDefInfo.DoNotConstruct]: (_registry, value) => DoNotConstruct.with(value.displayName || value.type),
-    [TypeDefInfo.Enum]: (_registry, value) => {
-        const subs = getSubDefArray(value);
-        return Enum.with(subs.every(({ type }) => type === 'Null')
-            ? subs.reduce((out, { index, name }, count) => {
-                if (!name) {
-                    throw new Error('No name found in sub definition');
-                }
-                out[name] = index || count;
-                return out;
-            }, {})
-            : getTypeClassMap(value));
-    },
-    [TypeDefInfo.HashMap]: (_registry, value) => createHashMap(HashMap, value),
-    [TypeDefInfo.Int]: (_registry, value) => createInt(Int, value),
-    // We have circular deps between Linkage & Struct
-    [TypeDefInfo.Linkage]: (_registry, value) => {
-        const type = `Option<${getSubType(value)}>`;
-        // eslint-disable-next-line sort-keys
-        const Clazz = Struct.with({ previous: type, next: type });
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        Clazz.prototype.toRawType = function () {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
-            return `Linkage<${this.next.toRawType(true)}>`;
-        };
-        return Clazz;
-    },
-    [TypeDefInfo.Null]: (_registry, _value) => Null,
-    [TypeDefInfo.Option]: (_registry, value) => {
-        if (!value.sub || Array.isArray(value.sub)) {
-            throw new Error('Expected type information for Option');
-        }
-        // NOTE This is opt-in (unhandled), not by default
-        // if (value.sub.type === 'bool') {
-        //   return OptionBool;
-        // }
-        return createWithSub(Option, value);
-    },
-    [TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
-    [TypeDefInfo.Range]: (_registry, value) => createWithSub(Range, value),
-    [TypeDefInfo.RangeInclusive]: (_registry, value) => createWithSub(RangeInclusive, value),
-    [TypeDefInfo.Result]: (_registry, value) => {
-        const [Ok, Err] = getTypeClassArray(value);
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return Result.with({ Err, Ok });
-    },
-    [TypeDefInfo.Set]: (_registry, value) => CodecSet.with(getSubDefArray(value).reduce((result, { index, name }) => {
-        if (!name || !isNumber(index)) {
-            throw new Error('No name found in sub definition');
-        }
-        result[name] = index;
-        return result;
-    }, {}), value.length),
-    [TypeDefInfo.Si]: (registry, value) => getTypeClass(registry, registry.lookup.getTypeDef(value.type)),
-    [TypeDefInfo.Struct]: (_registry, value) => Struct.with(getTypeClassMap(value), value.alias),
-    [TypeDefInfo.Tuple]: (_registry, value) => Tuple.with(getTypeClassArray(value)),
-    [TypeDefInfo.UInt]: (_registry, value) => createInt(UInt, value),
-    [TypeDefInfo.Vec]: (_registry, { sub }) => {
-        if (!sub || Array.isArray(sub)) {
-            throw new Error('Expected type information for vector');
-        }
-        return (sub.type === 'u8'
-            ? Bytes
-            : Vec.with(getTypeDefType(sub)));
-    },
-    [TypeDefInfo.VecFixed]: (_registry, { displayName, length, sub }) => {
-        if (!isNumber(length) || !sub || Array.isArray(sub)) {
-            throw new Error('Expected length & type information for fixed vector');
-        }
-        return (sub.type === 'u8'
-            ? U8aFixed.with((length * 8), displayName)
-            : VecFixed.with(getTypeDefType(sub), length));
-    },
-    [TypeDefInfo.WrapperKeepOpaque]: (_registry, value) => createWithSub(WrapperKeepOpaque, value),
-    [TypeDefInfo.WrapperOpaque]: (_registry, value) => createWithSub(WrapperOpaque, value)
-};
-export function constructTypeClass(registry, typeDef) {
-    try {
-        const Type = infoMapping[typeDef.info](registry, typeDef);
-        if (!Type) {
-            throw new Error('No class created');
-        }
-        // don't clobber any existing
-        if (!Type.__fallbackType && typeDef.fallbackType) {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore ...this is the only place we we actually assign this...
-            Type.__fallbackType = typeDef.fallbackType;
-        }
-        return Type;
-    }
-    catch (error) {
-        throw new Error(`Unable to construct class from ${stringify(typeDef)}: ${error.message}`);
-    }
-}
-export function getTypeClass(registry, typeDef) {
-    return registry.getUnsafe(typeDef.type, false, typeDef);
-}
-export function createClassUnsafe(registry, type) {
-    return (
-    // just retrieve via name, no creation via typeDef
-    registry.getUnsafe(type) ||
-        // we don't have an existing type, create the class via typeDef
-        getTypeClass(registry, registry.isLookupType(type)
-            ? registry.lookup.getTypeDef(type)
-            : getTypeDef(type)));
-}

package/build-tsc-esm/create/index.js

@@ -1,2 +0,0 @@
-export * from './class.js';
-export * from './type.js';

package/build-tsc-esm/create/type.js

@@ -1,63 +0,0 @@
-import { Option } from '@pezkuwi/types-codec';
-import { isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-import { createClassUnsafe } from './class.js';
-function checkInstance(created, matcher) {
-    const u8a = created.toU8a();
-    const rawType = created.toRawType();
-    const isOk = (
-    // full match, all ok
-    u8aEq(u8a, matcher) ||
-        (
-        // on a length-prefixed type, just check the actual length
-        ['Bytes', 'Text', 'Type'].includes(rawType) &&
-            matcher.length === created.length) ||
-        (
-        // when the created is empty and matcher is also empty, let it slide...
-        created.isEmpty &&
-            matcher.every((v) => !v)));
-    if (!isOk) {
-        throw new Error(`${rawType}:: Decoded input doesn't match input, received ${u8aToHex(matcher, 512)} (${matcher.length} bytes), created ${u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
-    }
-}
-function checkPedantic(created, [value]) {
-    if (isU8a(value)) {
-        checkInstance(created, value);
-    }
-    else if (isHex(value)) {
-        checkInstance(created, u8aToU8a(value));
-    }
-}
-function initType(registry, Type, params = [], { blockHash, isFallback, isOptional, isPedantic } = {}) {
-    const created = new (isOptional
-        ? Option.with(Type)
-        : Type)(registry, ...params);
-    isPedantic && checkPedantic(created, params);
-    if (blockHash) {
-        created.createdAtHash = createTypeUnsafe(registry, 'BlockHash', [blockHash]);
-    }
-    if (isFallback) {
-        created.isStorageFallback = true;
-    }
-    return created;
-}
-export function createTypeUnsafe(registry, type, params = [], options = {}) {
-    let Clazz = null;
-    let firstError = null;
-    try {
-        Clazz = createClassUnsafe(registry, type);
-        return initType(registry, Clazz, params, options);
-    }
-    catch (error) {
-        firstError = new Error(`createType(${type}):: ${error.message}`);
-    }
-    if (Clazz?.__fallbackType) {
-        try {
-            Clazz = createClassUnsafe(registry, Clazz.__fallbackType);
-            return initType(registry, Clazz, params, options);
-        }
-        catch {
-            // swallow, we will throw the first error again
-        }
-    }
-    throw firstError;
-}

package/build-tsc-esm/exports.js

@@ -1,2 +0,0 @@
-export * from './create/index.js';
-export * from './util/index.js';

package/build-tsc-esm/index.js

@@ -1,2 +0,0 @@
-import './packageDetect.js';
-export * from './bundle.js';

package/build-tsc-esm/packageDetect.js

@@ -1,4 +0,0 @@
-import { packageInfo as codecInfo } from '@pezkuwi/types-codec/packageInfo';
-import { detectPackage } from '@pezkuwi/util';
-import { packageInfo } from './packageInfo.js';
-detectPackage(packageInfo, null, [codecInfo]);

package/build-tsc-esm/packageInfo.js

@@ -1 +0,0 @@
-export const packageInfo = { name: '@pezkuwi/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: '16.5.8' };

package/build-tsc-esm/types/augmentRegistry.js

@@ -1 +0,0 @@
-import '@pezkuwi/types-codec/types/registry';

package/build-tsc-esm/types/index.js

@@ -1,3 +0,0 @@
-import './augmentRegistry.js';
-export * from './lookup.js';
-export * from './types.js';

package/build-tsc-esm/types/lookup.js

@@ -1 +0,0 @@
-export {};

package/build-tsc-esm/types/types.js

@@ -1,26 +0,0 @@
-export var TypeDefInfo;
-(function (TypeDefInfo) {
-    TypeDefInfo[TypeDefInfo["BTreeMap"] = 0] = "BTreeMap";
-    TypeDefInfo[TypeDefInfo["BTreeSet"] = 1] = "BTreeSet";
-    TypeDefInfo[TypeDefInfo["Compact"] = 2] = "Compact";
-    TypeDefInfo[TypeDefInfo["DoNotConstruct"] = 3] = "DoNotConstruct";
-    TypeDefInfo[TypeDefInfo["Enum"] = 4] = "Enum";
-    TypeDefInfo[TypeDefInfo["HashMap"] = 5] = "HashMap";
-    TypeDefInfo[TypeDefInfo["Int"] = 6] = "Int";
-    TypeDefInfo[TypeDefInfo["Linkage"] = 7] = "Linkage";
-    TypeDefInfo[TypeDefInfo["Null"] = 8] = "Null";
-    TypeDefInfo[TypeDefInfo["Option"] = 9] = "Option";
-    TypeDefInfo[TypeDefInfo["Plain"] = 10] = "Plain";
-    TypeDefInfo[TypeDefInfo["Range"] = 11] = "Range";
-    TypeDefInfo[TypeDefInfo["RangeInclusive"] = 12] = "RangeInclusive";
-    TypeDefInfo[TypeDefInfo["Result"] = 13] = "Result";
-    TypeDefInfo[TypeDefInfo["Set"] = 14] = "Set";
-    TypeDefInfo[TypeDefInfo["Si"] = 15] = "Si";
-    TypeDefInfo[TypeDefInfo["Struct"] = 16] = "Struct";
-    TypeDefInfo[TypeDefInfo["Tuple"] = 17] = "Tuple";
-    TypeDefInfo[TypeDefInfo["UInt"] = 18] = "UInt";
-    TypeDefInfo[TypeDefInfo["Vec"] = 19] = "Vec";
-    TypeDefInfo[TypeDefInfo["VecFixed"] = 20] = "VecFixed";
-    TypeDefInfo[TypeDefInfo["WrapperKeepOpaque"] = 21] = "WrapperKeepOpaque";
-    TypeDefInfo[TypeDefInfo["WrapperOpaque"] = 22] = "WrapperOpaque";
-})(TypeDefInfo || (TypeDefInfo = {}));

package/build-tsc-esm/util/encodeTypes.js

@@ -1,123 +0,0 @@
-import { isNumber, isUndefined, objectSpread, stringify } from '@pezkuwi/util';
-import { TypeDefInfo } from '../types/index.js';
-const stringIdentity = (value) => value.toString();
-const INFO_WRAP = ['BTreeMap', 'BTreeSet', 'Compact', 'HashMap', 'Option', 'Result', 'Vec'];
-export function paramsNotation(outer, inner, transform = stringIdentity) {
-    return `${outer}${inner
-        ? `<${(Array.isArray(inner) ? inner : [inner]).map(transform).join(', ')}>`
-        : ''}`;
-}
-function encodeWithParams(registry, typeDef, outer) {
-    const { info, sub } = typeDef;
-    switch (info) {
-        case TypeDefInfo.BTreeMap:
-        case TypeDefInfo.BTreeSet:
-        case TypeDefInfo.Compact:
-        case TypeDefInfo.HashMap:
-        case TypeDefInfo.Linkage:
-        case TypeDefInfo.Option:
-        case TypeDefInfo.Range:
-        case TypeDefInfo.RangeInclusive:
-        case TypeDefInfo.Result:
-        case TypeDefInfo.Vec:
-        case TypeDefInfo.WrapperKeepOpaque:
-        case TypeDefInfo.WrapperOpaque:
-            return paramsNotation(outer, sub, (p) => encodeTypeDef(registry, p));
-    }
-    throw new Error(`Unable to encode ${stringify(typeDef)} with params`);
-}
-function encodeSubTypes(registry, sub, asEnum, extra) {
-    const names = sub.map(({ name }) => name);
-    if (!names.every((n) => !!n)) {
-        throw new Error(`Subtypes does not have consistent names, ${names.join(', ')}`);
-    }
-    const inner = objectSpread({}, extra);
-    for (let i = 0, count = sub.length; i < count; i++) {
-        const def = sub[i];
-        if (!def.name) {
-            throw new Error(`No name found in ${stringify(def)}`);
-        }
-        inner[def.name] = encodeTypeDef(registry, def);
-    }
-    return stringify(asEnum
-        ? { _enum: inner }
-        : inner);
-}
-const encoders = {
-    [TypeDefInfo.BTreeMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeMap'),
-    [TypeDefInfo.BTreeSet]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeSet'),
-    [TypeDefInfo.Compact]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Compact'),
-    [TypeDefInfo.DoNotConstruct]: (registry, { displayName, lookupIndex, lookupName }) => `DoNotConstruct<${lookupName || displayName || (isUndefined(lookupIndex) ? 'Unknown' : registry.createLookupType(lookupIndex))}>`,
-    [TypeDefInfo.Enum]: (registry, { sub }) => {
-        if (!Array.isArray(sub)) {
-            throw new Error('Unable to encode Enum type');
-        }
-        // c-like enums have all Null entries
-        // TODO We need to take the disciminant into account and auto-add empty entries
-        return sub.every(({ type }) => type === 'Null')
-            ? stringify({ _enum: sub.map(({ name }, index) => `${name || `Empty${index}`}`) })
-            : encodeSubTypes(registry, sub, true);
-    },
-    [TypeDefInfo.HashMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'HashMap'),
-    [TypeDefInfo.Int]: (_registry, { length = 32 }) => `Int<${length}>`,
-    [TypeDefInfo.Linkage]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Linkage'),
-    [TypeDefInfo.Null]: (_registry, _typeDef) => 'Null',
-    [TypeDefInfo.Option]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Option'),
-    [TypeDefInfo.Plain]: (_registry, { displayName, type }) => displayName || type,
-    [TypeDefInfo.Range]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Range'),
-    [TypeDefInfo.RangeInclusive]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'RangeInclusive'),
-    [TypeDefInfo.Result]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Result'),
-    [TypeDefInfo.Set]: (_registry, { length = 8, sub }) => {
-        if (!Array.isArray(sub)) {
-            throw new Error('Unable to encode Set type');
-        }
-        return stringify({
-            _set: sub.reduce((all, { index, name }, count) => objectSpread(all, { [`${name || `Unknown${index || count}`}`]: index || count }), { _bitLength: length || 8 })
-        });
-    },
-    [TypeDefInfo.Si]: (_registry, { lookupName, type }) => lookupName || type,
-    [TypeDefInfo.Struct]: (registry, { alias, sub }) => {
-        if (!Array.isArray(sub)) {
-            throw new Error('Unable to encode Struct type');
-        }
-        return encodeSubTypes(registry, sub, false, alias
-            ? {
-                _alias: [...alias.entries()].reduce((all, [k, v]) => objectSpread(all, { [k]: v }), {})
-            }
-            : {});
-    },
-    [TypeDefInfo.Tuple]: (registry, { sub }) => {
-        if (!Array.isArray(sub)) {
-            throw new Error('Unable to encode Tuple type');
-        }
-        return `(${sub.map((type) => encodeTypeDef(registry, type)).join(',')})`;
-    },
-    [TypeDefInfo.UInt]: (_registry, { length = 32 }) => `UInt<${length}>`,
-    [TypeDefInfo.Vec]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Vec'),
-    [TypeDefInfo.VecFixed]: (_registry, { length, sub }) => {
-        if (!isNumber(length) || !sub || Array.isArray(sub)) {
-            throw new Error('Unable to encode VecFixed type');
-        }
-        return `[${sub.type};${length}]`;
-    },
-    [TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperKeepOpaque'),
-    [TypeDefInfo.WrapperOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperOpaque')
-};
-function encodeType(registry, typeDef, withLookup = true) {
-    return withLookup && typeDef.lookupName
-        ? typeDef.lookupName
-        : encoders[typeDef.info](registry, typeDef);
-}
-export function encodeTypeDef(registry, typeDef) {
-    // In the case of contracts we do have the unfortunate situation where the displayName would
-    // refer to "Option" when it is an option. For these, string it out, only using when actually
-    // not a top-level element to be used
-    return (typeDef.displayName && !INFO_WRAP.some((i) => typeDef.displayName === i))
-        ? typeDef.displayName
-        : encodeType(registry, typeDef);
-}
-export function withTypeString(registry, typeDef) {
-    return objectSpread({}, typeDef, {
-        type: encodeType(registry, typeDef, false)
-    });
-}

package/build-tsc-esm/util/getTypeDef.js

@@ -1,192 +0,0 @@
-import { sanitize } from '@pezkuwi/types-codec';
-import { isNumber, isString, objectSpread, stringify } from '@pezkuwi/util';
-import { TypeDefInfo } from '../types/index.js';
-import { typeSplit } from './typeSplit.js';
-const KNOWN_INTERNALS = ['_alias', '_fallback'];
-function getTypeString(typeOrObj) {
-    return isString(typeOrObj)
-        ? typeOrObj.toString()
-        : stringify(typeOrObj);
-}
-function isRustEnum(details) {
-    const values = Object.values(details);
-    if (values.some((v) => isNumber(v))) {
-        if (!values.every((v) => isNumber(v) && v >= 0 && v <= 255)) {
-            throw new Error('Invalid number-indexed enum definition');
-        }
-        return false;
-    }
-    return true;
-}
-function _decodeEnum(value, details, count, fallbackType) {
-    value.info = 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: TypeDefInfo.Plain,
-            name,
-            type: 'Null'
-        }));
-    }
-    else if (isRustEnum(details)) {
-        value.sub = Object.entries(details).map(([name, typeOrObj], index) => objectSpread({}, getTypeDef(getTypeString(typeOrObj || 'Null'), { name }, count), { index }));
-    }
-    else {
-        value.sub = Object.entries(details).map(([name, index]) => ({
-            index,
-            info: TypeDefInfo.Plain,
-            name,
-            type: 'Null'
-        }));
-    }
-    return value;
-}
-function _decodeSet(value, details, fallbackType) {
-    value.info = TypeDefInfo.Set;
-    value.fallbackType = fallbackType;
-    value.length = details._bitLength;
-    value.sub = Object
-        .entries(details)
-        .filter(([name]) => !name.startsWith('_'))
-        .map(([name, index]) => ({
-        index,
-        info: TypeDefInfo.Plain,
-        name,
-        type: 'Null'
-    }));
-    return value;
-}
-function _decodeStruct(value, type, _, count) {
-    const parsed = JSON.parse(type);
-    const keys = Object.keys(parsed);
-    if (parsed._enum) {
-        return _decodeEnum(value, parsed._enum, count, parsed._fallback);
-    }
-    else if (parsed._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;
-}
-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;
-            }
-            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;
-}
-function _decodeTuple(value, _, subType, count) {
-    value.sub = subType.length === 0
-        ? []
-        : typeSplit(subType).map((inner) => getTypeDef(inner, {}, count));
-    return value;
-}
-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;
-}
-function _decodeInt(value, type, subType) {
-    return _decodeAnyInt(value, type, subType, 'Int');
-}
-function _decodeUInt(value, type, subType) {
-    return _decodeAnyInt(value, type, subType, 'UInt');
-}
-function _decodeDoNotConstruct(value, type, _) {
-    const NAME_LENGTH = 'DoNotConstruct'.length;
-    value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
-    return value;
-}
-function hasWrapper(type, [start, end]) {
-    return (type.startsWith(start)) && (type.slice(-1 * end.length) === end);
-}
-const nestedExtraction = [
-    ['[', ']', TypeDefInfo.VecFixed, _decodeFixedVec],
-    ['{', '}', TypeDefInfo.Struct, _decodeStruct],
-    ['(', ')', TypeDefInfo.Tuple, _decodeTuple],
-    // the inner for these are the same as tuple, multiple values
-    ['BTreeMap<', '>', TypeDefInfo.BTreeMap, _decodeTuple],
-    ['HashMap<', '>', TypeDefInfo.HashMap, _decodeTuple],
-    ['Int<', '>', TypeDefInfo.Int, _decodeInt],
-    ['Result<', '>', TypeDefInfo.Result, _decodeTuple],
-    ['UInt<', '>', TypeDefInfo.UInt, _decodeUInt],
-    ['DoNotConstruct<', '>', TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]
-];
-const wrappedExtraction = [
-    ['BTreeSet<', '>', TypeDefInfo.BTreeSet],
-    ['Compact<', '>', TypeDefInfo.Compact],
-    ['Linkage<', '>', TypeDefInfo.Linkage],
-    ['Opaque<', '>', TypeDefInfo.WrapperOpaque],
-    ['Option<', '>', TypeDefInfo.Option],
-    ['Range<', '>', TypeDefInfo.Range],
-    ['RangeInclusive<', '>', TypeDefInfo.RangeInclusive],
-    ['Vec<', '>', TypeDefInfo.Vec],
-    ['WrapperKeepOpaque<', '>', TypeDefInfo.WrapperKeepOpaque],
-    ['WrapperOpaque<', '>', TypeDefInfo.WrapperOpaque]
-];
-function extractSubType(type, [start, end]) {
-    return type.substring(start.length, type.length - end.length);
-}
-export function getTypeDef(_type, { displayName, name } = {}, count = 0) {
-    // create the type via Type, allowing types to be sanitized
-    const type = sanitize(_type);
-    const value = { displayName, info: 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;
-}

package/build-tsc-esm/util/index.js

@@ -1,4 +0,0 @@
-export * from './encodeTypes.js';
-export * from './getTypeDef.js';
-export * from './typeSplit.js';
-export * from './xcm.js';

package/build-tsc-esm/util/typeSplit.js

@@ -1,57 +0,0 @@
-export 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, count = type.length; i < count; 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;
-        }
-    }
-    // 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;
-}

package/build-tsc-esm/util/xcm.js

@@ -1,5 +0,0 @@
-import { objectSpread } from '@pezkuwi/util';
-export const XCM_MAPPINGS = ['AssetInstance', 'Fungibility', 'Junction', 'Junctions', 'MultiAsset', 'MultiAssetFilter', 'MultiLocation', 'Response', 'WildFungibility', 'WildMultiAsset', 'Xcm', 'XcmError'];
-export function mapXcmTypes(version) {
-    return XCM_MAPPINGS.reduce((all, key) => objectSpread(all, { [key]: `${key}${version}` }), {});
-}