@dedot/codegen 0.0.1-alpha.28 → 0.0.1-alpha.29

package/cjs/generator/TypesGen.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypesGen = exports.BASIC_KNOWN_TYPES = void 0;
-const util_1 = require("@polkadot/util");
 const codecs_1 = require("@dedot/codecs");
 const utils_1 = require("@dedot/utils");
-const utils_2 = require("./utils");
-const known_types_1 = require("./known-types");
-const TypeImports_1 = require("./TypeImports");
-const known_codecs_1 = require("./known-codecs");
+const utils_js_1 = require("./utils.js");
+const known_types_js_1 = require("./known-types.js");
+const TypeImports_js_1 = require("./TypeImports.js");
+const known_codecs_js_1 = require("./known-codecs.js");
 // Skip generate types for these
 // as we do have native types for them
 const SKIP_TYPES = [
@@ -43,7 +42,7 @@ class TypesGen {
         this.metadata = metadata;
         this.registry = new codecs_1.PortableRegistry(this.metadata);
         this.includedTypes = this.#includedTypes();
-        this.typeImports = new TypeImports_1.TypeImports();
+        this.typeImports = new TypeImports_js_1.TypeImports();
     }
     generate() {
         this.clearCache();
@@ -51,14 +50,14 @@ class TypesGen {
         Object.values(this.includedTypes)
             .filter(({ skip, knownType }) => !(skip || knownType))
             .forEach(({ name, nameOut, id, docs }) => {
-            defTypeOut += `${(0, utils_2.commentBlock)(docs)}export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
+            defTypeOut += `${(0, utils_js_1.commentBlock)(docs)}export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
             if (this.#shouldGenerateTypeIn(id)) {
                 defTypeOut += `export type ${name} = ${this.generateType(id)};\n\n`;
             }
         });
         const importTypes = this.typeImports.toImports('./types');
-        const template = (0, utils_2.compileTemplate)('types.hbs');
-        return (0, utils_2.beautifySourceCode)(template({ importTypes, defTypeOut }));
+        const template = (0, utils_js_1.compileTemplate)('types.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
     typeCache = {};
     clearCache() {
@@ -103,7 +102,7 @@ class TypesGen {
         const { tag, value } = type;
         switch (tag) {
             case 'Primitive':
-                const $codec = (0, known_codecs_1.findKnownCodec)(value.kind);
+                const $codec = (0, known_codecs_js_1.findKnownCodec)(value.kind);
                 if ($codec.nativeType) {
                     return $codec.nativeType;
                 }
@@ -151,12 +150,12 @@ class TypesGen {
                     return 'null';
                 }
                 else if (members.every((x) => x.fields.length === 0)) {
-                    return members.map(({ name, docs }) => `${(0, utils_2.commentBlock)(docs)}'${(0, util_1.stringPascalCase)(name)}'`).join(' | ');
+                    return members.map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}'${(0, utils_1.stringPascalCase)(name)}'`).join(' | ');
                 }
                 else {
                     const membersType = [];
                     for (const { fields, name, docs } of members) {
-                        const keyName = (0, util_1.stringPascalCase)(name);
+                        const keyName = (0, utils_1.stringPascalCase)(name);
                         if (fields.length === 0) {
                             membersType.push([keyName, null, docs]);
                         }
@@ -164,7 +163,7 @@ class TypesGen {
                             const valueType = fields.length === 1
                                 ? this.generateType(fields[0].typeId, nestedLevel + 1, typeOut)
                                 : `[${fields
-                                    .map(({ typeId, docs }) => `${(0, utils_2.commentBlock)(docs)}${this.generateType(typeId, nestedLevel + 1, typeOut)}`)
+                                    .map(({ typeId, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${this.generateType(typeId, nestedLevel + 1, typeOut)}`)
                                     .join(', ')}]`;
                             membersType.push([keyName, valueType, docs]);
                         }
@@ -179,7 +178,7 @@ class TypesGen {
                         value: valueType ? `, ${valueKey}${this.#isOptionalType(valueType) ? '?' : ''}: ${valueType} ` : '',
                         docs,
                     }))
-                        .map(({ tag, value, docs }) => `${(0, utils_2.commentBlock)(docs)}{ ${tag}${value} }`)
+                        .map(({ tag, value, docs }) => `${(0, utils_js_1.commentBlock)(docs)}{ ${tag}${value} }`)
                         .join(' | ');
                 }
             }
@@ -226,7 +225,7 @@ class TypesGen {
             };
         });
         return `{${props
-            .map(({ name, type, optional, docs }) => `${(0, utils_2.commentBlock)(docs)}${name}${optional ? '?' : ''}: ${type}`)
+            .map(({ name, type, optional, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${name}${optional ? '?' : ''}: ${type}`)
             .join(',\n')}}`;
     }
     #isOptionalType(type) {
@@ -267,8 +266,8 @@ class TypesGen {
             const suffix = typeSuffixes.get(id) || '';
             let knownType = false;
             let name, nameOut;
-            if ((0, known_codecs_1.isKnownCodecType)(joinedPath)) {
-                const codecType = (0, known_codecs_1.findKnownCodecType)(path.at(-1));
+            if ((0, known_codecs_js_1.isKnownCodecType)(joinedPath)) {
+                const codecType = (0, known_codecs_js_1.findKnownCodecType)(path.at(-1));
                 name = codecType.typeIn;
                 nameOut = codecType.typeOut;
                 knownType = true;
@@ -315,7 +314,7 @@ class TypesGen {
      */
     #cleanPath(path) {
         return path
-            .map((one) => (0, util_1.stringPascalCase)(one))
+            .map((one) => (0, utils_1.stringPascalCase)(one))
             .filter((one, idx, currentPath) => idx === 0 || one !== currentPath[idx - 1])
             .join('');
     }
@@ -390,10 +389,10 @@ class TypesGen {
         if (diffParam?.typeId) {
             const diffType = types[diffParam.typeId];
             if (diffType.path.length > 0) {
-                return (0, util_1.stringPascalCase)(diffType.path.at(-1));
+                return (0, utils_1.stringPascalCase)(diffType.path.at(-1));
             }
             else if (diffType.type.tag === 'Primitive') {
-                return (0, util_1.stringPascalCase)(diffType.type.value.kind);
+                return (0, utils_1.stringPascalCase)(diffType.type.value.kind);
             }
         }
         // Last resort!
@@ -404,7 +403,7 @@ class TypesGen {
             typeName.forEach((one) => this.addTypeImport(one));
             return;
         }
-        if ((0, utils_1.isNativeType)(typeName)) {
+        if ((0, utils_js_1.isNativeType)(typeName)) {
             return;
         }
         for (let type of Object.values(this.includedTypes)) {
@@ -426,7 +425,7 @@ class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (known_types_1.knownTypes.includes(typeName)) {
+        if (known_types_js_1.knownTypes.includes(typeName)) {
             this.typeImports.addKnownType(typeName);
         }
         else {

package/cjs/generator/index.js

@@ -14,13 +14,13 @@ 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("./TypesGen"), exports);
-__exportStar(require("./ApiGen"), exports);
-__exportStar(require("./ConstsGen"), exports);
-__exportStar(require("./QueryGen"), exports);
-__exportStar(require("./RpcGen"), exports);
-__exportStar(require("./IndexGen"), exports);
-__exportStar(require("./ErrorsGen"), exports);
-__exportStar(require("./EventsGen"), exports);
-__exportStar(require("./TxGen"), exports);
-__exportStar(require("./RuntimeApisGen"), exports);
+__exportStar(require("./TypesGen.js"), exports);
+__exportStar(require("./ApiGen.js"), exports);
+__exportStar(require("./ConstsGen.js"), exports);
+__exportStar(require("./QueryGen.js"), exports);
+__exportStar(require("./RpcGen.js"), exports);
+__exportStar(require("./IndexGen.js"), exports);
+__exportStar(require("./ErrorsGen.js"), exports);
+__exportStar(require("./EventsGen.js"), exports);
+__exportStar(require("./TxGen.js"), exports);
+__exportStar(require("./RuntimeApisGen.js"), exports);

package/cjs/generator/utils.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReservedWord = exports.compileTemplate = exports.beautifySourceCode = exports.commentBlock = exports.TUPLE_TYPE_REGEX = exports.WRAPPER_TYPE_REGEX = void 0;
+exports.isNativeType = exports.isReservedWord = exports.compileTemplate = exports.beautifySourceCode = exports.commentBlock = exports.TUPLE_TYPE_REGEX = exports.WRAPPER_TYPE_REGEX = void 0;
 const fs = __importStar(require("fs"));
 const handlebars_1 = __importDefault(require("handlebars"));
 const path = __importStar(require("path"));
@@ -66,3 +66,32 @@ const TS_RESERVED_WORDS = ['new', 'class'];
  */
 const isReservedWord = (word) => TS_RESERVED_WORDS.includes(word);
 exports.isReservedWord = isReservedWord;
+const TS_PRIMITIVE_TYPES = [
+    'void',
+    'undefined',
+    'null',
+    'number',
+    'boolean',
+    'bigint',
+    'Map',
+    'Set',
+    'string',
+    'any',
+    'Array',
+    'Record',
+];
+/**
+ * Check if a type is native JS/TS type
+ * @param type
+ */
+const isNativeType = (type) => {
+    return TS_PRIMITIVE_TYPES.some((one) => {
+        if (typeof one === 'string') {
+            return one === type;
+        }
+        else {
+            return type.match(one);
+        }
+    });
+};
+exports.isNativeType = isNativeType;

package/cjs/index.js

@@ -23,25 +23,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTypes = exports.generateTypesFromChain = void 0;
+exports.generateTypes = exports.generateTypesFromEndpoint = void 0;
 const dedot_1 = require("dedot");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const generator_1 = require("./generator");
-const util_1 = require("@polkadot/util");
-async function generateTypesFromChain(network, endpoint, outDir) {
-    const api = await dedot_1.Dedot.create(endpoint);
+const index_js_1 = require("./generator/index.js");
+const utils_1 = require("@dedot/utils");
+async function generateTypesFromEndpoint(chain, endpoint, outDir) {
+    const api = await dedot_1.Dedot.new(endpoint);
     const { methods } = await api.rpc.rpc.methods();
     const apis = api.runtimeVersion?.apis || [];
-    if (!network.chain) {
-        network.chain = (0, util_1.stringCamelCase)(api.runtimeVersion?.specName || api.runtimeChain || 'local');
+    if (!chain) {
+        chain = (0, utils_1.stringCamelCase)(api.runtimeVersion?.specName || api.runtimeChain || 'local');
     }
-    await generateTypes(network, api.metadataLatest, methods, apis, outDir);
+    await generateTypes(chain, api.metadataLatest, methods, apis, outDir);
     await api.disconnect();
 }
-exports.generateTypesFromChain = generateTypesFromChain;
-async function generateTypes(network, metadata, rpcMethods, runtimeApis, outDir = '.') {
-    const dirPath = path.resolve(outDir, network.chain);
+exports.generateTypesFromEndpoint = generateTypesFromEndpoint;
+async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir = '.') {
+    const dirPath = path.resolve(outDir, chain);
     const defTypesFileName = path.join(dirPath, `types.d.ts`);
     const constsTypesFileName = path.join(dirPath, `consts.d.ts`);
     const queryTypesFileName = path.join(dirPath, `query.d.ts`);
@@ -54,15 +54,15 @@ async function generateTypes(network, metadata, rpcMethods, runtimeApis, outDir
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
-    const typesGen = new generator_1.TypesGen(metadata);
-    const constsGen = new generator_1.ConstsGen(typesGen);
-    const queryGen = new generator_1.QueryGen(typesGen);
-    const rpcGen = new generator_1.RpcGen(typesGen, rpcMethods);
-    const indexGen = new generator_1.IndexGen(network);
-    const errorsGen = new generator_1.ErrorsGen(typesGen);
-    const eventsGen = new generator_1.EventsGen(typesGen);
-    const runtimeApisGen = new generator_1.RuntimeApisGen(typesGen, runtimeApis);
-    const txGen = new generator_1.TxGen(typesGen);
+    const typesGen = new index_js_1.TypesGen(metadata);
+    const constsGen = new index_js_1.ConstsGen(typesGen);
+    const queryGen = new index_js_1.QueryGen(typesGen);
+    const rpcGen = new index_js_1.RpcGen(typesGen, rpcMethods);
+    const indexGen = new index_js_1.IndexGen(chain);
+    const errorsGen = new index_js_1.ErrorsGen(typesGen);
+    const eventsGen = new index_js_1.EventsGen(typesGen);
+    const runtimeApisGen = new index_js_1.RuntimeApisGen(typesGen, runtimeApis);
+    const txGen = new index_js_1.TxGen(typesGen);
     fs.writeFileSync(defTypesFileName, await typesGen.generate());
     fs.writeFileSync(errorsFileName, await errorsGen.generate());
     fs.writeFileSync(eventsFileName, await eventsGen.generate());

package/generator/ApiGen.d.ts

@@ -1,4 +1,4 @@
-import { TypesGen } from '../generator';
+import { TypesGen } from '../generator/index.js';
 export declare abstract class ApiGen {
     readonly typesGen: TypesGen;
     constructor(typesGen: TypesGen);

package/generator/ConstsGen.d.ts

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

package/generator/ConstsGen.js

@@ -1,7 +1,6 @@
-import { stringLowerFirst } from '@polkadot/util';
-import { normalizeName } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { normalizeName, stringCamelCase } from '@dedot/utils';
+import { ApiGen } from '../generator/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class ConstsGen extends ApiGen {
     generate() {
         const { pallets } = this.metadata;
@@ -15,7 +14,7 @@ export class ConstsGen extends ApiGen {
                 docs: one.docs,
             }));
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s constants`);
-            defTypeOut += `${stringLowerFirst(pallet.name)}: {
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${typedConstants.map(({ name, type, docs }) => `${commentBlock(docs)}${name}: ${type}`).join(',\n')}
           
         ${commentBlock('Generic pallet constant')}[name: string]: any,

package/generator/ErrorsGen.d.ts

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

package/generator/ErrorsGen.js

@@ -1,7 +1,6 @@
-import { ApiGen } from './ApiGen';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { assert } from '@dedot/utils';
+import { ApiGen } from './ApiGen.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
+import { assert, stringCamelCase, stringPascalCase } from '@dedot/utils';
 export class ErrorsGen extends ApiGen {
     generate() {
         const { pallets } = this.metadata;

package/generator/EventsGen.d.ts

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

package/generator/EventsGen.js

@@ -1,7 +1,6 @@
-import { ApiGen } from './ApiGen';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { assert } from '@dedot/utils';
+import { ApiGen } from './ApiGen.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
+import { assert, stringCamelCase, stringPascalCase } from '@dedot/utils';
 export class EventsGen extends ApiGen {
     generate() {
         const { pallets } = this.metadata;

package/generator/IndexGen.d.ts

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

package/generator/IndexGen.js

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

package/generator/QueryGen.d.ts

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

package/generator/QueryGen.js

@@ -1,7 +1,6 @@
-import { stringLowerFirst } from '@polkadot/util';
-import { normalizeName } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { normalizeName, stringCamelCase } from '@dedot/utils';
+import { ApiGen } from '../generator/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class QueryGen extends ApiGen {
     generate() {
         const { pallets } = this.metadata;
@@ -15,7 +14,7 @@ export class QueryGen extends ApiGen {
             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)}: {
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${queryDefs.join(',\n')}
         
         ${commentBlock('Generic pallet storage query')}[storage: string]: GenericStorageQuery;

package/generator/RpcGen.d.ts

@@ -1,4 +1,4 @@
-import { ApiGen, TypesGen } from '../generator';
+import { ApiGen, TypesGen } from '../generator/index.js';
 export declare class RpcGen extends ApiGen {
     #private;
     readonly typesGen: TypesGen;

package/generator/RpcGen.js

@@ -1,8 +1,7 @@
 import { findAliasRpcSpec, findRpcSpec, isUnsubscribeMethod } from '@dedot/specs';
-import { isNativeType } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX } from './utils';
-import { findKnownCodecType } from './known-codecs';
+import { ApiGen } from '../generator/index.js';
+import { isNativeType, beautifySourceCode, commentBlock, compileTemplate, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX, } from './utils.js';
+import { findKnownCodecType } from './known-codecs.js';
 const HIDDEN_RPCS = [
     // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
     'rpc_methods',

package/generator/RuntimeApisGen.d.ts

@@ -1,5 +1,5 @@
-import { TypesGen } from './TypesGen';
-import { RpcGen } from './RpcGen';
+import { TypesGen } from './TypesGen.js';
+import { RpcGen } from './RpcGen.js';
 export declare class RuntimeApisGen extends RpcGen {
     #private;
     readonly typesGen: TypesGen;

package/generator/RuntimeApisGen.js

@@ -1,8 +1,7 @@
 import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/specs';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-import { calculateRuntimeApiHash, stringSnakeCase } from '@dedot/utils';
-import { RpcGen } from './RpcGen';
-import { stringCamelCase } from '@polkadot/util';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
+import { calcRuntimeApiHash, stringSnakeCase, stringCamelCase } from '@dedot/utils';
+import { RpcGen } from './RpcGen.js';
 export class RuntimeApisGen extends RpcGen {
     typesGen;
     runtimeApis;
@@ -18,7 +17,7 @@ export class RuntimeApisGen extends RpcGen {
         if (this.metadata.apis.length > 0) {
             this.metadata.apis.forEach((runtimeApi) => {
                 const { name: runtimeApiName, methods } = runtimeApi;
-                runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${calculateRuntimeApiHash(runtimeApiName)}`);
+                runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${calcRuntimeApiHash(runtimeApiName)}`);
                 runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
             ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
               
@@ -109,7 +108,7 @@ export class RuntimeApisGen extends RpcGen {
         }, []);
     }
     #findRuntimeApiSpec = (runtimeApiHash, version) => {
-        const runtimeApiName = getRuntimeApiNames().find((one) => calculateRuntimeApiHash(one) === runtimeApiHash);
+        const runtimeApiName = getRuntimeApiNames().find((one) => calcRuntimeApiHash(one) === runtimeApiHash);
         return getRuntimeApiSpecs().find((one) => one.runtimeApiName === runtimeApiName && one.version === version);
     };
 }

package/generator/TxGen.d.ts

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

package/generator/TxGen.js

@@ -1,6 +1,6 @@
-import { ApiGen } from '../generator';
-import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from './utils';
+import { ApiGen } from '../generator/index.js';
+import { stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from './utils.js';
 export class TxGen extends ApiGen {
     generate() {
         const { pallets, types } = this.metadata;

package/generator/TypesGen.d.ts

@@ -1,5 +1,5 @@
 import { PortableRegistry, Field, MetadataLatest, PortableType, TypeId } from '@dedot/codecs';
-import { TypeImports } from './TypeImports';
+import { TypeImports } from './TypeImports.js';
 interface NamedType extends PortableType {
     name: string;
     nameOut: string;

package/generator/TypesGen.js

@@ -1,10 +1,9 @@
-import { stringPascalCase } from '@polkadot/util';
 import { PortableRegistry } from '@dedot/codecs';
-import { isNativeType, normalizeName } from '@dedot/utils';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-import { knownTypes } from './known-types';
-import { TypeImports } from './TypeImports';
-import { findKnownCodec, findKnownCodecType, isKnownCodecType } from './known-codecs';
+import { normalizeName, stringPascalCase } from '@dedot/utils';
+import { isNativeType, beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
+import { knownTypes } from './known-types.js';
+import { TypeImports } from './TypeImports.js';
+import { findKnownCodec, findKnownCodecType, isKnownCodecType } from './known-codecs.js';
 // Skip generate types for these
 // as we do have native types for them
 const SKIP_TYPES = [

package/generator/index.d.ts

@@ -1,10 +1,10 @@
-export * from './TypesGen';
-export * from './ApiGen';
-export * from './ConstsGen';
-export * from './QueryGen';
-export * from './RpcGen';
-export * from './IndexGen';
-export * from './ErrorsGen';
-export * from './EventsGen';
-export * from './TxGen';
-export * from './RuntimeApisGen';
+export * from './TypesGen.js';
+export * from './ApiGen.js';
+export * from './ConstsGen.js';
+export * from './QueryGen.js';
+export * from './RpcGen.js';
+export * from './IndexGen.js';
+export * from './ErrorsGen.js';
+export * from './EventsGen.js';
+export * from './TxGen.js';
+export * from './RuntimeApisGen.js';

package/generator/index.js

@@ -1,10 +1,10 @@
-export * from './TypesGen';
-export * from './ApiGen';
-export * from './ConstsGen';
-export * from './QueryGen';
-export * from './RpcGen';
-export * from './IndexGen';
-export * from './ErrorsGen';
-export * from './EventsGen';
-export * from './TxGen';
-export * from './RuntimeApisGen';
+export * from './TypesGen.js';
+export * from './ApiGen.js';
+export * from './ConstsGen.js';
+export * from './QueryGen.js';
+export * from './RpcGen.js';
+export * from './IndexGen.js';
+export * from './ErrorsGen.js';
+export * from './EventsGen.js';
+export * from './TxGen.js';
+export * from './RuntimeApisGen.js';

package/generator/utils.d.ts

@@ -8,3 +8,8 @@ export declare const compileTemplate: (templateFileName: string) => HandlebarsTe
  * @param word
  */
 export declare const isReservedWord: (word: string) => boolean;
+/**
+ * Check if a type is native JS/TS type
+ * @param type
+ */
+export declare const isNativeType: (type: string) => boolean;

package/generator/utils.js

@@ -33,3 +33,31 @@ const TS_RESERVED_WORDS = ['new', 'class'];
  * @param word
  */
 export const isReservedWord = (word) => TS_RESERVED_WORDS.includes(word);
+const TS_PRIMITIVE_TYPES = [
+    'void',
+    'undefined',
+    'null',
+    'number',
+    'boolean',
+    'bigint',
+    'Map',
+    'Set',
+    'string',
+    'any',
+    'Array',
+    'Record',
+];
+/**
+ * Check if a type is native JS/TS type
+ * @param type
+ */
+export const isNativeType = (type) => {
+    return TS_PRIMITIVE_TYPES.some((one) => {
+        if (typeof one === 'string') {
+            return one === type;
+        }
+        else {
+            return type.match(one);
+        }
+    });
+};

package/index.d.ts

@@ -1,4 +1,3 @@
 import { MetadataLatest } from '@dedot/codecs';
-import { NetworkInfo } from './types';
-export declare function generateTypesFromChain(network: NetworkInfo, endpoint: string, outDir: string): Promise<void>;
-export declare function generateTypes(network: NetworkInfo, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: any[], outDir?: string): Promise<void>;
+export declare function generateTypesFromEndpoint(chain: string, endpoint: string, outDir?: string): Promise<void>;
+export declare function generateTypes(chain: string, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: any[], outDir?: string): Promise<void>;