@hyperweb/telescope 1.17.2 → 1.17.4

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

@@ -8,10 +8,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 makeAliasNameWithPackageAtEnd({ package: packageName, name: functionName });
-        }
+        return makeAliasNameWithPackageAtEnd({
+            package: packageName,
+            name: functionName,
+        });
     }
     return functionName;
 }
@@ -24,15 +24,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;
@@ -55,7 +55,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`;
         }
@@ -64,11 +64,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
@@ -76,18 +76,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;
@@ -97,21 +97,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));
 }
 export const plugin = (builder) => {
-    if (!builder.options?.readme?.enabled && !builder.options?.mcpServer?.enabled) {
+    if (!builder.options?.readme?.enabled &&
+        !builder.options?.mcpServer?.enabled) {
         return;
     }
     const readmePath = join(builder.outPath, "README.md");
@@ -120,7 +121,9 @@ export 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;
@@ -135,10 +138,10 @@ export 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) {
@@ -156,7 +159,9 @@ export 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) {
@@ -167,29 +172,33 @@ export 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";
                 }
             });
         }
@@ -209,7 +218,9 @@ export 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) {
@@ -220,34 +231,38 @@ export 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/module/helpers/helper-func-types-interface.js

@@ -5,8 +5,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/module/helpers/helper-func-types.js

@@ -5,8 +5,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/module/helpers/internal-for-bigint.js

@@ -1,6 +1,6 @@
 export 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/module/helpers/internal.js

@@ -12,7 +12,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/module/helpers/react-query-hooks-icjs.js

@@ -9,7 +9,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperweb/telescope",
-  "version": "1.17.2",
+  "version": "1.17.4",
   "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",
@@ -90,10 +90,10 @@
     "@babel/parser": "^7.23.6",
     "@babel/traverse": "7.23.6",
     "@babel/types": "7.23.6",
-    "@cosmology/ast": "^1.12.1",
-    "@cosmology/proto-parser": "^1.11.1",
-    "@cosmology/types": "^1.13.1",
-    "@cosmology/utils": "^1.11.1",
+    "@cosmology/ast": "^1.12.2",
+    "@cosmology/proto-parser": "^1.11.2",
+    "@cosmology/types": "^1.13.2",
+    "@cosmology/utils": "^1.11.2",
     "@cosmwasm/ts-codegen": "0.35.7",
     "@types/parse-package-name": "0.1.0",
     "case": "1.6.3",
@@ -111,5 +111,5 @@
     "rimraf": "5.0.0",
     "yaml": "^2.3.4"
   },
-  "gitHead": "40a4298beb51c0a2f7bfb5d44c53c5c49d121632"
+  "gitHead": "21d41a6bf946480c10d5e5c18b76a680f40164e8"
 }

package/src/generators/create-bundle.ts

@@ -5,7 +5,43 @@ import {
   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?: Array<{ package: string; name: string }>) => {
+  if (!noAlias || noAlias.length === 0) {
+    return new Map<string, string>();
+  }
+
+  const nameToFirstPackage = new Map<string, string>();
+
+  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: string,
+  name: string,
+  nameToFirstPackage: Map<string, string>
+): boolean => {
+  const firstPackage = nameToFirstPackage.get(name);
+  return firstPackage === pkg;
+};
 
 export const plugin = (builder: TelescopeBuilder, bundler: Bundler) => {
   if (!builder.options.bundle.enabled) {
@@ -14,6 +50,9 @@ export const plugin = (builder: TelescopeBuilder, bundler: Bundler) => {
 
   let prog = [];
 
+  // Process noAlias configuration once at the beginning
+  const nameToFirstPackage = processNoAliasConfig((builder.options.bundle as any).noAlias);
+
   if (builder.options.bundle.type === "namespace") {
     const importPaths = duplicateImportPathsWithExt(
       bundler.bundle.importPaths,
@@ -56,29 +95,36 @@ export const plugin = (builder: TelescopeBuilder, bundler: Bundler) => {
       );
       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: string;
-            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 });
+        const typesWithAlias = exportObj.exportedIdentifiers.map(
+          (identifier) => {
+            const duplicatedType = duplicatedTypeNames.find(
+              (type) => type === identifier
+            );
+            if (duplicatedType) {
+              let alias: string;
+
+              // Check if this package/name combination should skip aliasing
+              if (shouldSkipAlias(exportObj.pkg, identifier, nameToFirstPackage)) {
+                alias = identifier; // Use original name, no alias
               } else {
-                alias = identifier;
+                // Generate alias as usual
+                if (exportObj.isHelperFunc) {
+                  alias = makeAliasNameWithPackageAtEnd({
+                    package: exportObj.pkg,
+                    name: identifier,
+                  });
+                } else {
+                  alias = makeAliasName({
+                    package: exportObj.pkg,
+                    name: identifier,
+                  });
+                }
               }
+              return { name: identifier, alias: alias };
             }
-            return { name: identifier, alias: alias };
+            return { name: identifier, alias: identifier };
           }
-          return { name: identifier, alias: identifier };
-        });
+        );
         prog.push(exportTypesWithAlias(typesWithAlias, exportObj.relativePath));
       } else {
         // export *