@dedot/codegen 0.0.1-alpha.4 → 0.0.1-alpha.40

package/cjs/generator/ErrorsGen.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorsGen = void 0;
-const ApiGen_1 = require("./ApiGen");
-const utils_1 = require("./utils");
-const util_1 = require("@polkadot/util");
-const utils_2 = require("@dedot/utils");
-class ErrorsGen extends ApiGen_1.ApiGen {
-    generate() {
-        const { pallets } = this.metadata;
-        this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError');
-        let defTypeOut = '';
-        for (let pallet of pallets) {
-            const errorTypeId = pallet.error;
-            if (!errorTypeId) {
-                continue;
-            }
-            const errorDefs = this.#getErrorDefs(errorTypeId);
-            defTypeOut += (0, utils_1.commentBlock)(`Pallet \`${pallet.name}\`'s errors`);
-            defTypeOut += `${(0, util_1.stringCamelCase)(pallet.name)}: {
-        ${errorDefs
-                .map(({ name, docs }) => `${(0, utils_1.commentBlock)(docs)}${(0, util_1.stringPascalCase)(name)}: GenericPalletError`)
-                .join(',\n')}
-          
-        ${(0, utils_1.commentBlock)('Generic pallet error')}[error: string]: GenericPalletError,
-      },`;
-        }
-        const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_1.compileTemplate)('errors.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
-    }
-    #getErrorDefs(errorTypeId) {
-        const def = this.metadata.types[errorTypeId];
-        (0, utils_2.assert)(def, `Error def not found for id ${errorTypeId}`);
-        const { tag, value } = def.type;
-        (0, utils_2.assert)(tag === 'Enum', `Invalid pallet error type!`);
-        return value.members;
-    }
-}
-exports.ErrorsGen = ErrorsGen;

package/cjs/generator/IndexGen.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexGen = void 0;
-const utils_1 = require("./utils");
-const util_1 = require("@polkadot/util");
-class IndexGen {
-    networkInfo;
-    constructor(networkInfo) {
-        this.networkInfo = networkInfo;
-    }
-    async generate() {
-        const { chain } = this.networkInfo;
-        const interfaceName = (0, util_1.stringPascalCase)(chain);
-        const template = (0, utils_1.compileTemplate)('index.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ interfaceName }));
-    }
-}
-exports.IndexGen = IndexGen;

package/cjs/generator/QueryGen.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryGen = void 0;
-const util_1 = require("@polkadot/util");
-const utils_1 = require("@dedot/utils");
-const generator_1 = require("../generator");
-const utils_2 = require("./utils");
-class QueryGen extends generator_1.ApiGen {
-    generate() {
-        const { pallets } = this.metadata;
-        this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainStorage', 'GenericStorageQuery', 'Callback');
-        let defTypeOut = '';
-        for (let pallet of pallets) {
-            const storage = pallet.storage;
-            if (!storage)
-                continue;
-            const queries = storage.entries.map((one) => this.#generateEntry(one));
-            const queryDefs = queries.map(({ name, valueType, keyType, docs }) => `${(0, utils_2.commentBlock)(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`);
-            defTypeOut += (0, utils_2.commentBlock)(`Pallet \`${pallet.name}\`'s storage queries`);
-            defTypeOut += `${(0, util_1.stringLowerFirst)(pallet.name)}: {
-        ${queryDefs.join(',\n')}
-        
-        ${(0, utils_2.commentBlock)('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
-      },`;
-        }
-        const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_2.compileTemplate)('query.hbs');
-        return (0, utils_2.beautifySourceCode)(template({ importTypes, defTypeOut }));
-    }
-    #generateEntry(entry) {
-        const { name, type, docs, modifier } = entry;
-        let valueType, keyType;
-        if (type.tag === 'Plain') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-        }
-        else if (type.tag === 'Map') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-            keyType = this.typesGen.generateType(type.value.keyTypeId, 1);
-        }
-        else {
-            throw Error('Invalid entry type!');
-        }
-        const isOptional = modifier === 'Optional';
-        valueType = `${valueType}${isOptional ? ' | undefined' : ''}`;
-        docs.push('\n');
-        if (keyType) {
-            docs.push(`@param {${keyType}} arg`);
-        }
-        docs.push(`@param {Callback<${valueType}> =} callback`);
-        return {
-            name: (0, utils_1.normalizeName)(name),
-            valueType,
-            keyType: keyType ? `arg: ${keyType}` : '',
-            docs,
-        };
-    }
-}
-exports.QueryGen = QueryGen;

package/cjs/generator/RpcGen.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcGen = void 0;
-const specs_1 = require("@dedot/specs");
-const utils_1 = require("@dedot/utils");
-const generator_1 = require("../generator");
-const utils_2 = require("./utils");
-const HIDDEN_RPCS = [
-    // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
-    'rpc_methods',
-];
-class RpcGen extends generator_1.ApiGen {
-    typesGen;
-    rpcMethods;
-    constructor(typesGen, rpcMethods) {
-        super(typesGen);
-        this.typesGen = typesGen;
-        this.rpcMethods = rpcMethods;
-        HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
-        rpcMethods.sort();
-    }
-    generate() {
-        this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericRpcCalls', 'Unsub', 'Callback', 'GenericRpcCall');
-        const specsByModule = this.rpcMethods
-            .filter((one) => !(0, specs_1.findAliasRpcSpec)(one)) // we'll ignore  alias rpc for now if defined in the specs! TODO should we generate alias rpc as well?
-            .filter((one) => !(0, specs_1.isUnsubscribeMethod)(one)) // we'll ignore unsubscribe method as well
-            .map((one) => {
-            const spec = (0, specs_1.findRpcSpec)(one);
-            if (spec) {
-                return spec;
-            }
-            const [module, ...methodParts] = one.split('_');
-            const method = methodParts.join('_');
-            return {
-                params: [],
-                type: 'GenericRpcCall',
-                module,
-                method,
-            };
-        })
-            .reduce((o, spec) => {
-            const { module, method } = spec;
-            // ignore if rpc name does not confront with the general convention
-            if (!module || !method) {
-                return o;
-            }
-            return {
-                ...o,
-                [module]: o[module] ? [...o[module], spec] : [spec],
-            };
-        }, {});
-        let rpcCallsOut = '';
-        Object.keys(specsByModule).forEach((module) => {
-            const specs = specsByModule[module];
-            // TODO add alias info to docs block!
-            rpcCallsOut += `${module}: {
-      ${specs.map((spec) => this.#generateMethodDef(spec)).join(',\n')},
-
-      [method: string]: GenericRpcCall,
-    },`;
-        });
-        // TODO include & define external types
-        const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_2.compileTemplate)('rpc.hbs');
-        return (0, utils_2.beautifySourceCode)(template({ importTypes, rpcCallsOut }));
-    }
-    #generateMethodDef(spec) {
-        const { name, type, module, method, docs = [], params, pubsub, deprecated } = spec;
-        const rpcName = name || `${module}_${method}`;
-        let defaultDocs = [`@rpcname: ${rpcName}`];
-        if (deprecated) {
-            defaultDocs.push(`@deprecated: ${deprecated}`);
-        }
-        if (type === 'GenericRpcCall' && params.length === 0) {
-            return `${(0, utils_2.commentBlock)(defaultDocs)}${method}: GenericRpcCall`;
-        }
-        this.addTypeImport(type, false);
-        params.forEach(({ type, isScale }) => {
-            this.addTypeImport(type, !!isScale);
-        });
-        const typedParams = params.map((param) => ({
-            ...param,
-            plainType: this.getGeneratedTypeName(param.type, !!param.isScale),
-        }));
-        const isSubscription = !!pubsub;
-        const paramsOut = typedParams.map(({ name, type, isOptional, isScale, plainType }) => `${name}${isOptional ? '?' : ''}: ${plainType}`);
-        const paramsDoc = typedParams.map(({ name, plainType }) => `@param {${plainType}} ${name}`);
-        const typeOut = this.getGeneratedTypeName(type, false);
-        if (isSubscription) {
-            defaultDocs.shift();
-            defaultDocs.unshift(`@pubsub: ${pubsub?.join(', ')}`);
-            paramsOut.push(`callback: Callback<${typeOut}>`);
-            return `${(0, utils_2.commentBlock)(docs, '\n', defaultDocs, paramsDoc)}${method}: GenericRpcCall<(${paramsOut.join(', ')}) => Promise<Unsub>>`;
-        }
-        else {
-            return `${(0, utils_2.commentBlock)(docs, '\n', defaultDocs, paramsDoc)}${method}: GenericRpcCall<(${paramsOut.join(', ')}) => Promise<${typeOut}>>`;
-        }
-    }
-    // TODO check typeIn, typeOut if param type, or rpc type isScale
-    addTypeImport(type, toTypeIn = true) {
-        if (Array.isArray(type)) {
-            type.forEach((one) => this.addTypeImport(one, toTypeIn));
-            return;
-        }
-        type = type.trim();
-        if ((0, utils_1.isNativeType)(type)) {
-            return;
-        }
-        // Handle generic wrapper types
-        const matchArray = type.match(utils_2.WRAPPER_TYPE_REGEX);
-        if (matchArray) {
-            const [_, $1, $2] = matchArray;
-            this.addTypeImport($1, toTypeIn);
-            if ($2.match(utils_2.WRAPPER_TYPE_REGEX) || $2.match(utils_2.TUPLE_TYPE_REGEX)) {
-                this.addTypeImport($2, toTypeIn);
-            }
-            else {
-                this.addTypeImport($2.split(','), toTypeIn);
-            }
-            return;
-        }
-        // Check tuple type
-        if (type.match(utils_2.TUPLE_TYPE_REGEX)) {
-            this.addTypeImport(type.slice(1, -1).split(','), toTypeIn);
-            return;
-        }
-        if (type.includes(' | ')) {
-            this.addTypeImport(type.split(' | ').map((one) => one.trim()), toTypeIn);
-            return;
-        }
-        try {
-            const codecType = this.#getCodecType(type, toTypeIn);
-            if ((0, utils_1.isNativeType)(codecType))
-                return;
-            this.typesGen.typeImports.addCodecType(codecType);
-            return;
-        }
-        catch (e) { }
-        this.typesGen.addTypeImport(type);
-    }
-    getGeneratedTypeName(type, toTypeIn = true) {
-        try {
-            const matchArray = type.match(utils_2.WRAPPER_TYPE_REGEX);
-            if (matchArray) {
-                const [_, $1, $2] = matchArray;
-                const wrapperTypeName = this.#getCodecType($1, toTypeIn);
-                if ($2.match(utils_2.WRAPPER_TYPE_REGEX) || $2.match(utils_2.TUPLE_TYPE_REGEX)) {
-                    return `${wrapperTypeName}<${this.getGeneratedTypeName($2, toTypeIn)}>`;
-                }
-                const innerTypeNames = $2
-                    .split(',')
-                    .map((one) => this.getGeneratedTypeName(one.trim(), toTypeIn))
-                    .join(', ');
-                return `${wrapperTypeName}<${innerTypeNames}>`;
-            }
-            else if (type.match(utils_2.TUPLE_TYPE_REGEX)) {
-                const innerTypeNames = type
-                    .slice(1, -1)
-                    .split(',')
-                    .map((one) => this.getGeneratedTypeName(one.trim(), toTypeIn))
-                    .join(', ');
-                return `[${innerTypeNames}]`;
-            }
-            return this.#getCodecType(type, toTypeIn);
-        }
-        catch (e) { }
-        return type;
-    }
-    #getCodecType(type, toTypeIn = true) {
-        const { typeIn, typeOut } = this.registry.findCodecType(type);
-        return toTypeIn ? typeIn : typeOut;
-    }
-}
-exports.RpcGen = RpcGen;

package/cjs/generator/RuntimeApisGen.js

@@ -1,120 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuntimeApisGen = void 0;
-const specs_1 = require("@dedot/specs");
-const utils_1 = require("./utils");
-const utils_2 = require("@dedot/utils");
-const RpcGen_1 = require("./RpcGen");
-const util_1 = require("@polkadot/util");
-class RuntimeApisGen extends RpcGen_1.RpcGen {
-    typesGen;
-    runtimeApis;
-    constructor(typesGen, runtimeApis) {
-        super(typesGen, []);
-        this.typesGen = typesGen;
-        this.runtimeApis = runtimeApis;
-    }
-    generate() {
-        this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericRuntimeApis', 'GenericRuntimeApiMethod');
-        let runtimeCallsOut = '';
-        if (this.metadata.apis.length > 0) {
-            this.metadata.apis.forEach((runtimeApi) => {
-                const { name: runtimeApiName, methods } = runtimeApi;
-                runtimeCallsOut += (0, utils_1.commentBlock)(`@runtimeapi: ${runtimeApiName} - ${(0, utils_2.calculateRuntimeApiHash)(runtimeApiName)}`);
-                runtimeCallsOut += `${(0, util_1.stringCamelCase)(runtimeApiName)}: {
-            ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
-              
-            ${(0, utils_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
-        }`;
-            });
-        }
-        else {
-            const specsByModule = this.#runtimeApisSpecsByModule();
-            Object.values(specsByModule).forEach((specs) => {
-                specs.forEach(({ methods, runtimeApiName, runtimeApiHash, version }) => {
-                    runtimeCallsOut += (0, utils_1.commentBlock)(`@runtimeapi: ${runtimeApiName} - ${runtimeApiHash}`, `@version: ${version}`);
-                    runtimeCallsOut += `${(0, util_1.stringCamelCase)(runtimeApiName)}: {
-            ${Object.keys(methods)
-                        .map((methodName) => this.#generateMethodDefFromSpec({ ...methods[methodName], runtimeApiName, methodName }))
-                        .join('\n')} 
-              
-            ${(0, utils_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
-          }`;
-                });
-            });
-        }
-        const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_1.compileTemplate)('runtime.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ importTypes, runtimeCallsOut }));
-    }
-    #isOptionalType(type) {
-        return type.startsWith('Option<') || type.endsWith('| undefined');
-    }
-    #isOptionalParam(params, type, idx) {
-        return this.#isOptionalType(type) && params.slice(idx + 1).every(({ type }) => this.#isOptionalType(type));
-    }
-    #generateMethodDefFromSpec(spec) {
-        const { docs = [], params, type, runtimeApiName, methodName } = spec;
-        const callName = `${runtimeApiName}_${(0, utils_2.stringSnakeCase)(methodName)}`;
-        const defaultDocs = [`@callname: ${callName}`];
-        this.addTypeImport(type, false);
-        params.forEach(({ type }) => this.addTypeImport(type));
-        const typedParams = params.map((param, idx) => ({
-            ...param,
-            isOptional: this.#isOptionalParam(params, param.type, idx),
-            plainType: this.getGeneratedTypeName(param.type),
-        }));
-        const paramsOut = typedParams
-            .map(({ name, isOptional, plainType }) => `${(0, util_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${plainType}`)
-            .join(', ');
-        const typeOut = this.getGeneratedTypeName(type, false);
-        return `${(0, utils_1.commentBlock)(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
-    }
-    #generateMethodDef(runtimeApiName, methodDef) {
-        const { name: methodName, inputs, output, docs } = methodDef;
-        const callName = `${runtimeApiName}_${(0, utils_2.stringSnakeCase)(methodName)}`;
-        const defaultDocs = [`@callname: ${callName}`];
-        const typeOut = this.typesGen.generateType(output, 1, true);
-        this.addTypeImport(typeOut, false);
-        const typedInputs = inputs
-            .map((input, idx) => ({
-            ...input,
-            type: this.typesGen.generateType(input.typeId, 1),
-        }))
-            .map((input, idx, inputs) => ({
-            ...input,
-            isOptional: this.#isOptionalParam(inputs, input.type, idx),
-        }));
-        this.addTypeImport(typedInputs.map((t) => t.type));
-        const paramsOut = typedInputs
-            .map(({ name, type, isOptional }) => `${(0, util_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${type}`)
-            .join(', ');
-        return `${(0, utils_1.commentBlock)(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${(0, util_1.stringCamelCase)(methodName)}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
-    }
-    #runtimeApisSpecsByModule() {
-        const specs = this.runtimeApis.map(([runtimeApiHash, version]) => {
-            const runtimeApiSpec = (0, specs_1.findRuntimeApiSpec)(runtimeApiHash, version);
-            if (!runtimeApiSpec)
-                return;
-            return {
-                ...runtimeApiSpec,
-                runtimeApiHash,
-            };
-        });
-        return specs.reduce((o, spec) => {
-            if (!spec) {
-                return o;
-            }
-            const { moduleName } = spec;
-            if (!moduleName) {
-                return o;
-            }
-            return {
-                ...o,
-                [moduleName]: o[moduleName] ? [...o[moduleName], spec] : [spec],
-            };
-        }, {});
-    }
-}
-exports.RuntimeApisGen = RuntimeApisGen;

package/cjs/packageInfo.js

@@ -1,5 +0,0 @@
-"use strict";
-// THIS FILE IS AUTO-GENERATED, DO NOT EDIT!
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packageInfo = void 0;
-exports.packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.23' };

package/genSupportedChainTypes.d.ts

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

package/genSupportedChainTypes.js

@@ -1,74 +0,0 @@
-import { generateTypes, generateTypesFromChain } from './index';
-import { rpc } from '@polkadot/types-support/metadata/static-substrate';
-import staticSubstrate from '@polkadot/types-support/metadata/v15/substrate-hex';
-import { $Metadata, CodecRegistry } from '@dedot/codecs';
-import { ConstantExecutor } from 'dedot';
-const NETWORKS = [
-    {
-        chain: 'substrate',
-        metadataHex: staticSubstrate,
-        rpcMethods: rpc.methods,
-    },
-    {
-        chain: 'polkadot',
-        endpoint: 'wss://rpc.polkadot.io',
-    },
-    {
-        chain: 'kusama',
-        endpoint: 'wss://kusama-rpc.polkadot.io',
-    },
-    {
-        chain: 'astar',
-        endpoint: 'wss://rpc.astar.network',
-    },
-    {
-        chain: 'moonbeam',
-        endpoint: 'wss://moonbeam.api.onfinality.io/public-ws',
-    },
-    {
-        chain: 'polkadotAssetHub',
-        endpoint: 'wss://polkadot-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'kusamaAssetHub',
-        endpoint: 'wss://kusama-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'rococoAssetHub',
-        endpoint: 'wss://rococo-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'aleph',
-        endpoint: 'wss://aleph-zero.api.onfinality.io/public-ws',
-    },
-    {
-        chain: 'westendAssetHub',
-        endpoint: 'wss://westend-asset-hub-rpc.polkadot.io',
-    },
-];
-const OUT_DIR = 'packages/chaintypes/src';
-async function run() {
-    for (const network of NETWORKS) {
-        const { chain, endpoint, metadataHex, rpcMethods } = network;
-        if (endpoint) {
-            console.log(`Generate types for ${chain} via endpoint ${endpoint}`);
-            await generateTypesFromChain(network, endpoint, OUT_DIR);
-        }
-        else if (metadataHex && rpcMethods) {
-            console.log(`Generate types for ${chain} via raw data`);
-            const metadata = $Metadata.tryDecode(metadataHex);
-            const runtimeVersion = getRuntimeVersion(metadata);
-            await generateTypes(network, metadata.latest, rpcMethods, runtimeVersion.apis, OUT_DIR);
-        }
-    }
-    console.log('DONE!');
-}
-const getRuntimeVersion = (metadata) => {
-    const registry = new CodecRegistry(metadata.latest);
-    const executor = new ConstantExecutor({
-        registry,
-        metadataLatest: metadata.latest,
-    });
-    return executor.execute('system', 'version');
-};
-run().catch(console.log);

package/generator/ConstsGen.d.ts

@@ -1,4 +0,0 @@
-import { ApiGen } from '../generator';
-export declare class ConstsGen extends ApiGen {
-    generate(): Promise<string>;
-}

package/generator/ErrorsGen.d.ts

@@ -1,5 +0,0 @@
-import { ApiGen } from './ApiGen';
-export declare class ErrorsGen extends ApiGen {
-    #private;
-    generate(): Promise<string>;
-}

package/generator/EventsGen.d.ts

@@ -1,5 +0,0 @@
-import { ApiGen } from './ApiGen';
-export declare class EventsGen extends ApiGen {
-    #private;
-    generate(): Promise<string>;
-}

package/generator/IndexGen.d.ts

@@ -1,6 +0,0 @@
-import { NetworkInfo } from '../types';
-export declare class IndexGen {
-    readonly networkInfo: NetworkInfo;
-    constructor(networkInfo: NetworkInfo);
-    generate(): Promise<string>;
-}

package/generator/IndexGen.js

@@ -1,14 +0,0 @@
-import { beautifySourceCode, compileTemplate } from './utils';
-import { stringPascalCase } from '@polkadot/util';
-export class IndexGen {
-    networkInfo;
-    constructor(networkInfo) {
-        this.networkInfo = networkInfo;
-    }
-    async generate() {
-        const { chain } = this.networkInfo;
-        const interfaceName = stringPascalCase(chain);
-        const template = compileTemplate('index.hbs');
-        return beautifySourceCode(template({ interfaceName }));
-    }
-}

package/generator/QueryGen.d.ts

@@ -1,5 +0,0 @@
-import { ApiGen } from '../generator';
-export declare class QueryGen extends ApiGen {
-    #private;
-    generate(): Promise<string>;
-}

package/generator/QueryGen.js

@@ -1,55 +0,0 @@
-import { stringLowerFirst } from '@polkadot/util';
-import { normalizeName } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-export class QueryGen extends ApiGen {
-    generate() {
-        const { pallets } = this.metadata;
-        this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainStorage', 'GenericStorageQuery', 'Callback');
-        let defTypeOut = '';
-        for (let pallet of pallets) {
-            const storage = pallet.storage;
-            if (!storage)
-                continue;
-            const queries = storage.entries.map((one) => this.#generateEntry(one));
-            const queryDefs = queries.map(({ name, valueType, keyType, docs }) => `${commentBlock(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`);
-            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s storage queries`);
-            defTypeOut += `${stringLowerFirst(pallet.name)}: {
-        ${queryDefs.join(',\n')}
-        
-        ${commentBlock('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
-      },`;
-        }
-        const importTypes = this.typesGen.typeImports.toImports();
-        const template = compileTemplate('query.hbs');
-        return beautifySourceCode(template({ importTypes, defTypeOut }));
-    }
-    #generateEntry(entry) {
-        const { name, type, docs, modifier } = entry;
-        let valueType, keyType;
-        if (type.tag === 'Plain') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-        }
-        else if (type.tag === 'Map') {
-            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-            keyType = this.typesGen.generateType(type.value.keyTypeId, 1);
-        }
-        else {
-            throw Error('Invalid entry type!');
-        }
-        const isOptional = modifier === 'Optional';
-        valueType = `${valueType}${isOptional ? ' | undefined' : ''}`;
-        docs.push('\n');
-        if (keyType) {
-            docs.push(`@param {${keyType}} arg`);
-        }
-        docs.push(`@param {Callback<${valueType}> =} callback`);
-        return {
-            name: normalizeName(name),
-            valueType,
-            keyType: keyType ? `arg: ${keyType}` : '',
-            docs,
-        };
-    }
-}

package/generator/RpcGen.d.ts

@@ -1,10 +0,0 @@
-import { ApiGen, TypesGen } from '../generator';
-export declare class RpcGen extends ApiGen {
-    #private;
-    readonly typesGen: TypesGen;
-    readonly rpcMethods: string[];
-    constructor(typesGen: TypesGen, rpcMethods: string[]);
-    generate(): Promise<string>;
-    addTypeImport(type: string | string[], toTypeIn?: boolean): void;
-    getGeneratedTypeName(type: string, toTypeIn?: boolean): string;
-}