@hyperweb/telescope 1.15.0

package/main/generators/create-mobx-bundle.js

@@ -0,0 +1,52 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const ast_1 = require("@cosmology/ast");
+const dotty = __importStar(require("dotty"));
+const utils_1 = require("../utils");
+const plugin = (builder) => {
+    // if mobx is enabled
+    // generate stores.ts based on query hooks generated in each package.
+    // eg: __fixtures__/output1/stores.ts
+    if (!builder.options.mobx?.enabled) {
+        return;
+    }
+    // get mapping of packages and rpc query filenames.
+    const obj = {};
+    const bundlerFiles = builder.stateManagers["mobx"];
+    if (!bundlerFiles || !bundlerFiles.length) {
+        return;
+    }
+    bundlerFiles.map((queryClient) => {
+        const path = `./${queryClient.localname.replace(/\.ts$/, '')}`;
+        dotty.put(obj, queryClient.package, path);
+    });
+    (0, utils_1.commonBundlePlugin)(builder, 'mobx.stores.ts', obj, (context, obj) => {
+        // generate code for createRpcQueryHooks and imports of related packages.
+        return (0, ast_1.createMobxQueryFactory)(context, obj);
+    });
+};
+exports.plugin = plugin;

package/main/generators/create-msg-funcs.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const ast_1 = require("@cosmology/ast");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const parse_1 = require("../parse");
+const utils_1 = require("@cosmology/utils");
+const types_1 = require("@cosmology/types");
+const files_1 = require("../utils/files");
+const plugin = (builder, bundler) => {
+    const mutationContexts = bundler.contexts.filter((context) => context.mutations.length > 0);
+    const clients = mutationContexts
+        .map((c) => {
+        const enabled = c.proto.pluginValue("helperFunctions.enabled");
+        if (!enabled)
+            return;
+        const serviceTypes = c.proto.pluginValue("helperFunctions.include.serviceTypes");
+        if (serviceTypes && !serviceTypes.includes("Tx")) {
+            return;
+        }
+        if (c.proto.isExcluded())
+            return;
+        const localname = bundler.getLocalFilename(c.ref, "rpc.func");
+        const localnameReact = bundler.getLocalFilename(c.ref, `rpc.react`);
+        const localnameVue = bundler.getLocalFilename(c.ref, `rpc.vue`);
+        const filename = bundler.getFilename(localname);
+        const filenameReact = bundler.getFilename(localnameReact);
+        const filenameVue = bundler.getFilename(localnameVue);
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        (0, parse_1.parse)(ctx);
+        const proto = (0, proto_parser_1.getNestedProto)(c.ref.traversed);
+        // hard-coding, for now, only Msg service
+        if (!proto?.Msg || proto.Msg?.type !== "Service") {
+            return;
+        }
+        const asts = [];
+        const reactAsts = [];
+        const vueAsts = [];
+        const helperCreatorNameList = [];
+        const bundlerFile = {
+            proto: c.ref.filename,
+            package: c.ref.proto.package,
+            localname,
+            filename,
+            isMsg: true,
+        };
+        types_1.TX_SVC_TYPES.forEach((svcKey) => {
+            if (proto[svcKey]) {
+                const svc = proto[svcKey];
+                const patterns = c.proto.pluginValue("helperFunctions.include.patterns");
+                const nameMappers = c.proto.pluginValue("helperFunctions.nameMappers");
+                const methodKeys = (0, utils_1.getQueryMethodNames)(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns || ["**"], String);
+                // see if the function is excluded.
+                if (!methodKeys || !methodKeys.length) {
+                    return;
+                }
+                // for each method key, create creators, hooks.
+                methodKeys.forEach((methodKey) => {
+                    // get helperCreatorName
+                    // get hookName
+                    const { creator: helperCreatorName, hook: hookName } = (0, utils_1.getHelperFuncName)(bundlerFile.package, methodKey, [nameMappers?.Msg, nameMappers?.All], "unchanged");
+                    helperCreatorNameList.push(helperCreatorName);
+                    const genCustomHooks = c.proto.pluginValue("helperFunctions.hooks.react");
+                    const genCustomHooksVue = c.proto.pluginValue("helperFunctions.hooks.vue");
+                    // Store the mapping in builder
+                    builder.addFunctionMapping(bundlerFile.package, svcKey, methodKey, helperCreatorName, hookName, svc.methods[methodKey].comment, svc.methods[methodKey].requestType, svc.methods[methodKey].responseType, localname, // function source file
+                    genCustomHooks ? localnameReact : undefined, // hook source file (React)
+                    bundler.getLocalFilename(c.ref) // type source file (main types file)
+                    );
+                    // gen helper funcs
+                    asts.push((0, ast_1.createMsgHelperCreator)(ctx.generic, svc.methods[methodKey], helperCreatorName));
+                    if (genCustomHooks) {
+                        // gen custom react hooks
+                        reactAsts.push((0, ast_1.createMsgHooks)(ctx.generic, svc.methods[methodKey], helperCreatorName, hookName));
+                    }
+                    if (genCustomHooksVue) {
+                        // gen custom vue hooks
+                        vueAsts.push((0, ast_1.createVueMsgHooks)(ctx.generic, svc.methods[methodKey], helperCreatorName, hookName));
+                    }
+                });
+            }
+        });
+        if (!asts.length) {
+            return;
+        }
+        const serviceImports = (0, imports_1.getDepsFromQueries)(ctx.mutations, localname);
+        const serviceImportsReact = (0, imports_1.getDepsFromQueries)(ctx.mutations, localnameReact);
+        const serviceImportsVue = (0, imports_1.getDepsFromQueries)(ctx.mutations, localnameVue);
+        // add imports from func file like query.rpc.func.ts without the .ts extension
+        const funcFileName = "./".concat(localname.substring(localname.lastIndexOf("/") + 1).replace(/\.ts$/, ""));
+        serviceImportsReact[funcFileName] = helperCreatorNameList;
+        serviceImportsVue[funcFileName] = helperCreatorNameList;
+        const imports = (0, imports_1.buildAllImports)(ctx, serviceImports, localname);
+        const importsReact = (0, imports_1.buildAllImports)(ctx, serviceImportsReact, localnameReact);
+        const importsVue = (0, imports_1.buildAllImports)(ctx, serviceImportsVue, localnameReact);
+        const prog = [].concat(imports).concat(ctx.body).concat(asts);
+        const progReact = [].concat(importsReact).concat(reactAsts);
+        const progVue = [].concat(importsVue).concat(vueAsts);
+        const exportedTypeNames = (0, files_1.getExportedTypeNames)(prog);
+        const exportedTypeNamesReact = (0, files_1.getExportedTypeNames)(progReact);
+        const exportedTypeNamesVue = (0, files_1.getExportedTypeNames)(progVue);
+        exportedTypeNames.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localname);
+        });
+        exportedTypeNamesReact.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localnameReact);
+        });
+        exportedTypeNamesVue.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localnameVue);
+        });
+        bundler.writeAst(prog, filename);
+        bundler.addExportObjToBundle(c.ref.proto.package, localname, exportedTypeNames, true);
+        if (reactAsts.length) {
+            bundler.writeAst(progReact, filenameReact);
+            bundler.addExportObjToBundle(c.ref.proto.package, localnameReact, exportedTypeNamesReact, true);
+        }
+        if (vueAsts.length) {
+            bundler.writeAst(progVue, filenameVue);
+            bundler.addExportObjToBundle(c.ref.proto.package, localnameVue, exportedTypeNamesVue, true);
+        }
+        bundler.addToBundle(c, localname);
+        return {
+            package: c.ref.proto.package,
+            localname,
+            filename,
+        };
+    })
+        .filter(Boolean);
+};
+exports.plugin = plugin;

package/main/generators/create-pinia-store-bundle.js

@@ -0,0 +1,50 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const utils_1 = require("../utils");
+const dotty = __importStar(require("dotty"));
+const ast_1 = require("@cosmology/ast");
+const plugin = (builder) => {
+    // if not enabled, exit
+    if (!builder.options?.pinia?.enabled) {
+        return;
+    }
+    // get mapping of packages and rpc query filenames.
+    const obj = {};
+    const bundlerFiles = builder.stateManagers['pinia'];
+    if (!bundlerFiles || !bundlerFiles.length) {
+        return;
+    }
+    bundlerFiles.map((queryClient) => {
+        const path = `./${queryClient.localname.replace(/\.ts$/, '')}`;
+        dotty.put(obj, queryClient.package, path);
+    });
+    (0, utils_1.commonBundlePlugin)(builder, 'pinia.store.ts', obj, (context, obj) => {
+        // generate code for createRpcQueryHooks and imports of related packages.
+        return (0, ast_1.createPiniaStoreFactory)(context, obj);
+    });
+};
+exports.plugin = plugin;

package/main/generators/create-pinia-store.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const parse_1 = require("../parse");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const ast_1 = require("@cosmology/ast");
+const plugin = (builder, bundler) => {
+    if (!builder.options.pinia?.enabled) {
+        return;
+    }
+    // get mapping of packages and rpc query filenames.
+    if (!builder.options.lcdClients?.enabled) {
+        return;
+    }
+    const queryContexts = bundler.contexts.filter((context) => context.queries.length > 0 || context.services.length > 0);
+    if (queryContexts.length > 0) {
+        const piniaBundlerFiles = [];
+        // [x] write out one registry helper for all contexts w/mutations
+        queryContexts.forEach((c) => {
+            const enabled = c.proto.pluginValue('lcdClients.enabled');
+            if (!enabled)
+                return;
+            const includePinia = c.proto.pluginValue('pinia.enabled') &&
+                (0, proto_parser_1.isRefIncluded)(c.ref, c.proto.pluginValue('pinia.include'));
+            if (!includePinia)
+                return;
+            if (c.proto.isExcluded())
+                return;
+            const ctx = bundler.getFreshContext(c);
+            // get mutations, services
+            (0, parse_1.parse)(ctx);
+            const proto = (0, proto_parser_1.getNestedProto)(c.ref.traversed);
+            //// Anything except Msg Service OK...
+            const allowedRpcServices = builder.options.rpcClients.enabledServices.filter((a) => a !== 'Msg');
+            let name, getImportsFrom;
+            // get imports
+            allowedRpcServices.forEach((svcKey) => {
+                if (proto[svcKey]) {
+                    if (svcKey === 'Query') {
+                        getImportsFrom = ctx.queries;
+                    }
+                    else {
+                        getImportsFrom = ctx.services;
+                    }
+                    name = svcKey;
+                }
+            });
+            const localname = bundler.getLocalFilename(c.ref, 'pinia.store');
+            const filename = bundler.getFilename(localname);
+            const bundlerFile = {
+                package: c.ref.proto.package,
+                localname,
+                filename
+            };
+            let ast = null;
+            allowedRpcServices.forEach((svcKey) => {
+                if (proto[svcKey]) {
+                    ast = (0, ast_1.createPiniaStore)(ctx.generic, proto[svcKey]);
+                }
+            });
+            if (!ast) {
+                return;
+            }
+            piniaBundlerFiles.push(bundlerFile);
+            const serviceImports = (0, imports_1.getDepsFromQueries)(getImportsFrom, localname);
+            const imports = (0, imports_1.buildAllImports)(ctx, serviceImports, localname);
+            const piniaImport = (0, imports_1.getImportStatements)('pinia', [
+                {
+                    type: 'import',
+                    name: 'defineStore',
+                    path: 'pinia'
+                },
+                {
+                    type: 'import',
+                    name: 'LCDQueryClient',
+                    path: './query.lcd'
+                }
+            ], builder.options);
+            const prog = []
+                .concat([...imports, ...piniaImport])
+                .concat(ctx.body)
+                .concat(ast);
+            bundler.writeAst(prog, filename);
+            bundler.addToBundle(c, localname);
+        });
+        bundler.addStateManagers('pinia', piniaBundlerFiles);
+    }
+};
+exports.plugin = plugin;

package/main/generators/create-query-funcs.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const ast_1 = require("@cosmology/ast");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const parse_1 = require("../parse");
+const types_1 = require("@cosmology/types");
+const utils_1 = require("@cosmology/utils");
+const files_1 = require("../utils/files");
+const plugin = (builder, bundler) => {
+    const clients = bundler.contexts
+        .map((c) => {
+        const enabled = c.proto.pluginValue("helperFunctions.enabled");
+        if (!enabled)
+            return;
+        const serviceTypes = c.proto.pluginValue("helperFunctions.include.serviceTypes");
+        if (serviceTypes &&
+            !serviceTypes.includes("Query") &&
+            !serviceTypes.includes("All")) {
+            return;
+        }
+        if (c.proto.isExcluded())
+            return;
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        (0, parse_1.parse)(ctx);
+        const proto = (0, proto_parser_1.getNestedProto)(c.ref.traversed);
+        //// Anything except Msg Service OK...
+        if (proto?.Msg) {
+            return;
+        }
+        let getImportsFrom;
+        if (proto.Query) {
+            getImportsFrom = ctx.queries;
+        }
+        else {
+            getImportsFrom = ctx.services;
+        }
+        const localname = bundler.getLocalFilename(c.ref, `rpc.func`);
+        const localnameReact = bundler.getLocalFilename(c.ref, `rpc.react`);
+        const localnameVue = bundler.getLocalFilename(c.ref, `rpc.vue`);
+        const filename = bundler.getFilename(localname);
+        const filenameReact = bundler.getFilename(localnameReact);
+        const filenameVue = bundler.getFilename(localnameVue);
+        const bundlerFile = {
+            proto: c.ref.filename,
+            package: c.ref.proto.package,
+            localname,
+            filename,
+        };
+        const asts = [];
+        const reactAsts = [];
+        const vueAsts = [];
+        const helperCreatorNameList = [];
+        types_1.QUERY_SVC_TYPES.forEach((svcKey) => {
+            if (proto[svcKey]) {
+                const svc = proto[svcKey];
+                const patterns = c.proto.pluginValue("helperFunctions.include.patterns");
+                const nameMappers = c.proto.pluginValue("helperFunctions.nameMappers");
+                const methodKeys = (0, utils_1.getQueryMethodNames)(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns || ["**"], String);
+                // see if the function is excluded.
+                if (!methodKeys || !methodKeys.length) {
+                    return;
+                }
+                // for each method key, create creators, hooks.
+                methodKeys.forEach((methodKey) => {
+                    // get helperCreatorName
+                    // get hookName
+                    const { creator: helperCreatorName, hook: hookName } = (0, utils_1.getHelperFuncName)(bundlerFile.package, methodKey, [nameMappers?.Query, nameMappers?.All], "get");
+                    helperCreatorNameList.push(helperCreatorName);
+                    const genCustomHooksReact = c.proto.pluginValue("helperFunctions.hooks.react");
+                    const genCustomHooksVue = c.proto.pluginValue("helperFunctions.hooks.vue");
+                    // Store the mapping in builder
+                    builder.addFunctionMapping(bundlerFile.package, svcKey, methodKey, helperCreatorName, hookName, svc.methods[methodKey].comment, svc.methods[methodKey].requestType, svc.methods[methodKey].responseType, localname, genCustomHooksReact ? localnameReact : undefined, bundler.getLocalFilename(c.ref));
+                    // gen helper funcs
+                    asts.push((0, ast_1.createQueryHelperCreator)(ctx.generic, svc.methods[methodKey], svc.name, methodKey, helperCreatorName));
+                    if (genCustomHooksReact) {
+                        // gen custom react hooks
+                        reactAsts.push((0, ast_1.createQueryHooks)(ctx.generic, svc.methods[methodKey], methodKey, helperCreatorName, hookName));
+                    }
+                    if (genCustomHooksVue) {
+                        // gen custom vue hooks
+                        vueAsts.push((0, ast_1.createVueQueryHooks)(ctx.generic, svc.methods[methodKey], methodKey, helperCreatorName, hookName));
+                    }
+                });
+            }
+        });
+        if (!asts.length) {
+            return;
+        }
+        const serviceImports = (0, imports_1.getDepsFromQueries)(getImportsFrom, localname);
+        const serviceImportsReact = (0, imports_1.getDepsFromQueries)(getImportsFrom, localnameReact);
+        const serviceImportsVue = (0, imports_1.getDepsFromQueries)(getImportsFrom, localnameVue);
+        // add imports from func file like query.rpc.func.ts without the .ts extension
+        const funcFileName = "./".concat(localname.substring(localname.lastIndexOf("/") + 1).replace(/\.ts$/, ""));
+        serviceImportsReact[funcFileName] = helperCreatorNameList;
+        serviceImportsVue[funcFileName] = helperCreatorNameList;
+        // TODO we do NOT need all imports...
+        const imports = (0, imports_1.buildAllImports)(ctx, serviceImports, localname);
+        const importsReact = (0, imports_1.buildAllImports)(ctx, serviceImportsReact, localnameReact);
+        const importsVue = (0, imports_1.buildAllImports)(ctx, serviceImportsVue, localnameReact);
+        const prog = [].concat(imports).concat(ctx.body).concat(asts);
+        const progReact = [].concat(importsReact).concat(reactAsts);
+        const progVue = [].concat(importsVue).concat(vueAsts);
+        const exportedTypeNames = (0, files_1.getExportedTypeNames)(prog);
+        const exportedTypeNamesReact = (0, files_1.getExportedTypeNames)(progReact);
+        const exportedTypeNamesVue = (0, files_1.getExportedTypeNames)(progVue);
+        exportedTypeNames.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localname);
+        });
+        exportedTypeNamesReact.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localnameReact);
+        });
+        exportedTypeNamesVue.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localnameVue);
+        });
+        bundler.writeAst(prog, filename);
+        bundler.addExportObjToBundle(c.ref.proto.package, localname, exportedTypeNames, true);
+        if (reactAsts.length) {
+            bundler.writeAst(progReact, filenameReact);
+            bundler.addExportObjToBundle(c.ref.proto.package, localnameReact, exportedTypeNamesReact, true);
+        }
+        if (vueAsts.length) {
+            bundler.writeAst(progVue, filenameVue);
+            bundler.addExportObjToBundle(c.ref.proto.package, localnameVue, exportedTypeNamesVue, true);
+        }
+        bundler.addToBundle(c, localname);
+        return bundlerFile;
+    })
+        .filter(Boolean);
+};
+exports.plugin = plugin;

package/main/generators/create-react-query-bundle.js

@@ -0,0 +1,103 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const build_1 = require("../build");
+const files_1 = require("../utils/files");
+const utils_1 = require("../utils");
+const dotty = __importStar(require("dotty"));
+const proto_parser_1 = require("@cosmology/proto-parser");
+const utils_2 = require("@cosmology/utils");
+const utils_3 = require("@cosmology/utils");
+const utils_4 = require("@cosmology/utils");
+const plugin = (builder) => {
+    // if react query is enabled
+    // generate hooks.ts based on query hooks generated in each package.
+    // eg: __fixtures__/output1/hooks.ts
+    if (!builder.options.reactQuery.enabled) {
+        return;
+    }
+    const localname = 'hooks.ts';
+    // get mapping of packages and rpc query filenames.
+    const obj = {};
+    const instantHooksMapping = {};
+    const methodSet = new Set();
+    const bundlerFiles = builder.stateManagers["reactQuery"];
+    if (!bundlerFiles || !bundlerFiles.length) {
+        return;
+    }
+    let nameMapping = builder.options.reactQuery?.instantExport?.nameMapping;
+    nameMapping = (0, utils_4.swapKeyValue)(nameMapping ?? {});
+    bundlerFiles.map(bundlerFile => {
+        const path = `./${bundlerFile.localname.replace(/\.ts$/, '')}`;
+        dotty.put(obj, bundlerFile.package, path);
+        // build instantHooksMapping
+        bundlerFile.instantExportedMethods?.forEach((method) => {
+            const methodName = method.name;
+            const useHookName = (0, utils_2.makeUseHookName)((0, utils_2.camel)(methodName));
+            const hookNameWithPkg = `${bundlerFile.package}.${useHookName}`;
+            let instantHookName = null;
+            if (nameMapping[hookNameWithPkg]) {
+                instantHookName = nameMapping[hookNameWithPkg];
+            }
+            else {
+                if (methodSet.has(useHookName)) {
+                    instantHookName = (0, utils_2.makeUsePkgHookName)(bundlerFile.package, methodName);
+                }
+                else {
+                    instantHookName = useHookName;
+                }
+            }
+            dotty.put(instantHooksMapping, instantHookName, {
+                useHookName,
+                importedVarName: (0, utils_3.variableSlug)(path),
+                comment: `${bundlerFile.package}.${useHookName}\n${method.comment ?? methodName}`
+            });
+            methodSet.add(instantHookName);
+        });
+    });
+    // create proto ref for context
+    const pkg = '@root';
+    const ref = (0, proto_parser_1.createEmptyProtoRef)(pkg, localname);
+    // create context
+    const pCtx = new build_1.TelescopeParseContext(ref, builder.store, builder.options);
+    // generate code for createRpcQueryHooks and imports of related packages.
+    const ast = (0, ast_1.createScopedRpcHookFactory)(pCtx.proto, obj, 'createRpcQueryHooks', instantHooksMapping);
+    // generate imports added by context.addUtil
+    const imports = (0, utils_1.fixlocalpaths)((0, imports_1.aggregateImports)(pCtx, {}, localname));
+    const importStmts = (0, imports_1.getImportStatements)(localname, imports, builder.options);
+    // construct the AST
+    const prog = []
+        .concat(importStmts)
+        .concat(ast);
+    // write the file.
+    const filename = (0, path_1.join)(builder.outPath, localname);
+    builder.files.push(localname);
+    (0, files_1.writeAstToFile)(builder.outPath, builder.options, prog, filename);
+};
+exports.plugin = plugin;

package/main/generators/create-registries.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const parse_1 = require("../parse");
+const files_1 = require("../utils/files");
+const plugin = (builder, bundler) => {
+    if (!builder.options.aminoEncoding?.enabled) {
+        return;
+    }
+    const mutationContexts = bundler
+        .contexts
+        .filter(context => context.mutations.length > 0);
+    // [x] write out one registry helper for all contexts w/mutations
+    const registries = mutationContexts.map(c => {
+        const enabled = c.amino.pluginValue('aminoEncoding.enabled');
+        if (!enabled)
+            return;
+        if (c.proto.isExcluded())
+            return;
+        const localname = bundler.getLocalFilename(c.ref, 'registry');
+        const filename = bundler.getFilename(localname);
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        (0, parse_1.parse)(ctx);
+        ctx.buildRegistry();
+        ctx.buildRegistryLoader();
+        ctx.buildHelperObject();
+        const serviceImports = (0, imports_1.getDepsFromMutations)(ctx.mutations, localname);
+        const imports = (0, imports_1.buildAllImports)(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body);
+        const exportedTypeNames = (0, files_1.getExportedTypeNames)(prog);
+        exportedTypeNames.forEach((name) => {
+            builder.store.setTypeFilesMapping(name, localname);
+        });
+        bundler.addExportObjToBundle(c.ref.proto.package, localname, exportedTypeNames);
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+        return {
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+    }).filter(Boolean);
+    bundler.addRegistries(registries);
+};
+exports.plugin = plugin;