@codama/renderers-rust 1.2.7 → 1.2.9

package/dist/index.node.mjs

@@ -1,3 +1,13 @@
+import { CodamaError, CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, logWarn, logError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
+import { REGISTERED_TYPE_NODE_KINDS, definedTypeNode, pascalCase, snakeCase, parseDocs, resolveNestedTypeNode, isNode, remainderCountNode, fixedCountNode, prefixedCountNode, arrayTypeNode, numberTypeNode, getAllPrograms, getAllAccounts, getAllInstructionsWithSubs, getAllDefinedTypes, VALUE_NODES, structTypeNodeFromInstructionArgumentNodes, isNodeFilter, camelCase, kebabCase, titleCase, assertIsNode, bytesValueNode, numberValueNode, arrayValueNode, isScalarEnum } from '@codama/nodes';
+import { createRenderMap, mergeRenderMaps, addToRenderMap, deleteDirectory, writeRenderMapVisitor } from '@codama/renderers-core';
+import { pipe, mergeVisitor, extendVisitor, visit, LinkableDictionary, NodeStack, staticVisitor, recordNodeStackVisitor, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor } from '@codama/visitors-core';
+import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder } from '@solana/codecs-strings';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import nunjucks from 'nunjucks';
+import { spawnSync } from 'child_process';
+
 // src/ImportMap.ts
 var DEFAULT_MODULE_MAP = {
   generated: "crate::generated",
@@ -68,54 +78,6 @@ var ImportMap = class _ImportMap {
     return importStatements.join("\n");
   }
 };
-
-// src/getRenderMapVisitor.ts
-import { logWarn } from "@codama/errors";
-import {
-  getAllAccounts,
-  getAllDefinedTypes,
-  getAllInstructionsWithSubs,
-  getAllPrograms,
-  isNode as isNode5,
-  isNodeFilter as isNodeFilter2,
-  pascalCase as pascalCase4,
-  resolveNestedTypeNode as resolveNestedTypeNode2,
-  snakeCase as snakeCase4,
-  structTypeNodeFromInstructionArgumentNodes,
-  VALUE_NODES as VALUE_NODES2
-} from "@codama/nodes";
-import { addToRenderMap, createRenderMap, mergeRenderMaps } from "@codama/renderers-core";
-import {
-  extendVisitor as extendVisitor2,
-  LinkableDictionary,
-  NodeStack,
-  pipe as pipe2,
-  recordLinkablesOnFirstVisitVisitor,
-  recordNodeStackVisitor,
-  staticVisitor,
-  visit as visit4
-} from "@codama/visitors-core";
-
-// src/getTypeManifestVisitor.ts
-import { CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, CodamaError as CodamaError2 } from "@codama/errors";
-import {
-  arrayTypeNode,
-  definedTypeNode,
-  fixedCountNode,
-  isNode as isNode4,
-  numberTypeNode,
-  parseDocs,
-  pascalCase as pascalCase3,
-  prefixedCountNode,
-  REGISTERED_TYPE_NODE_KINDS,
-  remainderCountNode,
-  resolveNestedTypeNode,
-  snakeCase as snakeCase3
-} from "@codama/nodes";
-import { extendVisitor, mergeVisitor, pipe, visit as visit3 } from "@codama/visitors-core";
-
-// src/utils/codecs.ts
-import { getBase16Encoder, getBase58Encoder, getBase64Encoder, getUtf8Encoder } from "@solana/codecs-strings";
 function getBytesFromBytesValueNode(node) {
   switch (node.encoding) {
     case "utf8":
@@ -129,26 +91,6 @@ function getBytesFromBytesValueNode(node) {
       return getBase64Encoder().encode(node.data);
   }
 }
-
-// src/utils/discriminatorConstant.ts
-import {
-  camelCase,
-  isNode as isNode2,
-  isNodeFilter,
-  snakeCase,
-  VALUE_NODES
-} from "@codama/nodes";
-import { visit as visit2 } from "@codama/visitors-core";
-
-// src/renderValueNodeVisitor.ts
-import {
-  arrayValueNode,
-  bytesValueNode,
-  isNode,
-  numberValueNode,
-  pascalCase
-} from "@codama/nodes";
-import { visit } from "@codama/visitors-core";
 function renderValueNode(value, getImportFrom, useStr = false) {
   return visit(value, renderValueNodeVisitor(getImportFrom, useStr));
 }
@@ -308,18 +250,18 @@ function getConstantDiscriminatorConstant(discriminatorNode, scope) {
   const index = discriminatorNodes.filter(isNodeFilter("constantDiscriminatorNode")).indexOf(discriminatorNode);
   const suffix = index <= 0 ? "" : `_${index + 1}`;
   const name = camelCase(`${prefix}_discriminator${suffix}`);
-  const typeManifest = visit2(discriminatorNode.constant.type, typeManifestVisitor);
+  const typeManifest = visit(discriminatorNode.constant.type, typeManifestVisitor);
   const value = renderValueNode(discriminatorNode.constant.value, getImportFrom);
   return getConstant(name, typeManifest, value);
 }
 function getFieldDiscriminatorConstant(discriminatorNode, scope) {
   const { fields, prefix, getImportFrom, typeManifestVisitor } = scope;
   const field = fields.find((f) => f.name === discriminatorNode.name);
-  if (!field || !field.defaultValue || !isNode2(field.defaultValue, VALUE_NODES)) {
+  if (!field || !field.defaultValue || !isNode(field.defaultValue, VALUE_NODES)) {
     return null;
   }
   const name = camelCase(`${prefix}_${discriminatorNode.name}`);
-  const typeManifest = visit2(field.type, typeManifestVisitor);
+  const typeManifest = visit(field.type, typeManifestVisitor);
   const value = renderValueNode(field.defaultValue, getImportFrom);
   return getConstant(name, typeManifest, value);
 }
@@ -327,9 +269,6 @@ function getConstant(name, typeManifest, value) {
   const type = { imports: typeManifest.imports, render: typeManifest.type };
   return mergeFragments([type, value], ([t, v]) => `pub const ${snakeCase(name).toUpperCase()}: ${t} = ${v};`);
 }
-
-// src/utils/linkOverrides.ts
-import { CODAMA_ERROR__UNEXPECTED_NODE_KIND, CodamaError } from "@codama/errors";
 function getImportFromFactory(overrides) {
   const linkOverrides = {
     accounts: overrides.accounts ?? {},
@@ -370,12 +309,6 @@ function getImportFromFactory(overrides) {
     }
   };
 }
-
-// src/utils/render.ts
-import { dirname as pathDirname, join } from "path";
-import { fileURLToPath } from "url";
-import { camelCase as camelCase2, kebabCase, pascalCase as pascalCase2, snakeCase as snakeCase2, titleCase } from "@codama/nodes";
-import nunjucks from "nunjucks";
 function rustDocblock(docs) {
   if (docs.length <= 0) return "";
   const lines = docs.map((doc) => `/// ${doc}`);
@@ -383,12 +316,12 @@ function rustDocblock(docs) {
 `;
 }
 var render = (template, context, options) => {
-  const dirname = true ? pathDirname(fileURLToPath(import.meta.url)) : __dirname;
-  const templates = false ? join(dirname, "..", "..", "public", "templates") : join(dirname, "templates");
+  const dirname$1 = dirname(fileURLToPath(import.meta.url)) ;
+  const templates = join(dirname$1, "templates");
   const env = nunjucks.configure(templates, { autoescape: false, trimBlocks: true, ...options });
-  env.addFilter("pascalCase", pascalCase2);
-  env.addFilter("camelCase", camelCase2);
-  env.addFilter("snakeCase", snakeCase2);
+  env.addFilter("pascalCase", pascalCase);
+  env.addFilter("camelCase", camelCase);
+  env.addFilter("snakeCase", snakeCase);
   env.addFilter("kebabCase", kebabCase);
   env.addFilter("titleCase", titleCase);
   env.addFilter("rustDocblock", rustDocblock);
@@ -398,14 +331,6 @@ var render = (template, context, options) => {
   });
   return env.render(template, context);
 };
-
-// src/utils/traitOptions.ts
-import {
-  assertIsNode,
-  camelCase as camelCase3,
-  isNode as isNode3,
-  isScalarEnum
-} from "@codama/nodes";
 var DEFAULT_TRAIT_OPTIONS = {
   baseDefaults: [
     "borsh::BorshSerialize",
@@ -435,7 +360,7 @@ function getTraitsFromNode(node, userOptions = {}) {
     return { imports: new ImportMap(), render: "" };
   }
   const sanitizedOverrides = Object.fromEntries(
-    Object.entries(options.overrides).map(([key, value]) => [camelCase3(key), value])
+    Object.entries(options.overrides).map(([key, value]) => [camelCase(key), value])
   );
   const nodeOverrides = sanitizedOverrides[node.name];
   const allTraits = nodeOverrides === void 0 ? getDefaultTraits(nodeType, options) : nodeOverrides;
@@ -457,9 +382,9 @@ function getTraitsFromNode(node, userOptions = {}) {
   return { imports, render: traitLines.join("") };
 }
 function getNodeType(node) {
-  if (isNode3(node, ["accountNode", "instructionNode"])) return "struct";
-  if (isNode3(node.type, "structTypeNode")) return "struct";
-  if (isNode3(node.type, "enumTypeNode")) {
+  if (isNode(node, ["accountNode", "instructionNode"])) return "struct";
+  if (isNode(node.type, "structTypeNode")) return "struct";
+  if (isNode(node.type, "enumTypeNode")) {
     return isScalarEnum(node.type) ? "scalarEnum" : "dataEnum";
   }
   return "alias";
@@ -513,7 +438,7 @@ function getSerdeFieldAttribute(serdeWith, node, userOptions = {}) {
     return "";
   }
   const sanitizedOverrides = Object.fromEntries(
-    Object.entries(options.overrides).map(([key, value]) => [camelCase3(key), value])
+    Object.entries(options.overrides).map(([key, value]) => [camelCase(key), value])
   );
   const nodeOverrides = sanitizedOverrides[node.name];
   const allTraits = nodeOverrides === void 0 ? getDefaultTraits(nodeType, options) : nodeOverrides;
@@ -561,9 +486,9 @@ function getTypeManifestVisitor(options) {
     ),
     (v) => extendVisitor(v, {
       visitAccount(account, { self }) {
-        parentName = pascalCase3(account.name);
+        parentName = pascalCase(account.name);
         parentNode = account;
-        const manifest = visit3(account.data, self);
+        const manifest = visit(account.data, self);
         const traits = getTraitsFromNode2(account);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
@@ -574,14 +499,14 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitArrayType(arrayType, { self }) {
-        const childManifest = visit3(arrayType.item, self);
-        if (isNode4(arrayType.count, "fixedCountNode")) {
+        const childManifest = visit(arrayType.item, self);
+        if (isNode(arrayType.count, "fixedCountNode")) {
           return {
             ...childManifest,
             type: `[${childManifest.type}; ${arrayType.count.value}]`
           };
         }
-        if (isNode4(arrayType.count, "remainderCountNode")) {
+        if (isNode(arrayType.count, "remainderCountNode")) {
           childManifest.imports.add("kaigan::types::RemainderVec");
           return {
             ...childManifest,
@@ -638,21 +563,21 @@ function getTypeManifestVisitor(options) {
           arraySize = prefixedCountNode(parentSize);
         }
         const arrayType = arrayTypeNode(numberTypeNode("u8"), arraySize);
-        return visit3(arrayType, self);
+        return visit(arrayType, self);
       },
       visitDefinedType(definedType, { self }) {
-        parentName = pascalCase3(definedType.name);
+        parentName = pascalCase(definedType.name);
         parentNode = definedType;
-        const manifest = visit3(definedType.type, self);
+        const manifest = visit(definedType.type, self);
         const traits = getTraitsFromNode2(definedType);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
         parentNode = null;
-        const renderedType = isNode4(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${pascalCase3(definedType.name)} = ${manifest.type};`;
+        const renderedType = isNode(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${pascalCase(definedType.name)} = ${manifest.type};`;
         return { ...manifest, type: `${traits.render}${renderedType}` };
       },
       visitDefinedTypeLink(node) {
-        const pascalCaseDefinedType = pascalCase3(node.name);
+        const pascalCaseDefinedType = pascalCase(node.name);
         const importFrom = getImportFrom(node);
         return {
           imports: new ImportMap().add(`${importFrom}::${pascalCaseDefinedType}`),
@@ -661,7 +586,7 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const name = pascalCase3(enumEmptyVariantType.name);
+        const name = pascalCase(enumEmptyVariantType.name);
         return {
           imports: new ImportMap(),
           nestedStructs: [],
@@ -669,14 +594,14 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumStructVariantType(enumStructVariantType, { self }) {
-        const name = pascalCase3(enumStructVariantType.name);
+        const name = pascalCase(enumStructVariantType.name);
         const originalParentName = parentName;
         if (!originalParentName) {
           throw new Error("Enum struct variant type must have a parent name.");
         }
         inlineStruct = true;
-        parentName = pascalCase3(originalParentName) + name;
-        const typeManifest = visit3(enumStructVariantType.struct, self);
+        parentName = pascalCase(originalParentName) + name;
+        const typeManifest = visit(enumStructVariantType.struct, self);
         inlineStruct = false;
         parentName = originalParentName;
         return {
@@ -685,13 +610,13 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
-        const name = pascalCase3(enumTupleVariantType.name);
+        const name = pascalCase(enumTupleVariantType.name);
         const originalParentName = parentName;
         if (!originalParentName) {
           throw new Error("Enum struct variant type must have a parent name.");
         }
-        parentName = pascalCase3(originalParentName) + name;
-        const childManifest = visit3(enumTupleVariantType.tuple, self);
+        parentName = pascalCase(originalParentName) + name;
+        const childManifest = visit(enumTupleVariantType.tuple, self);
         parentName = originalParentName;
         let derive = "";
         if (parentNode && childManifest.type === "(Pubkey)") {
@@ -717,25 +642,25 @@ function getTypeManifestVisitor(options) {
         if (!originalParentName) {
           throw new Error("Enum type must have a parent name.");
         }
-        const variants = enumType.variants.map((variant) => visit3(variant, self));
+        const variants = enumType.variants.map((variant) => visit(variant, self));
         const variantNames = variants.map((variant) => variant.type).join("\n");
         const mergedManifest = mergeManifests(variants);
         return {
           ...mergedManifest,
-          type: `pub enum ${pascalCase3(originalParentName)} {
+          type: `pub enum ${pascalCase(originalParentName)} {
 ${variantNames}
 }`
         };
       },
       visitFixedSizeType(fixedSizeType, { self }) {
         parentSize = fixedSizeType.size;
-        const manifest = visit3(fixedSizeType.type, self);
+        const manifest = visit(fixedSizeType.type, self);
         parentSize = null;
         return manifest;
       },
       visitMapType(mapType, { self }) {
-        const key = visit3(mapType.key, self);
-        const value = visit3(mapType.value, self);
+        const key = visit(mapType.key, self);
+        const value = visit(mapType.value, self);
         const mergedManifest = mergeManifests([key, value]);
         mergedManifest.imports.add("std::collections::HashMap");
         return {
@@ -761,7 +686,7 @@ ${variantNames}
         };
       },
       visitOptionType(optionType, { self }) {
-        const childManifest = visit3(optionType.item, self);
+        const childManifest = visit(optionType.item, self);
         const optionPrefix = resolveNestedTypeNode(optionType.prefix);
         if (optionPrefix.format === "u8" && optionPrefix.endian === "le") {
           return {
@@ -779,10 +704,10 @@ ${variantNames}
         };
       },
       visitRemainderOptionType(node) {
-        throw new CodamaError2(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
+        throw new CodamaError(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
       },
       visitSetType(setType, { self }) {
-        const childManifest = visit3(setType.item, self);
+        const childManifest = visit(setType.item, self);
         childManifest.imports.add("std::collections::HashSet");
         return {
           ...childManifest,
@@ -791,7 +716,7 @@ ${variantNames}
       },
       visitSizePrefixType(sizePrefixType, { self }) {
         parentSize = resolveNestedTypeNode(sizePrefixType.prefix);
-        const manifest = visit3(sizePrefixType.type, self);
+        const manifest = visit(sizePrefixType.type, self);
         parentSize = null;
         return manifest;
       },
@@ -810,7 +735,7 @@ ${variantNames}
             type: `[u8; ${parentSize}]`
           };
         }
-        if (isNode4(parentSize, "numberTypeNode") && parentSize.endian === "le") {
+        if (isNode(parentSize, "numberTypeNode") && parentSize.endian === "le") {
           switch (parentSize.format) {
             case "u32":
               return {
@@ -841,14 +766,14 @@ ${variantNames}
         if (!originalParentName) {
           throw new Error("Struct field type must have a parent name.");
         }
-        parentName = pascalCase3(originalParentName) + pascalCase3(structFieldType.name);
+        parentName = pascalCase(originalParentName) + pascalCase(structFieldType.name);
         nestedStruct = true;
         inlineStruct = false;
-        const fieldManifest = visit3(structFieldType.type, self);
+        const fieldManifest = visit(structFieldType.type, self);
         parentName = originalParentName;
         inlineStruct = originalInlineStruct;
         nestedStruct = originalNestedStruct;
-        const fieldName = snakeCase3(structFieldType.name);
+        const fieldName = snakeCase(structFieldType.name);
         const docblock = rustDocblock(parseDocs(structFieldType.docs));
         const resolvedNestedType = resolveNestedTypeNode(structFieldType.type);
         let derive = "";
@@ -865,9 +790,9 @@ ${variantNames}
               parentNode,
               traitOptions
             );
-          } else if (isNode4(resolvedNestedType, "arrayTypeNode") && isNode4(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
+          } else if (isNode(resolvedNestedType, "arrayTypeNode") && isNode(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
             derive = getSerdeFieldAttribute("serde_big_array::BigArray", parentNode, traitOptions);
-          } else if (isNode4(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && isNode4(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
+          } else if (isNode(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && isNode(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
             derive = getSerdeFieldAttribute(
               "serde_with::As::<serde_with::Bytes>",
               parentNode,
@@ -885,7 +810,7 @@ ${variantNames}
         if (!originalParentName) {
           throw new Error("Struct type must have a parent name.");
         }
-        const fields = structType.fields.map((field) => visit3(field, self));
+        const fields = structType.fields.map((field) => visit(field, self));
         const fieldTypes = fields.map((field) => field.type).join("\n");
         const mergedManifest = mergeManifests(fields);
         if (nestedStruct) {
@@ -897,11 +822,11 @@ ${variantNames}
             ...mergedManifest,
             nestedStructs: [
               ...mergedManifest.nestedStructs,
-              `${nestedTraits.render}pub struct ${pascalCase3(originalParentName)} {
+              `${nestedTraits.render}pub struct ${pascalCase(originalParentName)} {
 ${fieldTypes}
 }`
             ],
-            type: pascalCase3(originalParentName)
+            type: pascalCase(originalParentName)
           };
         }
         if (inlineStruct) {
@@ -911,13 +836,13 @@ ${fieldTypes}
         }
         return {
           ...mergedManifest,
-          type: `pub struct ${pascalCase3(originalParentName)} {
+          type: `pub struct ${pascalCase(originalParentName)} {
 ${fieldTypes}
 }`
         };
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => visit3(item, self));
+        const items = tupleType.items.map((item) => visit(item, self));
         const mergedManifest = mergeManifests(items);
         return {
           ...mergedManifest,
@@ -925,7 +850,7 @@ ${fieldTypes}
         };
       },
       visitZeroableOptionType(node) {
-        throw new CodamaError2(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
+        throw new CodamaError(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
       }
     })
   );
@@ -952,14 +877,14 @@ function getRenderMapVisitor(options = {}) {
     traitOptions: options.traitOptions
   });
   const anchorTraits = options.anchorTraits ?? true;
-  return pipe2(
+  return pipe(
     staticVisitor(() => createRenderMap(), {
       keys: ["rootNode", "programNode", "instructionNode", "accountNode", "definedTypeNode"]
     }),
-    (v) => extendVisitor2(v, {
+    (v) => extendVisitor(v, {
       visitAccount(node) {
-        const typeManifest = visit4(node, typeManifestVisitor);
-        const fields = resolveNestedTypeNode2(node.data).fields;
+        const typeManifest = visit(node, typeManifestVisitor);
+        const fields = resolveNestedTypeNode(node.data).fields;
         const discriminatorConstants = getDiscriminatorConstants({
           discriminatorNodes: node.discriminators ?? [],
           fields,
@@ -971,54 +896,52 @@ function getRenderMapVisitor(options = {}) {
         const pda = node.pda ? linkables.get([...stack.getPath(), node.pda]) : void 0;
         const pdaSeeds = pda?.seeds ?? [];
         const seeds = pdaSeeds.map((seed) => {
-          if (isNode5(seed, "variablePdaSeedNode")) {
-            const seedManifest2 = visit4(seed.type, typeManifestVisitor);
+          if (isNode(seed, "variablePdaSeedNode")) {
+            const seedManifest2 = visit(seed.type, typeManifestVisitor);
             seedsImports.mergeWith(seedManifest2.imports);
-            const resolvedType2 = resolveNestedTypeNode2(seed.type);
+            const resolvedType2 = resolveNestedTypeNode(seed.type);
             return { ...seed, resolvedType: resolvedType2, typeManifest: seedManifest2 };
           }
-          if (isNode5(seed.value, "programIdValueNode")) {
+          if (isNode(seed.value, "programIdValueNode")) {
             return seed;
           }
-          const seedManifest = visit4(seed.type, typeManifestVisitor);
+          const seedManifest = visit(seed.type, typeManifestVisitor);
           const valueManifest = renderValueNode(seed.value, getImportFrom, true);
           seedsImports.mergeWith(valueManifest.imports);
-          const resolvedType = resolveNestedTypeNode2(seed.type);
+          const resolvedType = resolveNestedTypeNode(seed.type);
           return { ...seed, resolvedType, typeManifest: seedManifest, valueManifest };
         });
-        const hasVariableSeeds = pdaSeeds.filter(isNodeFilter2("variablePdaSeedNode")).length > 0;
-        const constantSeeds = seeds.filter(isNodeFilter2("constantPdaSeedNode")).filter((seed) => !isNode5(seed.value, "programIdValueNode"));
+        const hasVariableSeeds = pdaSeeds.filter(isNodeFilter("variablePdaSeedNode")).length > 0;
+        const constantSeeds = seeds.filter(isNodeFilter("constantPdaSeedNode")).filter((seed) => !isNode(seed.value, "programIdValueNode"));
         const { imports } = typeManifest;
         if (hasVariableSeeds) {
           imports.mergeWith(seedsImports);
         }
-        return createRenderMap(
-          `accounts/${snakeCase4(node.name)}.rs`,
-          render("accountsPage.njk", {
+        return createRenderMap(`accounts/${snakeCase(node.name)}.rs`, {
+          content: render("accountsPage.njk", {
             account: node,
             anchorTraits,
             constantSeeds,
             discriminatorConstants: discriminatorConstants.render,
             hasVariableSeeds,
-            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedAccounts::${pascalCase4(node.name)}`).toString(dependencyMap),
+            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedAccounts::${pascalCase(node.name)}`).toString(dependencyMap),
             pda,
             program,
             seeds,
             typeManifest
           })
-        );
+        });
       },
       visitDefinedType(node) {
-        const typeManifest = visit4(node, typeManifestVisitor);
+        const typeManifest = visit(node, typeManifestVisitor);
         const imports = new ImportMap().mergeWithManifest(typeManifest);
-        return createRenderMap(
-          `types/${snakeCase4(node.name)}.rs`,
-          render("definedTypesPage.njk", {
+        return createRenderMap(`types/${snakeCase(node.name)}.rs`, {
+          content: render("definedTypesPage.njk", {
             definedType: node,
-            imports: imports.remove(`generatedTypes::${pascalCase4(node.name)}`).toString(dependencyMap),
+            imports: imports.remove(`generatedTypes::${pascalCase(node.name)}`).toString(dependencyMap),
             typeManifest
           })
-        );
+        });
       },
       visitInstruction(node) {
         const imports = new ImportMap();
@@ -1043,12 +966,12 @@ function getRenderMapVisitor(options = {}) {
             getImportFrom,
             getTraitsFromNode: getTraitsFromNode2,
             nestedStruct: true,
-            parentName: `${pascalCase4(node.name)}InstructionData`
+            parentName: `${pascalCase(node.name)}InstructionData`
           });
-          const manifest = visit4(argument.type, argumentVisitor);
+          const manifest = visit(argument.type, argumentVisitor);
           imports.mergeWith(manifest.imports);
-          const innerOptionType = isNode5(argument.type, "optionTypeNode") ? manifest.type.slice("Option<".length, -1) : null;
-          const hasDefaultValue = !!argument.defaultValue && isNode5(argument.defaultValue, VALUE_NODES2);
+          const innerOptionType = isNode(argument.type, "optionTypeNode") ? manifest.type.slice("Option<".length, -1) : null;
+          const hasDefaultValue = !!argument.defaultValue && isNode(argument.defaultValue, VALUE_NODES);
           let renderValue = null;
           if (hasDefaultValue) {
             const { imports: argImports, render: value } = renderValueNode(
@@ -1074,45 +997,42 @@ function getRenderMapVisitor(options = {}) {
         const structVisitor = getTypeManifestVisitor({
           getImportFrom,
           getTraitsFromNode: getTraitsFromNode2,
-          parentName: `${pascalCase4(node.name)}InstructionData`
+          parentName: `${pascalCase(node.name)}InstructionData`
         });
-        const typeManifest = visit4(struct, structVisitor);
+        const typeManifest = visit(struct, structVisitor);
         const dataTraits = getTraitsFromNode2(node);
         imports.mergeWith(dataTraits.imports);
-        return createRenderMap(
-          `instructions/${snakeCase4(node.name)}.rs`,
-          render("instructionsPage.njk", {
+        return createRenderMap(`instructions/${snakeCase(node.name)}.rs`, {
+          content: render("instructionsPage.njk", {
             dataTraits: dataTraits.render,
             discriminatorConstants: discriminatorConstants.render,
             hasArgs,
             hasOptional,
-            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedInstructions::${pascalCase4(node.name)}`).toString(dependencyMap),
+            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedInstructions::${pascalCase(node.name)}`).toString(dependencyMap),
             instruction: node,
             instructionArgs,
             program,
             typeManifest
           })
-        );
+        });
       },
       visitProgram(node, { self }) {
         program = node;
         let renders = mergeRenderMaps([
-          ...node.accounts.map((account) => visit4(account, self)),
-          ...node.definedTypes.map((type) => visit4(type, self)),
+          ...node.accounts.map((account) => visit(account, self)),
+          ...node.definedTypes.map((type) => visit(type, self)),
           ...getAllInstructionsWithSubs(node, {
             leavesOnly: !renderParentInstructions
-          }).map((ix) => visit4(ix, self))
+          }).map((ix) => visit(ix, self))
         ]);
         if (node.errors.length > 0) {
-          renders = addToRenderMap(
-            renders,
-            `errors/${snakeCase4(node.name)}.rs`,
-            render("errorsPage.njk", {
+          renders = addToRenderMap(renders, `errors/${snakeCase(node.name)}.rs`, {
+            content: render("errorsPage.njk", {
               errors: node.errors,
               imports: new ImportMap().toString(dependencyMap),
               program: node
             })
-          );
+          });
         }
         program = null;
         return renders;
@@ -1135,15 +1055,15 @@ function getRenderMapVisitor(options = {}) {
         };
         return mergeRenderMaps([
           createRenderMap({
-            ["accounts/mod.rs"]: accountsToExport.length > 0 ? render("accountsMod.njk", ctx) : void 0,
-            ["errors/mod.rs"]: programsToExport.length > 0 ? render("errorsMod.njk", ctx) : void 0,
-            ["instructions/mod.rs"]: instructionsToExport.length > 0 ? render("instructionsMod.njk", ctx) : void 0,
-            ["mod.rs"]: render("rootMod.njk", ctx),
-            ["programs.rs"]: programsToExport.length > 0 ? render("programsMod.njk", ctx) : void 0,
-            ["shared.rs"]: accountsToExport.length > 0 ? render("sharedPage.njk", ctx) : void 0,
-            ["types/mod.rs"]: definedTypesToExport.length > 0 ? render("definedTypesMod.njk", ctx) : void 0
+            ["accounts/mod.rs"]: accountsToExport.length > 0 ? { content: render("accountsMod.njk", ctx) } : void 0,
+            ["errors/mod.rs"]: programsToExport.length > 0 ? { content: render("errorsMod.njk", ctx) } : void 0,
+            ["instructions/mod.rs"]: instructionsToExport.length > 0 ? { content: render("instructionsMod.njk", ctx) } : void 0,
+            ["mod.rs"]: { content: render("rootMod.njk", ctx) },
+            ["programs.rs"]: programsToExport.length > 0 ? { content: render("programsMod.njk", ctx) } : void 0,
+            ["shared.rs"]: accountsToExport.length > 0 ? { content: render("sharedPage.njk", ctx) } : void 0,
+            ["types/mod.rs"]: definedTypesToExport.length > 0 ? { content: render("definedTypesMod.njk", ctx) } : void 0
           }),
-          ...getAllPrograms(node).map((p) => visit4(p, self))
+          ...getAllPrograms(node).map((p) => visit(p, self))
         ]);
       }
     }),
@@ -1159,18 +1079,12 @@ function getConflictsForInstructionAccountsAndArgs(instruction) {
   const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
   return [...new Set(duplicates)];
 }
-
-// src/renderVisitor.ts
-import { logError, logWarn as logWarn2 } from "@codama/errors";
-import { deleteDirectory, writeRenderMapVisitor } from "@codama/renderers-core";
-import { rootNodeVisitor, visit as visit5 } from "@codama/visitors-core";
-import { spawnSync } from "child_process";
 function renderVisitor(path, options = {}) {
   return rootNodeVisitor((root) => {
     if (options.deleteFolderBeforeRendering ?? true) {
       deleteDirectory(path);
     }
-    visit5(root, writeRenderMapVisitor(getRenderMapVisitor(options), path));
+    visit(root, writeRenderMapVisitor(getRenderMapVisitor(options), path));
     if (options.formatCode) {
       if (options.crateFolder) {
         const removeFalsy = (arg) => Boolean(arg);
@@ -1181,7 +1095,7 @@ function renderVisitor(path, options = {}) {
           )
         );
       } else {
-        logWarn2("No crate folder specified, skipping formatting.");
+        logWarn("No crate folder specified, skipping formatting.");
       }
     }
   });
@@ -1189,21 +1103,17 @@ function renderVisitor(path, options = {}) {
 function runFormatter(cmd, args) {
   const { stdout, stderr, error } = spawnSync(cmd, args);
   if (error?.message?.includes("ENOENT")) {
-    logWarn2(`Could not find ${cmd}, skipping formatting.`);
+    logWarn(`Could not find ${cmd}, skipping formatting.`);
     return;
   }
   if (stdout.length > 0) {
-    logWarn2(`(cargo-fmt) ${stdout ? stdout?.toString() : error}`);
+    logWarn(`(cargo-fmt) ${stdout ? stdout?.toString() : error}`);
   }
   if (stderr.length > 0) {
     logError(`(cargo-fmt) ${stderr ? stderr.toString() : error}`);
   }
 }
-export {
-  ImportMap,
-  renderVisitor as default,
-  getRenderMapVisitor,
-  getTypeManifestVisitor,
-  renderVisitor
-};
+
+export { ImportMap, renderVisitor as default, getRenderMapVisitor, getTypeManifestVisitor, renderVisitor };
+//# sourceMappingURL=index.node.mjs.map
 //# sourceMappingURL=index.node.mjs.map