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

package/cjs/{generator/TypesGen.js → shared/BaseTypesGen.js}

@@ -1,69 +1,96 @@
 "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");
+exports.BaseTypesGen = exports.BASIC_KNOWN_TYPES = void 0;
 const utils_1 = require("@dedot/utils");
-const utils_2 = require("./utils");
-const types_1 = require("@dedot/types");
-const TypeImports_1 = require("./TypeImports");
-// Skip generate types for these
-// as we do have native types for them
-const SKIP_TYPES = [
-    'BoundedBTreeMap',
-    'BoundedBTreeSet',
-    'BoundedVec',
-    'Box',
-    'BTreeMap',
-    'BTreeSet',
-    'Cow',
-    'Option',
-    'Range',
-    'RangeInclusive',
-    'Result',
-    'WeakBoundedVec',
-    'WrapperKeepOpaque',
-    'WrapperOpaque',
-];
+const utils_js_1 = require("../utils.js");
+const TypeImports_js_1 = require("./TypeImports.js");
+const known_codecs_js_1 = require("./known-codecs.js");
 // These are common & generic types, so we'll remove these from all paths at index 1
 // This helps make the type name shorter
 const PATH_RM_INDEX_1 = ['generic', 'misc', 'pallet', 'traits', 'types'];
 exports.BASIC_KNOWN_TYPES = ['BitSequence', 'Bytes', 'BytesLike', 'FixedBytes', 'FixedArray', 'Result'];
-const WRAPPER_TYPE_REGEX = /^(\w+)(<.*>)$/g;
-class TypesGen {
-    metadata;
-    /**
-     * Types will be generated its definition out.
-     */
+class BaseTypesGen {
+    types;
     includedTypes;
-    registry;
     typeImports;
-    constructor(metadata) {
-        this.metadata = metadata;
-        this.registry = new codecs_1.CodecRegistry(this.metadata);
-        this.includedTypes = this.#includedTypes();
-        this.typeImports = new TypeImports_1.TypeImports();
+    skipTypes;
+    constructor(types) {
+        this.types = types;
+        this.includedTypes = {};
+        this.typeImports = new TypeImports_js_1.TypeImports();
+        this.skipTypes = [];
     }
-    generate() {
-        this.clearCache();
-        let defTypeOut = '';
-        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`;
-            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 }));
+    shouldGenerateTypeIn(_id) {
+        return false;
     }
     typeCache = {};
     clearCache() {
         this.typeCache = {};
         this.typeImports.clear();
     }
+    includeTypes() {
+        const pathsCount = new Map();
+        const typesWithPath = this.types.filter((one) => one.path.length > 0);
+        const skipIds = [];
+        const typeSuffixes = new Map();
+        typesWithPath.forEach(({ path, id }) => {
+            const joinedPath = path.join('::');
+            if (pathsCount.has(joinedPath)) {
+                // We compare 2 types with the same path here,
+                //  if they are the same type -> skip the current one, keep the first occurrence
+                //  if they are not the same type but has the same path -> we'll try to calculate & add a suffix for the current type name
+                const firstOccurrenceTypeId = pathsCount.get(joinedPath)[0];
+                const sameType = this.typeEql(firstOccurrenceTypeId, id);
+                if (sameType) {
+                    skipIds.push(id);
+                }
+                else {
+                    pathsCount.get(joinedPath).push(id);
+                    typeSuffixes.set(id, this.extractDupTypeSuffix(id, firstOccurrenceTypeId, pathsCount.get(joinedPath).length));
+                }
+            }
+            else {
+                pathsCount.set(joinedPath, [id]);
+            }
+        });
+        return typesWithPath.reduce((o, type) => {
+            const { path, id } = type;
+            const joinedPath = path.join('::');
+            if (this.skipTypes.includes(joinedPath) || this.skipTypes.includes(path.at(-1))) {
+                return o;
+            }
+            const suffix = typeSuffixes.get(id) || '';
+            let knownType = false;
+            let name, nameOut;
+            const [isKnownCodecType, codecName] = (0, known_codecs_js_1.checkKnownCodecType)(joinedPath);
+            if (isKnownCodecType) {
+                const codecType = (0, known_codecs_js_1.findKnownCodecType)(codecName);
+                name = codecType.typeIn;
+                nameOut = codecType.typeOut;
+                knownType = true;
+            }
+            else if (PATH_RM_INDEX_1.includes(path[1])) {
+                const newPath = path.slice();
+                newPath.splice(1, 1);
+                name = this.cleanPath(newPath);
+            }
+            else {
+                name = this.cleanPath(path);
+            }
+            if (this.shouldGenerateTypeIn(id)) {
+                nameOut = name;
+                name = name.endsWith('Like') ? name : `${name}Like`;
+            }
+            o[id] = {
+                name: `${name}${suffix}`,
+                nameOut: nameOut ? `${nameOut}${suffix}` : `${name}${suffix}`,
+                knownType,
+                skip: skipIds.includes(id),
+                ...type,
+            };
+            return o;
+        }, {});
+    }
     generateType(typeId, nestedLevel = 0, typeOut = false) {
         if (nestedLevel > 0) {
             const includedDef = this.includedTypes[typeId];
@@ -94,15 +121,15 @@ class TypesGen {
         return type;
     }
     #generateType(typeId, nestedLevel = 0, typeOut = false) {
-        const def = this.metadata.types[typeId];
+        const def = this.types[typeId];
         if (!def) {
             throw new Error(`Type def not found ${JSON.stringify(def)}`);
         }
-        const { type, path, docs } = def;
-        const { tag, value } = type;
-        switch (tag) {
+        const { typeDef, path, docs } = def;
+        const { type, value } = typeDef;
+        switch (type) {
             case 'Primitive':
-                const $codec = this.registry.findCodec(value.kind);
+                const $codec = (0, known_codecs_js_1.findKnownCodec)(value.kind);
                 if ($codec.nativeType) {
                     return $codec.nativeType;
                 }
@@ -150,12 +177,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]);
                         }
@@ -163,7 +190,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]);
                         }
@@ -171,14 +198,14 @@ class TypesGen {
                             membersType.push([keyName, this.generateObjectType(fields, nestedLevel + 1, typeOut), docs]);
                         }
                     }
-                    const { tagKey, valueKey } = this.registry.portableRegistry.getEnumOptions(typeId);
+                    const { tagKey, valueKey } = this.getEnumOptions(typeId);
                     return membersType
                         .map(([keyName, valueType, docs]) => ({
-                        tag: `${tagKey}: '${keyName}'`,
+                        type: `${tagKey}: '${keyName}'`,
                         value: valueType ? `, ${valueKey}${this.#isOptionalType(valueType) ? '?' : ''}: ${valueType} ` : '',
                         docs,
                     }))
-                        .map(({ tag, value, docs }) => `${(0, utils_2.commentBlock)(docs)}{ ${tag}${value} }`)
+                        .map(({ type, value, docs }) => `${(0, utils_js_1.commentBlock)(docs)}{ ${type}${value} }`)
                         .join(' | ');
                 }
             }
@@ -200,9 +227,9 @@ class TypesGen {
                 return this.generateType(value.typeParam, nestedLevel + 1, typeOut);
             case 'Sequence':
             case 'SizedVec': {
-                const fixedSize = tag === 'SizedVec' ? `${value.len}` : null;
-                const $innerType = this.metadata.types[value.typeParam].type;
-                if ($innerType.tag === 'Primitive' && $innerType.value.kind === 'u8') {
+                const fixedSize = type === 'SizedVec' ? `${value.len}` : null;
+                const $innerType = this.types[value.typeParam].typeDef;
+                if ($innerType.type === 'Primitive' && $innerType.value.kind === 'u8') {
                     return fixedSize ? `FixedBytes<${fixedSize}>` : typeOut ? 'Bytes' : 'BytesLike';
                 }
                 else {
@@ -211,7 +238,7 @@ class TypesGen {
                 }
             }
             default:
-                throw new Error(`Invalid type! ${tag}`);
+                throw new Error(`Invalid type! ${type}`);
         }
     }
     generateObjectType(fields, nestedLevel = 0, typeOut = false) {
@@ -225,104 +252,26 @@ 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) {
         return type.endsWith('| undefined');
     }
-    #includedTypes() {
-        const { types } = this.metadata;
-        const pathsCount = new Map();
-        const typesWithPath = types.filter((one) => one.path.length > 0);
-        const skipIds = [];
-        const typeSuffixes = new Map();
-        typesWithPath.forEach(({ path, id }) => {
-            const joinedPath = path.join('::');
-            if (pathsCount.has(joinedPath)) {
-                // We compare 2 types with the same path here,
-                //  if they are the same type -> skip the current one, keep the first occurrence
-                //  if they are not the same type but has the same path -> we'll try to calculate & add a suffix for the current type name
-                const firstOccurrenceTypeId = pathsCount.get(joinedPath)[0];
-                const sameType = this.typeEql(firstOccurrenceTypeId, id);
-                if (sameType) {
-                    skipIds.push(id);
-                }
-                else {
-                    pathsCount.get(joinedPath).push(id);
-                    typeSuffixes.set(id, this.#extractDupTypeSuffix(id, firstOccurrenceTypeId, pathsCount.get(joinedPath).length));
-                }
-            }
-            else {
-                pathsCount.set(joinedPath, [id]);
-            }
-        });
-        return typesWithPath.reduce((o, type) => {
-            const { path, id } = type;
-            const joinedPath = path.join('::');
-            if (SKIP_TYPES.includes(joinedPath) || SKIP_TYPES.includes(path.at(-1))) {
-                return o;
-            }
-            const suffix = typeSuffixes.get(id) || '';
-            let knownType = false;
-            let name, nameOut;
-            if (this.registry.isKnownType(joinedPath)) {
-                const codecType = this.registry.findCodecType(path.at(-1));
-                name = codecType.typeIn;
-                nameOut = codecType.typeOut;
-                knownType = true;
-            }
-            else if (PATH_RM_INDEX_1.includes(path[1])) {
-                const newPath = path.slice();
-                newPath.splice(1, 1);
-                name = this.#cleanPath(newPath);
-            }
-            else {
-                name = this.#cleanPath(path);
-            }
-            if (this.#shouldGenerateTypeIn(id)) {
-                nameOut = name;
-                name = name.endsWith('Like') ? name : `${name}Like`;
-            }
-            o[id] = {
-                name: `${name}${suffix}`,
-                nameOut: nameOut ? `${nameOut}${suffix}` : `${name}${suffix}`,
-                knownType,
-                skip: skipIds.includes(id),
-                ...type,
-            };
-            return o;
-        }, {});
-    }
     #removeGenericPart(typeName) {
-        if (typeName.match(WRAPPER_TYPE_REGEX)) {
-            return typeName.replace(WRAPPER_TYPE_REGEX, (_, $1) => $1);
+        if (typeName.match(utils_js_1.WRAPPER_TYPE_REGEX)) {
+            return typeName.replace(utils_js_1.WRAPPER_TYPE_REGEX, (_, $1) => $1);
         }
         else {
             return typeName;
         }
     }
-    /**
-     * @description Remove duplicated part of the path
-     *
-     * Example:
-     * ["pallet_staking", "pallet", "pallet", "Event"]
-     * => ["pallet_staking", "pallet", "Event"]
-     *
-     * @param path
-     * @private
-     */
-    #cleanPath(path) {
+    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('');
     }
-    #shouldGenerateTypeIn(id) {
-        const { callTypeId } = this.metadata.extrinsic;
-        const palletCallTypeIds = this.registry.portableRegistry.getPalletCallTypeIds();
-        return callTypeId === id || palletCallTypeIds.includes(id);
-    }
     eqlCache = new Map();
     typeEql(idA, idB, level = 0) {
         const cacheKey = `${idA}==${idB}`;
@@ -335,36 +284,36 @@ class TypesGen {
     #typeEql(idA, idB, lvl = 0) {
         if (idA === idB)
             return true;
-        const { types } = this.metadata;
-        const typeA = types[idA];
-        const typeB = types[idB];
+        const typeA = this.types[idA];
+        const typeB = this.types[idB];
         if (typeA.path.join('::') !== typeB.path.join('::'))
             return false;
-        const { type: defA, params: paramsA } = typeA;
-        const { type: defB, params: paramsB } = typeB;
+        const { typeDef: defA, params: paramsA } = typeA;
+        const { typeDef: defB, params: paramsB } = typeB;
         if (!this.#eqlArray(paramsA, paramsB, (valA, valB) => this.#eqlTypeParam(valA, valB))) {
             return false;
         }
-        if (defA.tag !== defB.tag)
+        if (defA.type !== defB.type)
             return false;
-        if (defA.tag === 'BitSequence')
+        if (defA.type === 'BitSequence')
             return true;
-        if (defA.tag === 'Primitive' && defB.tag === 'Primitive') {
+        if (defA.type === 'Primitive' && defB.type === 'Primitive') {
             return defA.value.kind === defB.value.kind;
         }
-        if ((defA.tag === 'Compact' && defB.tag === 'Compact') || (defA.tag === 'Sequence' && defB.tag === 'Sequence')) {
+        if ((defA.type === 'Compact' && defB.type === 'Compact') ||
+            (defA.type === 'Sequence' && defB.type === 'Sequence')) {
             return this.typeEql(defA.value.typeParam, defB.value.typeParam, lvl + 1);
         }
-        if (defA.tag === 'SizedVec' && defB.tag === 'SizedVec') {
+        if (defA.type === 'SizedVec' && defB.type === 'SizedVec') {
             return defA.value.len === defB.value.len && this.typeEql(defA.value.typeParam, defB.value.typeParam, lvl + 1);
         }
-        if (defA.tag === 'Tuple' && defB.tag === 'Tuple') {
+        if (defA.type === 'Tuple' && defB.type === 'Tuple') {
             return this.#eqlArray(defA.value.fields, defB.value.fields, (val1, val2) => this.typeEql(val1, val2, lvl + 1));
         }
-        if (defA.tag === 'Struct' && defB.tag === 'Struct') {
+        if (defA.type === 'Struct' && defB.type === 'Struct') {
             return this.#eqlFields(defA.value.fields, defB.value.fields, lvl);
         }
-        if (defA.tag === 'Enum' && defB.tag === 'Enum') {
+        if (defA.type === 'Enum' && defB.type === 'Enum') {
             return this.#eqlArray(defA.value.members, defB.value.members, (val1, val2) => val1.name === val2.name && val1.index === val2.index && this.#eqlFields(val1.fields, val2.fields, lvl));
         }
         return false;
@@ -380,19 +329,18 @@ class TypesGen {
             (param1.typeId === undefined) === (param2.typeId === undefined) &&
             (param1.typeId === undefined || this.#typeEql(param1.typeId, param2.typeId)));
     }
-    #extractDupTypeSuffix(dupTypeId, originalTypeId, dupCount) {
-        const { types } = this.metadata;
-        const originalTypeParams = types[originalTypeId].params;
-        const dupTypeParams = types[dupTypeId].params;
+    extractDupTypeSuffix(dupTypeId, originalTypeId, dupCount) {
+        const originalTypeParams = this.types[originalTypeId].params;
+        const dupTypeParams = this.types[dupTypeId].params;
         const diffParam = dupTypeParams.find((one, idx) => !this.#eqlTypeParam(one, originalTypeParams[idx]));
         // TODO make sure these suffix is unique if a type is duplicated more than 2 times
         if (diffParam?.typeId) {
-            const diffType = types[diffParam.typeId];
+            const diffType = this.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);
+            else if (diffType.typeDef.type === 'Primitive') {
+                return (0, utils_1.stringPascalCase)(diffType.typeDef.value.kind);
             }
         }
         // Last resort!
@@ -403,7 +351,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)) {
@@ -425,12 +373,10 @@ class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (types_1.registry.has(typeName)) {
-            this.typeImports.addKnownType(typeName);
-        }
-        else {
-            this.typeImports.addOutType(typeName);
-        }
+        this.typeImports.addOutType(typeName);
+    }
+    getEnumOptions(_typeId) {
+        return { tagKey: 'type', valueKey: 'value' };
     }
 }
-exports.TypesGen = TypesGen;
+exports.BaseTypesGen = BaseTypesGen;

package/cjs/{generator → shared}/TypeImports.js

@@ -8,30 +8,47 @@ class TypeImports {
     codecTypes;
     // Known types that're not codecs or chain/portable types defined in @dedot/types
     knownTypes;
+    knownJsonRpcTypes;
     // External types to define explicitly
     outTypes;
+    // Know types defined in @dedot/contracts
+    contractTypes;
+    // Know types defined in @dedot/api/chaintypes or dedot/chaintypes
+    chainTypes;
     constructor() {
         this.portableTypes = new Set();
         this.codecTypes = new Set();
         this.knownTypes = new Set();
+        this.knownJsonRpcTypes = new Set();
         this.outTypes = new Set();
+        this.contractTypes = new Set();
+        this.chainTypes = new Set();
     }
     clear() {
         this.portableTypes.clear();
         this.codecTypes.clear();
         this.knownTypes.clear();
+        this.knownJsonRpcTypes.clear();
         this.outTypes.clear();
+        this.contractTypes.clear();
+        this.chainTypes.clear();
     }
-    toImports(...excludeModules) {
+    toImports(config) {
+        const { excludeModules = [], useSubPaths = false } = config || {};
         // TODO generate outTypes!
+        const prefix = useSubPaths ? '' : '@';
         const toImports = [
-            [this.knownTypes, '@dedot/types'],
-            [this.codecTypes, '@dedot/codecs'],
+            [this.knownTypes, `${prefix}dedot/types`],
+            [this.knownJsonRpcTypes, `${prefix}dedot/types/json-rpc`],
+            [this.codecTypes, `${prefix}dedot/codecs`],
+            [this.contractTypes, `${prefix}dedot/contracts`],
+            [this.chainTypes, prefix ? '@dedot/api/chaintypes' : 'dedot/chaintypes'],
             [this.portableTypes, './types'],
         ];
         return toImports
             .filter(([_, module]) => !excludeModules.includes(module))
             .map(([types, module]) => this.#toImportLine(types, module))
+            .filter((line) => line.length > 0)
             .join('\n');
     }
     #toImportLine(types, module) {
@@ -49,8 +66,17 @@ class TypeImports {
     addKnownType(...types) {
         types.forEach((one) => this.knownTypes.add(one));
     }
+    addKnownJsonRpcType(...types) {
+        types.forEach((one) => this.knownJsonRpcTypes.add(one));
+    }
     addOutType(...types) {
         types.forEach((one) => this.outTypes.add(one));
     }
+    addContractType(...types) {
+        types.forEach((one) => this.contractTypes.add(one));
+    }
+    addChainType(...types) {
+        types.forEach((one) => this.chainTypes.add(one));
+    }
 }
 exports.TypeImports = TypeImports;

package/cjs/{generator → shared}/index.js

@@ -14,13 +14,6 @@ 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("./BaseTypesGen.js"), exports);
+__exportStar(require("./known-codecs.js"), exports);
+__exportStar(require("./TypeImports.js"), exports);