@hyperweb/telescope 1.15.0

package/module/utils/index.js

@@ -0,0 +1,143 @@
+import { relative, dirname, extname } from 'path';
+import { restoreExtension, toPosixPath } from '@cosmology/utils';
+export const getRoot = (ref) => {
+    if (ref.traversed)
+        return ref.traversed;
+    return ref.proto;
+};
+// default example:
+// Long: { type: 'default', path: 'long', name: 'Long ' },
+// namespaced:
+// _m0: { type: 'namespace', path: 'protobufjs/minimal', name: '_m0' },
+export const UTILS = {
+    _m0: { type: 'namespace', path: 'protobufjs/minimal', name: '_m0' },
+    AminoHeight: '__helpers__',
+    AminoMsg: '@cosmjs/amino',
+    AminoTypes: '@cosmjs/stargate',
+    base64FromBytes: '__helpers__',
+    bytesFromBase64: '__helpers__',
+    BrowserHeaders: 'browser-headers',
+    connectComet: '@cosmjs/tendermint-rpc',
+    Decimal: '@cosmjs/math',
+    padDecimal: '__helpers__',
+    createProtobufRpcClient: '@cosmjs/stargate',
+    Pubkey: '@cosmjs/amino',
+    decodeBech32Pubkey: '@cosmjs/amino',
+    DeepPartial: '__helpers__',
+    defaultRegistryTypes: '@cosmjs/stargate',
+    encodeBech32Pubkey: '@cosmjs/amino',
+    Exact: '__helpers__',
+    fm: { type: 'namespace', path: '__grpc-gateway__', name: 'fm' },
+    encodePubkey: '@cosmjs/proto-signing',
+    decodePubkey: '@cosmjs/proto-signing',
+    fromBase64: '@cosmjs/encoding',
+    fromBech32: '@cosmjs/encoding',
+    fromDuration: '__helpers__',
+    fromHex: '@cosmjs/encoding',
+    fromJsonTimestamp: '__helpers__',
+    fromTimestamp: '__helpers__',
+    fromUtf8: '@cosmjs/encoding',
+    GeneratedType: '@cosmjs/proto-signing',
+    createTm34QueryClient: '__extern__',
+    createConnectCometQueryClient: '__extern__',
+    getRpcClient: '__extern__',
+    createRpcClient: '__extern__',
+    getRpcEndpointKey: '__extern__',
+    HttpEndpoint: '@cosmjs/tendermint-rpc',
+    isObject: '__helpers__',
+    isSet: '__helpers__',
+    LCDClient: '@cosmology/lcd',
+    Long: '__helpers__',
+    OfflineSigner: '@cosmjs/proto-signing',
+    omitDefault: '__helpers__',
+    ProtobufRpcClient: '@cosmjs/stargate',
+    QueryClient: '@cosmjs/stargate',
+    Registry: '@cosmjs/proto-signing',
+    Rpc: '__helpers__',
+    StdFee: '__types__',
+    TxRpc: '__types__',
+    BroadcastTxReq: '__types__',
+    BroadcastTxRes: '__types__',
+    DeliverTxResponse: '__types__',
+    EncodeObject: '__types__',
+    SigningClientParams: '__types__',
+    grpc: '@improbable-eng/grpc-web',
+    setPaginationParams: '__helpers__',
+    SigningStargateClient: '@cosmjs/stargate',
+    Tendermint34Client: '@cosmjs/tendermint-rpc',
+    toBase64: '@cosmjs/encoding',
+    toDuration: '__helpers__',
+    toTimestamp: '__helpers__',
+    toUtf8: '@cosmjs/encoding',
+    useQuery: '@tanstack/react-query',
+    ComputedRef: 'vue',
+    computed: 'vue',
+    Ref: 'vue',
+    useRpcEndpoint: '__react-query__',
+    useRpcClient: '__react-query__',
+    useTendermintClient: '__react-query__',
+    ReactQueryParams: '__react-query__',
+    buildUseMutation: '__react-query__',
+    UseQueryParams: '__react-query__',
+    buildUseQuery: '__react-query__',
+    UseQueryOptions: '@tanstack/react-query',
+    buildUseVueMutation: '__vue-query__',
+    buildUseVueQuery: '__vue-query__',
+    QueryStore: '__mobx__',
+    MobxResponse: '__mobx__',
+    useEndpoint: '__pinia-endpoint__',
+    JsonSafe: '__json-safe__',
+    override: 'mobx',
+    makeObservable: 'mobx',
+    NodeHttpTransport: '@improbable-eng/grpc-web-node-http-transport',
+    UnaryMethodDefinitionishR: '__grpc-web__',
+    UnaryMethodDefinitionish: '__grpc-web__',
+    BinaryReader: '__binary__',
+    BinaryWriter: '__binary__',
+    TelescopeGeneratedType: '__types__',
+    GlobalDecoderRegistry: '__registry__',
+    buildTx: '__helper-func-types__',
+    ISigningClient: '__helper-func-types__',
+    buildQuery: '__helper-func-types__',
+    EndpointOrRpc: '__helper-func-types__',
+    toConverters: '@interchainjs/cosmos/utils',
+    toEncoders: '@interchainjs/cosmos/utils'
+};
+export const UTIL_HELPERS = [
+    '__helpers__',
+    '__extern__',
+    '__react-query__',
+    '__vue-query__',
+    '__mobx__',
+    '__binary__',
+    '__pinia-endpoint__',
+    '__json-safe__',
+    '__grpc-gateway__',
+    '__grpc-web__',
+    '__types__',
+    '__registry__',
+    '__decimals__',
+    '__helper-func-types__'
+];
+export const fixlocalpaths = (imports) => {
+    return imports.map((imp) => {
+        const fixedPath = toPosixPath(imp.path);
+        return {
+            ...imp,
+            path: UTIL_HELPERS.includes(imp.path) ||
+                imp.path.startsWith('.') ||
+                imp.path.startsWith('@')
+                ? fixedPath
+                : `./${fixedPath}`,
+        };
+    });
+};
+export const getRelativePath = (f1, f2, ext) => {
+    const rel = relative(dirname(f1), f2);
+    let importPath = rel.replace(extname(rel), '');
+    if (!/^\./.test(importPath))
+        importPath = `./${importPath}`;
+    importPath = toPosixPath(importPath);
+    return restoreExtension(importPath, ext);
+};
+export * from './common-create-bundle';

package/module/utils/unused.js

@@ -0,0 +1,47 @@
+//@ts-nocheck
+import * as t from '@babel/types';
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import/blob/c5454c21e94698a2464a12baa5590761932a71a8/License#L1
+export const unused = {
+    Program: {
+        exit: (path) => {
+            const UnRefBindings = new Map();
+            for (const [name, binding] of Object.entries(path.scope.bindings)) {
+                if (!binding.path.parentPath || binding.kind !== 'module')
+                    continue;
+                const source = binding.path.parentPath.get('source');
+                const importName = source.node.value;
+                if (!t.isStringLiteral(source))
+                    continue;
+                const key = `${importName}(${source.node.loc &&
+                    source.node.loc.start.line})`;
+                if (!UnRefBindings.has(key)) {
+                    UnRefBindings.set(key, binding);
+                }
+                if (binding.referenced) {
+                    UnRefBindings.set(key, null);
+                }
+                else {
+                    const nodeType = binding.path.node.type;
+                    if (nodeType === 'ImportSpecifier') {
+                        binding.path.remove();
+                    }
+                    else if (nodeType === 'ImportDefaultSpecifier') {
+                        binding.path.remove();
+                    }
+                    else if (nodeType === 'ImportNamespaceSpecifier') {
+                        binding.path.remove();
+                    }
+                    else if (binding.path.parentPath) {
+                        binding.path.parentPath.remove();
+                    }
+                }
+            }
+            UnRefBindings.forEach((binding, key) => {
+                if (binding && binding.path.parentPath) {
+                    binding.path.parentPath.remove();
+                }
+            });
+        }
+    }
+};

package/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "@hyperweb/telescope",
+  "version": "1.15.0",
+  "description": "A TypeScript Transpiler for Cosmos Protobufs",
+  "author": "Dan Lynch <pyramation@gmail.com>",
+  "homepage": "https://github.com/hyperweb-io/telescope/tree/master/packages/telescope#readme",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "main/index.js",
+  "module": "module/index.js",
+  "typings": "types/index.d.ts",
+  "bin": {
+    "telescope": "main/telescope.js"
+  },
+  "directories": {
+    "lib": "src",
+    "test": "__tests__"
+  },
+  "files": [
+    "types",
+    "module",
+    "src",
+    "main"
+  ],
+  "scripts": {
+    "build:main": "yarn tsc -p tsconfig.json --outDir main --module commonjs",
+    "build:module": "yarn tsc -p tsconfig.json --outDir module --module es2022",
+    "build": "npm run build:module && npm run build:main",
+    "buidl": "npm run build",
+    "buidl:clean": "npm run clean && npm run buidl",
+    "clean": "rimraf ./types",
+    "prepare": "npm run build",
+    "dev": "cross-env NODE_ENV=development ts-node src/telescope",
+    "watch": "cross-env NODE_ENV=development ts-node-dev src/telescope",
+    "file": "cross-env NODE_ENV=development ts-node-dev src/file",
+    "lint": "eslint .",
+    "format": "eslint . --fix",
+    "test": "jest",
+    "test:funcs": "jest __tests__/telescope-helper-func.test.ts",
+    "test:min": "jest __tests__/telescope-v4.test.ts",
+    "test:misc": "jest __tests__/misc.test.ts",
+    "test:watch": "jest --watch",
+    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "transform": {
+      "^.+\\.ts?$": "ts-jest"
+    },
+    "transformIgnorePatterns": [
+      "<rootDir>/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "main/",
+      "module/",
+      "types/",
+      "git-modules"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hyperweb-io/telescope"
+  },
+  "keywords": [],
+  "bugs": {
+    "url": "https://github.com/hyperweb-io/telescope/issues"
+  },
+  "devDependencies": {
+    "@keplr-wallet/unit": "^0.12.53",
+    "@types/jest": "^29.5.0",
+    "ast-stringify": "0.1.0",
+    "cross-env": "^7.0.2",
+    "eslint": "8.38.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^29.5.0",
+    "jest-in-case": "^1.0.2",
+    "prettier": "^2.8.7",
+    "regenerator-runtime": "^0.13.11",
+    "ts-jest": "^29.1.0",
+    "ts-node": "10.9.1",
+    "ts-node-dev": "2.0.0",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.23.6",
+    "@babel/parser": "^7.23.6",
+    "@babel/traverse": "7.23.6",
+    "@babel/types": "7.23.6",
+    "@cosmology/ast": "^1.11.0",
+    "@cosmology/proto-parser": "^1.10.9",
+    "@cosmology/types": "^1.12.5",
+    "@cosmology/utils": "^1.10.7",
+    "@cosmwasm/ts-codegen": "0.35.7",
+    "@types/parse-package-name": "0.1.0",
+    "case": "1.6.3",
+    "dargs": "7.0.0",
+    "deepmerge": "4.3.1",
+    "dotty": "0.1.2",
+    "fuzzy": "0.1.3",
+    "glob": "8.0.3",
+    "inquirerer": "0.1.3",
+    "long": "^5.2.1",
+    "minimatch": "5.1.0",
+    "minimist": "1.2.8",
+    "mkdirp": "3.0.0",
+    "parse-package-name": "1.0.0",
+    "rimraf": "5.0.0",
+    "yaml": "^2.3.4"
+  },
+  "gitHead": "b83c69187e1ac8a6aa7284512f630a2a9aae054e"
+}

package/src/build.ts

@@ -0,0 +1,255 @@
+import { ProtoRef, TelescopeOptions } from '@cosmology/types';
+import { ProtoStore } from '@cosmology/proto-parser';
+import {
+    AminoParseContext,
+    createAminoConverter,
+    createCreateProtoType,
+    createObjectWithMethods,
+    createRegisterObject,
+    createProtoEnum,
+    createProtoEnumToJSON,
+    createProtoEnumFromJSON,
+    createProtoType,
+    createProtoInterfaceEncodedType,
+    createProtoTypeType,
+    createSDKType,
+    createAminoType,
+    createAminoTypeType,
+    createEnumSDKType,
+    createEnumAminoType,
+    makeAminoTypeInterface,
+    GenericParseContext,
+    ProtoParseContext,
+    createTypeRegistry,
+    createRegistryLoader,
+
+    // helper
+    createHelperObject,
+    createInterfaceDecoder,
+    createInterfaceFromAmino,
+    createInterfaceToAmino,
+    createRegisterAminoProtoMapping,
+} from '@cosmology/ast';
+import { ServiceMutation, ServiceQuery } from '@cosmology/types';
+
+export const getMutations = (mutations: ServiceMutation[]) => {
+    return mutations.map((mutation: ServiceMutation) => {
+        return {
+            typeUrl: `/${mutation.package}.${mutation.message}`,
+            TypeName: mutation.message,
+            methodName: mutation.methodName
+        }
+    });
+};
+
+export const getAminoProtos = (mutations: ServiceMutation[], store: ProtoStore) => {
+    return mutations.map(mutation => {
+        const ref = store.findProto(mutation.messageImport);
+        return store.get(ref, mutation.message).obj;
+    });
+};
+
+export const buildBaseTypeScriptClass = (
+    context: TelescopeParseContext,
+    name: string,
+    obj: any
+) => {
+    if (context.options.prototypes.enabled) {
+        context.body.push(createCreateProtoType(context.proto, name, obj));
+        context.body.push(createObjectWithMethods(context.proto, name, obj));
+
+        if(context.options.interfaces?.enabled && context.options.interfaces?.useGlobalDecoderRegistry && context.options.interfaces?.registerAllDecodersToGlobal){
+          const registerObj = createRegisterObject(context.proto, name, obj);
+          if(registerObj){
+            context.body.push(registerObj);
+
+            //createRegisterAminoProtoMapping
+            const registerAminoObj = createRegisterAminoProtoMapping(context.proto, name, obj);
+            if(registerAminoObj){
+              context.body.push(registerAminoObj);
+            }
+          }
+        }
+    }
+};
+
+export const buildBaseTypeScriptInterface = (
+    context: TelescopeParseContext,
+    name: string,
+    obj: any
+) => {
+
+    context.body.push(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(createProtoTypeType(context.proto, name, obj));
+    }
+
+    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
+        // conditional type
+        const interfaceType = createProtoInterfaceEncodedType(context.proto, name, obj);
+        if (interfaceType) {
+            context.body.push(interfaceType);
+        }
+        context.body.push(createAminoType(context.proto, name, obj));
+
+        if(!context.options.aminoEncoding?.disableMsgTypes){
+            context.body.push(createAminoTypeType(context.proto, name, obj));
+        }
+    }
+    if (context.options.useSDKTypes) {
+        context.body.push(createSDKType(context.proto, name, obj));
+    }
+};
+
+export const buildEnums = (
+    context: TelescopeParseContext,
+    name: string,
+    obj: any
+) => {
+    context.body.push(createProtoEnum(context.proto, name, obj));
+    if (context.options.useSDKTypes) {
+        context.body.push(createEnumSDKType(context.proto, name, obj));
+    }
+    if (context.options.aminoEncoding?.enabled && !context.options.aminoEncoding?.useLegacyInlineEncoding) {
+        context.body.push(createEnumAminoType(context.proto, name, obj));
+    }
+    context.body.push(createProtoEnumFromJSON(context.proto, name, obj));
+    context.body.push(createProtoEnumToJSON(context.proto, name, obj));
+};
+export interface TelescopeParseContext {
+    options: TelescopeOptions;
+    generic: GenericParseContext;
+    proto: ProtoParseContext;
+    amino: AminoParseContext;
+    store: ProtoStore;
+    ref: ProtoRef;
+    parsedImports: Record<string, any>;
+    body: any[];
+    mutations: ServiceMutation[];
+    queries: any[];
+    services: any[];
+    types: any[];
+}
+export class TelescopeParseContext implements TelescopeParseContext {
+    constructor(ref: ProtoRef, store: ProtoStore, options: TelescopeOptions) {
+        this.generic = new GenericParseContext(
+            ref, store, options
+        );
+        this.proto = new ProtoParseContext(
+            ref, store, options
+        );
+        this.amino = new 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: string, obj: any, isNested: boolean) {
+        this.types.push({
+            name,
+            obj,
+            isNested
+        });
+    }
+    addMutation(mutation: ServiceMutation) {
+        this.mutations.push(mutation);
+    }
+    addQuery(query: ServiceQuery) {
+        this.queries.push(query);
+    }
+    addService(query: any) {
+        this.services.push(query);
+    }
+    // build main Class with methods
+    buildBase() {
+        this.types.forEach(typeReg => {
+            const { name, obj } = typeReg;
+            if (obj.type === 'Enum') {
+                buildEnums(this, name, obj);
+            }
+        });
+        this.types.forEach(typeReg => {
+            const { name, obj } = typeReg;
+            if (obj.type === 'Type') {
+                buildBaseTypeScriptInterface(this, name, obj);
+            }
+        });
+        this.types.forEach(typeReg => {
+            const { name, obj } = typeReg;
+            if (obj.type === 'Type') {
+                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(createInterfaceDecoder(this.proto, this.ref, interfaceName));
+                    if (
+                        this.options.aminoEncoding?.enabled &&
+                        !this.options.aminoEncoding?.useLegacyInlineEncoding
+                    ) {
+                        this.body.push(createInterfaceFromAmino(this.proto, this.ref, interfaceName));
+                        this.body.push(createInterfaceToAmino(this.proto, this.ref, interfaceName));
+                    }
+                })
+            }
+        }
+    }
+
+    buildRegistry() {
+        this.body.push(createTypeRegistry(this.amino, getMutations(this.mutations)));
+    }
+    buildRegistryLoader() {
+        if (!this.options?.prototypes?.enableRegistryLoader) {
+          return
+        }
+
+        this.body.push(createRegistryLoader(this.amino));
+    }
+    buildAminoInterfaces() {
+        if (!this.options?.aminoEncoding?.enabled || !this.options?.aminoEncoding?.useLegacyInlineEncoding) return;
+        //
+        const protos = getAminoProtos(this.mutations, this.store);
+        protos.forEach(proto => {
+            this.body.push(makeAminoTypeInterface({
+                context: this.amino,
+                proto
+            }));
+        });
+    }
+    buildAminoConverter() {
+        this.body.push(createAminoConverter({
+            name: 'AminoConverter',
+            context: this.amino,
+            root: this.ref.traversed,
+            protos: getAminoProtos(this.mutations, this.store)
+        }));
+    }
+    buildHelperObject() {
+        if (!this.options?.prototypes?.enableMessageComposer) {
+          return
+        }
+        // add methods
+        this.body.push(createHelperObject({
+            context: this.amino,
+            name: 'MessageComposer',
+            mutations: getMutations(this.mutations)
+        }));
+    }
+}