@dedot/codegen 0.0.1-next.fecbe32d.13 → 0.1.0

package/cjs/{generator → shared}/known-codecs.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isKnownCodecType = exports.findKnownWrapperCodec = exports.findKnownCodec = exports.findKnownCodecType = exports.looseTypeCodecs = exports.normalizeCodecName = void 0;
+exports.checkKnownCodecType = exports.findKnownWrapperCodec = exports.findKnownCodec = exports.findKnownCodecType = exports.looseTypeCodecs = exports.normalizeCodecName = void 0;
 const Codecs = __importStar(require("@dedot/codecs"));
 const codecs_1 = require("@dedot/codecs");
 const $ = __importStar(require("@dedot/shape"));
@@ -57,6 +57,8 @@ const KNOWN_PATHS = [
     /^primitive_types::\w+$/,
     /^sp_arithmetic::per_things::\w+$/,
     /^sp_arithmetic::fixed_point::\w+$/,
+    'ink_primitives::types::Hash',
+    { path: 'ink_primitives::types::AccountId', codec: 'AccountId32' },
 ];
 const WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
 const TUPLE_TYPE_REGEX = /^\[(.*)]$/;
@@ -144,8 +146,25 @@ function findKnownWrapperCodec(typeName) {
     }
 }
 exports.findKnownWrapperCodec = findKnownWrapperCodec;
-function isKnownCodecType(path) {
+function checkKnownCodecType(path) {
     const joinedPath = Array.isArray(path) ? path.join('::') : path;
-    return KNOWN_PATHS.some((one) => joinedPath.match(one));
+    const knownPath = KNOWN_PATHS.find((one) => {
+        if (typeof one === 'string') {
+            return one === joinedPath;
+        }
+        else if (one instanceof RegExp) {
+            return one.test(joinedPath);
+        }
+        else {
+            return one.path === joinedPath;
+        }
+    });
+    if (!knownPath) {
+        return [false, ''];
+    }
+    if (typeof knownPath === 'string' || knownPath instanceof RegExp) {
+        return [true, joinedPath.split('::').at(-1)];
+    }
+    return [true, knownPath.codec];
 }
-exports.isKnownCodecType = isKnownCodecType;
+exports.checkKnownCodecType = checkKnownCodecType;

package/cjs/typink/generator/ConstructorQueryGen.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorQueryGen = void 0;
+const utils_js_1 = require("../../utils.js");
+const QueryGen_js_1 = require("./QueryGen.js");
+class ConstructorQueryGen extends QueryGen_js_1.QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericConstructorQuery', 'GenericConstructorQueryCall', 'ConstructorCallOptions', 'ContractInstantiateResult');
+        const { constructors } = this.contractMetadata.spec;
+        const constructorsOut = this.doGenerate(constructors, 'ConstructorCallOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/constructor-query.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, constructorsOut }));
+    }
+    generateMethodDef(def) {
+        const { args } = def;
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ConstructorCallOptions) => Promise<ContractInstantiateResult<ChainApi>>>`;
+    }
+}
+exports.ConstructorQueryGen = ConstructorQueryGen;

package/cjs/typink/generator/ConstructorTxGen.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorTxGen = void 0;
+const utils_js_1 = require("../../utils.js");
+const QueryGen_js_1 = require("./QueryGen.js");
+class ConstructorTxGen extends QueryGen_js_1.QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericConstructorTx', 'GenericConstructorTxCall', 'ConstructorTxOptions', 'GenericInstantiateSubmittableExtrinsic');
+        const { constructors } = this.contractMetadata.spec;
+        const constructorsOut = this.doGenerate(constructors, 'ConstructorTxOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/constructor-tx.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, constructorsOut }));
+    }
+    generateMethodDef(def) {
+        const { args } = def;
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi>>`;
+    }
+}
+exports.ConstructorTxGen = ConstructorTxGen;

package/cjs/typink/generator/EventsGen.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsGen = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
+const QueryGen_js_1 = require("./QueryGen.js");
+class EventsGen extends QueryGen_js_1.QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addContractType('GenericContractEvents', 'GenericContractEvent');
+        const { events } = this.contractMetadata.spec;
+        let eventsOut = '';
+        events.forEach((event) => {
+            const { docs, label } = event;
+            const isV5 = 'signature_topic' in event;
+            eventsOut += `${(0, utils_js_1.commentBlock)(docs, '\n', isV5 ? event.signature_topic ? `@signature_topic: ${event.signature_topic}` : '- Anonymous event' : '')}`;
+            eventsOut += `${(0, utils_1.stringPascalCase)(label)}: ${this.#generateEventDef(event)};\n\n`;
+        });
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/events.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, eventsOut }));
+    }
+    #generateEventDef(event) {
+        const { args, label } = event;
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        return `GenericContractEvent<'${(0, utils_1.stringPascalCase)(label)}', {${paramsOut}}>`;
+    }
+    generateParamsOut(args) {
+        return args
+            .map(({ type: { type }, label, docs, indexed }) => `${(0, utils_js_1.commentBlock)(docs, '\n', `@indexed: ${indexed}`)}${(0, utils_1.stringCamelCase)(label)}: ${this.typesGen.generateType(type, 1)}`)
+            .join(', ');
+    }
+}
+exports.EventsGen = EventsGen;

package/cjs/typink/generator/IndexGen.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexGen = void 0;
+const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../../shared/index.js");
+const utils_js_1 = require("../../utils.js");
+const SUFFIX = 'contract_api';
+class IndexGen {
+    contractMetadata;
+    constructor(contractMetadata) {
+        this.contractMetadata = contractMetadata;
+    }
+    generate(useSubPaths = false) {
+        const contractName = (0, utils_1.stringPascalCase)(`${this.contractMetadata.contract.name}_${SUFFIX}`);
+        const typeImports = new index_js_1.TypeImports();
+        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
+        typeImports.addContractType('GenericContractApi');
+        typeImports.addChainType('SubstrateApi');
+        const importTypes = typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/index.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ contractName, importTypes }));
+    }
+}
+exports.IndexGen = IndexGen;

package/cjs/typink/generator/QueryGen.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryGen = void 0;
+const contracts_1 = require("@dedot/contracts");
+const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
+class QueryGen {
+    contractMetadata;
+    typesGen;
+    constructor(contractMetadata, typeGen) {
+        this.contractMetadata = contractMetadata;
+        this.typesGen = typeGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractQuery', 'GenericContractQueryCall', 'ContractCallOptions', 'GenericContractCallResult', 'ContractCallResult');
+        const { messages } = this.contractMetadata.spec;
+        const queryCallsOut = this.doGenerate(messages, 'ContractCallOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/query.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, queryCallsOut }));
+    }
+    doGenerate(messages, optionsTypeName) {
+        let callsOut = '';
+        messages.forEach((messageDef) => {
+            const { label, docs, selector, args } = messageDef;
+            callsOut += `${(0, utils_js_1.commentBlock)(docs, '\n', args.map((arg) => `@param {${this.typesGen.generateType(arg.type.type, 1)}} ${(0, utils_1.stringCamelCase)(arg.label)}`), optionsTypeName ? `@param {${optionsTypeName}} options` : '', '\n', `@selector ${selector}`)}`;
+            callsOut += `${(0, contracts_1.normalizeLabel)(label)}: ${this.generateMethodDef(messageDef)};\n\n`;
+        });
+        return callsOut;
+    }
+    generateMethodDef(def) {
+        const { args, returnType } = def;
+        this.importType(returnType.type);
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        const typeOut = this.typesGen.generateType(returnType.type, 0, true);
+        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
+    }
+    generateParamsOut(args) {
+        return args
+            .map(({ type: { type }, label }) => `${(0, utils_1.stringCamelCase)(label)}: ${this.typesGen.generateType(type, 1)}`)
+            .join(', ');
+    }
+    importType(typeId) {
+        const contractType = this.contractMetadata.types[typeId];
+        const typeDef = (0, contracts_1.normalizeContractTypeDef)(this.contractMetadata.types[typeId].type.def);
+        if (this.typesGen.includedTypes[contractType.id]) {
+            this.typesGen.addTypeImport(this.typesGen.includedTypes[contractType.id].name);
+            return;
+        }
+        const { type, value } = typeDef;
+        switch (type) {
+            case 'Compact':
+            case 'Primitive':
+            case 'BitSequence':
+                return;
+            case 'Struct':
+                return value.fields.forEach(({ typeId }) => this.importType(typeId));
+            case 'Enum':
+                return value.members.forEach(({ fields }) => fields.map(({ typeId }) => this.importType(typeId)).flat());
+            case 'Tuple':
+                return value.fields.forEach((typeId) => this.importType(typeId));
+            case 'SizedVec':
+                return this.importType(value.typeParam);
+            case 'Sequence':
+                return this.importType(value.typeParam);
+        }
+    }
+}
+exports.QueryGen = QueryGen;

package/cjs/typink/generator/TxGen.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxGen = void 0;
+const utils_js_1 = require("../../utils.js");
+const QueryGen_js_1 = require("./QueryGen.js");
+class TxGen extends QueryGen_js_1.QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractTx', 'GenericContractTxCall', 'ContractTxOptions', 'ContractSubmittableExtrinsic');
+        const { messages } = this.contractMetadata.spec;
+        const txMessages = messages.filter((one) => one.mutates);
+        const txCallsOut = this.doGenerate(txMessages, 'ContractTxOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/tx.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, txCallsOut }));
+    }
+    generateMethodDef(def) {
+        const { args } = def;
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>>`;
+    }
+}
+exports.TxGen = TxGen;

package/cjs/typink/generator/TypesGen.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypesGen = void 0;
+const contracts_1 = require("@dedot/contracts");
+const index_js_1 = require("../../shared/index.js");
+const utils_js_1 = require("../../utils.js");
+const SKIP_TYPES = ['Result', 'Option'];
+class TypesGen extends index_js_1.BaseTypesGen {
+    contractMetadata;
+    constructor(contractMetadata) {
+        super((0, contracts_1.extractContractTypes)(contractMetadata));
+        this.contractMetadata = contractMetadata;
+        this.skipTypes = SKIP_TYPES;
+        this.includedTypes = this.includeTypes();
+    }
+    generate(useSubPaths = false) {
+        let defTypeOut = '';
+        Object.values(this.includedTypes)
+            .filter(({ skip, knownType }) => !(skip || knownType))
+            .forEach(({ nameOut, id }) => {
+            defTypeOut += `export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
+        });
+        const importTypes = this.typeImports.toImports({ excludeModules: ['./types'], useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('typink/templates/types.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
+    }
+}
+exports.TypesGen = TypesGen;

package/cjs/typink/generator/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IndexGen.js"), exports);
+__exportStar(require("./QueryGen.js"), exports);
+__exportStar(require("./TypesGen.js"), exports);
+__exportStar(require("./TxGen.js"), exports);
+__exportStar(require("./ConstructorTxGen.js"), exports);
+__exportStar(require("./ConstructorQueryGen.js"), exports);
+__exportStar(require("./EventsGen.js"), exports);

package/cjs/typink/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateContractTypes = void 0;
+const contracts_1 = require("@dedot/contracts");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const index_js_1 = require("./generator/index.js");
+async function generateContractTypes(metadata, contract, outDir = '.', extension = 'd.ts', useSubPaths = false) {
+    let contractMetadata = typeof metadata === 'string' ? (0, contracts_1.parseRawMetadata)(metadata) : metadata;
+    contract = contract || contractMetadata.contract.name;
+    const dirPath = path_1.default.resolve(outDir, contract);
+    const typesFileName = path_1.default.join(dirPath, `types.${extension}`);
+    const queryTypesFileName = path_1.default.join(dirPath, `query.${extension}`);
+    const txTypesFileName = path_1.default.join(dirPath, `tx.${extension}`);
+    const constructorTxTypesFileName = path_1.default.join(dirPath, `constructor-tx.${extension}`);
+    const constructorQueryTypesFileName = path_1.default.join(dirPath, `constructor-query.${extension}`);
+    const eventsTypesFile = path_1.default.join(dirPath, `events.${extension}`);
+    const indexTypesFileName = path_1.default.join(dirPath, `index.${extension}`);
+    if (!fs_1.default.existsSync(dirPath)) {
+        fs_1.default.mkdirSync(dirPath, { recursive: true });
+    }
+    const typesGen = new index_js_1.TypesGen(contractMetadata);
+    const queryGen = new index_js_1.QueryGen(contractMetadata, typesGen);
+    const txGen = new index_js_1.TxGen(contractMetadata, typesGen);
+    const constructorTxGen = new index_js_1.ConstructorTxGen(contractMetadata, typesGen);
+    const constructorQueryGen = new index_js_1.ConstructorQueryGen(contractMetadata, typesGen);
+    const eventsGen = new index_js_1.EventsGen(contractMetadata, typesGen);
+    const indexGen = new index_js_1.IndexGen(contractMetadata);
+    fs_1.default.writeFileSync(typesFileName, await typesGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(queryTypesFileName, await queryGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(txTypesFileName, await txGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(constructorQueryTypesFileName, await constructorQueryGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(constructorTxTypesFileName, await constructorTxGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(eventsTypesFile, await eventsGen.generate(useSubPaths));
+    fs_1.default.writeFileSync(indexTypesFileName, await indexGen.generate(useSubPaths));
+}
+exports.generateContractTypes = generateContractTypes;

package/cjs/typink/templates/constructor-query.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ConstructorQuery<ChainApi extends GenericSubstrateApi> extends GenericConstructorQuery<ChainApi> {
+    {{{ constructorsOut }}}
+}

package/cjs/typink/templates/constructor-tx.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ConstructorTx<ChainApi extends GenericSubstrateApi> extends GenericConstructorTx<ChainApi> {
+    {{{ constructorsOut }}}
+}

package/cjs/typink/templates/events.hbs

@@ -0,0 +1,8 @@
+// Generated by dedot cli
+
+import { GenericSubstrateApi } from '@dedot/types';
+{{{ importTypes }}}
+
+export interface ContractEvents<ChainApi extends GenericSubstrateApi> extends GenericContractEvents<ChainApi> {
+    {{{ eventsOut }}}
+}

package/cjs/typink/templates/index.hbs

@@ -0,0 +1,16 @@
+// Generated by dedot cli
+
+{{{importTypes}}}
+import { ContractQuery } from './query';
+import { ContractTx } from './tx';
+import { ConstructorQuery } from './constructor-query';
+import { ConstructorTx } from './constructor-tx';
+import { ContractEvents } from './events'
+
+export interface {{{contractName}}}<Rv extends RpcVersion = RpcV2, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi> {
+    query: ContractQuery<ChainApi[Rv]>;
+    tx: ContractTx<ChainApi[Rv]>;
+    constructorQuery: ConstructorQuery<ChainApi[Rv]>;
+    constructorTx: ConstructorTx<ChainApi[Rv]>;
+    events: ContractEvents<ChainApi[Rv]>;
+}

package/cjs/typink/templates/query.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ContractQuery<ChainApi extends GenericSubstrateApi> extends GenericContractQuery<ChainApi> {
+    {{{ queryCallsOut }}}
+}

package/cjs/typink/templates/tx.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ContractTx<ChainApi extends GenericSubstrateApi> extends GenericContractTx<ChainApi> {
+    {{{ txCallsOut }}}
+}

package/cjs/typink/templates/types.hbs

@@ -0,0 +1,5 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+{{{ defTypeOut }}}

package/cjs/{generator/utils.js → utils.js}

@@ -36,7 +36,7 @@ exports.WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
 exports.TUPLE_TYPE_REGEX = /^\[(.*)]$/;
 const commentBlock = (...docs) => {
     const flatLines = docs.flat();
-    if (flatLines.length === 0) {
+    if (flatLines.length === 0 || !flatLines.some((o) => !!o)) {
         return '';
     }
     else {
@@ -49,12 +49,12 @@ ${flatLines.map((line) => `* ${line.replaceAll(/\s+/g, ' ').trim()}`).join('\n')
 };
 exports.commentBlock = commentBlock;
 const beautifySourceCode = async (source) => {
-    const prettierOptions = await prettier.resolveConfig(path.resolve((0, dirname_1.currentDirname)(), '../../../../.prettierrc.js'));
+    const prettierOptions = await prettier.resolveConfig(path.resolve((0, dirname_1.currentDirname)(), '../../../.prettierrc.cjs'));
     return prettier.format(source, { parser: 'babel-ts', ...prettierOptions });
 };
 exports.beautifySourceCode = beautifySourceCode;
-const compileTemplate = (templateFileName) => {
-    const templateFilePath = path.resolve((0, dirname_1.currentDirname)(), `../templates/${templateFileName}`);
+const compileTemplate = (templateFile) => {
+    const templateFilePath = path.resolve((0, dirname_1.currentDirname)(), templateFile);
     return handlebars_1.default.compile(fs.readFileSync(templateFilePath, 'utf8'));
 };
 exports.compileTemplate = compileTemplate;

package/index.d.ts

@@ -1,3 +1,2 @@
-import { MetadataLatest } from '@dedot/codecs';
-export declare function generateTypesFromEndpoint(chain: string, endpoint: string, outDir?: string, extension?: string): Promise<void>;
-export declare function generateTypes(chain: string, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: Record<string, number>, outDir?: string, extension?: string): Promise<void>;
+export * from './chaintypes/index.js';
+export * from './typink/index.js';

package/index.js

@@ -1,48 +1,2 @@
-import { stringCamelCase } from '@dedot/utils';
-import { Dedot } from 'dedot';
-import * as fs from 'fs';
-import * as path from 'path';
-import { ConstsGen, ErrorsGen, EventsGen, IndexGen, QueryGen, JsonRpcGen, RuntimeApisGen, TxGen, TypesGen, } from './generator/index.js';
-export async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts') {
-    const api = await Dedot.new(endpoint);
-    const { methods } = await api.rpc.rpc_methods();
-    const apis = api.runtimeVersion.apis || {};
-    if (!chain) {
-        chain = stringCamelCase(api.runtimeVersion.specName || 'local');
-    }
-    await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension);
-    await api.disconnect();
-}
-export async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir = '.', extension = 'd.ts') {
-    const dirPath = path.resolve(outDir, chain);
-    const defTypesFileName = path.join(dirPath, `types.${extension}`);
-    const constsTypesFileName = path.join(dirPath, `consts.${extension}`);
-    const queryTypesFileName = path.join(dirPath, `query.${extension}`);
-    const jsonRpcFileName = path.join(dirPath, `json-rpc.${extension}`);
-    const indexFileName = path.join(dirPath, `index.${extension}`);
-    const errorsFileName = path.join(dirPath, `errors.${extension}`);
-    const eventsFileName = path.join(dirPath, `events.${extension}`);
-    const runtimeApisFileName = path.join(dirPath, `runtime.${extension}`);
-    const txFileName = path.join(dirPath, `tx.${extension}`);
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-    }
-    const typesGen = new TypesGen(metadata);
-    const constsGen = new ConstsGen(typesGen);
-    const queryGen = new QueryGen(typesGen);
-    const jsonRpcGen = new JsonRpcGen(typesGen, rpcMethods);
-    const indexGen = new IndexGen(chain);
-    const errorsGen = new ErrorsGen(typesGen);
-    const eventsGen = new EventsGen(typesGen);
-    const runtimeApisGen = new RuntimeApisGen(typesGen, runtimeApis);
-    const txGen = new TxGen(typesGen);
-    fs.writeFileSync(defTypesFileName, await typesGen.generate());
-    fs.writeFileSync(errorsFileName, await errorsGen.generate());
-    fs.writeFileSync(eventsFileName, await eventsGen.generate());
-    fs.writeFileSync(jsonRpcFileName, await jsonRpcGen.generate());
-    fs.writeFileSync(queryTypesFileName, await queryGen.generate());
-    fs.writeFileSync(constsTypesFileName, await constsGen.generate());
-    fs.writeFileSync(txFileName, await txGen.generate());
-    fs.writeFileSync(indexFileName, await indexGen.generate());
-    fs.writeFileSync(runtimeApisFileName, await runtimeApisGen.generate());
-}
+export * from './chaintypes/index.js';
+export * from './typink/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.0.1-next.fecbe32d.13+fecbe32",
+  "version": "0.1.0",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/codegen",
@@ -15,35 +15,33 @@
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json && yarn copy",
     "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo",
-    "copy": "cp -R ./src/templates ./dist && cp -R ./src/templates ./dist/cjs"
+    "copy": "cp -R ./src/chaintypes/templates ./dist/chaintypes && cp -R ./src/chaintypes/templates ./dist/cjs/chaintypes && cp -R ./src/typink/templates ./dist/typink && cp -R ./src/typink/templates ./dist/cjs/typink"
   },
   "dependencies": {
-    "@dedot/codecs": "0.0.1-next.fecbe32d.13+fecbe32",
-    "@dedot/shape": "0.0.1-next.fecbe32d.13+fecbe32",
-    "@dedot/specs": "0.0.1-next.fecbe32d.13+fecbe32",
-    "@dedot/utils": "0.0.1-next.fecbe32d.13+fecbe32",
-    "dedot": "0.0.1-next.fecbe32d.13+fecbe32",
+    "@dedot/api": "0.1.0",
+    "@dedot/codecs": "0.1.0",
+    "@dedot/providers": "0.1.0",
+    "@dedot/runtime-specs": "0.1.0",
+    "@dedot/shape": "0.1.0",
+    "@dedot/types": "0.1.0",
+    "@dedot/utils": "0.1.0",
     "handlebars": "^4.7.8",
-    "prettier": "^3.0.3"
+    "prettier": "^3.3.3"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "fecbe32d9d4b04cdb6802bf0ac604222f54b8331",
+  "gitHead": "c8220a4ab4b171fe04adb49759318bde865d7c17",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      },
-      "require": {
-        "types": "./index.d.ts",
-        "default": "./cjs/index.js"
-      }
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./cjs/index.js",
+      "default": "./index.js"
     }
   }
 }

package/{generator/TypesGen.d.ts → shared/BaseTypesGen.d.ts}

@@ -1,6 +1,7 @@
-import { Field, MetadataLatest, PortableRegistry, PortableType, TypeId } from '@dedot/codecs';
+import { Field, PortableType, TypeId } from '@dedot/codecs';
+import { EnumOptions } from '@dedot/shape';
 import { TypeImports } from './TypeImports.js';
-interface NamedType extends PortableType {
+export interface NamedType extends PortableType {
     name: string;
     nameOut: string;
     skip?: boolean;
@@ -8,23 +9,23 @@ interface NamedType extends PortableType {
     suffix?: string;
 }
 export declare const BASIC_KNOWN_TYPES: string[];
-export declare class TypesGen {
+export declare abstract class BaseTypesGen {
     #private;
-    metadata: MetadataLatest;
-    /**
-     * Types will be generated its definition out.
-     */
+    types: PortableType[];
     includedTypes: Record<TypeId, NamedType>;
-    registry: PortableRegistry;
     typeImports: TypeImports;
-    constructor(metadata: MetadataLatest);
-    generate(): Promise<string>;
+    skipTypes: string[];
+    protected constructor(types: PortableType[]);
+    shouldGenerateTypeIn(_id: TypeId): boolean;
     typeCache: Record<string, string>;
     clearCache(): void;
+    includeTypes(): Record<TypeId, NamedType>;
     generateType(typeId: TypeId, nestedLevel?: number, typeOut?: boolean): string;
     generateObjectType(fields: Field[], nestedLevel?: number, typeOut?: boolean): string;
+    cleanPath(path: string[]): string;
     eqlCache: Map<string, boolean>;
     typeEql(idA: number, idB: number, level?: number): boolean;
+    extractDupTypeSuffix(dupTypeId: TypeId, originalTypeId: TypeId, dupCount: number): string;
     addTypeImport(typeName: string | string[]): void;
+    getEnumOptions(_typeId: TypeId): EnumOptions;
 }
-export {};