@hyperweb/telescope 1.15.0

package/module/protod/bufbuild.js

@@ -0,0 +1,76 @@
+import fs from "fs";
+import YAML from "yaml";
+import { isPathExist } from "./utils";
+import { crossGlob as glob } from '@cosmology/utils';
+export function parseBufLockFile(filePath) {
+    if (!isPathExist(filePath)) {
+        console.warn(`No such file ${filePath}`);
+        return [];
+    }
+    const bufLock = fs.readFileSync(filePath, "utf8");
+    const deps = bufLock.split(/-\s/);
+    const repos = [];
+    deps.forEach((dep) => {
+        if (!dep.startsWith("remote")) {
+            return;
+        }
+        const bufDep = {
+            owner: /owner:\s(.+)/.exec(dep)?.[1],
+            repo: /repository:\s(.+)/.exec(dep)?.[1],
+        };
+        if (!bufDep.owner || !bufDep.repo) {
+            throw new Error("owner or repository is missing.");
+        }
+        repos.push(bufDep);
+    });
+    return repos;
+}
+export function parseBufYamlFile(filePath) {
+    if (!isPathExist(filePath)) {
+        console.warn(`No such file ${filePath}`);
+        return [];
+    }
+    const { deps } = YAML.parse(fs.readFileSync(filePath, "utf8"));
+    if (deps) {
+        return deps.map((dep) => {
+            const [_, owner, repo] = dep.split("/");
+            return {
+                owner,
+                repo: repo.split(":")[0],
+            };
+        });
+    }
+    return [];
+}
+export function findAllBufYamlFiles(dir) {
+    return glob(`${dir}/**/buf.yaml`, {
+        ignore: `${dir}/node_modules/**`,
+    });
+}
+export function findAllBufLockFiles(dir) {
+    return glob(`${dir}/**/buf.lock`, {
+        ignore: `${dir}/node_modules/**`,
+    });
+}
+export function getAllBufDeps(dir) {
+    const bufDeps = [];
+    const bufLockFiles = findAllBufLockFiles(dir);
+    bufLockFiles.map(async (filePath) => {
+        const deps = parseBufLockFile(filePath);
+        deps.forEach((dep) => {
+            if (bufDeps.findIndex((_dep) => _dep.owner == dep.owner && _dep.repo == dep.repo) == -1) {
+                bufDeps.push(dep);
+            }
+        });
+    });
+    const bufYamlFiles = findAllBufYamlFiles(dir);
+    bufYamlFiles.map(async (filePath) => {
+        const deps = await parseBufYamlFile(filePath);
+        deps.forEach((dep) => {
+            if (bufDeps.findIndex((_dep) => _dep.owner == dep.owner && _dep.repo == dep.repo) == -1) {
+                bufDeps.push(dep);
+            }
+        });
+    });
+    return bufDeps;
+}

package/module/protod/config.js

@@ -0,0 +1,27 @@
+export const bufInfo = [
+    {
+        owner: "protocolbuffers",
+        repo: "wellknowntypes",
+        git: [
+            {
+                owner: "protocolbuffers",
+                repo: "protobuf",
+            },
+        ],
+    },
+    {
+        owner: "cosmos",
+        repo: "gogo-proto",
+        git: [
+            {
+                owner: "cosmos",
+                repo: "gogoproto",
+            },
+        ],
+    },
+];
+export const presetProtoDirMapping = {
+    "gogo/protobuf/master": ".",
+    "googleapis/googleapis/master": ".",
+    "protocolbuffers/protobuf/main": "src",
+};

package/module/protod/git-repo.js

@@ -0,0 +1,54 @@
+import { exec, getMainBranchName, isPathExist, makeDir, removeFolder, } from "./utils";
+const branchCache = {};
+export class GitRepo {
+    owner;
+    repo;
+    ssh;
+    constructor(owner, repo, ssh = false) {
+        this.owner = owner;
+        this.repo = repo;
+        this.ssh = ssh;
+    }
+    get fullName() {
+        return `${this.owner}/${this.repo}`;
+    }
+    get httpsUrl() {
+        return `https://github.com/${this.fullName}.git`;
+    }
+    get sshUrl() {
+        return `git@github.com:${this.fullName}.git`;
+    }
+    async getMainBranchName() {
+        const url = this.ssh ? this.sshUrl : this.httpsUrl;
+        if (branchCache[url]) {
+            return branchCache[url];
+        }
+        branchCache[url] = await getMainBranchName(url);
+        return branchCache[url];
+    }
+    clone(branch, depth = 1, outDir = "./git-modules", isOverride) {
+        const dir = `${outDir}/${this.fullName}/${branch}`;
+        try {
+            if (!isOverride && isPathExist(dir)) {
+                console.log(`Folder ${dir} already exists, skip cloning`);
+                return dir;
+            }
+            else {
+                console.log(`Cloning to ${dir}`);
+            }
+            removeFolder(dir);
+            makeDir(dir);
+            exec(`git clone ${this.ssh ? this.sshUrl : this.httpsUrl} --depth ${depth} --branch ${branch} --single-branch ${dir}`);
+            console.log(`Cloned ${this.fullName}/${branch} to ${dir}`);
+            return dir;
+        }
+        catch (error) {
+            if (error.message.startsWith("Cloning into")) {
+                return dir;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}

package/module/protod/index.js

@@ -0,0 +1 @@
+export * from "./recursive";

package/module/protod/recursive.js

@@ -0,0 +1,125 @@
+import { getAllBufDeps } from "./bufbuild";
+import { GitRepo } from "./git-repo";
+import { join, dirname, resolve, relative } from "path";
+import { getCorrespondingGit, makeDir, parseProtoFile } from "./utils";
+import fs from "fs";
+import { crossGlob as glob } from '@cosmology/utils';
+export async function cloneAll({ repos, gitModulesDir, protoDirMapping, ssh, }) {
+    let clonedResult = {};
+    for (const { owner, repo, branch } of repos) {
+        const cloned = await clone({
+            owner,
+            repo,
+            branch,
+            gitModulesDir,
+            protoDirMapping,
+            ssh,
+            cloned: clonedResult,
+        });
+        for (const [key, value] of Object.entries(cloned)) {
+            clonedResult[key] = value;
+        }
+    }
+    return clonedResult;
+}
+export async function clone({ owner, repo, branch, gitModulesDir: outDir, protoDirMapping, ssh, cloned, }) {
+    let clonedResult = cloned ?? {};
+    const gitRepo = new GitRepo(owner, repo, ssh);
+    const gitBranch = branch ?? (await gitRepo.getMainBranchName());
+    const resultKey = `${owner}/${repo}/${gitBranch}`;
+    if (clonedResult[resultKey]) {
+        console.log(`Skip cloning ${resultKey}`);
+        return clonedResult;
+    }
+    const gitDir = gitRepo.clone(gitBranch, 1, outDir);
+    const protoDir = protoDirMapping?.[`${owner}/${repo}/${gitBranch}`] ?? "proto";
+    clonedResult[`${owner}/${repo}/${gitBranch}`] = {
+        owner,
+        repo,
+        branch: gitBranch,
+        protoDir,
+        protoPath: resolve(`${outDir}/${owner}/${repo}/${gitBranch}/${protoDir}`),
+    };
+    const bufDeps = await getAllBufDeps(gitDir);
+    await Promise.all(bufDeps.map(async (bufRepo) => {
+        const gitRepos = getCorrespondingGit(bufRepo);
+        await Promise.all(gitRepos.map(async (gitRepo) => {
+            const gitRepoObj = new GitRepo(gitRepo.owner, gitRepo.repo, ssh);
+            const branch = await gitRepoObj.getMainBranchName();
+            const depsClonedResult = await clone({
+                ...gitRepo,
+                gitModulesDir: outDir,
+                branch,
+                protoDirMapping,
+                ssh,
+                cloned: clonedResult,
+            });
+            for (const [key, value] of Object.entries(depsClonedResult)) {
+                clonedResult[key] = value;
+            }
+        }));
+    }));
+    return clonedResult;
+}
+export function extractProto({ sources, targets, outDir }) {
+    const extractProtoFiles = extractProtoFromDirs({
+        targets,
+        sources,
+    });
+    extractProtoFiles.map(({ sourceFile, target }) => {
+        const targetFile = join(outDir, target);
+        const deepTargetDir = dirname(targetFile);
+        makeDir(deepTargetDir);
+        fs.copyFileSync(sourceFile, targetFile);
+        console.info(`Copied ${target} from ${sourceFile.replace(target, "")}`);
+    });
+}
+function extractProtoFromDirs({ targets, sources, }) {
+    const extractProtoFiles = [];
+    const existingFiles = new Set();
+    if (!targets || targets.length === 0) {
+        return [];
+    }
+    if (!sources || Object.keys(sources).length === 0) {
+        return [];
+    }
+    for (const target of targets) {
+        for (const source of Object.values(sources)) {
+            const sourceProtoPath = resolve(source.protoPath);
+            const files = glob(join(sourceProtoPath, target));
+            extractProtoFiles.push(...files
+                .map((file) => {
+                const copyTarget = relative(sourceProtoPath, file);
+                const duplicate = existingFiles.has(copyTarget);
+                existingFiles.add(copyTarget);
+                if (!duplicate) {
+                    const resultFiles = [
+                        {
+                            sourceFile: file,
+                            target: copyTarget,
+                        },
+                    ];
+                    const newTargets = parseProtoFile(file);
+                    if (newTargets && newTargets.length > 0) {
+                        const deps = extractProtoFromDirs({
+                            targets: newTargets,
+                            sources,
+                        });
+                        const filteredDeps = deps?.filter((dep) => {
+                            const depDuplicate = existingFiles.has(dep.target);
+                            existingFiles.add(dep.target);
+                            return !depDuplicate;
+                        });
+                        if (filteredDeps && filteredDeps.length > 0) {
+                            resultFiles.push(...filteredDeps);
+                        }
+                    }
+                    return resultFiles;
+                }
+            })
+                .flat()
+                .filter(Boolean));
+        }
+    }
+    return extractProtoFiles;
+}

package/module/protod/types.js

@@ -0,0 +1 @@
+export {};

package/module/protod/utils.js

@@ -0,0 +1,77 @@
+import { exec as _exec } from "shelljs";
+import fs from "fs";
+import { bufInfo } from "./config";
+import { crossGlob as glob } from '@cosmology/utils';
+export function exec(command, verbose = false) {
+    const { code, stdout, stderr } = _exec(command);
+    if (code === 0) {
+        if (verbose) {
+            console.log(stdout);
+        }
+    }
+    else {
+        console.error(`Failed: ${command}`);
+        throw new Error(stderr);
+    }
+    return { stdout };
+}
+export async function getMainBranchName(url) {
+    console.log(`Checking main branch for ${url}`);
+    const { stdout } = exec(`git ls-remote -h ${url} main`);
+    if (stdout) {
+        return "main";
+    }
+    const { stdout: stdout2 } = exec(`git ls-remote -h ${url} master`);
+    if (stdout2) {
+        return "master";
+    }
+    throw new Error("Can't find `main` or `master` branch");
+}
+export function getCorrespondingGit(bufRepo) {
+    const bufItem = bufInfo.find((repo) => repo.owner === bufRepo.owner && repo.repo === bufRepo.repo);
+    if (bufItem) {
+        return bufItem.git;
+    }
+    else {
+        return [bufRepo];
+    }
+}
+export function parseProtoFile(filePath) {
+    if (!isPathExist(filePath)) {
+        console.warn(`No such file ${filePath}`);
+        return [];
+    }
+    let proto;
+    try {
+        proto = fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        console.log(filePath);
+        throw new Error(error);
+    }
+    const deps = [];
+    proto?.split("\n").forEach((line) => {
+        if (line.trim().startsWith("import ")) {
+            const dep = /import\s"(.+)";?/.exec(line)?.[1];
+            if (!dep) {
+                throw Error(`Failed to parse line: ${line}`);
+            }
+            deps.push(dep);
+        }
+    });
+    return deps;
+}
+export function isPathExist(path) {
+    return fs.existsSync(path);
+}
+export function findAllProtoFiles(dir) {
+    return glob(`${dir}/**/*.proto`, {
+        ignore: `${dir}/node_modules/**`,
+    });
+}
+export function removeFolder(dir) {
+    fs.rmSync(dir, { recursive: true, force: true });
+}
+export function makeDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}

package/module/telescope.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { cli } from './cli';
+var argv = require('minimist')(process.argv.slice(2), {
+    boolean: ['ssh']
+});
+(async () => {
+    await cli(argv);
+})();

package/module/types.js

@@ -0,0 +1 @@
+export {};

package/module/utils/common-create-bundle.js

@@ -0,0 +1,25 @@
+import { aggregateImports, getImportStatements } from '../imports';
+import { join } from 'path';
+import { TelescopeParseContext } from '../build';
+import { writeAstToFile } from '../utils/files';
+import { fixlocalpaths } from '../utils';
+import { createEmptyProtoRef } from '@cosmology/proto-parser';
+export const commonBundlePlugin = (builder, bundleFilename, packageMappings, astFn) => {
+    const localname = bundleFilename;
+    // create proto ref for context
+    const pkg = '@root';
+    const ref = createEmptyProtoRef(pkg, localname);
+    // create context
+    const pCtx = new TelescopeParseContext(ref, builder.store, builder.options);
+    // generate code for createRpcQueryHooks and imports of related packages.
+    const ast = astFn(pCtx.proto, packageMappings);
+    // generate imports added by context.addUtil
+    const imports = fixlocalpaths(aggregateImports(pCtx, {}, localname));
+    const importStmts = getImportStatements(localname, imports, builder.options);
+    // construct the AST
+    const prog = [].concat(importStmts).concat(ast);
+    // write the file.
+    const filename = join(builder.outPath, localname);
+    builder.files.push(localname);
+    writeAstToFile(builder.outPath, builder.options, prog, filename);
+};

package/module/utils/contracts.js

@@ -0,0 +1,33 @@
+import { readSchemas } from '@cosmwasm/ts-codegen';
+import { pascal } from 'case';
+import { basename, dirname, join } from 'path';
+import { readFileSync, readdirSync } from 'fs';
+export const getDirectories = source => readdirSync(source, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name);
+export const getContracts = () => {
+    const contracts = getDirectories('./contracts')
+        .map(contractDirname => {
+        return {
+            name: `${contractDirname}`,
+            value: `./contracts/${contractDirname}`
+        };
+    });
+    return contracts;
+};
+export const getContractSchemata = async (schemata, out, argv) => {
+    const s = [];
+    for (let i = 0; i < schemata.length; i++) {
+        const path = schemata[i];
+        const pkg = JSON.parse(readFileSync(join(path, 'package.json'), 'utf-8'));
+        const name = basename(path);
+        const folder = basename(dirname(path));
+        const contractName = pascal(pkg.contract) || pascal(name);
+        const schemas = await readSchemas({ schemaDir: path });
+        const outPath = join(out, folder);
+        s.push({
+            contractName, schemas, outPath
+        });
+    }
+    return s;
+};

package/module/utils/files.js

@@ -0,0 +1,106 @@
+import * as t from "@babel/types";
+import { parse } from "@babel/parser";
+import { mkdirp } from "mkdirp";
+import { writeFileSync } from "fs";
+import { dirname } from "path";
+import minimatch from "minimatch";
+import generate from "@babel/generator";
+import { unused } from "./unused";
+import traverse from "@babel/traverse";
+import { toPosixPath } from "@cosmology/utils";
+export function getExportedTypeNames(program) {
+    const exportedNames = [];
+    const ast = t.program(program);
+    const content = generate(ast).code;
+    const plugins = ["typescript"];
+    const newAst = parse(content, {
+        sourceType: "module",
+        plugins,
+    });
+    traverse(newAst, {
+        ExportNamedDeclaration(path) {
+            const node = path.node;
+            // Handle direct declarations (type aliases, interfaces, enums)
+            if (node.declaration) {
+                const decl = node.declaration;
+                const isTypeExport = node.exportKind === "type";
+                const isTypeDecl = [
+                    "TSTypeAliasDeclaration",
+                    "TSInterfaceDeclaration",
+                    "TSEnumDeclaration",
+                ].includes(decl.type);
+                if (isTypeExport || isTypeDecl) {
+                    if ("id" in decl && decl.id?.type === "Identifier") {
+                        exportedNames.push(decl.id.name);
+                    }
+                }
+                // Handle const declarations that might be types (e.g., const schemas)
+                if (decl.type === "VariableDeclaration" && decl.kind === "const") {
+                    decl.declarations.forEach((declarator) => {
+                        if (declarator.id?.type === "Identifier") {
+                            exportedNames.push(declarator.id.name);
+                        }
+                    });
+                }
+            }
+            // Handle export specifiers (e.g., export { SomeType })
+            if (node.specifiers && node.specifiers.length > 0) {
+                const isTypeExport = node.exportKind === "type";
+                if (isTypeExport) {
+                    node.specifiers.forEach((spec) => {
+                        if (spec.type === "ExportSpecifier" && spec.exported.type === "Identifier") {
+                            exportedNames.push(spec.exported.name);
+                        }
+                    });
+                }
+            }
+        },
+    });
+    return exportedNames;
+}
+export const writeAstToFile = (outPath, options, program, filename) => {
+    const ast = t.program(program);
+    const content = generate(ast).code;
+    if (options.removeUnusedImports) {
+        const plugins = ["typescript"];
+        const newAst = parse(content, {
+            sourceType: "module",
+            plugins,
+        });
+        traverse(newAst, unused);
+        const content2 = generate(newAst).code;
+        writeContentToFile(toPosixPath(outPath), options, content2, toPosixPath(filename));
+    }
+    else {
+        writeContentToFile(toPosixPath(outPath), options, content, toPosixPath(filename));
+    }
+};
+export const writeContentToFile = (outPath, options, content, filename) => {
+    let esLintPrefix = "";
+    let tsLintPrefix = "";
+    let nameWithoutPath = filename.replace(outPath, "");
+    // strip off leading slash
+    if (nameWithoutPath.startsWith("/"))
+        nameWithoutPath = nameWithoutPath.replace(/^\//, "");
+    options.tsDisable.patterns.forEach((pattern) => {
+        if (minimatch(nameWithoutPath, pattern)) {
+            tsLintPrefix = `//@ts-nocheck\n`;
+        }
+    });
+    options.eslintDisable.patterns.forEach((pattern) => {
+        if (minimatch(nameWithoutPath, pattern)) {
+            esLintPrefix = `/* eslint-disable */\n`;
+        }
+    });
+    if (options.tsDisable.files.includes(nameWithoutPath) ||
+        options.tsDisable.disableAll) {
+        tsLintPrefix = `//@ts-nocheck\n`;
+    }
+    if (options.eslintDisable.files.includes(nameWithoutPath) ||
+        options.eslintDisable.disableAll) {
+        esLintPrefix = `/* eslint-disable */\n`;
+    }
+    const text = tsLintPrefix + esLintPrefix + content;
+    mkdirp.sync(dirname(filename));
+    writeFileSync(filename, text);
+};