@macalinao/codama-rename-visitor 0.1.1 → 0.2.1

package/README.md

@@ -1,123 +1,40 @@
 # @macalinao/codama-rename-visitor
 
-A Codama visitor for renaming instructions and events within a Solana program.
+[![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)
 
-## Installation
+A Codama visitor for renaming accounts, instructions, and defined types within Solana programs.
 
-```bash
-npm install @macalinao/codama-rename-visitor
-```
-
-## Usage
-
-This visitor allows you to rename instructions and events in your Codama IDL. It's particularly useful when you want to change the naming conventions of your program without modifying the original IDL.
-
-### Renaming Instructions
+## Documentation
 
-```typescript
-import { renameInstructionsVisitor } from "@macalinao/codama-rename-visitor";
-import { visit } from "codama";
-
-// Rename specific instructions
-const visitor = renameInstructionsVisitor({
-  oldInstructionName: "newInstructionName",
-  transfer: "transferTokens",
-  mint: "mintNft"
-});
-
-const updatedRoot = visit(root, visitor);
-```
+Full documentation and examples are available at [coda.ianm.com/docs/packages/codama-rename-visitor](https://coda.ianm.com/docs/packages/codama-rename-visitor).
 
-### Renaming Events
+## Quick Start
 
-```typescript
-import { renameEventsVisitor } from "@macalinao/codama-rename-visitor";
-import { visit } from "codama";
-
-// Rename specific events (as defined types)
-const visitor = renameEventsVisitor({
-  oldEventName: "newEventName",
-  tokenMinted: "nftMinted",
-  transferComplete: "transferFinished"
-});
-
-const updatedRoot = visit(root, visitor);
+```bash
+npm install @macalinao/codama-rename-visitor
 ```
 
-### Program-Specific Renaming (Recommended)
-
-The `renameVisitor` follows the same pattern as Codama's `addPdasVisitor`, where you specify renames for specific programs:
-
 ```typescript
 import { renameVisitor } from "@macalinao/codama-rename-visitor";
-import { visit } from "codama";
 
-// Rename elements in specific programs
 const visitor = renameVisitor({
-  quarryMine: {
-    instructions: {
-      claimRewards: "claimRewardsMine"
-    }
-  },
-  token: {
+  myProgram: {
     instructions: {
-      transfer: "transferTokens",
-      mint: "mintNft"
+      oldName: "newName"
     },
-    events: {
-      tokenMinted: "nftMinted"
+    accounts: {
+      oldAccount: "newAccount"
+    },
+    definedTypes: {
+      oldType: "newType"
     }
   }
 });
-
-const updatedRoot = visit(root, visitor);
 ```
 
-### Legacy Single-Program Renaming
-
-For backward compatibility, you can still use the legacy format for single-program renaming:
-
-```typescript
-import { renameVisitor } from "@macalinao/codama-rename-visitor";
-import { visit } from "codama";
-
-// Legacy format: rename in the current program
-const visitor = renameVisitor({
-  instructions: {
-    transfer: "transferTokens",
-    mint: "mintNft"
-  },
-  events: {
-    tokenMinted: "nftMinted",
-    transferComplete: "transferFinished"
-  }
-});
-
-const updatedRoot = visit(root, visitor);
-```
-
-## API
-
-### `renameVisitor(renamesByProgram: Record<string, ProgramRenameOptions>)`
-
-Creates a visitor that renames instructions, events, and defined types in specific programs. This is the recommended API.
-
-- `renamesByProgram`: Object mapping program names to their rename configurations
-  - Each program can specify:
-    - `instructions`: Mapping of old instruction names to new names
-    - `events`: Mapping of old event names to new names  
-    - `definedTypes`: Mapping of old defined type names to new names
-
-### `renameInstructionsVisitor(mapping: Record<string, string>)`
-
-Creates a visitor that renames instructions based on the provided mapping. Applies to all programs.
-
-### `renameEventsVisitor(mapping: Record<string, string>)`
-
-Creates a visitor that renames events (defined types) based on the provided mapping. Applies to all programs.
-
 ## License
 
 Copyright © 2025 Ian Macalinao
 
-Licensed under the Apache License, Version 2.0
+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