@pezkuwi/typegen 16.5.5 → 16.5.6

package/cjs/generate/tx.js

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

package/cjs/generate/types.js

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

package/cjs/index.js

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

package/cjs/interfacesTs.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const tslib_1 = require("tslib");
+const asset_hub_dicle_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/asset-hub-dicle-hex"));
+const asset_hub_pezkuwi_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/asset-hub-pezkuwi-hex"));
+const dicle_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/dicle-hex"));
+const pezkuwi_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/pezkuwi-hex"));
+const bizinikiwi_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/bizinikiwi-hex"));
+const index_js_1 = require("./generate/index.js");
+const BASE = 'packages/api-augment/src';
+const METAS = Object.entries({ assetHubDicle: asset_hub_dicle_hex_1.default, assetHubPezkuwi: asset_hub_pezkuwi_hex_1.default, dicle: dicle_hex_1.default, pezkuwi: pezkuwi_hex_1.default, bizinikiwi: bizinikiwi_hex_1.default });
+function main() {
+    (0, index_js_1.generateDefaultInterface)();
+    (0, index_js_1.generateDefaultLookup)();
+    (0, index_js_1.generateDefaultRpc)();
+    (0, index_js_1.generateDefaultTsDef)();
+    for (const [name, staticMeta] of METAS) {
+        console.log();
+        console.log(`*** Generating for ${name}`);
+        (0, index_js_1.generateDefaultConsts)(`${BASE}/${name}/consts.ts`, staticMeta);
+        (0, index_js_1.generateDefaultErrors)(`${BASE}/${name}/errors.ts`, staticMeta);
+        (0, index_js_1.generateDefaultEvents)(`${BASE}/${name}/events.ts`, staticMeta);
+        (0, index_js_1.generateDefaultQuery)(`${BASE}/${name}/query.ts`, staticMeta);
+        (0, index_js_1.generateDefaultRuntime)(`${BASE}/${name}/runtime.ts`, staticMeta);
+        (0, index_js_1.generateDefaultTx)(`${BASE}/${name}/tx.ts`, staticMeta);
+    }
+}