@hyperweb/telescope 1.17.2 → 1.17.4

package/README.md

@@ -747,7 +747,6 @@ See [Helper Functions Configuration](#helper-functions-configuration) for more i
 | ------------------------------ | --------------------------------------------------------------  | ---------- |
 | `bundle.enabled`               | Bundle all files into a scoped index file                       | `true`     |
 | `bundle.type`                  | Bundle type: "namespace" or "module"                            | `"namespace"` |
-> **Warning:** This option is not recommended. It will generate a bundle file that exports all the types and functions under one namespace. This will make the bundle file very large and hard to maintain. e.g. using `cosmos.bank.v1beta1.MsgSend` might be intuitive, but it will also include `cosmos.gov.v1beta1.*` and other types in the final bundle file. So use this option with caution.
 
 ### MCP Server
 

package/main/generators/create-bundle.js

@@ -3,11 +3,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.plugin = void 0;
 const ast_1 = require("@cosmology/ast");
 const utils_1 = require("@cosmology/utils");
+/**
+ * Process noAlias configuration to create a map of names to their first package
+ * This ensures that only the first occurrence of a name skips aliasing
+ */
+const processNoAliasConfig = (noAlias) => {
+    if (!noAlias || noAlias.length === 0) {
+        return new Map();
+    }
+    const nameToFirstPackage = new Map();
+    for (const entry of noAlias) {
+        if (!nameToFirstPackage.has(entry.name)) {
+            nameToFirstPackage.set(entry.name, entry.package);
+        }
+    }
+    return nameToFirstPackage;
+};
+/**
+ * Check if a package/name combination should skip aliasing
+ */
+const shouldSkipAlias = (pkg, name, nameToFirstPackage) => {
+    const firstPackage = nameToFirstPackage.get(name);
+    return firstPackage === pkg;
+};
 const plugin = (builder, bundler) => {
     if (!builder.options.bundle.enabled) {
         return;
     }
     let prog = [];
+    // Process noAlias configuration once at the beginning
+    const nameToFirstPackage = processNoAliasConfig(builder.options.bundle.noAlias);
     if (builder.options.bundle.type === "namespace") {
         const importPaths = (0, utils_1.duplicateImportPathsWithExt)(bundler.bundle.importPaths, builder.options.restoreImportExtension);
         // [x] bundle
@@ -44,22 +69,23 @@ const plugin = (builder, bundler) => {
                     const duplicatedType = duplicatedTypeNames.find((type) => type === identifier);
                     if (duplicatedType) {
                         let alias;
-                        if (exportObj.isHelperFunc) {
-                            const serialNumber = builder.store.getAndIncTypeSerialNumber(identifier);
-                            if (serialNumber > 0) {
-                                alias = (0, utils_1.makeAliasNameWithPackageAtEnd)({ package: exportObj.pkg, name: identifier });
-                            }
-                            else {
-                                alias = identifier;
-                            }
+                        // Check if this package/name combination should skip aliasing
+                        if (shouldSkipAlias(exportObj.pkg, identifier, nameToFirstPackage)) {
+                            alias = identifier; // Use original name, no alias
                         }
                         else {
-                            const serialNumber = builder.store.getAndIncTypeSerialNumber(identifier);
-                            if (serialNumber > 0) {
-                                alias = (0, utils_1.makeAliasName)({ package: exportObj.pkg, name: identifier });
+                            // Generate alias as usual
+                            if (exportObj.isHelperFunc) {
+                                alias = (0, utils_1.makeAliasNameWithPackageAtEnd)({
+                                    package: exportObj.pkg,
+                                    name: identifier,
+                                });
                             }
                             else {
-                                alias = identifier;
+                                alias = (0, utils_1.makeAliasName)({
+                                    package: exportObj.pkg,
+                                    name: identifier,
+                                });
                             }
                         }
                         return { name: identifier, alias: alias };

package/main/generators/create-root-readme.js

@@ -11,10 +11,10 @@ function getAliasedFunctionName(builder, functionName, packageName) {
     const duplicatedHelperFuncs = builder.store.getHelperFuncsInMultipleFiles();
     const isDuplicated = duplicatedHelperFuncs.includes(functionName);
     if (isDuplicated) {
-        const serialNumber = builder.store.getAndIncTypeSerialNumber(functionName);
-        if (serialNumber > 0) {
-            return (0, utils_1.makeAliasNameWithPackageAtEnd)({ package: packageName, name: functionName });
-        }
+        return (0, utils_1.makeAliasNameWithPackageAtEnd)({
+            package: packageName,
+            name: functionName,
+        });
     }
     return functionName;
 }
@@ -27,15 +27,15 @@ function cleanComment(comment) {
     // Remove lint directives and technical annotations
     const cleanedComment = comment
         // Remove buf:lint:ignore directives
-        .replace(/buf:lint:ignore\s+[A-Z_]+/gi, '')
+        .replace(/buf:lint:ignore\s+[A-Z_]+/gi, "")
         // Remove other common lint directives
-        .replace(/lint:ignore[:\s]+[A-Z_]+/gi, '')
+        .replace(/lint:ignore[:\s]+[A-Z_]+/gi, "")
         // Remove protolint directives
-        .replace(/protolint:disable[:\s]+[A-Z_]+/gi, '')
+        .replace(/protolint:disable[:\s]+[A-Z_]+/gi, "")
         // Remove eslint directives
-        .replace(/eslint-disable[:\s-]+[a-z-]+/gi, '')
+        .replace(/eslint-disable[:\s-]+[a-z-]+/gi, "")
         // Remove multiple consecutive spaces
-        .replace(/\s+/g, ' ')
+        .replace(/\s+/g, " ")
         // Remove leading/trailing whitespace
         .trim();
     return cleanedComment;
@@ -58,7 +58,7 @@ function getImportPath(builder, functionName, packageName, projectName, sourceFi
         const aliasedName = getAliasedFunctionName(builder, functionName, packageName);
         if (aliasedName !== functionName) {
             // Extract the top-level package name (e.g., 'akash' from 'akash.audit.v1beta2')
-            const topLevelPackage = packageName.split('.')[0];
+            const topLevelPackage = packageName.split(".")[0];
             // Function is aliased and should be available in bundle
             return `${projectName}/${topLevelPackage}/bundle`;
         }
@@ -67,11 +67,11 @@ function getImportPath(builder, functionName, packageName, projectName, sourceFi
     // This handles all functions with specific file locations
     if (sourceFilename) {
         // Remove .ts extension and convert to proper import path
-        const filePath = sourceFilename.replace(/\.ts$/, '');
+        const filePath = sourceFilename.replace(/\.ts$/, "");
         return `${projectName}/${filePath}`;
     }
     // Fallback: import from the specific package path
-    return `${projectName}/${packageName.replace(/\./g, '/')}`;
+    return `${projectName}/${packageName.replace(/\./g, "/")}`;
 }
 /**
  * Gets all types for a package by looking at export objects and filtering out extended forms
@@ -79,18 +79,18 @@ function getImportPath(builder, functionName, packageName, projectName, sourceFi
 function getTypesForPackage(builder, packageName) {
     const types = [];
     // Get all contexts for this package
-    const packageContexts = builder.contexts.filter(ctx => ctx.ref.proto.package === packageName);
-    packageContexts.forEach(context => {
+    const packageContexts = builder.contexts.filter((ctx) => ctx.ref.proto.package === packageName);
+    packageContexts.forEach((context) => {
         // Get types from this context
-        const contextTypes = context.types.filter(type => !type.isNested);
-        contextTypes.forEach(typeInfo => {
+        const contextTypes = context.types.filter((type) => !type.isNested);
+        contextTypes.forEach((typeInfo) => {
             const typeName = typeInfo.name;
             // Filter out extended forms (these are created during code generation but not in the types array)
-            if (!typeName.endsWith('ProtoMsg') &&
-                !typeName.endsWith('Amino') &&
-                !typeName.endsWith('AminoMsg') &&
-                !typeName.endsWith('Encoded') &&
-                !typeName.endsWith('SDKType')) {
+            if (!typeName.endsWith("ProtoMsg") &&
+                !typeName.endsWith("Amino") &&
+                !typeName.endsWith("AminoMsg") &&
+                !typeName.endsWith("Encoded") &&
+                !typeName.endsWith("SDKType")) {
                 // Get the actual source file from the store mapping
                 const typeFiles = builder.store.getTypeFilesMapping(typeName);
                 let sourceFile;
@@ -100,21 +100,22 @@ function getTypesForPackage(builder, packageName) {
                 }
                 else {
                     // Fallback to context ref filename if not in mapping
-                    sourceFile = context.ref.filename.replace(/\.proto$/, '.ts');
+                    sourceFile = context.ref.filename.replace(/\.proto$/, ".ts");
                 }
                 types.push({
                     name: typeName,
-                    sourceFile
+                    sourceFile,
                 });
             }
         });
     });
     // Remove duplicates and sort
-    const uniqueTypes = types.filter((type, index, self) => index === self.findIndex(t => t.name === type.name));
+    const uniqueTypes = types.filter((type, index, self) => index === self.findIndex((t) => t.name === type.name));
     return uniqueTypes.sort((a, b) => a.name.localeCompare(b.name));
 }
 const plugin = (builder) => {
-    if (!builder.options?.readme?.enabled && !builder.options?.mcpServer?.enabled) {
+    if (!builder.options?.readme?.enabled &&
+        !builder.options?.mcpServer?.enabled) {
         return;
     }
     const readmePath = (0, path_1.join)(builder.outPath, "README.md");
@@ -123,7 +124,9 @@ const plugin = (builder) => {
     const functionMappings = builder.getFunctionMappings();
     // Generate package documentation
     let packageDocs = "";
-    Object.keys(functionMappings).sort().forEach(packageName => {
+    Object.keys(functionMappings)
+        .sort()
+        .forEach((packageName) => {
         const packageServices = functionMappings[packageName];
         // Check if package has any methods before adding it
         const hasQueryMethods = packageServices.Query && Object.keys(packageServices.Query).length > 0;
@@ -138,10 +141,10 @@ const plugin = (builder) => {
             packageDocs += `### Types\n\n`;
             packageDocs += `| Type | Name | Source |\n`;
             packageDocs += `| --- | --- | --- |\n`;
-            types.forEach(type => {
+            types.forEach((type) => {
                 packageDocs += `| Type | \`${type.name}\` | [View source ↗](${type.sourceFile}) |\n`;
             });
-            packageDocs += '\n';
+            packageDocs += "\n";
         }
         // Query section
         if (packageServices.Query) {
@@ -159,7 +162,9 @@ const plugin = (builder) => {
                 }
                 // Add import code block
                 const functionImportPath = getImportPath(builder, method.functionName, packageName, projectName, method.sourceFilename);
-                const hookImportPath = method.hookName ? getImportPath(builder, method.hookName, packageName, projectName, method.hookSourceFilename) : functionImportPath;
+                const hookImportPath = method.hookName
+                    ? getImportPath(builder, method.hookName, packageName, projectName, method.hookSourceFilename)
+                    : functionImportPath;
                 packageDocs += `\`\`\`ts\n`;
                 packageDocs += `import { ${aliasedFunctionName} } from '${functionImportPath}'\n`;
                 if (method.hookName && aliasedHookName !== aliasedFunctionName) {
@@ -170,29 +175,33 @@ const plugin = (builder) => {
                 packageDocs += `| Field | Value | Source |\n`;
                 packageDocs += `| --- | --- | --- |\n`;
                 // Function source
-                const functionSourcePath = method.sourceFilename || `${packageName.replace(/\./g, '/')}/query.rpc.func.ts`;
+                const functionSourcePath = method.sourceFilename ||
+                    `${packageName.replace(/\./g, "/")}/query.rpc.func.ts`;
                 packageDocs += `| Function | \`${aliasedFunctionName}\` | [View source ↗](${functionSourcePath}) |\n`;
                 // Hook source (React)
                 if (method.hookName && aliasedHookName !== aliasedFunctionName) {
-                    const hookSourcePath = method.hookSourceFilename || `${packageName.replace(/\./g, '/')}/query.rpc.react.ts`;
+                    const hookSourcePath = method.hookSourceFilename ||
+                        `${packageName.replace(/\./g, "/")}/query.rpc.react.ts`;
                     packageDocs += `| Hook | \`${aliasedHookName}\` | [View source ↗](${hookSourcePath}) |\n`;
                 }
                 // Request type source
                 if (method.requestType) {
-                    const requestSourcePath = method.typeSourceFilename || `${packageName.replace(/\./g, '/')}/query.ts`;
+                    const requestSourcePath = method.typeSourceFilename ||
+                        `${packageName.replace(/\./g, "/")}/query.ts`;
                     packageDocs += `| Request | \`${method.requestType}\` | [View source ↗](${requestSourcePath}) |\n`;
                 }
                 // Response type source
                 if (method.responseType) {
-                    const responseSourcePath = method.typeSourceFilename || `${packageName.replace(/\./g, '/')}/query.ts`;
+                    const responseSourcePath = method.typeSourceFilename ||
+                        `${packageName.replace(/\./g, "/")}/query.ts`;
                     packageDocs += `| Response | \`${method.responseType}\` | [View source ↗](${responseSourcePath}) |\n`;
                 }
                 // Add spacing between methods (but not after the last one)
                 if (index < queryMethods.length - 1) {
-                    packageDocs += '\n---\n\n';
+                    packageDocs += "\n---\n\n";
                 }
                 else {
-                    packageDocs += '\n';
+                    packageDocs += "\n";
                 }
             });
         }
@@ -212,7 +221,9 @@ const plugin = (builder) => {
                 }
                 // Add import code block
                 const functionImportPath = getImportPath(builder, method.functionName, packageName, projectName, method.sourceFilename);
-                const hookImportPath = method.hookName ? getImportPath(builder, method.hookName, packageName, projectName, method.hookSourceFilename) : functionImportPath;
+                const hookImportPath = method.hookName
+                    ? getImportPath(builder, method.hookName, packageName, projectName, method.hookSourceFilename)
+                    : functionImportPath;
                 packageDocs += `\`\`\`ts\n`;
                 packageDocs += `import { ${aliasedFunctionName} } from '${functionImportPath}'\n`;
                 if (method.hookName && aliasedHookName !== aliasedFunctionName) {
@@ -223,34 +234,38 @@ const plugin = (builder) => {
                 packageDocs += `| Field | Value | Source |\n`;
                 packageDocs += `| --- | --- | --- |\n`;
                 // Function source
-                const functionSourcePath = method.sourceFilename || `${packageName.replace(/\./g, '/')}/tx.rpc.func.ts`;
+                const functionSourcePath = method.sourceFilename ||
+                    `${packageName.replace(/\./g, "/")}/tx.rpc.func.ts`;
                 packageDocs += `| Function | \`${aliasedFunctionName}\` | [View source ↗](${functionSourcePath}) |\n`;
                 // Hook source (React)
                 if (method.hookName && aliasedHookName !== aliasedFunctionName) {
-                    const hookSourcePath = method.hookSourceFilename || `${packageName.replace(/\./g, '/')}/tx.rpc.react.ts`;
+                    const hookSourcePath = method.hookSourceFilename ||
+                        `${packageName.replace(/\./g, "/")}/tx.rpc.react.ts`;
                     packageDocs += `| Hook | \`${aliasedHookName}\` | [View source ↗](${hookSourcePath}) |\n`;
                 }
                 // Request type source
                 if (method.requestType) {
-                    const requestSourcePath = method.typeSourceFilename || `${packageName.replace(/\./g, '/')}/tx.ts`;
+                    const requestSourcePath = method.typeSourceFilename ||
+                        `${packageName.replace(/\./g, "/")}/tx.ts`;
                     packageDocs += `| Request | \`${method.requestType}\` | [View source ↗](${requestSourcePath}) |\n`;
                 }
                 // Response type source
                 if (method.responseType) {
-                    const responseSourcePath = method.typeSourceFilename || `${packageName.replace(/\./g, '/')}/tx.ts`;
+                    const responseSourcePath = method.typeSourceFilename ||
+                        `${packageName.replace(/\./g, "/")}/tx.ts`;
                     packageDocs += `| Response | \`${method.responseType}\` | [View source ↗](${responseSourcePath}) |\n`;
                 }
                 // Add spacing between methods (but not after the last one)
                 if (index < msgMethods.length - 1) {
-                    packageDocs += '\n---\n\n';
+                    packageDocs += "\n---\n\n";
                 }
                 else {
-                    packageDocs += '\n';
+                    packageDocs += "\n";
                 }
             });
         }
         // Add spacing between packages
-        packageDocs += '\n';
+        packageDocs += "\n";
     });
     const readmeContent = `# Package Documentation
 ${packageDocs}`;

package/main/helpers/helper-func-types-interface.js

@@ -8,8 +8,8 @@ import { BinaryReader, BinaryWriter } from "./binary${options.restoreImportExten
 import { getRpcClient } from "./extern${options.restoreImportExtension ?? ""}";` : ''}
 import { isRpc, Rpc } from "./helpers${options.restoreImportExtension ?? ""}";${!options.isGeneratingCosmosTypes ? `
 import { TelescopeGeneratedCodec, DeliverTxResponse, Message, StdFee } from "./types${options.restoreImportExtension ?? ""}";` : ''}${!options.isGeneratingCosmosTypes ? `
-import { toConverters, toEncoders } from "@interchainjs/cosmos/utils";
-import { ISigningClient } from "@interchainjs/cosmos/types/signing-client${options.restoreImportExtension ?? ""}";` : ''}
+import { toConverters, toEncoders } from "@interchainjs/cosmos";
+import { ISigningClient } from "@interchainjs/cosmos";` : ''}
 
 export interface QueryBuilderOptions<TReq, TRes> {
   encode: (request: TReq, writer?: BinaryWriter) => BinaryWriter

package/main/helpers/helper-func-types.js

@@ -8,8 +8,8 @@ import { BinaryReader, BinaryWriter } from "./binary${options.restoreImportExten
 import { getRpcClient } from "./extern${options.restoreImportExtension ?? ""}";` : ''}
 import { isRpc, Rpc } from "./helpers${options.restoreImportExtension ?? ""}";${!options.isGeneratingCosmosTypes ? `
 import { TelescopeGeneratedCodec, DeliverTxResponse, Message, StdFee } from "./types${options.restoreImportExtension ?? ""}";` : ''}${!options.isGeneratingCosmosTypes ? `
-import { toConverters, toEncoders } from "@interchainjs/cosmos/utils";
-import { ISigningClient } from "@interchainjs/cosmos/types/signing-client${options.restoreImportExtension ?? ""}";` : ''}
+import { toConverters, toEncoders } from "@interchainjs/cosmos";
+import { ISigningClient } from "@interchainjs/cosmos";` : ''}
 
 export interface QueryBuilderOptions<TReq, TRes> {
   encode: (request: TReq, writer?: BinaryWriter) => BinaryWriter

package/main/helpers/internal-for-bigint.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHelperForBigint = void 0;
 const getHelperForBigint = (options) => {
     return `${options.useInterchainJs ?
-        'export { fromBase64 as bytesFromBase64, toBase64 as base64FromBytes } from \'@interchainjs/encoding/base64\';' :
+        'export { fromBase64 as bytesFromBase64, toBase64 as base64FromBytes } from \'@interchainjs/encoding\';' :
         `declare var self: any | undefined;
 declare var window: any | undefined;
 declare var global: any | undefined;

package/main/helpers/internal.js

@@ -15,7 +15,7 @@ if (_m0.util.Long !== Long) {
 export { Long };
 
 ${options.useInterchainJs ?
-        'export { fromBase64 as bytesFromBase64, toBase64 as base64FromBytes } from \'@interchainjs/encoding/base64\';' :
+        'export { fromBase64 as bytesFromBase64, toBase64 as base64FromBytes } from \'@interchainjs/encoding\';' :
         `declare var self: any | undefined;
 declare var window: any | undefined;
 declare var global: any | undefined;

package/main/helpers/react-query-hooks-icjs.js

@@ -12,7 +12,7 @@ import {
   ITxArgs,
   EndpointOrRpc,
 } from './helper-func-types${options.restoreImportExtension ?? ""}'
-import { ISigningClient, isISigningClient } from "@interchainjs/cosmos/types/signing-client${options.restoreImportExtension ?? ""}";
+import { ISigningClient, isISigningClient } from "@interchainjs/cosmos";
 import {
   StdFee,
   DeliverTxResponse,

package/module/generators/create-bundle.js

@@ -1,10 +1,35 @@
 import { exportAllFromRelPath, exportTypesWithAlias, recursiveModuleBundle, } from "@cosmology/ast";
-import { duplicateImportPathsWithExt, makeAliasName, makeAliasNameWithPackageAtEnd } from "@cosmology/utils";
+import { duplicateImportPathsWithExt, makeAliasName, makeAliasNameWithPackageAtEnd, } from "@cosmology/utils";
+/**
+ * Process noAlias configuration to create a map of names to their first package
+ * This ensures that only the first occurrence of a name skips aliasing
+ */
+const processNoAliasConfig = (noAlias) => {
+    if (!noAlias || noAlias.length === 0) {
+        return new Map();
+    }
+    const nameToFirstPackage = new Map();
+    for (const entry of noAlias) {
+        if (!nameToFirstPackage.has(entry.name)) {
+            nameToFirstPackage.set(entry.name, entry.package);
+        }
+    }
+    return nameToFirstPackage;
+};
+/**
+ * Check if a package/name combination should skip aliasing
+ */
+const shouldSkipAlias = (pkg, name, nameToFirstPackage) => {
+    const firstPackage = nameToFirstPackage.get(name);
+    return firstPackage === pkg;
+};
 export const plugin = (builder, bundler) => {
     if (!builder.options.bundle.enabled) {
         return;
     }
     let prog = [];
+    // Process noAlias configuration once at the beginning
+    const nameToFirstPackage = processNoAliasConfig(builder.options.bundle.noAlias);
     if (builder.options.bundle.type === "namespace") {
         const importPaths = duplicateImportPathsWithExt(bundler.bundle.importPaths, builder.options.restoreImportExtension);
         // [x] bundle
@@ -41,22 +66,23 @@ export const plugin = (builder, bundler) => {
                     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;
-                            }
+                        // Check if this package/name combination should skip aliasing
+                        if (shouldSkipAlias(exportObj.pkg, identifier, nameToFirstPackage)) {
+                            alias = identifier; // Use original name, no alias
                         }
                         else {
-                            const serialNumber = builder.store.getAndIncTypeSerialNumber(identifier);
-                            if (serialNumber > 0) {
-                                alias = makeAliasName({ package: exportObj.pkg, name: identifier });
+                            // Generate alias as usual
+                            if (exportObj.isHelperFunc) {
+                                alias = makeAliasNameWithPackageAtEnd({
+                                    package: exportObj.pkg,
+                                    name: identifier,
+                                });
                             }
                             else {
-                                alias = identifier;
+                                alias = makeAliasName({
+                                    package: exportObj.pkg,
+                                    name: identifier,
+                                });
                             }
                         }
                         return { name: identifier, alias: alias };