@hyperweb/telescope 1.15.0

package/module/generators/create-bundle.js

@@ -0,0 +1,79 @@
+import { exportAllFromRelPath, exportTypesWithAlias, recursiveModuleBundle, } from "@cosmology/ast";
+import { duplicateImportPathsWithExt, makeAliasName, makeAliasNameWithPackageAtEnd } from "@cosmology/utils";
+export const plugin = (builder, bundler) => {
+    if (!builder.options.bundle.enabled) {
+        return;
+    }
+    let prog = [];
+    if (builder.options.bundle.type === "namespace") {
+        const importPaths = duplicateImportPathsWithExt(bundler.bundle.importPaths, builder.options.restoreImportExtension);
+        // [x] bundle
+        const body = recursiveModuleBundle(builder.options, bundler.bundle.bundleVariables);
+        prog = prog.concat(importPaths).concat(body);
+    }
+    else if (builder.options.bundle.type === "module") {
+        // get export objs
+        const exportObjs = bundler.bundle.exportObjs;
+        if (!exportObjs) {
+            return;
+        }
+        // check each of exported identifiers is duplicated
+        exportObjs.forEach((exportObj) => {
+            const duplicatedTypeNames = exportObj.exportedIdentifiers.filter((identifier) => {
+                let isDuplicated = false;
+                if (exportObj.isHelperFunc) {
+                    const duplicatedHelperFuncs = builder.store.getHelperFuncsInMultipleFiles();
+                    isDuplicated = duplicatedHelperFuncs.some((helperFunc) => {
+                        return helperFunc === identifier;
+                    });
+                }
+                else {
+                    const duplicatedTypes = builder.store.getTypesInMultipleFiles();
+                    isDuplicated = duplicatedTypes.some((type) => {
+                        return type === identifier;
+                    });
+                }
+                return isDuplicated;
+            });
+            if (duplicatedTypeNames.length > 0) {
+                // export each, some duplicated with alias
+                const typesWithAlias = exportObj.exportedIdentifiers.map((identifier) => {
+                    const duplicatedType = duplicatedTypeNames.find((type) => type === identifier);
+                    if (duplicatedType) {
+                        let alias;
+                        if (exportObj.isHelperFunc) {
+                            const serialNumber = builder.store.getAndIncTypeSerialNumber(identifier);
+                            if (serialNumber > 0) {
+                                alias = makeAliasNameWithPackageAtEnd({ package: exportObj.pkg, name: identifier });
+                            }
+                            else {
+                                alias = identifier;
+                            }
+                        }
+                        else {
+                            const serialNumber = builder.store.getAndIncTypeSerialNumber(identifier);
+                            if (serialNumber > 0) {
+                                alias = makeAliasName({ package: exportObj.pkg, name: identifier });
+                            }
+                            else {
+                                alias = identifier;
+                            }
+                        }
+                        return { name: identifier, alias: alias };
+                    }
+                    return { name: identifier, alias: identifier };
+                });
+                prog.push(exportTypesWithAlias(typesWithAlias, exportObj.relativePath));
+            }
+            else {
+                // export *
+                prog.push(exportAllFromRelPath(exportObj.relativePath));
+            }
+        });
+    }
+    const localname = bundler.bundle.bundleFile;
+    const filename = bundler.getFilename(localname);
+    bundler.writeAst(prog, filename);
+    // [x] write an index file for each base
+    bundler.files.forEach((file) => builder.files.push(file));
+};

package/module/generators/create-cosmwasm-bundle.js

@@ -0,0 +1,11 @@
+import { TSBuilder } from '@cosmwasm/ts-codegen';
+export const plugin = async (builder) => {
+    if (!builder.options.cosmwasm) {
+        return;
+    }
+    const input = builder.options.cosmwasm;
+    const cosmWasmBuilder = new TSBuilder(input);
+    await cosmWasmBuilder.build();
+    const file = input.options.bundle.bundleFile;
+    builder.files.push(file);
+};

package/module/generators/create-custom-stargate-clients.js

@@ -0,0 +1,96 @@
+import { join, dirname, relative } from 'path';
+import { importNamespace, GenericParseContext, createStargateClient, createStargateClientOptions, createStargateClientProtoRegistry, createStargateClientAminoRegistry, createGetTxRpc } from '@cosmology/ast';
+import { camel, pascal } from 'case';
+import { duplicateImportPathsWithExt, variableSlug, toPosixPath, isPackageIncluded } from '@cosmology/utils';
+import { buildAllImportsFromGenericContext } from '../imports';
+import { writeAstToFile } from '../utils/files';
+export const plugin = (builder, allRegistries, allConverters) => {
+    builder.options.rpcClients.clientStyle.customClientOption.map((currentClient) => {
+        if (!allRegistries || !allRegistries.length) {
+            return;
+        }
+        const registryImports = [];
+        const converterImports = [];
+        const clientFile = currentClient.fileName;
+        builder.files.push(clientFile);
+        const ctxRef = {
+            absolute: '/',
+            filename: '/',
+            proto: {
+                imports: [],
+                package: currentClient.name,
+                root: {},
+            }
+        };
+        const ctx = new GenericParseContext(ctxRef, null, builder.options);
+        const registryVariables = [];
+        const converterVariables = [];
+        const filteredRegistries = allRegistries.filter(item => isPackageIncluded(item.package, currentClient.include.patterns));
+        filteredRegistries.forEach(registry => {
+            let rel = relative(dirname(clientFile), registry.localname);
+            if (!rel.startsWith('.'))
+                rel = `./${rel}`;
+            rel = toPosixPath(rel);
+            const variable = variableSlug(registry.localname);
+            registryVariables.push(variable);
+            registryImports.push(importNamespace(variable, rel));
+        });
+        const filteredConverters = allConverters.filter(item => isPackageIncluded(item.package, currentClient.include.patterns));
+        filteredConverters.forEach(converter => {
+            let rel = relative(dirname(clientFile), converter.localname);
+            if (!rel.startsWith('.'))
+                rel = `./${rel}`;
+            rel = toPosixPath(rel);
+            const variable = variableSlug(converter.localname);
+            converterVariables.push(variable);
+            converterImports.push(importNamespace(variable, rel));
+        });
+        const name = 'get' + pascal(currentClient.name + 'SigningClient');
+        const txRpcName = 'get' + pascal(currentClient.name + 'SigningTxRpc');
+        const prefix = camel(currentClient.name);
+        const aminos = createStargateClientAminoRegistry({
+            context: ctx,
+            aminos: converterVariables,
+            aminoConverters: prefix + 'AminoConverters'
+        });
+        const protos = createStargateClientProtoRegistry({
+            context: ctx,
+            registries: registryVariables,
+            protoTypeRegistry: prefix + 'ProtoRegistry'
+        });
+        const clientOptions = createStargateClientOptions({
+            context: ctx,
+            name: name + 'Options',
+            protoTypeRegistry: prefix + 'ProtoRegistry',
+            aminoConverters: prefix + 'AminoConverters'
+        });
+        const clientBody = createStargateClient({
+            context: ctx,
+            name,
+            options: name + 'Options',
+        });
+        let getTxRpc;
+        if (ctx.pluginValue("stargateClients.addGetTxRpc")) {
+            getTxRpc = createGetTxRpc(ctx, txRpcName, name);
+        }
+        const imports = buildAllImportsFromGenericContext(ctx, clientFile);
+        let importDecls = [...imports, ...registryImports, ...converterImports];
+        importDecls = duplicateImportPathsWithExt(importDecls, builder.options.restoreImportExtension);
+        let cProg = importDecls
+            .concat(aminos)
+            .concat(protos)
+            .concat(clientOptions)
+            .concat(clientBody);
+        // replace all backslash path for windows
+        for (let i = 0; i < cProg.length; i++) {
+            if (cProg[i].source?.value) {
+                cProg[i].source.value = toPosixPath(cProg[i].source?.value);
+            }
+        }
+        if (getTxRpc) {
+            cProg = cProg.concat(getTxRpc);
+        }
+        const clientOutFile = join(builder.outPath, clientFile);
+        writeAstToFile(builder.outPath, builder.options, cProg, clientOutFile);
+    });
+};

package/module/generators/create-helpers.js

@@ -0,0 +1,112 @@
+import { join, dirname } from "path";
+import { mkdirp } from "mkdirp";
+import pkg from "../../package.json";
+import { writeContentToFile } from "../utils/files";
+import { external, externalComet, externalIcJs, getHelper, getHelperForBigint, getReactQueryHelper, getVueQueryHelperHooks, mobx, grpcGateway, grpcWeb, pinia, varint, utf8, getHelperForBinary, getRegistryHelper, getTypesHelper, jsonSafe, decimal, getHelperFuncTypes, getHelperFuncTypesForInterface, getReactQueryHelperHooks, getReactQueryHelperHooksIcJs, } from "../helpers";
+const version = process.env.NODE_ENV === "test" ? "latest" : pkg.version;
+const header = `/**
+* This file and any referenced files were automatically generated by ${pkg.name}@${version}
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+\n`;
+const write = (builder, indexFile, content) => {
+    const indexOutFile = join(builder.outPath, indexFile);
+    mkdirp.sync(dirname(indexOutFile));
+    writeContentToFile(builder.outPath, builder.options, header + content, indexOutFile);
+};
+export const plugin = (builder) => {
+    write(builder, "helpers.ts", builder.options.prototypes.typingsFormat.num64 === "bigint"
+        ? getHelperForBigint(builder.options)
+        : getHelper(builder.options));
+    // should be exported
+    if (builder.options.stargateClients.addGetTxRpc ||
+        builder.options.includeExternalHelpers ||
+        builder.options.reactQuery?.enabled ||
+        builder.options?.helperFunctions?.enabled) {
+        // also react-query needs these...
+        builder.files.push("extern.ts");
+        if (builder.options?.helperFunctions?.enabled) {
+            write(builder, "extern.ts", externalIcJs);
+        }
+        else {
+            write(builder, "extern.ts", builder.options.rpcClients?.useConnectComet || builder.options.rpcClients?.useMakeClient ? externalComet : external);
+        }
+    }
+    if (builder.options.helperFunctions?.enabled) {
+        builder.files.push("helper-func-types.ts");
+        if (builder.options.interfaces?.enabled && builder.options.helperFunctions?.useGlobalDecoderRegistry) {
+            write(builder, "helper-func-types.ts", getHelperFuncTypesForInterface(builder.options));
+        }
+        else {
+            write(builder, "helper-func-types.ts", getHelperFuncTypes(builder.options));
+        }
+    }
+    if (builder.options.reactQuery?.enabled ||
+        (builder.options?.helperFunctions?.enabled &&
+            builder.options?.helperFunctions?.hooks?.react)) {
+        builder.files.push("react-query.ts");
+        if (builder.options?.helperFunctions?.enabled &&
+            builder.options?.helperFunctions?.hooks?.react) {
+            if (builder.options?.useInterchainJs) {
+                write(builder, "react-query.ts", getReactQueryHelperHooksIcJs(builder.options));
+            }
+            else {
+                write(builder, "react-query.ts", getReactQueryHelperHooks(builder.options));
+            }
+        }
+        else {
+            write(builder, "react-query.ts", getReactQueryHelper(builder.options));
+        }
+    }
+    if (builder.options?.helperFunctions?.enabled &&
+        builder.options?.helperFunctions?.hooks?.vue) {
+        builder.files.push("vue-query.ts");
+        write(builder, "vue-query.ts", getVueQueryHelperHooks(builder.options));
+    }
+    if (builder.options.mobx?.enabled) {
+        builder.files.push("mobx.ts");
+        write(builder, "mobx.ts", mobx);
+    }
+    if (builder.options.pinia?.enabled) {
+        builder.files.push("pinia-endpoint.ts");
+        write(builder, "pinia-endpoint.ts", pinia);
+    }
+    if (builder.options.rpcClients?.type === "grpc-gateway") {
+        builder.files.push("grpc-gateway.ts");
+        write(builder, "grpc-gateway.ts", grpcGateway);
+    }
+    if (builder.options.rpcClients?.type === "grpc-web") {
+        builder.files.push("grpc-web.ts");
+        write(builder, "grpc-web.ts", grpcWeb);
+    }
+    if (builder.options.prototypes.typingsFormat.customTypes.useEnhancedDecimal) {
+        builder.files.push("decimals.ts");
+        write(builder, "decimals.ts", decimal);
+    }
+    if (!builder.options.prototypes.typingsFormat.toJsonUnknown &&
+        builder.options.prototypes.methods.toJSON) {
+        builder.files.push("json-safe.ts");
+        write(builder, "json-safe.ts", jsonSafe);
+    }
+    if (builder.options.prototypes.typingsFormat.num64 === "bigint") {
+        builder.files.push("varint.ts");
+        write(builder, "varint.ts", varint);
+        builder.files.push("utf8.ts");
+        write(builder, "utf8.ts", utf8);
+        builder.files.push("binary.ts");
+        write(builder, "binary.ts", getHelperForBinary(builder.options));
+    }
+    if (builder.options.prototypes?.typingsFormat?.useTelescopeGeneratedType ||
+        (builder.options.interfaces?.enabled &&
+            (builder.options.interfaces?.useGlobalDecoderRegistry || builder.options.helperFunctions?.useGlobalDecoderRegistry)) ||
+        builder.options.helperFunctions?.enabled) {
+        builder.files.push("types.ts");
+        write(builder, "types.ts", getTypesHelper(builder.options));
+    }
+    if (builder.options.interfaces?.enabled &&
+        (builder.options.interfaces?.useGlobalDecoderRegistry || builder.options.helperFunctions?.useGlobalDecoderRegistry)) {
+        builder.files.push("registry.ts");
+        write(builder, "registry.ts", getRegistryHelper(builder.options));
+    }
+};

package/module/generators/create-index.js

@@ -0,0 +1,45 @@
+import { getRelativePath } from "../utils";
+import { join, dirname } from "path";
+import { mkdirp } from "mkdirp";
+import * as t from "@babel/types";
+import generate from "@babel/generator";
+//@ts-ignore
+import pkg from "../../package.json";
+import { writeContentToFile } from "../utils/files";
+const version = process.env.NODE_ENV === "test" ? "latest" : pkg.version;
+export const plugin = (builder) => {
+    if (!builder.options.bundle.enabled) {
+        return;
+    }
+    // finally, write one index file with all files, exported
+    const indexFile = "index.ts";
+    const indexOutFile = join(builder.outPath, indexFile);
+    const stmts = builder.files.map((file) => t.exportAllDeclaration(t.stringLiteral(getRelativePath(indexFile, file, builder.options.restoreImportExtension))));
+    const finalAst = t.program(stmts);
+    const indexContent = generate(finalAst).code;
+    mkdirp.sync(dirname(indexOutFile));
+    const header = `/**
+  * This file and any referenced files were automatically generated by ${pkg.name}@${version}
+  * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+    * and run the transpile command or npm scripts command that is used to regenerate this bundle.
+  */
+ \n`;
+    writeContentToFile(builder.outPath, builder.options, header + indexContent, indexOutFile);
+    if (builder.options.bundle.enabled &&
+        builder.options.bundle.type === "module") {
+        const typePackageMapping = builder.store.getTypesInMultipleFiles();
+        const servicePackageMapping = builder.store.getHelperFuncsInMultipleFiles();
+        const typePackageMappingMap = typePackageMapping.reduce((obj, type) => {
+            const pkg = builder.store.getTypeFilesMapping(type);
+            obj[type] = pkg.join(", ");
+            return obj;
+        }, {});
+        // console.log("types in multiple files:", JSON.stringify(typePackageMappingMap, null, 2));
+        const servicePackageMappingMap = servicePackageMapping.reduce((obj, service) => {
+            const pkg = builder.store.getHelperFuncFilesMapping(service);
+            obj[service] = pkg.join(", ");
+            return obj;
+        }, {});
+        // console.log("services in multiple files:", JSON.stringify(servicePackageMappingMap, null, 2));
+    }
+};

package/module/generators/create-lcd-client-all.js

@@ -0,0 +1,89 @@
+import * as dotty from 'dotty';
+import { getNestedProto, isRefIncluded, createEmptyProtoRef } from '@cosmology/proto-parser';
+import { join } from 'path';
+import { createScopedLCDFactory } from '@cosmology/ast';
+import { fixlocalpaths, getRelativePath } from '../utils';
+import { TelescopeParseContext } from '../build';
+import { aggregateImports, getImportStatements } from '../imports';
+export const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.lcdClients?.enabled) {
+        return;
+    }
+    // if no scopes, do them all!
+    if (!builder.options.lcdClients.scoped ||
+        !builder.options.lcdClients.scoped.length ||
+        !builder.options.lcdClients.scopedIsExclusive) {
+        return createAllLCDBundles(builder, bundler);
+    }
+};
+const getFileName = (dir, filename) => {
+    const localname = join(dir, filename ?? 'lcd.ts');
+    if (localname.endsWith('.ts'))
+        return localname;
+    return localname + '.ts';
+};
+const createAllLCDBundles = (builder, bundler) => {
+    if (!builder.options.lcdClients.bundle)
+        return;
+    const dir = bundler.bundle.base;
+    const filename = 'lcd.ts';
+    // refs with services
+    const refs = builder.store.getProtos().filter((ref) => {
+        const proto = getNestedProto(ref.traversed);
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients.enabledServices.filter(a => a !== 'Msg');
+        const found = allowedRpcServices.some(svc => {
+            return proto?.[svc] &&
+                proto[svc]?.type === 'Service';
+        });
+        if (!found) {
+            return;
+        }
+        return true;
+    });
+    const check = refs.filter((ref) => {
+        const [base] = ref.proto.package.split('.');
+        return base === bundler.bundle.base;
+    });
+    if (!check.length) {
+        // if there are no services
+        // exit the plugin
+        return;
+    }
+    const packages = refs.reduce((m, ref) => {
+        const [base] = ref.proto.package.split('.');
+        if (base === 'cosmos' || base === bundler.bundle.base)
+            return [...new Set([...m, ref.proto.package])];
+        return m;
+    }, []);
+    const methodName = 'createLCDClient';
+    const localname = getFileName(dir, filename);
+    const obj = {};
+    builder.lcdClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        // if (!packages.includes(file.package)) {
+        if (!isRefIncluded(createEmptyProtoRef(file.package, file.proto), {
+            packages,
+        })) {
+            return;
+        }
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = getRelativePath(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+    const ctx = new TelescopeParseContext(createEmptyProtoRef(dir, localname), builder.store, builder.options);
+    const lcdast = createScopedLCDFactory(ctx.proto, obj, methodName, 'LCDQueryClient' // make option later
+    );
+    const imports = aggregateImports(ctx, {}, localname);
+    const importStmts = getImportStatements(localname, [...fixlocalpaths(imports)], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(lcdast);
+    const writeFilename = bundler.getFilename(localname);
+    bundler.writeAst(prog, writeFilename);
+    bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+};

package/module/generators/create-lcd-client-scoped.js

@@ -0,0 +1,62 @@
+import * as dotty from 'dotty';
+import { isRefIncluded, createEmptyProtoRef } from '@cosmology/proto-parser';
+import { join } from 'path';
+import { createScopedLCDFactory } from '@cosmology/ast';
+import { fixlocalpaths, getRelativePath } from '../utils';
+import { TelescopeParseContext } from '../build';
+import { aggregateImports, getImportStatements } from '../imports';
+export const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.lcdClients?.enabled) {
+        return;
+    }
+    // we have scopes!
+    builder.options.lcdClients.scoped?.forEach(lcd => {
+        if (lcd.dir !== bundler.bundle.base)
+            return;
+        makeLCD(builder, bundler, lcd);
+    });
+};
+const getFileName = (dir, filename) => {
+    const localname = join(dir, filename ?? 'lcd.ts');
+    if (localname.endsWith('.ts'))
+        return localname;
+    return localname + '.ts';
+};
+const makeLCD = (builder, bundler, lcd) => {
+    const dir = lcd.dir;
+    const packages = lcd.packages;
+    const protos = lcd.protos;
+    const methodName = lcd.methodName ?? 'createLCDClient';
+    const localname = getFileName(dir, lcd.filename);
+    const obj = {};
+    builder.lcdClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        // if (!packages.includes(file.package)) {
+        if (!isRefIncluded(createEmptyProtoRef(file.package, file.proto), {
+            packages,
+            protos
+        })) {
+            return;
+        }
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = getRelativePath(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+    const ctx = new TelescopeParseContext(createEmptyProtoRef(dir, localname), builder.store, builder.options);
+    const lcdast = createScopedLCDFactory(ctx.proto, obj, methodName, 'LCDQueryClient' // make option later
+    );
+    const imports = aggregateImports(ctx, {}, localname);
+    const importStmts = getImportStatements(localname, [...fixlocalpaths(imports)], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(lcdast);
+    const filename = bundler.getFilename(localname);
+    bundler.writeAst(prog, filename);
+    if (lcd.addToBundle) {
+        bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+    }
+};

package/module/generators/create-lcd-clients.js

@@ -0,0 +1,74 @@
+import { buildAllImports, getDepsFromQueries } from '../imports';
+import { getNestedProto } from '@cosmology/proto-parser';
+import { parse } from '../parse';
+import { createLCDClient, } from '@cosmology/ast';
+export const plugin = (builder, bundler) => {
+    if (!builder.options.lcdClients.enabled) {
+        return;
+    }
+    const queryContexts = bundler
+        .contexts
+        .filter(context => context.queries.length > 0 ||
+        context.services.length > 0);
+    // [x] write out one registry helper for all contexts w/mutations
+    const lcdClients = queryContexts.map(c => {
+        const enabled = c.proto.pluginValue('lcdClients.enabled');
+        if (!enabled)
+            return;
+        if (c.proto.isExcluded())
+            return;
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        parse(ctx);
+        const proto = getNestedProto(c.ref.traversed);
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients.enabledServices.filter(a => a !== 'Msg');
+        const found = allowedRpcServices.some(svc => {
+            return proto?.[svc] &&
+                proto[svc]?.type === 'Service';
+        });
+        if (!found) {
+            return;
+        }
+        ///
+        let getImportsFrom;
+        // get imports
+        allowedRpcServices.forEach(svcKey => {
+            if (proto[svcKey]) {
+                if (svcKey === 'Query') {
+                    getImportsFrom = ctx.queries;
+                }
+                else {
+                    getImportsFrom = ctx.services;
+                }
+            }
+        });
+        const localname = bundler.getLocalFilename(c.ref, 'lcd');
+        const filename = bundler.getFilename(localname);
+        let ast = null;
+        allowedRpcServices.forEach(svcKey => {
+            if (proto[svcKey]) {
+                ast = createLCDClient(ctx.generic, proto[svcKey]);
+            }
+        });
+        if (!ast) {
+            return;
+        }
+        const serviceImports = getDepsFromQueries(getImportsFrom, localname);
+        const imports = buildAllImports(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body)
+            .concat(ast);
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+        return {
+            proto: c.ref.filename,
+            // TODO use this to build LCD aggregators with scopes
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+    }).filter(Boolean);
+    bundler.addLCDClients(lcdClients);
+};