@pezkuwi/typegen 16.5.18 → 16.5.32

package/build/cjs/generate/runtime.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateCallTypes = generateCallTypes;
-exports.generateDefaultRuntime = generateDefaultRuntime;
-const tslib_1 = require("tslib");
-const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
-const defaultDefs = tslib_1.__importStar(require("@pezkuwi/types/interfaces/definitions"));
-const definitions_1 = tslib_1.__importDefault(require("@pezkuwi/types-augment/lookup/definitions"));
-const util_1 = require("@pezkuwi/util");
-const util_crypto_1 = require("@pezkuwi/util-crypto");
-const index_js_1 = require("../util/index.js");
-const types_js_1 = require("./types.js");
-const generateCallsTypesTemplate = handlebars_1.default.compile((0, index_js_1.readTemplate)('calls'));
-const aliases = {
-    AssetHubZagrosRuntimeRuntimeCall: 'RuntimeCall',
-    AssetHubPezkuwiRuntimeRuntimeCall: 'RuntimeCall',
-    AssetHubDicleRuntimeOriginCaller: 'OriginCaller',
-    AssetHubDicleRuntimeRuntimeCall: 'RuntimeCall',
-    DicleRuntimeConstantsProxyProxyType: 'ProxyType',
-    KitchensinkRuntimeRuntimeCall: 'RuntimeCall',
-    KitchensinkRuntimeRuntimeParametersKey: 'RuntimeParametersKey',
-    OpaqueValue: 'Bytes',
-    PezkuwiTeyrchainPrimitivesPrimitivesId: 'ParaId',
-    PezkuwiTeyrchainPrimitivesPrimitivesValidationCodeHash: 'ValidationCodeHash',
-    PezkuwiPrimitivesV7SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
-    PezkuwiPrimitivesV8SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
-    PezkuwiRuntimeRuntimeCall: 'RuntimeCall',
-    PrimitiveTypesH160: 'H160',
-    PrimitiveTypesH256: 'H256',
-    PrimitiveTypesU256: 'U256',
-    PezspConsensusBabeOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
-    PezspConsensusSlotsSlot: 'Slot',
-    PezspConsensusSlotsSlotDuration: 'SlotDuration',
-    PezspCoreCryptoAccountId32: 'AccountId32',
-    PezspCoreOpaqueMetadata: 'OpaqueMetadata',
-    PezspRuntimeOpaqueValue: 'Bytes',
-    PezspRuntimeUncheckedExtrinsic: 'Extrinsic',
-    StagingDicleRuntimeOriginCaller: 'OriginCaller',
-    StagingDicleRuntimeRuntimeCall: 'RuntimeCall',
-    StagingDicleRuntimeRuntimeParameters: 'RuntimeParameters',
-    StagingDicleRuntimeRuntimeParametersKey: 'RuntimeParametersKey',
-    StagingZagrosRuntimeRuntimeCall: 'RuntimeCall'
-};
-const getTypesViaAlias = (registry, id) => {
-    const rawTypeName = registry.lookup.getName(id) || registry.lookup.getTypeDef(id).type;
-    const typeName = (0, index_js_1.rebrandTypeName)(rawTypeName);
-    if (aliases[typeName]) {
-        return aliases[typeName];
-    }
-    return typeName;
-};
-/** @internal */
-function getMethods(registry, methods) {
-    const result = {};
-    methods.forEach((m) => {
-        const { deprecationInfo, docs, inputs, name, output } = m;
-        let description = docs.map((d) => d.toString()).join();
-        if (!deprecationInfo.isNotDeprecated) {
-            const deprecationNotice = (0, types_js_1.getDeprecationNotice)(deprecationInfo, (0, util_1.stringCamelCase)(name));
-            const notice = description.length ? `\n * ${deprecationNotice}` : ` * ${deprecationNotice}`;
-            description += notice;
-        }
-        result[name.toString()] = {
-            description,
-            params: inputs.map(({ name, type }) => {
-                return { name: name.toString(), type: getTypesViaAlias(registry, type) };
-            }),
-            type: getTypesViaAlias(registry, output)
-        };
-    });
-    return result;
-}
-/** @internal */
-function getRuntimeDefViaMetadata(registry) {
-    const result = {};
-    const { apis } = registry.metadata;
-    for (let i = 0, count = apis.length; i < count; i++) {
-        const { methods, name } = apis[i];
-        result[name.toString()] = [{
-                methods: getMethods(registry, methods),
-                // We set the version to 0 here since it will not be relevant when we are grabbing the runtime apis
-                // from the Metadata.
-                version: 0
-            }];
-    }
-    return Object.entries(result);
-}
-/** @internal */
-function getDefs(apis, defs, registry) {
-    const named = {};
-    const all = Object.values(defs);
-    const isApiInMetadata = registry.metadata.apis.length > 0;
-    if (isApiInMetadata) {
-        const sections = getRuntimeDefViaMetadata(registry);
-        for (let j = 0, jcount = sections.length; j < jcount; j++) {
-            const [_section, secs] = sections[j];
-            const sec = secs[0];
-            const sectionHash = (0, util_crypto_1.blake2AsHex)(_section, 64);
-            const section = (0, util_1.stringCamelCase)(_section);
-            const methods = Object.entries(sec.methods);
-            if (!named[section]) {
-                named[section] = {};
-            }
-            for (let m = 0, mcount = methods.length; m < mcount; m++) {
-                const [_method, def] = methods[m];
-                const method = (0, util_1.stringCamelCase)(_method);
-                named[section][method] = (0, util_1.objectSpread)({ method, name: `${_section}_${_method}`, section, sectionHash }, def);
-            }
-        }
-    }
-    else {
-        for (let j = 0, jcount = all.length; j < jcount; j++) {
-            const set = all[j].runtime;
-            if (set) {
-                const sections = Object.entries(set);
-                for (let i = 0, scount = sections.length; i < scount; i++) {
-                    const [_section, sec] = sections[i];
-                    const sectionHash = (0, util_crypto_1.blake2AsHex)(_section, 64);
-                    const api = apis?.find(([h]) => h === sectionHash);
-                    if (api) {
-                        const ver = sec.find(({ version }) => version === api[1]);
-                        if (ver) {
-                            const methods = Object.entries(ver.methods);
-                            const mcount = methods.length;
-                            if (mcount) {
-                                const section = (0, util_1.stringCamelCase)(_section);
-                                if (!named[section]) {
-                                    named[section] = {};
-                                }
-                                for (let m = 0; m < mcount; m++) {
-                                    const [_method, def] = methods[m];
-                                    const method = (0, util_1.stringCamelCase)(_method);
-                                    named[section][method] = (0, util_1.objectSpread)({ method, name: `${_section}_${method}`, section, sectionHash, version: ver.version }, def);
-                                }
-                            }
-                        }
-                        else {
-                            console.warn(`Unable to find matching version for runtime ${_section}, expected ${api[1]}`);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return named;
-}
-/** @internal */
-function generateCallTypes(registry, meta, dest, extraTypes, isStrict, customLookupDefinitions) {
-    (0, index_js_1.writeFile)(dest, () => {
-        const allTypes = {
-            '@pezkuwi/types-augment': {
-                lookup: {
-                    ...definitions_1.default,
-                    ...customLookupDefinitions
-                }
-            },
-            '@pezkuwi/types/interfaces': defaultDefs,
-            ...extraTypes
-        };
-        const imports = (0, index_js_1.createImports)(allTypes);
-        // find the system.Version in metadata
-        let apis = null;
-        const sysp = meta.asLatest.pallets.find(({ name }) => name.eq('System'));
-        if (sysp) {
-            const verc = sysp.constants.find(({ name }) => name.eq('Version'));
-            if (verc) {
-                apis = registry.createType('RuntimeVersion', verc.value).apis.map(([k, v]) => [k.toHex(), v.toNumber()]);
-            }
-            else {
-                console.error('Unable to find System.Version pallet, skipping API extraction');
-            }
-        }
-        else {
-            console.error('Unable to find System pallet, skipping API extraction');
-        }
-        const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
-            return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
-        }, {});
-        const definitions = getDefs(apis, imports.definitions, registry);
-        const callKeys = Object.keys(definitions);
-        const modules = callKeys.map((section) => {
-            const calls = definitions[section];
-            const allMethods = Object.keys(calls).sort().map((methodName) => {
-                const def = calls[methodName];
-                (0, index_js_1.setImports)(allDefs, imports, [def.type]);
-                const args = def.params.map((param) => {
-                    const similarTypes = (0, index_js_1.getSimilarTypes)(registry, imports.definitions, param.type, imports);
-                    (0, index_js_1.setImports)(allDefs, imports, [param.type, ...similarTypes]);
-                    return `${param.name}: ${similarTypes.join(' | ')}`;
-                });
-                return {
-                    args: args.join(', '),
-                    docs: [def.description],
-                    name: methodName,
-                    sectionHash: def.sectionHash,
-                    sectionName: def.section,
-                    sectionVersion: def.version,
-                    type: (0, index_js_1.formatType)(registry, allDefs, def.type, imports)
-                };
-            }).sort((a, b) => a.name.localeCompare(b.name));
-            return {
-                items: allMethods,
-                name: section || 'unknown',
-                sectionHash: allMethods.length && allMethods[0].sectionHash,
-                sectionName: allMethods.length && allMethods[0].sectionName,
-                sectionVersion: allMethods.length && allMethods[0].sectionVersion
-            };
-        }).filter(({ items }) => items.length).sort((a, b) => a.name.localeCompare(b.name));
-        if (modules.length) {
-            imports.typesTypes['Observable'] = true;
-        }
-        return generateCallsTypesTemplate({
-            headerType: 'chain',
-            imports,
-            isStrict,
-            modules,
-            types: [
-                ...Object.keys(imports.localTypes).sort().map((packagePath) => ({
-                    file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-                    types: Object.keys(imports.localTypes[packagePath])
-                })),
-                {
-                    file: '@pezkuwi/api-base/types',
-                    types: ['ApiTypes', 'AugmentedCall', 'DecoratedCallBase']
-                }
-            ]
-        });
-    });
-}
-function generateDefaultRuntime(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
-    const { metadata, registry } = (0, index_js_1.initMeta)(data, extraTypes);
-    generateCallTypes(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

package/build/cjs/generate/tsDef.d.ts

@@ -1,16 +0,0 @@
-import type { Registry } from '@pezkuwi/types/types';
-import type { TypeDef } from '@pezkuwi/types-create/types';
-import type { ModuleTypes } from '../util/imports.js';
-import type { TypeImports } from '../util/index.js';
-import { TypeDefInfo } from '@pezkuwi/types-create';
-/** @internal */
-export declare function createGetter(definitions: Record<string, ModuleTypes>, name: string | undefined, type: string, imports: TypeImports): string;
-export declare const typeEncoders: Record<TypeDefInfo, (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports) => string>;
-/** @internal */
-export declare function generateTsDefFor(registry: Registry, importDefinitions: Record<string, Record<string, ModuleTypes>>, defName: string, { types }: {
-    types: Record<string, any>;
-}, outputDir: string): void;
-/** @internal */
-export declare function generateTsDef(importDefinitions: Record<string, Record<string, ModuleTypes>>, outputDir: string, generatingPackage: string): void;
-/** @internal */
-export declare function generateDefaultTsDef(): void;

package/build/cjs/generate/tsDef.js

@@ -1,254 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeEncoders = void 0;
-exports.createGetter = createGetter;
-exports.generateTsDefFor = generateTsDefFor;
-exports.generateTsDef = generateTsDef;
-exports.generateDefaultTsDef = generateDefaultTsDef;
-const tslib_1 = require("tslib");
-const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const create_1 = require("@pezkuwi/types/create");
-const defaultDefinitions = tslib_1.__importStar(require("@pezkuwi/types/interfaces/definitions"));
-const types_create_1 = require("@pezkuwi/types-create");
-const util_1 = require("@pezkuwi/util");
-const index_js_1 = require("../util/index.js");
-const generateTsDefIndexTemplate = handlebars_1.default.compile((0, index_js_1.readTemplate)('tsDef/index'));
-const generateTsDefModuleTypesTemplate = handlebars_1.default.compile((0, index_js_1.readTemplate)('tsDef/moduleTypes'));
-const generateTsDefTypesTemplate = handlebars_1.default.compile((0, index_js_1.readTemplate)('tsDef/types'));
-/** @internal */
-function createGetter(definitions, name = '', type, imports) {
-    (0, index_js_1.setImports)(definitions, imports, [type]);
-    return `  readonly ${name}: ${type};\n`;
-}
-/** @internal */
-function errorUnhandled(_, _definitions, def, _imports) {
-    throw new Error(`Generate: ${def.name || ''}: Unhandled type ${types_create_1.TypeDefInfo[def.info]}`);
-}
-/** @internal */
-function tsExport(registry, definitions, def, imports) {
-    return (0, index_js_1.exportInterface)(def.lookupIndex, def.name, (0, index_js_1.formatType)(registry, definitions, def, imports, false));
-}
-/** @internal */
-function tsEnum(registry, definitions, { lookupIndex, name: enumName, sub }, imports, withShortcut = false) {
-    (0, index_js_1.setImports)(definitions, imports, ['Enum']);
-    const indent = withShortcut ? '  ' : '';
-    const named = sub.filter(({ name }) => !!name && !name.startsWith('__Unused'));
-    const keys = named.map((def) => {
-        const { info, lookupName, name = '', sub, type } = def;
-        const getter = (0, util_1.stringPascalCase)(name.replace(' ', '_'));
-        const isComplex = [types_create_1.TypeDefInfo.Option, types_create_1.TypeDefInfo.Range, types_create_1.TypeDefInfo.RangeInclusive, types_create_1.TypeDefInfo.Result, types_create_1.TypeDefInfo.Struct, types_create_1.TypeDefInfo.Tuple, types_create_1.TypeDefInfo.Vec, types_create_1.TypeDefInfo.VecFixed].includes(info);
-        let extractedLookupName;
-        // When the parent type does not have a lookupName, and the sub type is the same
-        // type as the parent we can take the lookupName from the sub.
-        // This is specific to `StagingXcmV4Junction`.
-        // see: https://github.com/pezkuwichain/pezkuwi-api/pull/5812
-        if (sub && !Array.isArray(sub) && type.includes(`${sub.type};`)) {
-            if (sub.lookupName === 'StagingXcmV4Junction') {
-                extractedLookupName = sub.lookupName;
-            }
-            else if (sub.lookupName === 'StagingXcmV5Junction') {
-                extractedLookupName = `Vec<${sub.lookupName}>`;
-            }
-        }
-        const asGetter = type === 'Null' || info === types_create_1.TypeDefInfo.DoNotConstruct
-            ? ''
-            : createGetter(definitions, `as${getter}`, lookupName || extractedLookupName || (isComplex ? (0, index_js_1.formatType)(registry, definitions, info === types_create_1.TypeDefInfo.Struct ? def : type, imports, withShortcut) : type), imports);
-        const isGetter = info === types_create_1.TypeDefInfo.DoNotConstruct
-            ? ''
-            : createGetter(definitions, `is${getter}`, 'boolean', imports);
-        switch (info) {
-            case types_create_1.TypeDefInfo.Compact:
-            case types_create_1.TypeDefInfo.Plain:
-            case types_create_1.TypeDefInfo.Range:
-            case types_create_1.TypeDefInfo.RangeInclusive:
-            case types_create_1.TypeDefInfo.Result:
-            case types_create_1.TypeDefInfo.Si:
-            case types_create_1.TypeDefInfo.Struct:
-            case types_create_1.TypeDefInfo.Tuple:
-            case types_create_1.TypeDefInfo.Vec:
-            case types_create_1.TypeDefInfo.BTreeMap:
-            case types_create_1.TypeDefInfo.BTreeSet:
-            case types_create_1.TypeDefInfo.Option:
-            case types_create_1.TypeDefInfo.VecFixed:
-            case types_create_1.TypeDefInfo.WrapperKeepOpaque:
-            case types_create_1.TypeDefInfo.WrapperOpaque:
-                return `${indent}${isGetter}${indent}${asGetter}`;
-            case types_create_1.TypeDefInfo.DoNotConstruct:
-            case types_create_1.TypeDefInfo.Null:
-                return `${indent}${isGetter}`;
-            default:
-                throw new Error(`Enum: ${enumName || 'undefined'}: Unhandled type ${types_create_1.TypeDefInfo[info]}, ${(0, util_1.stringify)(def)}`);
-        }
-    });
-    return (0, index_js_1.exportInterface)(lookupIndex, enumName, 'Enum', `${keys.join('')}  ${indent}readonly type: ${named.map(({ name = '' }) => `'${(0, util_1.stringPascalCase)(name.replace(' ', '_'))}'`).join(' | ')};\n`, withShortcut);
-}
-function tsInt(_, definitions, def, imports, type = 'Int') {
-    (0, index_js_1.setImports)(definitions, imports, [type]);
-    return (0, index_js_1.exportInterface)(def.lookupIndex, def.name, type);
-}
-/** @internal */
-function tsNull(_registry, definitions, { lookupIndex = -1, name }, imports) {
-    (0, index_js_1.setImports)(definitions, imports, ['Null']);
-    // * @description extends [[${base}]]
-    const doc = `/** @name ${name || ''}${lookupIndex !== -1 ? ` (${lookupIndex})` : ''} */\n`;
-    return `${doc}export type ${name || ''} = Null;`;
-}
-/** @internal */
-function tsResultGetter(registry, definitions, resultName = '', getter, def, imports) {
-    const { info, lookupName, type } = def;
-    const asGetter = type === 'Null'
-        ? ''
-        : createGetter(definitions, `as${getter}`, lookupName || (info === types_create_1.TypeDefInfo.Tuple ? (0, index_js_1.formatType)(registry, definitions, def, imports, false) : type), imports);
-    const isGetter = createGetter(definitions, `is${getter}`, 'boolean', imports);
-    switch (info) {
-        case types_create_1.TypeDefInfo.Option:
-        case types_create_1.TypeDefInfo.Plain:
-        case types_create_1.TypeDefInfo.Si:
-        case types_create_1.TypeDefInfo.Tuple:
-        case types_create_1.TypeDefInfo.Vec:
-        case types_create_1.TypeDefInfo.BTreeMap:
-        case types_create_1.TypeDefInfo.BTreeSet:
-        case types_create_1.TypeDefInfo.WrapperKeepOpaque:
-        case types_create_1.TypeDefInfo.WrapperOpaque:
-            return `${isGetter}${asGetter}`;
-        case types_create_1.TypeDefInfo.Null:
-            return `${isGetter}`;
-        default:
-            throw new Error(`Result: ${resultName}: Unhandled type ${types_create_1.TypeDefInfo[info]}, ${(0, util_1.stringify)(def)}`);
-    }
-}
-/** @internal */
-function tsResult(registry, definitions, def, imports) {
-    const [okDef, errorDef] = def.sub;
-    const inner = [
-        tsResultGetter(registry, definitions, def.name, 'Err', errorDef, imports),
-        tsResultGetter(registry, definitions, def.name, 'Ok', okDef, imports)
-    ].join('');
-    (0, index_js_1.setImports)(definitions, imports, [def.type]);
-    const fmtType = def.lookupName && def.name !== def.lookupName
-        ? def.lookupName
-        : (0, index_js_1.formatType)(registry, definitions, def, imports, false);
-    return (0, index_js_1.exportInterface)(def.lookupIndex, def.name, fmtType, inner);
-}
-/** @internal */
-function tsSi(_registry, _definitions, typeDef, _imports) {
-    // FIXME
-    return `// SI: ${(0, util_1.stringify)(typeDef)}`;
-}
-/** @internal */
-function tsSet(_, definitions, { lookupIndex, name: setName, sub }, imports) {
-    (0, index_js_1.setImports)(definitions, imports, ['Set']);
-    const types = sub.map(({ name }) => {
-        (0, util_1.assert)(name, 'Invalid TypeDef found, no name specified');
-        return createGetter(definitions, `is${name}`, 'boolean', imports);
-    });
-    return (0, index_js_1.exportInterface)(lookupIndex, setName, 'Set', types.join(''));
-}
-/** @internal */
-function tsStruct(registry, definitions, { lookupIndex, name: structName, sub }, imports) {
-    (0, index_js_1.setImports)(definitions, imports, ['Struct']);
-    const keys = sub.map((def) => {
-        const fmtType = def.lookupName && def.name !== def.lookupName
-            ? def.lookupName
-            : def.info === types_create_1.TypeDefInfo.Enum
-                ? `${tsEnum(registry, definitions, def, imports, true)} & Enum`
-                : (0, index_js_1.formatType)(registry, definitions, def, imports, false);
-        return createGetter(definitions, def.name, fmtType, imports);
-    });
-    return (0, index_js_1.exportInterface)(lookupIndex, structName, 'Struct', keys.join(''));
-}
-/** @internal */
-function tsUInt(registry, definitions, def, imports) {
-    return tsInt(registry, definitions, def, imports, 'UInt');
-}
-/** @internal */
-function tsVec(registry, definitions, def, imports) {
-    const type = def.sub.type;
-    if (type === 'u8') {
-        if (def.info === types_create_1.TypeDefInfo.VecFixed) {
-            (0, index_js_1.setImports)(definitions, imports, ['U8aFixed']);
-            return (0, index_js_1.exportInterface)(def.lookupIndex, def.name, 'U8aFixed');
-        }
-        else {
-            (0, index_js_1.setImports)(definitions, imports, ['Bytes']);
-            return (0, index_js_1.exportInterface)(def.lookupIndex, def.name, 'Bytes');
-        }
-    }
-    const fmtType = def.lookupName && def.name !== def.lookupName
-        ? def.lookupName
-        : (0, index_js_1.formatType)(registry, definitions, def, imports, false);
-    return (0, index_js_1.exportInterface)(def.lookupIndex, def.name, fmtType);
-}
-exports.typeEncoders = {
-    [types_create_1.TypeDefInfo.BTreeMap]: tsExport,
-    [types_create_1.TypeDefInfo.BTreeSet]: tsExport,
-    [types_create_1.TypeDefInfo.Compact]: tsExport,
-    [types_create_1.TypeDefInfo.DoNotConstruct]: tsExport,
-    [types_create_1.TypeDefInfo.Enum]: tsEnum,
-    [types_create_1.TypeDefInfo.HashMap]: tsExport,
-    [types_create_1.TypeDefInfo.Int]: tsInt,
-    [types_create_1.TypeDefInfo.Linkage]: errorUnhandled,
-    [types_create_1.TypeDefInfo.Null]: tsNull,
-    [types_create_1.TypeDefInfo.Option]: tsExport,
-    [types_create_1.TypeDefInfo.Plain]: tsExport,
-    [types_create_1.TypeDefInfo.Range]: tsExport,
-    [types_create_1.TypeDefInfo.RangeInclusive]: tsExport,
-    [types_create_1.TypeDefInfo.Result]: tsResult,
-    [types_create_1.TypeDefInfo.Set]: tsSet,
-    [types_create_1.TypeDefInfo.Si]: tsSi,
-    [types_create_1.TypeDefInfo.Struct]: tsStruct,
-    [types_create_1.TypeDefInfo.Tuple]: tsExport,
-    [types_create_1.TypeDefInfo.UInt]: tsUInt,
-    [types_create_1.TypeDefInfo.Vec]: tsVec,
-    [types_create_1.TypeDefInfo.VecFixed]: tsVec,
-    [types_create_1.TypeDefInfo.WrapperKeepOpaque]: tsExport,
-    [types_create_1.TypeDefInfo.WrapperOpaque]: tsExport
-};
-/** @internal */
-function generateInterfaces(registry, definitions, { types }, imports) {
-    return Object.entries(types).map(([name, type]) => {
-        const def = (0, types_create_1.getTypeDef)((0, util_1.isString)(type) ? type : (0, util_1.stringify)(type), { name });
-        return [name, exports.typeEncoders[def.info](registry, definitions, def, imports)];
-    });
-}
-/** @internal */
-function generateTsDefFor(registry, importDefinitions, defName, { types }, outputDir) {
-    const imports = { ...(0, index_js_1.createImports)(importDefinitions, { types }), interfaces: [] };
-    const definitions = imports.definitions;
-    const interfaces = generateInterfaces(registry, definitions, { types }, imports);
-    const items = interfaces.sort((a, b) => a[0].localeCompare(b[0])).map(([, definition]) => definition);
-    (0, index_js_1.writeFile)(node_path_1.default.join(outputDir, defName, 'types.ts'), () => generateTsDefModuleTypesTemplate({
-        headerType: 'defs',
-        imports,
-        items,
-        name: defName,
-        types: [
-            ...Object.keys(imports.localTypes).sort().map((packagePath) => ({
-                file: packagePath.replace('@pezkuwi/types/augment', '@pezkuwi/types'),
-                types: Object.keys(imports.localTypes[packagePath])
-            }))
-        ]
-    }), true);
-    (0, index_js_1.writeFile)(node_path_1.default.join(outputDir, defName, 'index.ts'), () => generateTsDefIndexTemplate({ headerType: 'defs' }), true);
-}
-/** @internal */
-function generateTsDef(importDefinitions, outputDir, generatingPackage) {
-    const registry = new create_1.TypeRegistry();
-    (0, index_js_1.writeFile)(node_path_1.default.join(outputDir, 'types.ts'), () => {
-        const definitions = importDefinitions[generatingPackage];
-        Object.entries(definitions).forEach(([defName, obj]) => {
-            console.log(`\tExtracting interfaces for ${defName}`);
-            generateTsDefFor(registry, importDefinitions, defName, obj, outputDir);
-        });
-        return generateTsDefTypesTemplate({
-            headerType: 'defs',
-            items: Object.keys(definitions)
-        });
-    });
-    (0, index_js_1.writeFile)(node_path_1.default.join(outputDir, 'index.ts'), () => generateTsDefIndexTemplate({ headerType: 'defs' }), true);
-}
-/** @internal */
-function generateDefaultTsDef() {
-    generateTsDef({ '@pezkuwi/types/interfaces': defaultDefinitions }, 'packages/types/src/interfaces', '@pezkuwi/types/interfaces');
-}

package/build/cjs/generate/tx.d.ts

@@ -1,5 +0,0 @@
-import type { Definitions } from '@pezkuwi/types/types';
-import type { HexString } from '@pezkuwi/util/types';
-import { type ExtraTypes } from './types.js';
-/** @internal */
-export declare function generateDefaultTx(dest: string, data: HexString, extraTypes?: ExtraTypes, isStrict?: boolean, customLookupDefinitions?: Definitions): void;

package/build/cjs/generate/tx.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDefaultTx = generateDefaultTx;
-const tslib_1 = require("tslib");
-const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
-const defaultDefs = tslib_1.__importStar(require("@pezkuwi/types/interfaces/definitions"));
-const definitions_1 = tslib_1.__importDefault(require("@pezkuwi/types-augment/lookup/definitions"));
-const util_1 = require("@pezkuwi/util");
-const index_js_1 = require("../util/index.js");
-const lookup_js_1 = require("./lookup.js");
-const types_js_1 = require("./types.js");
-const MAPPED_NAMES = {
-    class: 'clazz',
-    new: 'updated'
-};
-const generateForMetaTemplate = handlebars_1.default.compile((0, index_js_1.readTemplate)('tx'));
-function mapName(_name) {
-    const name = (0, util_1.stringCamelCase)(_name);
-    return MAPPED_NAMES[name] || name;
-}
-/** @internal */
-function generateForMeta(registry, meta, dest, extraTypes, isStrict, customLookupDefinitions) {
-    (0, index_js_1.writeFile)(dest, () => {
-        const allTypes = {
-            '@pezkuwi/types-augment': {
-                lookup: {
-                    ...definitions_1.default,
-                    ...customLookupDefinitions
-                }
-            },
-            '@pezkuwi/types/interfaces': defaultDefs,
-            ...extraTypes
-        };
-        const imports = (0, index_js_1.createImports)(allTypes);
-        const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
-            return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
-        }, {});
-        const { lookup, pallets } = meta.asLatest;
-        const usedTypes = new Set([]);
-        const modules = pallets
-            .sort(index_js_1.compareName)
-            .filter(({ calls }) => calls.isSome)
-            .map((data) => {
-            const name = data.name;
-            const calls = data.calls.unwrap();
-            const deprecationInfo = calls.deprecationInfo.toJSON();
-            (0, index_js_1.setImports)(allDefs, imports, ['SubmittableExtrinsic']);
-            const sectionName = (0, util_1.stringCamelCase)(name);
-            const items = lookup.getSiType(calls.type).def.asVariant.variants
-                .map(({ docs, fields, index, name }) => {
-                const rawStatus = deprecationInfo?.[index.toNumber()];
-                if (rawStatus) {
-                    const deprecationVariantInfo = meta.registry.createTypeUnsafe('VariantDeprecationInfoV16', [rawStatus]);
-                    const deprecationNotice = (0, types_js_1.getDeprecationNotice)(deprecationVariantInfo, name.toString(), 'Call');
-                    const notice = docs.length ? ['', deprecationNotice] : [deprecationNotice];
-                    docs.push(...notice.map((text) => meta.registry.createType('Text', text)));
-                }
-                const typesInfo = fields.map(({ name, type, typeName }, index) => {
-                    const typeDef = registry.lookup.getTypeDef(type);
-                    return [
-                        name.isSome
-                            ? mapName(name.unwrap())
-                            : `param${index}`,
-                        (0, index_js_1.rebrandTypeName)(typeName.isSome
-                            ? typeName.toString()
-                            : typeDef.type),
-                        (0, index_js_1.rebrandTypeName)(typeDef.isFromSi
-                            ? typeDef.type
-                            : typeDef.lookupName || typeDef.type)
-                    ];
-                });
-                const params = typesInfo
-                    .map(([name, , typeStr]) => {
-                    const similarTypes = (0, index_js_1.getSimilarTypes)(registry, allDefs, typeStr, imports);
-                    (0, index_js_1.setImports)(allDefs, imports, [typeStr, ...similarTypes]);
-                    // Add the type to the list of used types
-                    if (!(imports.primitiveTypes[typeStr])) {
-                        usedTypes.add(typeStr);
-                    }
-                    return `${name}: ${similarTypes.join(' | ')}`;
-                })
-                    .join(', ');
-                return {
-                    args: typesInfo.map(([, , typeStr]) => (0, index_js_1.formatType)(registry, allDefs, typeStr, imports)).join(', '),
-                    docs,
-                    name: (0, util_1.stringCamelCase)(name),
-                    params
-                };
-            })
-                .sort(index_js_1.compareName);
-            return {
-                items,
-                name: sectionName
-            };
-        })
-            .sort(index_js_1.compareName);
-        // filter out the unused lookup types from imports
-        (0, lookup_js_1.ignoreUnusedLookups)([...usedTypes], imports);
-        return generateForMetaTemplate({
-            headerType: 'chain',
-            imports,
-            isStrict,
-            modules,
-            types: [
-                ...Object.keys(imports.localTypes).sort().map((packagePath) => ({
-                    file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-                    types: Object.keys(imports.localTypes[packagePath])
-                })),
-                {
-                    file: '@pezkuwi/api-base/types',
-                    types: ['ApiTypes', 'AugmentedSubmittable', 'SubmittableExtrinsic', 'SubmittableExtrinsicFunction']
-                }
-            ]
-        });
-    });
-}
-/** @internal */
-function generateDefaultTx(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
-    const { metadata, registry } = (0, index_js_1.initMeta)(data, extraTypes);
-    return generateForMeta(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

package/build/cjs/generate/types.d.ts

@@ -1,12 +0,0 @@
-import type { Option, Text } from '@pezkuwi/types-codec';
-export type ExtraTypes = Record<string, Record<string, {
-    runtime?: Record<string, any>;
-    types: Record<string, any>;
-}>>;
-export declare function getDeprecationNotice<T extends {
-    isDeprecated: boolean;
-    asDeprecated: {
-        note: Text;
-        since: Option<Text>;
-    };
-}>(deprecationInfo: T, name: string, label?: string): string;

package/build/cjs/generate/types.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDeprecationNotice = getDeprecationNotice;
-function getDeprecationNotice(deprecationInfo, name, label) {
-    let deprecationNotice = '@deprecated';
-    if (deprecationInfo.isDeprecated) {
-        const { note, since } = deprecationInfo.asDeprecated;
-        const sinceText = since.isSome ? ` Since ${since.unwrap().toString()}.` : '';
-        deprecationNotice += ` ${note.toString()}${sinceText}`;
-    }
-    else {
-        const labelText = label ? `${label} ` : '';
-        deprecationNotice += ` ${labelText}${name} has been deprecated`;
-    }
-    return deprecationNotice;
-}

package/build/cjs/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-require("./packageDetect.js");
-tslib_1.__exportStar(require("./bundle.js"), exports);