@macalinao/codama-rename-visitor 0.1.0 → 0.2.0

package/README.md

@@ -1,9 +1,30 @@
 # @macalinao/codama-rename-visitor
 
+[![npm version](https://img.shields.io/npm/v/@macalinao/codama-rename-visitor.svg)](https://www.npmjs.com/package/@macalinao/codama-rename-visitor)
+[![npm downloads](https://img.shields.io/npm/dm/@macalinao/codama-rename-visitor.svg)](https://www.npmjs.com/package/@macalinao/codama-rename-visitor)
+
 A Codama visitor for renaming instructions and events within a Solana program.
 
+## Quick Start with Coda CLI
+
+This visitor works seamlessly with the [Coda CLI](https://coda.ianm.com) for automated client generation:
+
+```bash
+# Install Coda CLI
+bun add -D @macalinao/coda
+
+# Initialize configuration 
+coda init
+
+# Add this visitor to your coda.config.mjs
+```
+
+Coda provides zero-config client generation with powerful customization through visitors like this one. Learn more at [coda.ianm.com](https://coda.ianm.com).
+
 ## Installation
 
+For direct usage:
+
 ```bash
 npm install @macalinao/codama-rename-visitor
 ```
@@ -118,4 +139,6 @@ Creates a visitor that renames events (defined types) based on the provided mapp
 
 ## License
 
-MIT
+Copyright © 2025 Ian Macalinao
+
+Licensed under the Apache License, Version 2.0

package/dist/index.d.ts

@@ -1,98 +1,6 @@
-import { rootNodeVisitor } from "codama";
-/**
- * Rename mapping for a single program
- */
-export interface ProgramRenameOptions {
-    /** Mapping of old instruction names to new instruction names */
-    instructions?: Record<string, string>;
-    /** Mapping of old event names (as defined types) to new event names */
-    events?: Record<string, string>;
-    /** Mapping of old defined type names to new defined type names */
-    definedTypes?: Record<string, string>;
-}
-/**
- * Options for the rename visitor (legacy interface)
- */
-export type RenameVisitorOptions = ProgramRenameOptions;
-/**
- * Creates a visitor that renames instructions in a Codama IDL.
- *
- * @param mapping - Object mapping old instruction names to new instruction names
- * @returns A root node visitor that renames instructions
- *
- * @example
- * ```typescript
- * const visitor = renameInstructionsVisitor({
- *   "transfer": "transferTokens",
- *   "mint": "mintNft"
- * });
- * codama.update(visitor);
- * ```
- */
-export declare function renameInstructionsVisitor(mapping: Record<string, string>): ReturnType<typeof rootNodeVisitor>;
-/**
- * Creates a visitor that renames events (as defined types) in a Codama IDL.
- *
- * Events in Anchor IDLs are typically converted to defined types in Codama,
- * so this visitor renames specific defined types that represent events.
- *
- * @param mapping - Object mapping old event names to new event names
- * @param eventSuffix - Optional suffix to identify event types (default: "Event")
- * @returns A root node visitor that renames events
- *
- * @example
- * ```typescript
- * const visitor = renameEventsVisitor({
- *   "tokenMinted": "nftMinted",
- *   "transferComplete": "transferFinished"
- * });
- * codama.update(visitor);
- * ```
- */
-export declare function renameEventsVisitor(mapping: Record<string, string>, eventSuffix?: string): ReturnType<typeof rootNodeVisitor>;
-/**
- * Creates a visitor that renames defined types in a Codama IDL.
- *
- * @param mapping - Object mapping old defined type names to new defined type names
- * @returns A root node visitor that renames defined types
- *
- * @example
- * ```typescript
- * const visitor = renameDefinedTypesVisitor({
- *   "counter": "counterAccount",
- *   "config": "programConfig"
- * });
- * codama.update(visitor);
- * ```
- */
-export declare function renameDefinedTypesVisitor(mapping: Record<string, string>): ReturnType<typeof rootNodeVisitor>;
-/**
- * Creates a visitor that renames instructions, events, and defined types in specific programs.
- * This follows the same pattern as addPdasVisitor from Codama.
- *
- * @param renamesByProgram - Object mapping program names to their rename configurations
- * @returns A root node visitor that performs all specified renames
- *
- * @example
- * ```typescript
- * const visitor = renameVisitor({
- *   quarryMine: {
- *     instructions: {
- *       claimRewards: "claimRewardsMine"
- *     }
- *   },
- *   token: {
- *     instructions: {
- *       transfer: "transferTokens",
- *       mint: "mintNft"
- *     },
- *     events: {
- *       tokenMinted: "nftMinted"
- *     }
- *   }
- * });
- * codama.update(visitor);
- * ```
- */
-export declare function renameVisitor(renamesByProgram: Record<string, ProgramRenameOptions>): ReturnType<typeof rootNodeVisitor>;
+export { renameAccountsVisitor, renameAccountTransform, } from "./rename-accounts-visitor.js";
+export { renameDefinedTypesVisitor, renameDefinedTypeTransform, } from "./rename-defined-types-visitor.js";
+export { renameInstructionsVisitor, renameInstructionTransform, } from "./rename-instructions-visitor.js";
+export { renameVisitor } from "./rename-visitor.js";
+export type { ProgramRenameOptions } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,eAAe,EAEhB,MAAM,QAAQ,CAAC;AAEhB;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,oBAAoB,CAAC;AAExD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,UAAU,CAAC,OAAO,eAAe,CAAC,CAoBpC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,WAAW,SAAU,GACpB,UAAU,CAAC,OAAO,eAAe,CAAC,CA8BpC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,UAAU,CAAC,OAAO,eAAe,CAAC,CAoBpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAC3B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,GACrD,UAAU,CAAC,OAAO,eAAe,CAAC,CAsGpC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,221 +1,5 @@
-import { assertIsNode, bottomUpTransformerVisitor, camelCase, rootNodeVisitor, visit, } from "codama";
-/**
- * Creates a visitor that renames instructions in a Codama IDL.
- *
- * @param mapping - Object mapping old instruction names to new instruction names
- * @returns A root node visitor that renames instructions
- *
- * @example
- * ```typescript
- * const visitor = renameInstructionsVisitor({
- *   "transfer": "transferTokens",
- *   "mint": "mintNft"
- * });
- * codama.update(visitor);
- * ```
- */
-export function renameInstructionsVisitor(mapping) {
-    return rootNodeVisitor((root) => {
-        const instructionVisitor = bottomUpTransformerVisitor([
-            {
-                select: "[instructionNode]",
-                transform: (node) => {
-                    assertIsNode(node, "instructionNode");
-                    const newName = mapping[node.name];
-                    if (!newName) {
-                        return node;
-                    }
-                    return {
-                        ...node,
-                        name: camelCase(newName),
-                    };
-                },
-            },
-        ]);
-        return visit(root, instructionVisitor);
-    });
-}
-/**
- * Creates a visitor that renames events (as defined types) in a Codama IDL.
- *
- * Events in Anchor IDLs are typically converted to defined types in Codama,
- * so this visitor renames specific defined types that represent events.
- *
- * @param mapping - Object mapping old event names to new event names
- * @param eventSuffix - Optional suffix to identify event types (default: "Event")
- * @returns A root node visitor that renames events
- *
- * @example
- * ```typescript
- * const visitor = renameEventsVisitor({
- *   "tokenMinted": "nftMinted",
- *   "transferComplete": "transferFinished"
- * });
- * codama.update(visitor);
- * ```
- */
-export function renameEventsVisitor(mapping, eventSuffix = "Event") {
-    return rootNodeVisitor((root) => {
-        const eventVisitor = bottomUpTransformerVisitor([
-            {
-                select: "[definedTypeNode]",
-                transform: (node) => {
-                    assertIsNode(node, "definedTypeNode");
-                    // Check if this is an event type (by suffix or by being in the mapping)
-                    const isEventBySuffix = node.name.endsWith(eventSuffix);
-                    const isEventInMapping = mapping[node.name] !== undefined;
-                    if (!(isEventBySuffix || isEventInMapping)) {
-                        return node;
-                    }
-                    const newName = mapping[node.name];
-                    if (!newName) {
-                        return node;
-                    }
-                    return {
-                        ...node,
-                        name: camelCase(newName),
-                    };
-                },
-            },
-        ]);
-        return visit(root, eventVisitor);
-    });
-}
-/**
- * Creates a visitor that renames defined types in a Codama IDL.
- *
- * @param mapping - Object mapping old defined type names to new defined type names
- * @returns A root node visitor that renames defined types
- *
- * @example
- * ```typescript
- * const visitor = renameDefinedTypesVisitor({
- *   "counter": "counterAccount",
- *   "config": "programConfig"
- * });
- * codama.update(visitor);
- * ```
- */
-export function renameDefinedTypesVisitor(mapping) {
-    return rootNodeVisitor((root) => {
-        const typeVisitor = bottomUpTransformerVisitor([
-            {
-                select: "[definedTypeNode]",
-                transform: (node) => {
-                    assertIsNode(node, "definedTypeNode");
-                    const newName = mapping[node.name];
-                    if (!newName) {
-                        return node;
-                    }
-                    return {
-                        ...node,
-                        name: camelCase(newName),
-                    };
-                },
-            },
-        ]);
-        return visit(root, typeVisitor);
-    });
-}
-/**
- * Creates a visitor that renames instructions, events, and defined types in specific programs.
- * This follows the same pattern as addPdasVisitor from Codama.
- *
- * @param renamesByProgram - Object mapping program names to their rename configurations
- * @returns A root node visitor that performs all specified renames
- *
- * @example
- * ```typescript
- * const visitor = renameVisitor({
- *   quarryMine: {
- *     instructions: {
- *       claimRewards: "claimRewardsMine"
- *     }
- *   },
- *   token: {
- *     instructions: {
- *       transfer: "transferTokens",
- *       mint: "mintNft"
- *     },
- *     events: {
- *       tokenMinted: "nftMinted"
- *     }
- *   }
- * });
- * codama.update(visitor);
- * ```
- */
-export function renameVisitor(renamesByProgram) {
-    return rootNodeVisitor((root) => {
-        // Check if this is the legacy single-program format
-        // (has instructions, events, or definedTypes at the top level)
-        const isLegacyFormat = "instructions" in renamesByProgram ||
-            "events" in renamesByProgram ||
-            "definedTypes" in renamesByProgram;
-        if (isLegacyFormat) {
-            // Legacy support: treat as single program renames
-            const options = renamesByProgram;
-            let transformedRoot = root;
-            // Apply instruction renaming
-            if (options.instructions &&
-                Object.keys(options.instructions).length > 0) {
-                transformedRoot = visit(transformedRoot, renameInstructionsVisitor(options.instructions));
-            }
-            // Apply event renaming
-            if (options.events && Object.keys(options.events).length > 0) {
-                transformedRoot = visit(transformedRoot, renameEventsVisitor(options.events));
-            }
-            // Apply defined type renaming
-            if (options.definedTypes &&
-                Object.keys(options.definedTypes).length > 0) {
-                transformedRoot = visit(transformedRoot, renameDefinedTypesVisitor(options.definedTypes));
-            }
-            return transformedRoot;
-        }
-        // New format: program-specific renames
-        const transforms = [];
-        // Process each program's rename configuration
-        Object.entries(renamesByProgram).forEach(([programName, renameOptions]) => {
-            // Add instruction renames for this program
-            if (renameOptions.instructions) {
-                Object.entries(renameOptions.instructions).forEach(([oldName, newName]) => {
-                    transforms.push({
-                        select: `[programNode]${programName}.[instructionNode]${oldName}`,
-                        transform: (node) => {
-                            assertIsNode(node, "instructionNode");
-                            return {
-                                ...node,
-                                name: camelCase(newName),
-                            };
-                        },
-                    });
-                });
-            }
-            // Add event/defined type renames for this program
-            if (renameOptions.events || renameOptions.definedTypes) {
-                const allTypeRenames = {
-                    ...(renameOptions.events ?? {}),
-                    ...(renameOptions.definedTypes ?? {}),
-                };
-                Object.entries(allTypeRenames).forEach(([oldName, newName]) => {
-                    transforms.push({
-                        select: `[programNode]${programName}.[definedTypeNode]${oldName}`,
-                        transform: (node) => {
-                            assertIsNode(node, "definedTypeNode");
-                            return {
-                                ...node,
-                                name: camelCase(newName),
-                            };
-                        },
-                    });
-                });
-            }
-        });
-        if (transforms.length === 0) {
-            return root;
-        }
-        const visitor = bottomUpTransformerVisitor(transforms);
-        return visit(root, visitor);
-    });
-}
+export { renameAccountsVisitor, renameAccountTransform, } from "./rename-accounts-visitor.js";
+export { renameDefinedTypesVisitor, renameDefinedTypeTransform, } from "./rename-defined-types-visitor.js";
+export { renameInstructionsVisitor, renameInstructionTransform, } from "./rename-instructions-visitor.js";
+export { renameVisitor } from "./rename-visitor.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DefinedTypeNode, InstructionNode, Node, RootNode } from \"codama\";\nimport {\n  assertIsNode,\n  bottomUpTransformerVisitor,\n  camelCase,\n  rootNodeVisitor,\n  visit,\n} from \"codama\";\n\n/**\n * Rename mapping for a single program\n */\nexport interface ProgramRenameOptions {\n  /** Mapping of old instruction names to new instruction names */\n  instructions?: Record<string, string>;\n  /** Mapping of old event names (as defined types) to new event names */\n  events?: Record<string, string>;\n  /** Mapping of old defined type names to new defined type names */\n  definedTypes?: Record<string, string>;\n}\n\n/**\n * Options for the rename visitor (legacy interface)\n */\nexport type RenameVisitorOptions = ProgramRenameOptions;\n\n/**\n * Creates a visitor that renames instructions in a Codama IDL.\n *\n * @param mapping - Object mapping old instruction names to new instruction names\n * @returns A root node visitor that renames instructions\n *\n * @example\n * ```typescript\n * const visitor = renameInstructionsVisitor({\n *   \"transfer\": \"transferTokens\",\n *   \"mint\": \"mintNft\"\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameInstructionsVisitor(\n  mapping: Record<string, string>,\n): ReturnType<typeof rootNodeVisitor> {\n  return rootNodeVisitor((root) => {\n    const instructionVisitor = bottomUpTransformerVisitor([\n      {\n        select: \"[instructionNode]\",\n        transform: (node) => {\n          assertIsNode(node, \"instructionNode\");\n          const newName = mapping[node.name];\n          if (!newName) {\n            return node;\n          }\n          return {\n            ...node,\n            name: camelCase(newName),\n          } as InstructionNode;\n        },\n      },\n    ]);\n    return visit(root, instructionVisitor);\n  });\n}\n\n/**\n * Creates a visitor that renames events (as defined types) in a Codama IDL.\n *\n * Events in Anchor IDLs are typically converted to defined types in Codama,\n * so this visitor renames specific defined types that represent events.\n *\n * @param mapping - Object mapping old event names to new event names\n * @param eventSuffix - Optional suffix to identify event types (default: \"Event\")\n * @returns A root node visitor that renames events\n *\n * @example\n * ```typescript\n * const visitor = renameEventsVisitor({\n *   \"tokenMinted\": \"nftMinted\",\n *   \"transferComplete\": \"transferFinished\"\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameEventsVisitor(\n  mapping: Record<string, string>,\n  eventSuffix = \"Event\",\n): ReturnType<typeof rootNodeVisitor> {\n  return rootNodeVisitor((root) => {\n    const eventVisitor = bottomUpTransformerVisitor([\n      {\n        select: \"[definedTypeNode]\",\n        transform: (node) => {\n          assertIsNode(node, \"definedTypeNode\");\n\n          // Check if this is an event type (by suffix or by being in the mapping)\n          const isEventBySuffix = node.name.endsWith(eventSuffix);\n          const isEventInMapping = mapping[node.name] !== undefined;\n\n          if (!(isEventBySuffix || isEventInMapping)) {\n            return node;\n          }\n\n          const newName = mapping[node.name];\n          if (!newName) {\n            return node;\n          }\n\n          return {\n            ...node,\n            name: camelCase(newName),\n          } as DefinedTypeNode;\n        },\n      },\n    ]);\n    return visit(root, eventVisitor);\n  });\n}\n\n/**\n * Creates a visitor that renames defined types in a Codama IDL.\n *\n * @param mapping - Object mapping old defined type names to new defined type names\n * @returns A root node visitor that renames defined types\n *\n * @example\n * ```typescript\n * const visitor = renameDefinedTypesVisitor({\n *   \"counter\": \"counterAccount\",\n *   \"config\": \"programConfig\"\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameDefinedTypesVisitor(\n  mapping: Record<string, string>,\n): ReturnType<typeof rootNodeVisitor> {\n  return rootNodeVisitor((root) => {\n    const typeVisitor = bottomUpTransformerVisitor([\n      {\n        select: \"[definedTypeNode]\",\n        transform: (node) => {\n          assertIsNode(node, \"definedTypeNode\");\n          const newName = mapping[node.name];\n          if (!newName) {\n            return node;\n          }\n          return {\n            ...node,\n            name: camelCase(newName),\n          } as DefinedTypeNode;\n        },\n      },\n    ]);\n    return visit(root, typeVisitor);\n  });\n}\n\n/**\n * Creates a visitor that renames instructions, events, and defined types in specific programs.\n * This follows the same pattern as addPdasVisitor from Codama.\n *\n * @param renamesByProgram - Object mapping program names to their rename configurations\n * @returns A root node visitor that performs all specified renames\n *\n * @example\n * ```typescript\n * const visitor = renameVisitor({\n *   quarryMine: {\n *     instructions: {\n *       claimRewards: \"claimRewardsMine\"\n *     }\n *   },\n *   token: {\n *     instructions: {\n *       transfer: \"transferTokens\",\n *       mint: \"mintNft\"\n *     },\n *     events: {\n *       tokenMinted: \"nftMinted\"\n *     }\n *   }\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameVisitor(\n  renamesByProgram: Record<string, ProgramRenameOptions>,\n): ReturnType<typeof rootNodeVisitor> {\n  return rootNodeVisitor((root) => {\n    // Check if this is the legacy single-program format\n    // (has instructions, events, or definedTypes at the top level)\n    const isLegacyFormat =\n      \"instructions\" in renamesByProgram ||\n      \"events\" in renamesByProgram ||\n      \"definedTypes\" in renamesByProgram;\n\n    if (isLegacyFormat) {\n      // Legacy support: treat as single program renames\n      const options = renamesByProgram as unknown as RenameVisitorOptions;\n      let transformedRoot = root;\n\n      // Apply instruction renaming\n      if (\n        options.instructions &&\n        Object.keys(options.instructions).length > 0\n      ) {\n        transformedRoot = visit(\n          transformedRoot,\n          renameInstructionsVisitor(options.instructions),\n        ) as RootNode;\n      }\n\n      // Apply event renaming\n      if (options.events && Object.keys(options.events).length > 0) {\n        transformedRoot = visit(\n          transformedRoot,\n          renameEventsVisitor(options.events),\n        ) as RootNode;\n      }\n\n      // Apply defined type renaming\n      if (\n        options.definedTypes &&\n        Object.keys(options.definedTypes).length > 0\n      ) {\n        transformedRoot = visit(\n          transformedRoot,\n          renameDefinedTypesVisitor(options.definedTypes),\n        ) as RootNode;\n      }\n\n      return transformedRoot;\n    }\n\n    // New format: program-specific renames\n    const transforms: {\n      select: string;\n      transform: (node: Node) => Node | null;\n    }[] = [];\n\n    // Process each program's rename configuration\n    Object.entries(renamesByProgram).forEach(([programName, renameOptions]) => {\n      // Add instruction renames for this program\n      if (renameOptions.instructions) {\n        Object.entries(renameOptions.instructions).forEach(\n          ([oldName, newName]) => {\n            transforms.push({\n              select: `[programNode]${programName}.[instructionNode]${oldName}`,\n              transform: (node) => {\n                assertIsNode(node, \"instructionNode\");\n                return {\n                  ...node,\n                  name: camelCase(newName),\n                } as InstructionNode;\n              },\n            });\n          },\n        );\n      }\n\n      // Add event/defined type renames for this program\n      if (renameOptions.events || renameOptions.definedTypes) {\n        const allTypeRenames = {\n          ...(renameOptions.events ?? {}),\n          ...(renameOptions.definedTypes ?? {}),\n        };\n\n        Object.entries(allTypeRenames).forEach(([oldName, newName]) => {\n          transforms.push({\n            select: `[programNode]${programName}.[definedTypeNode]${oldName}`,\n            transform: (node) => {\n              assertIsNode(node, \"definedTypeNode\");\n              return {\n                ...node,\n                name: camelCase(newName),\n              } as DefinedTypeNode;\n            },\n          });\n        });\n      }\n    });\n\n    if (transforms.length === 0) {\n      return root;\n    }\n\n    const visitor = bottomUpTransformerVisitor(transforms);\n    return visit(root, visitor);\n  });\n}\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC","sourcesContent":["export {\n  renameAccountsVisitor,\n  renameAccountTransform,\n} from \"./rename-accounts-visitor.js\";\nexport {\n  renameDefinedTypesVisitor,\n  renameDefinedTypeTransform,\n} from \"./rename-defined-types-visitor.js\";\nexport {\n  renameInstructionsVisitor,\n  renameInstructionTransform,\n} from \"./rename-instructions-visitor.js\";\nexport { renameVisitor } from \"./rename-visitor.js\";\nexport type { ProgramRenameOptions } from \"./types.js\";\n"]}

package/dist/rename-accounts-visitor.d.ts

@@ -0,0 +1,26 @@
+import type { AccountNode, Node, rootNodeVisitor } from "codama";
+/**
+ * Transform function that renames an account node based on a mapping.
+ *
+ * @param node - The node to transform
+ * @param mapping - Object mapping old account names to new account names
+ * @returns The transformed account node
+ */
+export declare function renameAccountTransform(node: Node, mapping: Record<string, string>): AccountNode;
+/**
+ * Creates a visitor that renames accounts in a Codama IDL.
+ *
+ * @param mapping - Object mapping old account names to new account names
+ * @returns A root node visitor that renames accounts
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameAccountsVisitor({
+ *   "userAccount": "user",
+ *   "configAccount": "config"
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export declare function renameAccountsVisitor(mapping: Record<string, string>): ReturnType<typeof rootNodeVisitor>;
+//# sourceMappingURL=rename-accounts-visitor.d.ts.map

package/dist/rename-accounts-visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-accounts-visitor.d.ts","sourceRoot":"","sources":["../src/rename-accounts-visitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAGjE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,WAAW,CAUb;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,UAAU,CAAC,OAAO,eAAe,CAAC,CAOpC"}

package/dist/rename-accounts-visitor.js

@@ -0,0 +1,43 @@
+import { assertIsNode, bottomUpTransformerVisitor, camelCase } from "codama";
+/**
+ * Transform function that renames an account node based on a mapping.
+ *
+ * @param node - The node to transform
+ * @param mapping - Object mapping old account names to new account names
+ * @returns The transformed account node
+ */
+export function renameAccountTransform(node, mapping) {
+    assertIsNode(node, "accountNode");
+    const newName = mapping[node.name];
+    if (!newName) {
+        return node;
+    }
+    return {
+        ...node,
+        name: camelCase(newName),
+    };
+}
+/**
+ * Creates a visitor that renames accounts in a Codama IDL.
+ *
+ * @param mapping - Object mapping old account names to new account names
+ * @returns A root node visitor that renames accounts
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameAccountsVisitor({
+ *   "userAccount": "user",
+ *   "configAccount": "config"
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export function renameAccountsVisitor(mapping) {
+    return bottomUpTransformerVisitor([
+        {
+            select: "[accountNode]",
+            transform: (node) => renameAccountTransform(node, mapping),
+        },
+    ]);
+}
+//# sourceMappingURL=rename-accounts-visitor.js.map

package/dist/rename-accounts-visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-accounts-visitor.js","sourceRoot":"","sources":["../src/rename-accounts-visitor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,0BAA0B,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CACpC,IAAU,EACV,OAA+B;IAE/B,YAAY,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;IAClC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO;QACL,GAAG,IAAI;QACP,IAAI,EAAE,SAAS,CAAC,OAAO,CAAC;KACzB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,qBAAqB,CACnC,OAA+B;IAE/B,OAAO,0BAA0B,CAAC;QAChC;YACE,MAAM,EAAE,eAAe;YACvB,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,sBAAsB,CAAC,IAAI,EAAE,OAAO,CAAC;SAC3D;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { AccountNode, Node, rootNodeVisitor } from \"codama\";\nimport { assertIsNode, bottomUpTransformerVisitor, camelCase } from \"codama\";\n\n/**\n * Transform function that renames an account node based on a mapping.\n *\n * @param node - The node to transform\n * @param mapping - Object mapping old account names to new account names\n * @returns The transformed account node\n */\nexport function renameAccountTransform(\n  node: Node,\n  mapping: Record<string, string>,\n): AccountNode {\n  assertIsNode(node, \"accountNode\");\n  const newName = mapping[node.name];\n  if (!newName) {\n    return node;\n  }\n  return {\n    ...node,\n    name: camelCase(newName),\n  };\n}\n\n/**\n * Creates a visitor that renames accounts in a Codama IDL.\n *\n * @param mapping - Object mapping old account names to new account names\n * @returns A root node visitor that renames accounts\n *\n * @example\n * ```typescript\n * const visitor = renameAccountsVisitor({\n *   \"userAccount\": \"user\",\n *   \"configAccount\": \"config\"\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameAccountsVisitor(\n  mapping: Record<string, string>,\n): ReturnType<typeof rootNodeVisitor> {\n  return bottomUpTransformerVisitor([\n    {\n      select: \"[accountNode]\",\n      transform: (node) => renameAccountTransform(node, mapping),\n    },\n  ]);\n}\n"]}

package/dist/rename-defined-types-visitor.d.ts

@@ -0,0 +1,27 @@
+import type { DefinedTypeNode, Node } from "codama";
+import { rootNodeVisitor } from "codama";
+/**
+ * Transform function that renames a defined type node based on a mapping.
+ *
+ * @param node - The node to transform
+ * @param mapping - Object mapping old defined type names to new defined type names
+ * @returns The transformed defined type node
+ */
+export declare function renameDefinedTypeTransform(node: Node, mapping: Record<string, string>): DefinedTypeNode;
+/**
+ * Creates a visitor that renames defined types in a Codama IDL.
+ *
+ * @param mapping - Object mapping old defined type names to new defined type names
+ * @returns A root node visitor that renames defined types
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameDefinedTypesVisitor({
+ *   "counter": "counterAccount",
+ *   "config": "programConfig"
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export declare function renameDefinedTypesVisitor(mapping: Record<string, string>): ReturnType<typeof rootNodeVisitor>;
+//# sourceMappingURL=rename-defined-types-visitor.d.ts.map

package/dist/rename-defined-types-visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-defined-types-visitor.d.ts","sourceRoot":"","sources":["../src/rename-defined-types-visitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACpD,OAAO,EAIL,eAAe,EAEhB,MAAM,QAAQ,CAAC;AAEhB;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,eAAe,CAUjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,UAAU,CAAC,OAAO,eAAe,CAAC,CAUpC"}

package/dist/rename-defined-types-visitor.js

@@ -0,0 +1,46 @@
+import { assertIsNode, bottomUpTransformerVisitor, camelCase, rootNodeVisitor, visit, } from "codama";
+/**
+ * Transform function that renames a defined type node based on a mapping.
+ *
+ * @param node - The node to transform
+ * @param mapping - Object mapping old defined type names to new defined type names
+ * @returns The transformed defined type node
+ */
+export function renameDefinedTypeTransform(node, mapping) {
+    assertIsNode(node, "definedTypeNode");
+    const newName = mapping[node.name];
+    if (!newName) {
+        return node;
+    }
+    return {
+        ...node,
+        name: camelCase(newName),
+    };
+}
+/**
+ * Creates a visitor that renames defined types in a Codama IDL.
+ *
+ * @param mapping - Object mapping old defined type names to new defined type names
+ * @returns A root node visitor that renames defined types
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameDefinedTypesVisitor({
+ *   "counter": "counterAccount",
+ *   "config": "programConfig"
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export function renameDefinedTypesVisitor(mapping) {
+    return rootNodeVisitor((root) => {
+        const typeVisitor = bottomUpTransformerVisitor([
+            {
+                select: "[definedTypeNode]",
+                transform: (node) => renameDefinedTypeTransform(node, mapping),
+            },
+        ]);
+        return visit(root, typeVisitor);
+    });
+}
+//# sourceMappingURL=rename-defined-types-visitor.js.map

package/dist/rename-defined-types-visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-defined-types-visitor.js","sourceRoot":"","sources":["../src/rename-defined-types-visitor.ts"],"names":[],"mappings":"AACA,OAAO,EACL,YAAY,EACZ,0BAA0B,EAC1B,SAAS,EACT,eAAe,EACf,KAAK,GACN,MAAM,QAAQ,CAAC;AAEhB;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAAU,EACV,OAA+B;IAE/B,YAAY,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC;IACtC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO;QACL,GAAG,IAAI;QACP,IAAI,EAAE,SAAS,CAAC,OAAO,CAAC;KACzB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,yBAAyB,CACvC,OAA+B;IAE/B,OAAO,eAAe,CAAC,CAAC,IAAI,EAAE,EAAE;QAC9B,MAAM,WAAW,GAAG,0BAA0B,CAAC;YAC7C;gBACE,MAAM,EAAE,mBAAmB;gBAC3B,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,0BAA0B,CAAC,IAAI,EAAE,OAAO,CAAC;aAC/D;SACF,CAAC,CAAC;QACH,OAAO,KAAK,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { DefinedTypeNode, Node } from \"codama\";\nimport {\n  assertIsNode,\n  bottomUpTransformerVisitor,\n  camelCase,\n  rootNodeVisitor,\n  visit,\n} from \"codama\";\n\n/**\n * Transform function that renames a defined type node based on a mapping.\n *\n * @param node - The node to transform\n * @param mapping - Object mapping old defined type names to new defined type names\n * @returns The transformed defined type node\n */\nexport function renameDefinedTypeTransform(\n  node: Node,\n  mapping: Record<string, string>,\n): DefinedTypeNode {\n  assertIsNode(node, \"definedTypeNode\");\n  const newName = mapping[node.name];\n  if (!newName) {\n    return node;\n  }\n  return {\n    ...node,\n    name: camelCase(newName),\n  };\n}\n\n/**\n * Creates a visitor that renames defined types in a Codama IDL.\n *\n * @param mapping - Object mapping old defined type names to new defined type names\n * @returns A root node visitor that renames defined types\n *\n * @example\n * ```typescript\n * const visitor = renameDefinedTypesVisitor({\n *   \"counter\": \"counterAccount\",\n *   \"config\": \"programConfig\"\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameDefinedTypesVisitor(\n  mapping: Record<string, string>,\n): ReturnType<typeof rootNodeVisitor> {\n  return rootNodeVisitor((root) => {\n    const typeVisitor = bottomUpTransformerVisitor([\n      {\n        select: \"[definedTypeNode]\",\n        transform: (node) => renameDefinedTypeTransform(node, mapping),\n      },\n    ]);\n    return visit(root, typeVisitor);\n  });\n}\n"]}

package/dist/rename-instructions-visitor.d.ts

@@ -0,0 +1,26 @@
+import type { InstructionNode, Node, NodeKind, Visitor } from "codama";
+/**
+ * Transform function that renames an instruction node based on a mapping.
+ *
+ * @param node - The node to transform
+ * @param mapping - Object mapping old instruction names to new instruction names
+ * @returns The transformed instruction node
+ */
+export declare function renameInstructionTransform(node: Node, mapping: Record<string, string>): InstructionNode;
+/**
+ * Creates a visitor that renames instructions in a Codama IDL.
+ *
+ * @param mapping - Object mapping old instruction names to new instruction names
+ * @returns A root node visitor that renames instructions
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameInstructionsVisitor({
+ *   "transfer": "transferTokens",
+ *   "mint": "mintNft"
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export declare function renameInstructionsVisitor<TNodeKind extends NodeKind = NodeKind>(mapping: Record<string, string>): Visitor<Node | null, TNodeKind>;
+//# sourceMappingURL=rename-instructions-visitor.d.ts.map

package/dist/rename-instructions-visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-instructions-visitor.d.ts","sourceRoot":"","sources":["../src/rename-instructions-visitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAGvE;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,eAAe,CAUjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,SAAS,QAAQ,GAAG,QAAQ,EACrC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,EAAE,SAAS,CAAC,CAOlE"}

package/dist/rename-instructions-visitor.js

@@ -0,0 +1,43 @@
+import { assertIsNode, bottomUpTransformerVisitor, camelCase } from "codama";
+/**
+ * Transform function that renames an instruction node based on a mapping.
+ *
+ * @param node - The node to transform
+ * @param mapping - Object mapping old instruction names to new instruction names
+ * @returns The transformed instruction node
+ */
+export function renameInstructionTransform(node, mapping) {
+    assertIsNode(node, "instructionNode");
+    const newName = mapping[node.name];
+    if (!newName) {
+        return node;
+    }
+    return {
+        ...node,
+        name: camelCase(newName),
+    };
+}
+/**
+ * Creates a visitor that renames instructions in a Codama IDL.
+ *
+ * @param mapping - Object mapping old instruction names to new instruction names
+ * @returns A root node visitor that renames instructions
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameInstructionsVisitor({
+ *   "transfer": "transferTokens",
+ *   "mint": "mintNft"
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export function renameInstructionsVisitor(mapping) {
+    return bottomUpTransformerVisitor([
+        {
+            select: "[instructionNode]",
+            transform: (node) => renameInstructionTransform(node, mapping),
+        },
+    ]);
+}
+//# sourceMappingURL=rename-instructions-visitor.js.map

package/dist/rename-instructions-visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-instructions-visitor.js","sourceRoot":"","sources":["../src/rename-instructions-visitor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,0BAA0B,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAAU,EACV,OAA+B;IAE/B,YAAY,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC;IACtC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO;QACL,GAAG,IAAI;QACP,IAAI,EAAE,SAAS,CAAC,OAAO,CAAC;KACzB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,yBAAyB,CAEvC,OAA+B;IAC/B,OAAO,0BAA0B,CAAC;QAChC;YACE,MAAM,EAAE,mBAAmB;YAC3B,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,0BAA0B,CAAC,IAAI,EAAE,OAAO,CAAC;SAC/D;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { InstructionNode, Node, NodeKind, Visitor } from \"codama\";\nimport { assertIsNode, bottomUpTransformerVisitor, camelCase } from \"codama\";\n\n/**\n * Transform function that renames an instruction node based on a mapping.\n *\n * @param node - The node to transform\n * @param mapping - Object mapping old instruction names to new instruction names\n * @returns The transformed instruction node\n */\nexport function renameInstructionTransform(\n  node: Node,\n  mapping: Record<string, string>,\n): InstructionNode {\n  assertIsNode(node, \"instructionNode\");\n  const newName = mapping[node.name];\n  if (!newName) {\n    return node;\n  }\n  return {\n    ...node,\n    name: camelCase(newName),\n  };\n}\n\n/**\n * Creates a visitor that renames instructions in a Codama IDL.\n *\n * @param mapping - Object mapping old instruction names to new instruction names\n * @returns A root node visitor that renames instructions\n *\n * @example\n * ```typescript\n * const visitor = renameInstructionsVisitor({\n *   \"transfer\": \"transferTokens\",\n *   \"mint\": \"mintNft\"\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameInstructionsVisitor<\n  TNodeKind extends NodeKind = NodeKind,\n>(mapping: Record<string, string>): Visitor<Node | null, TNodeKind> {\n  return bottomUpTransformerVisitor([\n    {\n      select: \"[instructionNode]\",\n      transform: (node) => renameInstructionTransform(node, mapping),\n    },\n  ]);\n}\n"]}