@hyperweb/telescope 1.15.0

package/main/build.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelescopeParseContext = exports.buildEnums = exports.buildBaseTypeScriptInterface = exports.buildBaseTypeScriptClass = exports.getAminoProtos = exports.getMutations = void 0;
+const ast_1 = require("@cosmology/ast");
+const getMutations = (mutations) => {
+    return mutations.map((mutation) => {
+        return {
+            typeUrl: `/${mutation.package}.${mutation.message}`,
+            TypeName: mutation.message,
+            methodName: mutation.methodName
+        };
+    });
+};
+exports.getMutations = getMutations;
+const getAminoProtos = (mutations, store) => {
+    return mutations.map(mutation => {
+        const ref = store.findProto(mutation.messageImport);
+        return store.get(ref, mutation.message).obj;
+    });
+};
+exports.getAminoProtos = getAminoProtos;
+const buildBaseTypeScriptClass = (context, name, obj) => {
+    if (context.options.prototypes.enabled) {
+        context.body.push((0, ast_1.createCreateProtoType)(context.proto, name, obj));
+        context.body.push((0, ast_1.createObjectWithMethods)(context.proto, name, obj));
+        if (context.options.interfaces?.enabled && context.options.interfaces?.useGlobalDecoderRegistry && context.options.interfaces?.registerAllDecodersToGlobal) {
+            const registerObj = (0, ast_1.createRegisterObject)(context.proto, name, obj);
+            if (registerObj) {
+                context.body.push(registerObj);
+                //createRegisterAminoProtoMapping
+                const registerAminoObj = (0, ast_1.createRegisterAminoProtoMapping)(context.proto, name, obj);
+                if (registerAminoObj) {
+                    context.body.push(registerAminoObj);
+                }
+            }
+        }
+    }
+};
+exports.buildBaseTypeScriptClass = buildBaseTypeScriptClass;
+const buildBaseTypeScriptInterface = (context, name, obj) => {
+    context.body.push((0, ast_1.createProtoType)(context.proto, name, obj));
+    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding || context.options.prototypes?.methods?.fromProto || context.options.prototypes?.methods?.toProto) {
+        context.body.push((0, ast_1.createProtoTypeType)(context.proto, name, obj));
+    }
+    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
+        // conditional type
+        const interfaceType = (0, ast_1.createProtoInterfaceEncodedType)(context.proto, name, obj);
+        if (interfaceType) {
+            context.body.push(interfaceType);
+        }
+        context.body.push((0, ast_1.createAminoType)(context.proto, name, obj));
+        if (!context.options.aminoEncoding?.disableMsgTypes) {
+            context.body.push((0, ast_1.createAminoTypeType)(context.proto, name, obj));
+        }
+    }
+    if (context.options.useSDKTypes) {
+        context.body.push((0, ast_1.createSDKType)(context.proto, name, obj));
+    }
+};
+exports.buildBaseTypeScriptInterface = buildBaseTypeScriptInterface;
+const buildEnums = (context, name, obj) => {
+    context.body.push((0, ast_1.createProtoEnum)(context.proto, name, obj));
+    if (context.options.useSDKTypes) {
+        context.body.push((0, ast_1.createEnumSDKType)(context.proto, name, obj));
+    }
+    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
+        context.body.push((0, ast_1.createEnumAminoType)(context.proto, name, obj));
+    }
+    context.body.push((0, ast_1.createProtoEnumFromJSON)(context.proto, name, obj));
+    context.body.push((0, ast_1.createProtoEnumToJSON)(context.proto, name, obj));
+};
+exports.buildEnums = buildEnums;
+class TelescopeParseContext {
+    constructor(ref, store, options) {
+        this.generic = new ast_1.GenericParseContext(ref, store, options);
+        this.proto = new ast_1.ProtoParseContext(ref, store, options);
+        this.amino = new ast_1.AminoParseContext(ref, store, options);
+        this.options = options;
+        this.ref = ref;
+        this.store = store;
+        this.parsedImports = {};
+        this.body = [];
+        this.queries = [];
+        this.services = [];
+        this.mutations = [];
+        this.types = [];
+    }
+    hasMutations() {
+        return this.mutations.length > 0;
+    }
+    addType(name, obj, isNested) {
+        this.types.push({
+            name,
+            obj,
+            isNested
+        });
+    }
+    addMutation(mutation) {
+        this.mutations.push(mutation);
+    }
+    addQuery(query) {
+        this.queries.push(query);
+    }
+    addService(query) {
+        this.services.push(query);
+    }
+    // build main Class with methods
+    buildBase() {
+        this.types.forEach(typeReg => {
+            const { name, obj } = typeReg;
+            if (obj.type === 'Enum') {
+                (0, exports.buildEnums)(this, name, obj);
+            }
+        });
+        this.types.forEach(typeReg => {
+            const { name, obj } = typeReg;
+            if (obj.type === 'Type') {
+                (0, exports.buildBaseTypeScriptInterface)(this, name, obj);
+            }
+        });
+        this.types.forEach(typeReg => {
+            const { name, obj } = typeReg;
+            if (obj.type === 'Type') {
+                (0, exports.buildBaseTypeScriptClass)(this, name, obj);
+            }
+        });
+        // interfaces
+        if (this.options.interfaces.enabled && !this.options.interfaces.useGlobalDecoderRegistry) {
+            const interfaces = Object.keys(this.ref.traversed.acceptsInterface ?? {});
+            if (interfaces.length) {
+                interfaces.forEach(interfaceName => {
+                    this.body.push((0, ast_1.createInterfaceDecoder)(this.proto, this.ref, interfaceName));
+                    if (this.options.aminoEncoding?.enabled &&
+                        !this.options.aminoEncoding?.useLegacyInlineEncoding) {
+                        this.body.push((0, ast_1.createInterfaceFromAmino)(this.proto, this.ref, interfaceName));
+                        this.body.push((0, ast_1.createInterfaceToAmino)(this.proto, this.ref, interfaceName));
+                    }
+                });
+            }
+        }
+    }
+    buildRegistry() {
+        this.body.push((0, ast_1.createTypeRegistry)(this.amino, (0, exports.getMutations)(this.mutations)));
+    }
+    buildRegistryLoader() {
+        if (!this.options?.prototypes?.enableRegistryLoader) {
+            return;
+        }
+        this.body.push((0, ast_1.createRegistryLoader)(this.amino));
+    }
+    buildAminoInterfaces() {
+        if (!this.options?.aminoEncoding?.enabled || !this.options?.aminoEncoding?.useLegacyInlineEncoding)
+            return;
+        //
+        const protos = (0, exports.getAminoProtos)(this.mutations, this.store);
+        protos.forEach(proto => {
+            this.body.push((0, ast_1.makeAminoTypeInterface)({
+                context: this.amino,
+                proto
+            }));
+        });
+    }
+    buildAminoConverter() {
+        this.body.push((0, ast_1.createAminoConverter)({
+            name: 'AminoConverter',
+            context: this.amino,
+            root: this.ref.traversed,
+            protos: (0, exports.getAminoProtos)(this.mutations, this.store)
+        }));
+    }
+    buildHelperObject() {
+        if (!this.options?.prototypes?.enableMessageComposer) {
+            return;
+        }
+        // add methods
+        this.body.push((0, ast_1.createHelperObject)({
+            context: this.amino,
+            name: 'MessageComposer',
+            mutations: (0, exports.getMutations)(this.mutations)
+        }));
+    }
+}
+exports.TelescopeParseContext = TelescopeParseContext;

package/main/builder.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelescopeBuilder = void 0;
+const proto_parser_1 = require("@cosmology/proto-parser");
+const build_1 = require("./build");
+const types_1 = require("@cosmology/types");
+const utils_1 = require("@cosmology/utils");
+const bundle_1 = require("./bundle");
+const bundler_1 = require("./bundler");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const path_1 = require("path");
+const create_types_1 = require("./generators/create-types");
+const create_amino_converters_1 = require("./generators/create-amino-converters");
+const create_registries_1 = require("./generators/create-registries");
+const create_lcd_clients_1 = require("./generators/create-lcd-clients");
+const create_aggregated_lcd_client_1 = require("./generators/create-aggregated-lcd-client");
+const create_lcd_client_scoped_1 = require("./generators/create-lcd-client-scoped");
+const create_lcd_client_all_1 = require("./generators/create-lcd-client-all");
+const create_rpc_query_client_scoped_1 = require("./generators/create-rpc-query-client-scoped");
+const create_rpc_query_client_all_1 = require("./generators/create-rpc-query-client-all");
+const create_rpc_msg_client_scoped_1 = require("./generators/create-rpc-msg-client-scoped");
+const create_rpc_msg_client_all_1 = require("./generators/create-rpc-msg-client-all");
+const create_rpc_query_clients_1 = require("./generators/create-rpc-query-clients");
+const create_rpc_msg_clients_1 = require("./generators/create-rpc-msg-clients");
+const create_query_funcs_1 = require("./generators/create-query-funcs");
+const create_msg_funcs_1 = require("./generators/create-msg-funcs");
+const create_react_query_bundle_1 = require("./generators/create-react-query-bundle");
+const create_mobx_bundle_1 = require("./generators/create-mobx-bundle");
+const create_stargate_clients_1 = require("./generators/create-stargate-clients");
+const create_custom_stargate_clients_1 = require("./generators/create-custom-stargate-clients");
+const create_all_stargate_clients_1 = require("./generators/create-all-stargate-clients");
+const create_sdk_module_stargate_clients_1 = require("./generators/create-sdk-module-stargate-clients");
+const create_bundle_1 = require("./generators/create-bundle");
+const create_index_1 = require("./generators/create-index");
+const create_helpers_1 = require("./generators/create-helpers");
+const create_cosmwasm_bundle_1 = require("./generators/create-cosmwasm-bundle");
+const create_pinia_store_1 = require("./generators/create-pinia-store");
+const create_pinia_store_bundle_1 = require("./generators/create-pinia-store-bundle");
+const create_rpc_ops_bundle_1 = require("./generators/create-rpc-ops-bundle");
+const customize_utils_1 = require("./generators/customize-utils");
+const create_root_readme_1 = require("./generators/create-root-readme");
+const create_mcp_server_1 = require("./generators/create-mcp-server");
+const sanitizeOptions = (options) => {
+    // If an element at the same key is present for both x and y, the value from y will appear in the result.
+    options = (0, deepmerge_1.default)(types_1.defaultTelescopeOptions, options ?? {});
+    // correct the path for windows
+    if (options.cosmwasm) {
+        options.cosmwasm.outPath = (0, utils_1.toPosixPath)(options.cosmwasm.outPath);
+        options.cosmwasm.contracts = options.cosmwasm.contracts.map((item) => {
+            item.dir = (0, utils_1.toPosixPath)(item.dir);
+            return item;
+        });
+    }
+    // strip off leading slashes
+    options.tsDisable.files = options.tsDisable.files.map((file) => file.startsWith('/') ? file : file.replace(/^\//, ''));
+    options.eslintDisable.files = options.eslintDisable.files.map((file) => file.startsWith('/') ? file : file.replace(/^\//, ''));
+    // uniq bc of deepmerge
+    options.rpcClients.enabledServices = [
+        ...new Set([...options.rpcClients.enabledServices]),
+    ];
+    return options;
+};
+class TelescopeBuilder {
+    store;
+    protoDirs;
+    outPath;
+    options;
+    contexts = [];
+    files = [];
+    converters = [];
+    lcdClients = [];
+    rpcQueryClients = [];
+    rpcMsgClients = [];
+    registries = [];
+    stateManagers = {};
+    // Function mapping storage: package -> service -> method -> functionName
+    functionMappings = {};
+    constructor({ protoDirs, outPath, store, options, }) {
+        const fixedDirs = protoDirs.map((directory) => {
+            return (0, utils_1.toPosixPath)(directory);
+        });
+        this.protoDirs = fixedDirs;
+        this.outPath = (0, path_1.resolve)((0, utils_1.toPosixPath)(outPath));
+        this.options = sanitizeOptions(options);
+        this.store = store ?? new proto_parser_1.ProtoStore(fixedDirs, this.options);
+        this.store.traverseAll();
+    }
+    context(ref) {
+        const ctx = new build_1.TelescopeParseContext(ref, this.store, this.options);
+        this.contexts.push(ctx);
+        return ctx;
+    }
+    addFunctionMapping(packageName, serviceName, methodName, functionName, hookName, comment, requestType, responseType, sourceFilename, hookSourceFilename, typeSourceFilename) {
+        if (!this.functionMappings[packageName]) {
+            this.functionMappings[packageName] = {};
+        }
+        if (!this.functionMappings[packageName][serviceName]) {
+            this.functionMappings[packageName][serviceName] = {};
+        }
+        this.functionMappings[packageName][serviceName][methodName] = {
+            functionName,
+            hookName,
+            comment,
+            requestType,
+            responseType,
+            sourceFilename,
+            hookSourceFilename,
+            typeSourceFilename
+        };
+    }
+    getFunctionMappings() {
+        return this.functionMappings;
+    }
+    addStateManagers(type, files) {
+        const state = this.stateManagers[type];
+        if (!state) {
+            this.stateManagers[type] = [];
+        }
+        [].push.apply(this.stateManagers[type], files);
+    }
+    addRPCQueryClients(files) {
+        [].push.apply(this.rpcQueryClients, files);
+    }
+    addRPCMsgClients(files) {
+        [].push.apply(this.rpcMsgClients, files);
+    }
+    addLCDClients(files) {
+        [].push.apply(this.lcdClients, files);
+    }
+    addRegistries(files) {
+        [].push.apply(this.registries, files);
+    }
+    addConverters(files) {
+        [].push.apply(this.converters, files);
+    }
+    async build() {
+        // check warnings
+        if (!this.options.aminoEncoding?.enabled &&
+            (this.options.prototypes?.methods?.fromAmino ||
+                this.options.prototypes?.methods?.toAmino)) {
+            console.warn("There could be compilation errors in generated code, because 'aminoEncoding.enabled: false' means amino types wouldn't be created, but 'toAmino' or 'fromAmino' need amino types.");
+        }
+        if (!this.options.prototypes.methods.fromPartial) {
+            console.warn("The 'fromPartial' option will be deprecated in a future version. Encoder objects need fromPartial to be a creator function to create instance of the type. So it should always be left on, otherwise there could be compilation errors in generated code.");
+        }
+        (0, customize_utils_1.plugin)(this);
+        const allConverters = [];
+        const allRegistries = [];
+        // [x] get bundle of all packages
+        const bundles = (0, bundle_1.bundlePackages)(this.store).map((bundle) => {
+            // store bundleFile in filesToInclude
+            const bundler = new bundler_1.Bundler(this, bundle);
+            // [x] write out all TS files for package
+            (0, create_types_1.plugin)(this, bundler);
+            // [x] write out one amino helper for all contexts w/mutations
+            (0, create_amino_converters_1.plugin)(this, bundler);
+            // [x] write out one registry helper for all contexts w/mutations
+            (0, create_registries_1.plugin)(this, bundler);
+            // [x] write out one registry helper for all contexts w/mutations
+            (0, create_lcd_clients_1.plugin)(this, bundler);
+            (0, create_query_funcs_1.plugin)(this, bundler);
+            (0, create_rpc_query_clients_1.plugin)(this, bundler);
+            (0, create_msg_funcs_1.plugin)(this, bundler);
+            (0, create_rpc_msg_clients_1.plugin)(this, bundler);
+            (0, create_pinia_store_1.plugin)(this, bundler);
+            if (this.options.rpcClients.clientStyle.useUpdatedClientStyle) {
+                // generate sdk-module client file
+                if (this.options.rpcClients.clientStyle.type.includes('sdk-module-client') && this.options.rpcClients.clientStyle.sdkModuleClientOption.includes(bundler.bundle.base)) {
+                    (0, create_sdk_module_stargate_clients_1.plugin)(this, bundler);
+                }
+                // store registry and converter for all/custom client generation
+                if (bundler.registries) {
+                    allRegistries.push(...bundler.registries);
+                }
+                if (bundler.converters) {
+                    allConverters.push(...bundler.converters);
+                }
+            }
+            else {
+                // [x] write out one client for each base package, referencing the last two steps
+                (0, create_stargate_clients_1.plugin)(this, bundler);
+            }
+            return bundler;
+        });
+        if (this.options.rpcClients.clientStyle.useUpdatedClientStyle) {
+            // generate cutsom client file
+            if (this.options.rpcClients.clientStyle.type.includes('custom-client') && this.options.rpcClients.clientStyle.customClientOption && this.options.rpcClients.clientStyle.customClientOption.length !== 0) {
+                (0, create_custom_stargate_clients_1.plugin)(this, allRegistries, allConverters);
+            }
+            // generate all module client file
+            if (this.options.rpcClients.clientStyle.type.includes('all-client')) {
+                (0, create_all_stargate_clients_1.plugin)(this, allRegistries, allConverters);
+            }
+        }
+        // post run plugins
+        bundles.forEach((bundler) => {
+            (0, create_lcd_client_all_1.plugin)(this, bundler);
+            (0, create_lcd_client_scoped_1.plugin)(this, bundler);
+            (0, create_rpc_query_client_all_1.plugin)(this, bundler);
+            (0, create_rpc_query_client_scoped_1.plugin)(this, bundler);
+            (0, create_rpc_msg_client_all_1.plugin)(this, bundler);
+            (0, create_rpc_msg_client_scoped_1.plugin)(this, bundler);
+            (0, create_bundle_1.plugin)(this, bundler);
+        });
+        (0, create_rpc_ops_bundle_1.plugin)(this);
+        (0, create_react_query_bundle_1.plugin)(this);
+        (0, create_mobx_bundle_1.plugin)(this);
+        (0, create_aggregated_lcd_client_1.plugin)(this);
+        await (0, create_cosmwasm_bundle_1.plugin)(this);
+        (0, create_helpers_1.plugin)(this);
+        (0, create_pinia_store_bundle_1.plugin)(this);
+        // finally, write one index file with all files, exported
+        (0, create_index_1.plugin)(this);
+        (0, create_root_readme_1.plugin)(this);
+        // Generate MCP server at the very end after all files are written
+        if (this.options.mcpServer?.enabled && bundles.length > 0) {
+            // Use the first bundle that has contexts (typically the main aggregated bundle)
+            const primaryBundle = bundles.find(bundler => bundler.contexts.length > 0);
+            if (primaryBundle) {
+                (0, create_mcp_server_1.plugin)(this, primaryBundle);
+            }
+        }
+        console.log(`✨ files transpiled in '${this.outPath}'`);
+    }
+}
+exports.TelescopeBuilder = TelescopeBuilder;

package/main/bundle.js

@@ -0,0 +1,162 @@
+"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.createFileBundle = exports.parsePackage = exports.parseContextsForRegistry = exports.bundleBaseRegistries = exports.bundleRegistries = exports.bundlePackages = exports.getPackagesBundled = exports.getPackages = void 0;
+const proto_parser_1 = require("@cosmology/proto-parser");
+const ast_1 = require("@cosmology/ast");
+const dotty = __importStar(require("dotty"));
+const path_1 = require("path");
+const utils_1 = require("@cosmology/utils");
+// TODO move to store
+const getPackages = (store) => {
+    return store.getProtos().reduce((m, proto) => {
+        if (proto.proto.package) {
+            m[proto.proto.package] = m[proto.proto.package] || [];
+            m[proto.proto.package].push(proto);
+        }
+        return m;
+    }, {});
+};
+exports.getPackages = getPackages;
+const getPackagesBundled = (store) => {
+    const objectified = {};
+    const pkgs = (0, exports.getPackages)(store);
+    Object.keys(pkgs).forEach(key => {
+        if ((0, proto_parser_1.isRefExcluded)((0, proto_parser_1.createEmptyProtoRef)(key), store.options.prototypes?.excluded))
+            return;
+        const files = pkgs[key];
+        dotty.put(objectified, key, {
+            pkg: key,
+            files: files.filter(file => {
+                return !(0, proto_parser_1.isRefExcluded)((0, proto_parser_1.createEmptyProtoRef)(key, file.filename), store.options.prototypes?.excluded);
+            })
+        });
+    });
+    return objectified;
+};
+exports.getPackagesBundled = getPackagesBundled;
+const bundlePackages = (store) => {
+    const allPackages = (0, exports.getPackagesBundled)(store);
+    return Object.keys(allPackages).map(base => {
+        const pkgs = allPackages[base];
+        const bundleVariables = {};
+        const bundleFile = (0, utils_1.toPosixPath)((0, path_1.join)(base, 'bundle.ts'));
+        const importPaths = [];
+        (0, exports.parsePackage)(store.options, pkgs, bundleFile, importPaths, bundleVariables);
+        return {
+            bundleVariables,
+            bundleFile,
+            importPaths,
+            base
+        };
+    });
+};
+exports.bundlePackages = bundlePackages;
+// TODO review bundle registry methods
+const bundleRegistries = (telescope) => {
+    const withMutations = telescope.contexts.filter(ctx => ctx.mutations.length);
+    const obj = withMutations.reduce((m, ctx) => {
+        m[ctx.ref.proto.package] = m[ctx.ref.proto.package] ?? [];
+        m[ctx.ref.proto.package].push(ctx);
+        return m;
+    }, {});
+    return Object.entries(obj)
+        .map(([pkg, serviceProtos]) => {
+        return {
+            package: pkg,
+            contexts: serviceProtos
+        };
+    });
+};
+exports.bundleRegistries = bundleRegistries;
+const bundleBaseRegistries = (telescope) => {
+    const withMutations = telescope.contexts.filter(ctx => ctx.mutations.length);
+    const obj = withMutations.reduce((m, ctx) => {
+        const base = ctx.ref.proto.package.split('.')[0];
+        m[base] = m[base] ?? {};
+        m[base][ctx.ref.proto.package] = m[base][ctx.ref.proto.package] ?? [];
+        m[base][ctx.ref.proto.package].push(ctx);
+        return m;
+    }, {});
+    return Object.entries(obj)
+        .map(([pkg, withServices]) => {
+        const serviceProtos = Object.entries(withServices)
+            .map(([pkg, withServices]) => {
+            return {
+                package: pkg,
+                contexts: withServices
+            };
+        });
+        return {
+            base: pkg,
+            pkgs: serviceProtos
+        };
+    });
+};
+exports.bundleBaseRegistries = bundleBaseRegistries;
+const parseContextsForRegistry = (contexts) => {
+    return contexts.map((ctx) => {
+        const responses = ctx.mutations.map(m => m.response);
+        const imports = ctx.mutations.reduce((m, msg) => {
+            m[msg.messageImport] = m[msg.messageImport] ?? [];
+            m[msg.messageImport].push(msg.message);
+            return m;
+        }, {});
+        return {
+            filename: ctx.ref.filename,
+            imports,
+            objects: ctx.types
+                .filter(type => !type.isNested)
+                .filter(type => !responses.includes(type.name))
+                .map(type => type.name)
+        };
+    });
+};
+exports.parseContextsForRegistry = parseContextsForRegistry;
+const parsePackage = (options, obj, bundleFile, importPaths, bundleVariables) => {
+    if (!obj)
+        return;
+    if (obj.pkg && obj.files) {
+        obj.files.forEach(file => {
+            (0, exports.createFileBundle)(options, obj.pkg, file.filename, bundleFile, importPaths, bundleVariables);
+        });
+        return;
+    }
+    Object.keys(obj).forEach(mini => {
+        (0, exports.parsePackage)(options, obj[mini], bundleFile, importPaths, bundleVariables);
+    });
+};
+exports.parsePackage = parsePackage;
+let counter = 0;
+const createFileBundle = (options, pkg, filename, bundleFile, importPaths, bundleVariables) => {
+    let rel = (0, path_1.relative)((0, path_1.dirname)(bundleFile), filename);
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    const variable = `_${counter++}`;
+    importPaths.push((0, ast_1.importNamespace)(variable, (0, utils_1.toPosixPath)(rel)));
+    dotty.put(bundleVariables, pkg + '.__export', true);
+    dotty.put(bundleVariables, pkg + '.' + variable, true);
+};
+exports.createFileBundle = createFileBundle;

package/main/bundler.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bundler = void 0;
+const path_1 = require("path");
+const build_1 = require("./build");
+const bundle_1 = require("./bundle");
+const files_1 = require("./utils/files");
+const utils_1 = require("@cosmology/utils");
+class Bundler {
+    builder;
+    contexts = [];
+    bundle;
+    files;
+    converters = [];
+    lcdClients = [];
+    rpcQueryClients = [];
+    rpcMsgClients = [];
+    registries = [];
+    stateManagers = {};
+    constructor(builder, bundle) {
+        this.builder = builder;
+        this.bundle = bundle;
+        this.files = [bundle.bundleFile];
+    }
+    addStateManagers(type, files) {
+        const state = this.stateManagers[type];
+        if (!state) {
+            this.stateManagers[type] = [];
+        }
+        [].push.apply(this.stateManagers[type], files);
+        this.builder.addStateManagers(type, files);
+    }
+    addLCDClients(files) {
+        [].push.apply(this.lcdClients, files);
+        this.builder.addLCDClients(files);
+    }
+    addRPCQueryClients(files) {
+        [].push.apply(this.rpcQueryClients, files);
+        this.builder.addRPCQueryClients(files);
+    }
+    addRPCMsgClients(files) {
+        [].push.apply(this.rpcMsgClients, files);
+        this.builder.addRPCMsgClients(files);
+    }
+    addRegistries(files) {
+        [].push.apply(this.registries, files);
+        this.builder.addRegistries(files);
+    }
+    addConverters(files) {
+        [].push.apply(this.converters, files);
+        this.builder.addConverters(files);
+    }
+    getFreshContext(context) {
+        return new build_1.TelescopeParseContext(context.ref, context.store, this.builder.options);
+    }
+    getLocalFilename(ref, suffix) {
+        return suffix
+            ? ref.filename.replace(/\.proto$/, `.${suffix}.ts`)
+            : ref.filename.replace(/\.proto$/, `.ts`);
+    }
+    getFilename(localname) {
+        return (0, path_1.resolve)((0, path_1.join)(this.builder.outPath, localname));
+    }
+    writeAst(program, filename) {
+        (0, files_1.writeAstToFile)(this.builder.outPath, this.builder.options, program, filename);
+    }
+    // addToBundle adds the path into the namespaced bundle object
+    addToBundle(context, localname) {
+        (0, bundle_1.createFileBundle)(this.builder.options, context.ref.proto.package, localname, this.bundle.bundleFile, this.bundle.importPaths, this.bundle.bundleVariables);
+    }
+    addToBundleToPackage(packagename, localname) {
+        (0, bundle_1.createFileBundle)(this.builder.options, packagename, localname, this.bundle.bundleFile, this.bundle.importPaths, this.bundle.bundleVariables);
+    }
+    addExportObjToBundle(pkg, localname, exportedIdentifiers, isHelperFunc) {
+        if (!this.bundle.exportObjs) {
+            this.bundle.exportObjs = [];
+        }
+        let rel = (0, path_1.relative)((0, path_1.dirname)(this.bundle.bundleFile), localname);
+        if (!rel.startsWith("."))
+            rel = `./${rel}`;
+        rel = (0, utils_1.toPosixPath)(rel);
+        rel = rel.replace((0, path_1.extname)(rel), "");
+        const existing = this.bundle.exportObjs.find((e) => e.localname === localname);
+        if (existing) {
+            // use Set to avoid duplicates
+            existing.exportedIdentifiers = [
+                ...new Set([...existing.exportedIdentifiers, ...exportedIdentifiers]),
+            ];
+            return;
+        }
+        this.bundle.exportObjs.push({
+            localname,
+            relativePath: rel,
+            exportedIdentifiers: [...new Set(exportedIdentifiers)],
+            isHelperFunc,
+            pkg,
+        });
+    }
+}
+exports.Bundler = Bundler;