@macalinao/codama-rename-visitor 0.3.3 → 0.4.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export type { ProgramRenameOptions } from "./types.js";
-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.d.ts.map
+import { ProgramRenameOptions } from "./types.js";
+import { renameAccountTransform, renameAccountsVisitor } from "./rename-accounts-visitor.js";
+import { renameDefinedTypeTransform, renameDefinedTypesVisitor } from "./rename-defined-types-visitor.js";
+import { renameInstructionTransform, renameInstructionsVisitor } from "./rename-instructions-visitor.js";
+import { renameVisitor } from "./rename-visitor.js";
+export { type ProgramRenameOptions, renameAccountTransform, renameAccountsVisitor, renameDefinedTypeTransform, renameDefinedTypesVisitor, renameInstructionTransform, renameInstructionsVisitor, renameVisitor };

package/dist/index.js

@@ -1,5 +1,5 @@
-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
+import { renameAccountTransform, renameAccountsVisitor } from "./rename-accounts-visitor.js";
+import { renameDefinedTypeTransform, renameDefinedTypesVisitor } from "./rename-defined-types-visitor.js";
+import { renameInstructionTransform, renameInstructionsVisitor } from "./rename-instructions-visitor.js";
+import { renameVisitor } from "./rename-visitor.js";
+export { renameAccountTransform, renameAccountsVisitor, renameDefinedTypeTransform, renameDefinedTypesVisitor, renameInstructionTransform, renameInstructionsVisitor, renameVisitor };

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

@@ -1,26 +1,30 @@
-import type { AccountNode, Node, rootNodeVisitor } from "codama";
+import { AccountNode, Node, Visitor } from "codama";
+
+//#region src/rename-accounts-visitor.d.ts
 /**
- * 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;
+* 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
+*/
+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>;
+* 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);
+* ```
+*/
+declare function renameAccountsVisitor(mapping: Record<string, string>): Visitor<Node | null, "rootNode">;
+//#endregion
+export { renameAccountTransform, renameAccountsVisitor };
 //# sourceMappingURL=rename-accounts-visitor.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"rename-accounts-visitor.d.ts","names":[],"sources":["../src/rename-accounts-visitor.ts"],"mappings":";;;;;AAUA;;;;;iBAAgB,sBAAA,CACd,IAAA,EAAM,IAAA,EACN,OAAA,EAAS,MAAA,mBACR,WAAA;;;;;;;;;AAAA;AA2BH;;;;;;iBAAgB,qBAAA,CACd,OAAA,EAAS,MAAA,mBACR,OAAA,CAAQ,IAAA"}

package/dist/rename-accounts-visitor.js

@@ -1,43 +1,43 @@
 import { assertIsNode, bottomUpTransformerVisitor, camelCase } from "codama";
+//#region src/rename-accounts-visitor.ts
 /**
- * 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),
-    };
+* 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
+*/
+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),
-        },
-    ]);
+* 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);
+* ```
+*/
+function renameAccountsVisitor(mapping) {
+	return bottomUpTransformerVisitor([{
+		select: "[accountNode]",
+		transform: (node) => renameAccountTransform(node, mapping)
+	}]);
 }
+//#endregion
+export { renameAccountTransform, renameAccountsVisitor };
+
 //# sourceMappingURL=rename-accounts-visitor.js.map

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

@@ -1 +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"]}
+{"version":3,"file":"rename-accounts-visitor.js","names":[],"sources":["../src/rename-accounts-visitor.ts"],"sourcesContent":["import type { AccountNode, Node, Visitor } 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): Visitor<Node | null, \"rootNode\"> {\n  return bottomUpTransformerVisitor([\n    {\n      select: \"[accountNode]\",\n      transform: (node) => renameAccountTransform(node, mapping),\n    },\n  ]);\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,uBACd,MACA,SACa;CACb,aAAa,MAAM,aAAa;CAChC,MAAM,UAAU,QAAQ,KAAK;CAC7B,IAAI,CAAC,SACH,OAAO;CAET,OAAO;EACL,GAAG;EACH,MAAM,UAAU,OAAO;CACzB;AACF;;;;;;;;;;;;;;;;AAiBA,SAAgB,sBACd,SACkC;CAClC,OAAO,2BAA2B,CAChC;EACE,QAAQ;EACR,YAAY,SAAS,uBAAuB,MAAM,OAAO;CAC3D,CACF,CAAC;AACH"}

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

@@ -1,27 +1,30 @@
-import type { DefinedTypeNode, Node } from "codama";
-import { rootNodeVisitor } from "codama";
+import { DefinedTypeNode, Node, Visitor } from "codama";
+
+//#region src/rename-defined-types-visitor.d.ts
 /**
- * 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;
+* 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
+*/
+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>;
+* 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);
+* ```
+*/
+declare function renameDefinedTypesVisitor(mapping: Record<string, string>): Visitor<Node | null, "rootNode">;
+//#endregion
+export { renameDefinedTypeTransform, renameDefinedTypesVisitor };
 //# sourceMappingURL=rename-defined-types-visitor.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"rename-defined-types-visitor.d.ts","names":[],"sources":["../src/rename-defined-types-visitor.ts"],"mappings":";;;;;AAgBA;;;;;iBAAgB,0BAAA,CACd,IAAA,EAAM,IAAA,EACN,OAAA,EAAS,MAAA,mBACR,eAAA;;;;;;;;;AAAA;AA2BH;;;;;;iBAAgB,yBAAA,CACd,OAAA,EAAS,MAAA,mBACR,OAAA,CAAQ,IAAA"}

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

@@ -1,46 +1,45 @@
-import { assertIsNode, bottomUpTransformerVisitor, camelCase, rootNodeVisitor, visit, } from "codama";
+import { assertIsNode, bottomUpTransformerVisitor, camelCase, rootNodeVisitor, visit } from "codama";
+//#region src/rename-defined-types-visitor.ts
 /**
- * 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),
-    };
+* 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
+*/
+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);
-    });
+* 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);
+* ```
+*/
+function renameDefinedTypesVisitor(mapping) {
+	return rootNodeVisitor((root) => {
+		return visit(root, bottomUpTransformerVisitor([{
+			select: "[definedTypeNode]",
+			transform: (node) => renameDefinedTypeTransform(node, mapping)
+		}]));
+	});
 }
+//#endregion
+export { renameDefinedTypeTransform, renameDefinedTypesVisitor };
+
 //# sourceMappingURL=rename-defined-types-visitor.js.map

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

@@ -1 +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"]}
+{"version":3,"file":"rename-defined-types-visitor.js","names":[],"sources":["../src/rename-defined-types-visitor.ts"],"sourcesContent":["import type { DefinedTypeNode, Node, Visitor } 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): Visitor<Node | null, \"rootNode\"> {\n  return rootNodeVisitor<Node | null>((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"],"mappings":";;;;;;;;;AAgBA,SAAgB,2BACd,MACA,SACiB;CACjB,aAAa,MAAM,iBAAiB;CACpC,MAAM,UAAU,QAAQ,KAAK;CAC7B,IAAI,CAAC,SACH,OAAO;CAET,OAAO;EACL,GAAG;EACH,MAAM,UAAU,OAAO;CACzB;AACF;;;;;;;;;;;;;;;;AAiBA,SAAgB,0BACd,SACkC;CAClC,OAAO,iBAA8B,SAAS;EAO5C,OAAO,MAAM,MANO,2BAA2B,CAC7C;GACE,QAAQ;GACR,YAAY,SAAS,2BAA2B,MAAM,OAAO;EAC/D,CACF,CAC6B,CAAC;CAChC,CAAC;AACH"}

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

@@ -1,26 +1,30 @@
-import type { InstructionNode, Node, NodeKind, Visitor } from "codama";
+import { InstructionNode, Node, NodeKind, Visitor } from "codama";
+
+//#region src/rename-instructions-visitor.d.ts
 /**
- * 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;
+* 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
+*/
+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>;
+* 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);
+* ```
+*/
+declare function renameInstructionsVisitor<TNodeKind extends NodeKind = NodeKind>(mapping: Record<string, string>): Visitor<Node | null, TNodeKind>;
+//#endregion
+export { renameInstructionTransform, renameInstructionsVisitor };
 //# sourceMappingURL=rename-instructions-visitor.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"rename-instructions-visitor.d.ts","names":[],"sources":["../src/rename-instructions-visitor.ts"],"mappings":";;;;;AAUA;;;;;iBAAgB,0BAAA,CACd,IAAA,EAAM,IAAA,EACN,OAAA,EAAS,MAAA,mBACR,eAAA;;;;;;;;;AAAA;AA2BH;;;;;;iBAAgB,yBAAA,mBACI,QAAA,GAAW,QAAA,EAC7B,OAAA,EAAS,MAAA,mBAAyB,OAAA,CAAQ,IAAA,SAAa,SAAA"}

package/dist/rename-instructions-visitor.js

@@ -1,43 +1,43 @@
 import { assertIsNode, bottomUpTransformerVisitor, camelCase } from "codama";
+//#region src/rename-instructions-visitor.ts
 /**
- * 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),
-    };
+* 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
+*/
+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),
-        },
-    ]);
+* 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);
+* ```
+*/
+function renameInstructionsVisitor(mapping) {
+	return bottomUpTransformerVisitor([{
+		select: "[instructionNode]",
+		transform: (node) => renameInstructionTransform(node, mapping)
+	}]);
 }
+//#endregion
+export { renameInstructionTransform, renameInstructionsVisitor };
+
 //# sourceMappingURL=rename-instructions-visitor.js.map

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

@@ -1 +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"]}
+{"version":3,"file":"rename-instructions-visitor.js","names":[],"sources":["../src/rename-instructions-visitor.ts"],"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"],"mappings":";;;;;;;;;AAUA,SAAgB,2BACd,MACA,SACiB;CACjB,aAAa,MAAM,iBAAiB;CACpC,MAAM,UAAU,QAAQ,KAAK;CAC7B,IAAI,CAAC,SACH,OAAO;CAET,OAAO;EACL,GAAG;EACH,MAAM,UAAU,OAAO;CACzB;AACF;;;;;;;;;;;;;;;;AAiBA,SAAgB,0BAEd,SAAkE;CAClE,OAAO,2BAA2B,CAChC;EACE,QAAQ;EACR,YAAY,SAAS,2BAA2B,MAAM,OAAO;CAC/D,CACF,CAAC;AACH"}

package/dist/rename-visitor.d.ts

@@ -1,35 +1,8 @@
-import type { ProgramRenameOptions } from "./types.js";
-import { rootNodeVisitor } from "codama";
-/**
- * Creates a visitor that renames accounts, instructions, 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"
- *     },
- *     accounts: {
- *       miner: "minerAccount"
- *     }
- *   },
- *   token: {
- *     instructions: {
- *       transfer: "transferTokens",
- *       mint: "mintNft"
- *     },
- *     definedTypes: {
- *       tokenData: "tokenMetadata"
- *     }
- *   }
- * });
- * codama.update(visitor);
- * ```
- */
-export declare function renameVisitor(renamesByProgram: Record<string, ProgramRenameOptions>): ReturnType<typeof rootNodeVisitor>;
+import { ProgramRenameOptions } from "./types.js";
+import { Node, Visitor } from "codama";
+
+//#region src/rename-visitor.d.ts
+declare function renameVisitor(renamesByProgram: Record<string, ProgramRenameOptions>): Visitor<Node | null, "rootNode">;
+//#endregion
+export { renameVisitor };
 //# sourceMappingURL=rename-visitor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rename-visitor.d.ts","sourceRoot":"","sources":["../src/rename-visitor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAA8B,eAAe,EAAS,MAAM,QAAQ,CAAC;AAK5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,aAAa,CAC3B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,GACrD,UAAU,CAAC,OAAO,eAAe,CAAC,CAqDpC"}
+{"version":3,"file":"rename-visitor.d.ts","names":[],"sources":["../src/rename-visitor.ts"],"mappings":";;;;iBA8DgB,aAAA,CACd,gBAAA,EAAkB,MAAA,SAAe,oBAAA,IAChC,OAAA,CAAQ,IAAA"}