@pezkuwi/types-create 16.5.8 → 16.5.10

package/build/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/util/encodeTypes.d.ts

@@ -1,11 +0,0 @@
-import type { Registry } from '@pezkuwi/types-codec/types';
-import type { TypeDef } from '@pezkuwi/types-create/types';
-interface ToString {
-    toString: () => string;
-}
-export declare function paramsNotation<T extends ToString>(outer: string, inner?: T | T[], transform?: (_: T) => string): string;
-export declare function encodeTypeDef(registry: Registry, typeDef: TypeDef): string;
-export declare function withTypeString(registry: Registry, typeDef: Omit<TypeDef, 'type'> & {
-    type?: string;
-}): TypeDef;
-export {};

package/build/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/util/getTypeDef.d.ts

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

package/build/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/util/index.d.ts

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

package/build/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/util/typeSplit.d.ts

@@ -1 +0,0 @@
-export declare function typeSplit(type: string): string[];

package/build/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/util/xcm.d.ts

@@ -1,2 +0,0 @@
-export declare const XCM_MAPPINGS: string[];
-export declare function mapXcmTypes(version: 'V0' | 'V1' | 'V2' | 'V3' | 'V4' | 'V5'): Record<string, string>;

package/build/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}` }), {});
-}

package/build-deno/README.md

@@ -1,3 +0,0 @@
-# @pezkuwi/types-create
-
-Base type-creation functionality.

package/build-deno/bundle.ts

@@ -1,5 +0,0 @@
-
-export { packageInfo } from './packageInfo.ts';
-export { TypeDefInfo } from './types/index.ts';
-
-export * from './exports.ts';