@hyperweb/telescope 1.15.0

package/module/generators/create-types.js

@@ -0,0 +1,137 @@
+import * as t from "@babel/types";
+import { buildAllImports } from "../imports";
+import { parse } from "../parse";
+import { writeFileSync } from "fs";
+import { dirname } from "path";
+import { mkdirp } from "mkdirp";
+import { getNestedProto } from "@cosmology/proto-parser";
+import { createRpcClientClass, createRpcClientImpl, createRpcClientInterface, createRpcQueryExtension, } from "@cosmology/ast";
+import { camel, getQueryMethodNames, swapKeyValue } from "@cosmology/utils";
+import { getExportedTypeNames } from "../utils/files";
+export const plugin = (builder, bundler) => {
+    const instantRpcBundlerFiles = {};
+    // [x] search for all files that live in package
+    const baseProtos = builder.store.getProtos().filter((ref) => {
+        return ref.proto.package.split(".")[0] === bundler.bundle.base;
+    });
+    // [x] write out all TS files for package
+    bundler.contexts = baseProtos
+        .map((ref) => {
+        const context = builder.context(ref);
+        parse(context);
+        context.buildBase();
+        const allTypes = context.types.filter((type) => type.obj.type === "Enum" || type.obj.type === "Type");
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients.enabledServices.filter((a) => a !== "Msg");
+        const localname = bundler.getLocalFilename(ref);
+        const filename = bundler.getFilename(localname);
+        const bundlerFile = {
+            proto: context.ref.filename,
+            package: context.ref.proto.package,
+            localname,
+            filename,
+        };
+        if (context.proto.pluginValue("rpcClients.inline")) {
+            const proto = getNestedProto(context.ref.traversed);
+            const instantOps = context.options.rpcClients?.instantOps ?? [];
+            const useCamelCase = context.options.rpcClients?.camelCase;
+            allowedRpcServices.forEach((svcKey) => {
+                if (proto[svcKey]) {
+                    const svc = proto[svcKey];
+                    context.body.push(createRpcClientInterface(context.generic, proto[svcKey]));
+                    instantOps.forEach((item) => {
+                        let nameMapping = {
+                            ...swapKeyValue(item.nameMapping?.All ?? {}),
+                            ...swapKeyValue(item.nameMapping?.Query ?? {}),
+                        };
+                        // get all query methods
+                        const patterns = item.include?.patterns;
+                        const serviceTypes = item.include?.serviceTypes;
+                        if (serviceTypes && !serviceTypes.includes("Query")) {
+                            return;
+                        }
+                        const methodKeys = getQueryMethodNames(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns, useCamelCase ? camel : String);
+                        if (!methodKeys || !methodKeys.length) {
+                            return;
+                        }
+                        context.body.push(createRpcClientInterface(context.generic, svc, item.className, methodKeys, nameMapping));
+                        bundlerFile.instantExportedMethods = methodKeys.map((key) => proto[svcKey].methods[key]);
+                        if (!instantRpcBundlerFiles[item.className]) {
+                            instantRpcBundlerFiles[item.className] = [];
+                        }
+                        instantRpcBundlerFiles[item.className].push({ ...bundlerFile });
+                    });
+                    context.body.push(createRpcClientClass(context.generic, proto[svcKey]));
+                    if (context.proto.pluginValue("rpcClients.extensions")) {
+                        context.body.push(createRpcQueryExtension(context.generic, proto[svcKey]));
+                    }
+                    else {
+                        const env = context.proto.pluginValue("env");
+                        if (env === "v-next") {
+                            context.body.push(createRpcClientImpl(context.generic, proto[svcKey]));
+                        }
+                    }
+                }
+            });
+            if (proto.Msg) {
+                bundlerFile.isMsg = true;
+                context.body.push(createRpcClientInterface(context.generic, proto.Msg));
+                instantOps.forEach((item) => {
+                    let nameMapping = {
+                        ...swapKeyValue(item.nameMapping?.All ?? {}),
+                        ...swapKeyValue(item.nameMapping?.Msg ?? {}),
+                    };
+                    // get all msg methods
+                    const patterns = item.include?.patterns;
+                    const serviceTypes = item.include?.serviceTypes;
+                    if (serviceTypes && !serviceTypes.includes("Tx")) {
+                        return;
+                    }
+                    const methodKeys = getQueryMethodNames(bundlerFile.package, Object.keys(proto.Msg.methods ?? {}), patterns, useCamelCase ? camel : String);
+                    if (!methodKeys || !methodKeys.length) {
+                        return;
+                    }
+                    context.body.push(createRpcClientInterface(context.generic, proto.Msg, item.className, methodKeys, nameMapping));
+                    bundlerFile.instantExportedMethods = methodKeys.map((key) => proto["Msg"].methods[key]);
+                    if (!instantRpcBundlerFiles[item.className]) {
+                        instantRpcBundlerFiles[item.className] = [];
+                    }
+                    instantRpcBundlerFiles[item.className].push({ ...bundlerFile });
+                });
+                context.body.push(createRpcClientClass(context.generic, proto.Msg));
+                const env = context.proto.pluginValue("env");
+                if (env === "v-next") {
+                    context.body.push(createRpcClientImpl(context.generic, proto.Msg));
+                }
+            }
+        }
+        // build BASE file
+        const importStmts = buildAllImports(context, null, context.ref.filename);
+        const prog = [].concat(importStmts);
+        // package var
+        if (context.proto.pluginValue("prototypes.includePackageVar")) {
+            prog.push(t.exportNamedDeclaration(t.variableDeclaration("const", [
+                t.variableDeclarator(t.identifier("protobufPackage"), t.stringLiteral(context.ref.proto.package)),
+            ])));
+        }
+        // body
+        prog.push.apply(prog, context.body);
+        if (context.body.length > 0) {
+            const exportedTypeNames = getExportedTypeNames(prog);
+            exportedTypeNames.forEach((name) => {
+                context.store.setTypeFilesMapping(name, localname);
+            });
+            bundler.writeAst(prog, filename);
+            bundler.addExportObjToBundle(context.ref.proto.package, localname, exportedTypeNames);
+        }
+        else {
+            mkdirp.sync(dirname(filename));
+            writeFileSync(filename, `export {}`);
+        }
+        return context;
+    })
+        .filter(Boolean);
+    Object.keys(instantRpcBundlerFiles).forEach((className) => {
+        bundler.addStateManagers(`instantRpc_${className}`, instantRpcBundlerFiles[className]);
+    });
+};

package/module/generators/customize-utils.js

@@ -0,0 +1,46 @@
+import { UTILS } from '../utils';
+export const plugin = (builder) => {
+    if (builder.options.useInterchainJs) {
+        UTILS.encodePubkey = '@interchainjs/pubkey';
+        UTILS.decodePubkey = '@interchainjs/pubkey';
+        UTILS.fromBase64 = '@interchainjs/encoding';
+        UTILS.fromBech32 = '@interchainjs/encoding';
+        UTILS.fromHex = '@interchainjs/encoding';
+        UTILS.fromUtf8 = '@interchainjs/encoding';
+        UTILS.toBase64 = '@interchainjs/encoding';
+        UTILS.toUtf8 = '@interchainjs/encoding';
+        UTILS.Decimal = '@interchainjs/math';
+        UTILS.DeliverTxResponse = '@interchainjs/types';
+    }
+    if (builder.options.prototypes.typingsFormat.customTypes.useEnhancedDecimal ===
+        true) {
+        UTILS.Decimal = '__decimals__';
+    }
+    else {
+        if (builder.options.useInterchainJs) {
+            UTILS.Decimal = '@interchainjs/math';
+        }
+        else {
+            UTILS.Decimal = '@cosmjs/math';
+        }
+    }
+    if (builder.options.prototypes.typingsFormat.customTypes.base64Lib ===
+        '@endo/base64') {
+        UTILS.base64FromBytes = {
+            type: 'import',
+            path: '@endo/base64',
+            name: 'encodeBase64',
+            importAs: 'base64FromBytes',
+        };
+        UTILS.bytesFromBase64 = {
+            type: 'import',
+            path: '@endo/base64',
+            name: 'decodeBase64',
+            importAs: 'bytesFromBase64',
+        };
+    }
+    else {
+        UTILS.base64FromBytes = '__helpers__';
+        UTILS.bytesFromBase64 = '__helpers__';
+    }
+};

package/module/helpers/__test__/internalTimestamp.js

@@ -0,0 +1,39 @@
+import Long from 'long';
+export function isSet(value) {
+    return value !== null && value !== undefined;
+}
+export function toTimestamp(date) {
+    const seconds = numberToLong(date.getTime() / 1_000);
+    const nanos = date.getTime() % 1000 * 1000000;
+    return {
+        seconds,
+        nanos
+    };
+}
+;
+export function fromTimestamp(t) {
+    let millis = t.seconds.toNumber() * 1000;
+    millis += t.nanos / 1000000;
+    return new Date(millis);
+}
+;
+const timestampFromJSON = (object) => {
+    return {
+        seconds: isSet(object.seconds) ? Long.fromValue(object.seconds) : Long.ZERO,
+        nanos: isSet(object.nanos) ? Number(object.nanos) : 0,
+    };
+};
+export function fromJsonTimestamp(o) {
+    if (o instanceof Date) {
+        return toTimestamp(o);
+    }
+    else if (typeof o === "string") {
+        return toTimestamp(new Date(o));
+    }
+    else {
+        return timestampFromJSON(o);
+    }
+}
+function numberToLong(number) {
+    return Long.fromNumber(number);
+}

package/module/helpers/__test__/internalTimestampBigint.js

@@ -0,0 +1,38 @@
+export function isSet(value) {
+    return value !== null && value !== undefined;
+}
+export function toTimestamp(date) {
+    const seconds = numberToLong(date.getTime() / 1_000);
+    const nanos = (date.getTime() % 1000) * 1000000;
+    return {
+        seconds,
+        nanos
+    };
+}
+export function fromTimestamp(t) {
+    let millis = Number(t.seconds) * 1000;
+    millis += t.nanos / 1000000;
+    return new Date(millis);
+}
+const timestampFromJSON = (object) => {
+    return {
+        seconds: isSet(object.seconds)
+            ? BigInt(object.seconds.toString())
+            : BigInt(0),
+        nanos: isSet(object.nanos) ? Number(object.nanos) : 0
+    };
+};
+export function fromJsonTimestamp(o) {
+    if (o instanceof Date) {
+        return toTimestamp(o);
+    }
+    else if (typeof o === 'string') {
+        return toTimestamp(new Date(o));
+    }
+    else {
+        return timestampFromJSON(o);
+    }
+}
+function numberToLong(number) {
+    return BigInt(Math.trunc(number));
+}