@pezkuwi/types-create 16.5.16 → 16.5.18

package/build/package.json

@@ -0,0 +1,291 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues",
+  "description": "Type creator helpers",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/types-create#readme",
+  "license": "Apache-2.0",
+  "name": "@pezkuwi/types-create",
+  "repository": {
+    "directory": "packages/types-create",
+    "type": "git",
+    "url": "https://github.com/pezkuwichain/pezkuwi-api.git"
+  },
+  "sideEffects": [
+    "./packageDetect.js",
+    "./cjs/packageDetect.js"
+  ],
+  "type": "module",
+  "version": "16.5.18",
+  "main": "./cjs/index.js",
+  "module": "./cjs/index.js",
+  "types": "./cjs/index.d.ts",
+  "exports": {
+    "./cjs/package.json": "./cjs/package.json",
+    "./cjs/*": "./cjs/*.js",
+    ".": {
+      "module": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "require": {
+        "types": "./cjs/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "default": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      }
+    },
+    "./bundle": {
+      "module": {
+        "types": "./bundle.d.ts",
+        "default": "./bundle.js"
+      },
+      "require": {
+        "types": "./cjs/bundle.d.ts",
+        "default": "./cjs/bundle.js"
+      },
+      "default": {
+        "types": "./bundle.d.ts",
+        "default": "./bundle.js"
+      }
+    },
+    "./create": {
+      "module": {
+        "types": "./create/index.d.ts",
+        "default": "./create/index.js"
+      },
+      "require": {
+        "types": "./cjs/create/index.d.ts",
+        "default": "./cjs/create/index.js"
+      },
+      "default": {
+        "types": "./create/index.d.ts",
+        "default": "./create/index.js"
+      }
+    },
+    "./create/class": {
+      "module": {
+        "types": "./create/class.d.ts",
+        "default": "./create/class.js"
+      },
+      "require": {
+        "types": "./cjs/create/class.d.ts",
+        "default": "./cjs/create/class.js"
+      },
+      "default": {
+        "types": "./create/class.d.ts",
+        "default": "./create/class.js"
+      }
+    },
+    "./create/type": {
+      "module": {
+        "types": "./create/type.d.ts",
+        "default": "./create/type.js"
+      },
+      "require": {
+        "types": "./cjs/create/type.d.ts",
+        "default": "./cjs/create/type.js"
+      },
+      "default": {
+        "types": "./create/type.d.ts",
+        "default": "./create/type.js"
+      }
+    },
+    "./exports": {
+      "module": {
+        "types": "./exports.d.ts",
+        "default": "./exports.js"
+      },
+      "require": {
+        "types": "./cjs/exports.d.ts",
+        "default": "./cjs/exports.js"
+      },
+      "default": {
+        "types": "./exports.d.ts",
+        "default": "./exports.js"
+      }
+    },
+    "./package.json": {
+      "require": "./cjs/package.json",
+      "default": "./package.json"
+    },
+    "./packageDetect": {
+      "module": {
+        "types": "./packageDetect.d.ts",
+        "default": "./packageDetect.js"
+      },
+      "require": {
+        "types": "./cjs/packageDetect.d.ts",
+        "default": "./cjs/packageDetect.js"
+      },
+      "default": {
+        "types": "./packageDetect.d.ts",
+        "default": "./packageDetect.js"
+      }
+    },
+    "./packageInfo.js": {
+      "module": {
+        "types": "./packageInfo.d.ts",
+        "default": "./packageInfo.js"
+      },
+      "require": {
+        "types": "./cjs/packageInfo.d.ts",
+        "default": "./cjs/packageInfo.js"
+      },
+      "default": {
+        "types": "./packageInfo.d.ts",
+        "default": "./packageInfo.js"
+      }
+    },
+    "./packageInfo": {
+      "module": {
+        "types": "./packageInfo.d.ts",
+        "default": "./packageInfo.js"
+      },
+      "require": {
+        "types": "./cjs/packageInfo.d.ts",
+        "default": "./cjs/packageInfo.js"
+      },
+      "default": {
+        "types": "./packageInfo.d.ts",
+        "default": "./packageInfo.js"
+      }
+    },
+    "./types": {
+      "module": {
+        "types": "./types/index.d.ts",
+        "default": "./types/index.js"
+      },
+      "require": {
+        "types": "./cjs/types/index.d.ts",
+        "default": "./cjs/types/index.js"
+      },
+      "default": {
+        "types": "./types/index.d.ts",
+        "default": "./types/index.js"
+      }
+    },
+    "./types/augmentRegistry": {
+      "module": {
+        "types": "./types/augmentRegistry.d.ts",
+        "default": "./types/augmentRegistry.js"
+      },
+      "require": {
+        "types": "./cjs/types/augmentRegistry.d.ts",
+        "default": "./cjs/types/augmentRegistry.js"
+      },
+      "default": {
+        "types": "./types/augmentRegistry.d.ts",
+        "default": "./types/augmentRegistry.js"
+      }
+    },
+    "./types/lookup": {
+      "module": {
+        "types": "./types/lookup.d.ts",
+        "default": "./types/lookup.js"
+      },
+      "require": {
+        "types": "./cjs/types/lookup.d.ts",
+        "default": "./cjs/types/lookup.js"
+      },
+      "default": {
+        "types": "./types/lookup.d.ts",
+        "default": "./types/lookup.js"
+      }
+    },
+    "./types/types": {
+      "module": {
+        "types": "./types/types.d.ts",
+        "default": "./types/types.js"
+      },
+      "require": {
+        "types": "./cjs/types/types.d.ts",
+        "default": "./cjs/types/types.js"
+      },
+      "default": {
+        "types": "./types/types.d.ts",
+        "default": "./types/types.js"
+      }
+    },
+    "./util": {
+      "module": {
+        "types": "./util/index.d.ts",
+        "default": "./util/index.js"
+      },
+      "require": {
+        "types": "./cjs/util/index.d.ts",
+        "default": "./cjs/util/index.js"
+      },
+      "default": {
+        "types": "./util/index.d.ts",
+        "default": "./util/index.js"
+      }
+    },
+    "./util/encodeTypes": {
+      "module": {
+        "types": "./util/encodeTypes.d.ts",
+        "default": "./util/encodeTypes.js"
+      },
+      "require": {
+        "types": "./cjs/util/encodeTypes.d.ts",
+        "default": "./cjs/util/encodeTypes.js"
+      },
+      "default": {
+        "types": "./util/encodeTypes.d.ts",
+        "default": "./util/encodeTypes.js"
+      }
+    },
+    "./util/getTypeDef": {
+      "module": {
+        "types": "./util/getTypeDef.d.ts",
+        "default": "./util/getTypeDef.js"
+      },
+      "require": {
+        "types": "./cjs/util/getTypeDef.d.ts",
+        "default": "./cjs/util/getTypeDef.js"
+      },
+      "default": {
+        "types": "./util/getTypeDef.d.ts",
+        "default": "./util/getTypeDef.js"
+      }
+    },
+    "./util/typeSplit": {
+      "module": {
+        "types": "./util/typeSplit.d.ts",
+        "default": "./util/typeSplit.js"
+      },
+      "require": {
+        "types": "./cjs/util/typeSplit.d.ts",
+        "default": "./cjs/util/typeSplit.js"
+      },
+      "default": {
+        "types": "./util/typeSplit.d.ts",
+        "default": "./util/typeSplit.js"
+      }
+    },
+    "./util/xcm": {
+      "module": {
+        "types": "./util/xcm.d.ts",
+        "default": "./util/xcm.js"
+      },
+      "require": {
+        "types": "./cjs/util/xcm.d.ts",
+        "default": "./cjs/util/xcm.js"
+      },
+      "default": {
+        "types": "./util/xcm.d.ts",
+        "default": "./util/xcm.js"
+      }
+    }
+  },
+  "dependencies": {
+    "@pezkuwi/types": "16.5.9",
+    "@pezkuwi/types-codec": "16.5.9",
+    "@pezkuwi/util": "14.0.11",
+    "tslib": "^2.8.1"
+  }
+}

package/build/packageDetect.d.ts

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

package/build/packageDetect.js

@@ -0,0 +1,4 @@
+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/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/build/packageInfo.js

@@ -0,0 +1 @@
+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.18' };

package/build/types/augmentRegistry.d.ts

@@ -0,0 +1,11 @@
+import '@pezkuwi/types-codec/types/registry';
+import type { Codec, CodecClass, ICompact, INumber, LookupString } from '@pezkuwi/types-codec/types';
+import type { ILookup, TypeDef } from '@pezkuwi/types-create/types';
+declare module '@pezkuwi/types-codec/types/registry' {
+    interface Registry {
+        readonly lookup: ILookup;
+        createLookupType(lookupId: ICompact<INumber> | number): LookupString;
+        getUnsafe<T extends Codec = Codec, K extends string = string>(name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<T> | undefined;
+        setLookup(lookup: ILookup): void;
+    }
+}

package/build/types/augmentRegistry.js

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

package/build/types/index.d.ts

@@ -0,0 +1,4 @@
+import './augmentRegistry.js';
+export type { CodecCreateOptions as CreateOptions } from '@pezkuwi/types-codec/types';
+export * from './lookup.js';
+export * from './types.js';

package/build/types/index.js

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

package/build/types/lookup.d.ts

@@ -0,0 +1,14 @@
+import type { Option, Text } from '@pezkuwi/types-codec';
+import type { ICompact, INumber, LookupString } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from './types.js';
+interface SiTypeBase {
+    def: {
+        asTuple: ICompact<INumber>[];
+    };
+}
+export interface ILookup {
+    getSiType(lookupId: ICompact<INumber> | LookupString | number): SiTypeBase;
+    getTypeDef(lookupId: ICompact<INumber> | LookupString | number): TypeDef;
+    sanitizeField(name: Option<Text>): [string | null, string | null];
+}
+export {};

package/build/types/lookup.js

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

package/build/types/types.d.ts

@@ -0,0 +1,43 @@
+export declare enum TypeDefInfo {
+    BTreeMap = 0,
+    BTreeSet = 1,
+    Compact = 2,
+    DoNotConstruct = 3,
+    Enum = 4,
+    HashMap = 5,
+    Int = 6,
+    Linkage = 7,
+    Null = 8,
+    Option = 9,
+    Plain = 10,
+    Range = 11,
+    RangeInclusive = 12,
+    Result = 13,
+    Set = 14,
+    Si = 15,
+    Struct = 16,
+    Tuple = 17,
+    UInt = 18,
+    Vec = 19,
+    VecFixed = 20,
+    WrapperKeepOpaque = 21,
+    WrapperOpaque = 22
+}
+export interface TypeDef {
+    alias?: Map<string, string> | undefined;
+    displayName?: string | undefined;
+    docs?: string[] | undefined;
+    fallbackType?: string | undefined;
+    info: TypeDefInfo;
+    index?: number;
+    isFromSi?: boolean;
+    length?: number;
+    lookupIndex?: number;
+    lookupName?: string | undefined;
+    lookupNameRoot?: string | undefined;
+    name?: string | undefined;
+    namespace?: string | undefined;
+    sub?: TypeDef | TypeDef[];
+    type: string;
+    typeName?: string | undefined;
+}

package/build/types/types.js

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,123 @@
+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

@@ -0,0 +1,8 @@
+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 {};