@codama/renderers-rust 1.0.0

package/dist/index.node.mjs

@@ -0,0 +1,900 @@
+import { CodamaError, CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, logWarn, logError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
+import { REGISTERED_TYPE_NODE_KINDS, pascalCase, isNode, resolveNestedTypeNode, remainderCountNode, arrayTypeNode, numberTypeNode, isScalarEnum, snakeCase, isNodeFilter, VALUE_NODES, structTypeNodeFromInstructionArgumentNodes, getAllInstructionsWithSubs, getAllPrograms, getAllAccounts, getAllDefinedTypes, camelCase, kebabCase, titleCase, fixedCountNode, prefixedCountNode, numberValueNode, arrayValueNode, bytesValueNode } from '@codama/nodes';
+import { RenderMap, deleteDirectory, writeRenderMapVisitor } from '@codama/renderers-core';
+import { pipe, mergeVisitor, extendVisitor, visit, LinkableDictionary, staticVisitor, recordLinkablesVisitor, rootNodeVisitor } from '@codama/visitors-core';
+import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder } from '@solana/codecs-strings';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import nunjucks from 'nunjucks';
+import { spawnSync } from 'child_process';
+
+// src/ImportMap.ts
+var DEFAULT_MODULE_MAP = {
+  generated: "crate::generated",
+  generatedAccounts: "crate::generated::accounts",
+  generatedErrors: "crate::generated::errors",
+  generatedInstructions: "crate::generated::instructions",
+  generatedTypes: "crate::generated::types",
+  hooked: "crate::hooked",
+  mplEssentials: "mpl_toolbox",
+  mplToolbox: "mpl_toolbox"
+};
+var ImportMap = class _ImportMap {
+  _imports = /* @__PURE__ */ new Set();
+  _aliases = /* @__PURE__ */ new Map();
+  get imports() {
+    return this._imports;
+  }
+  get aliases() {
+    return this._aliases;
+  }
+  add(imports) {
+    const newImports = typeof imports === "string" ? [imports] : imports;
+    newImports.forEach((i) => this._imports.add(i));
+    return this;
+  }
+  remove(imports) {
+    const importsToRemove = typeof imports === "string" ? [imports] : imports;
+    importsToRemove.forEach((i) => this._imports.delete(i));
+    return this;
+  }
+  mergeWith(...others) {
+    others.forEach((other) => {
+      this.add(other._imports);
+      other._aliases.forEach((alias, importName) => this.addAlias(importName, alias));
+    });
+    return this;
+  }
+  mergeWithManifest(manifest) {
+    return this.mergeWith(manifest.imports);
+  }
+  addAlias(importName, alias) {
+    this._aliases.set(importName, alias);
+    return this;
+  }
+  isEmpty() {
+    return this._imports.size === 0;
+  }
+  resolveDependencyMap(dependencies) {
+    const dependencyMap = { ...DEFAULT_MODULE_MAP, ...dependencies };
+    const newImportMap = new _ImportMap();
+    const resolveDependency = (i) => {
+      const dependencyKey = Object.keys(dependencyMap).find((key) => i.startsWith(`${key}::`));
+      if (!dependencyKey) return i;
+      const dependencyValue = dependencyMap[dependencyKey];
+      return dependencyValue + i.slice(dependencyKey.length);
+    };
+    this._imports.forEach((i) => newImportMap.add(resolveDependency(i)));
+    this._aliases.forEach((alias, i) => newImportMap.addAlias(resolveDependency(i), alias));
+    return newImportMap;
+  }
+  toString(dependencies) {
+    const resolvedMap = this.resolveDependencyMap(dependencies);
+    const importStatements = [...resolvedMap.imports].map((i) => {
+      const alias = resolvedMap.aliases.get(i);
+      if (alias) return `use ${i} as ${alias};`;
+      return `use ${i};`;
+    });
+    return importStatements.join("\n");
+  }
+};
+function getBytesFromBytesValueNode(node) {
+  switch (node.encoding) {
+    case "utf8":
+      return getUtf8Encoder().encode(node.data);
+    case "base16":
+      return getBase16Encoder().encode(node.data);
+    case "base58":
+      return getBase58Encoder().encode(node.data);
+    case "base64":
+    default:
+      return getBase64Encoder().encode(node.data);
+  }
+}
+function getImportFromFactory(overrides) {
+  const linkOverrides = {
+    accounts: overrides.accounts ?? {},
+    definedTypes: overrides.definedTypes ?? {},
+    instructions: overrides.instructions ?? {},
+    pdas: overrides.pdas ?? {},
+    programs: overrides.programs ?? {},
+    resolvers: overrides.resolvers ?? {}
+  };
+  return (node) => {
+    const kind = node.kind;
+    switch (kind) {
+      case "accountLinkNode":
+        return linkOverrides.accounts[node.name] ?? "generatedAccounts";
+      case "definedTypeLinkNode":
+        return linkOverrides.definedTypes[node.name] ?? "generatedTypes";
+      case "instructionLinkNode":
+        return linkOverrides.instructions[node.name] ?? "generatedInstructions";
+      case "pdaLinkNode":
+        return linkOverrides.pdas[node.name] ?? "generatedAccounts";
+      case "programLinkNode":
+        return linkOverrides.programs[node.name] ?? "generatedPrograms";
+      case "resolverValueNode":
+        return linkOverrides.resolvers[node.name] ?? "hooked";
+      default:
+        throw new CodamaError(CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+          expectedKinds: [
+            "AccountLinkNode",
+            "DefinedTypeLinkNode",
+            "InstructionLinkNode",
+            "PdaLinkNode",
+            "ProgramLinkNode",
+            "resolverValueNode"
+          ],
+          kind,
+          node
+        });
+    }
+  };
+}
+function rustDocblock(docs) {
+  if (docs.length <= 0) return "";
+  const lines = docs.map((doc) => `/// ${doc}`);
+  return `${lines.join("\n")}
+`;
+}
+var render = (template, context, options) => {
+  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", pascalCase);
+  env.addFilter("camelCase", camelCase);
+  env.addFilter("snakeCase", snakeCase);
+  env.addFilter("kebabCase", kebabCase);
+  env.addFilter("titleCase", titleCase);
+  env.addFilter("rustDocblock", rustDocblock);
+  return env.render(template, context);
+};
+
+// src/getTypeManifestVisitor.ts
+function getTypeManifestVisitor(options) {
+  const { getImportFrom } = options;
+  let parentName = options.parentName ?? null;
+  let nestedStruct = options.nestedStruct ?? false;
+  let inlineStruct = false;
+  let parentSize = null;
+  return pipe(
+    mergeVisitor(
+      () => ({ imports: new ImportMap(), nestedStructs: [], type: "" }),
+      (_, values) => ({
+        ...mergeManifests(values),
+        type: values.map((v) => v.type).join("\n")
+      }),
+      [...REGISTERED_TYPE_NODE_KINDS, "definedTypeLinkNode", "definedTypeNode", "accountNode"]
+    ),
+    (v) => extendVisitor(v, {
+      visitAccount(account, { self }) {
+        parentName = pascalCase(account.name);
+        const manifest = visit(account.data, self);
+        manifest.imports.add(["borsh::BorshSerialize", "borsh::BorshDeserialize"]);
+        parentName = null;
+        return {
+          ...manifest,
+          type: `#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+${manifest.type}`
+        };
+      },
+      visitArrayType(arrayType, { self }) {
+        const childManifest = visit(arrayType.item, self);
+        if (isNode(arrayType.count, "fixedCountNode")) {
+          return {
+            ...childManifest,
+            type: `[${childManifest.type}; ${arrayType.count.value}]`
+          };
+        }
+        if (isNode(arrayType.count, "remainderCountNode")) {
+          childManifest.imports.add("kaigan::types::RemainderVec");
+          return {
+            ...childManifest,
+            type: `RemainderVec<${childManifest.type}>`
+          };
+        }
+        const prefix = resolveNestedTypeNode(arrayType.count.prefix);
+        if (prefix.endian === "le") {
+          switch (prefix.format) {
+            case "u32":
+              return {
+                ...childManifest,
+                type: `Vec<${childManifest.type}>`
+              };
+            case "u8":
+            case "u16":
+            case "u64": {
+              const prefixFormat = prefix.format.toUpperCase();
+              childManifest.imports.add(`kaigan::types::${prefixFormat}PrefixVec`);
+              return {
+                ...childManifest,
+                type: `${prefixFormat}PrefixVec<${childManifest.type}>`
+              };
+            }
+            case "shortU16": {
+              childManifest.imports.add("solana_program::short_vec::ShortVec");
+              return {
+                ...childManifest,
+                type: `ShortVec<${childManifest.type}>`
+              };
+            }
+            default:
+              throw new Error(`Array prefix not supported: ${prefix.format}`);
+          }
+        }
+        throw new Error("Array size not supported by Borsh");
+      },
+      visitBooleanType(booleanType) {
+        const resolvedSize = resolveNestedTypeNode(booleanType.size);
+        if (resolvedSize.format === "u8" && resolvedSize.endian === "le") {
+          return {
+            imports: new ImportMap(),
+            nestedStructs: [],
+            type: "bool"
+          };
+        }
+        throw new Error("Bool size not supported by Borsh");
+      },
+      visitBytesType(_bytesType, { self }) {
+        let arraySize = remainderCountNode();
+        if (typeof parentSize === "number") {
+          arraySize = fixedCountNode(parentSize);
+        } else if (parentSize && typeof parentSize === "object") {
+          arraySize = prefixedCountNode(parentSize);
+        }
+        const arrayType = arrayTypeNode(numberTypeNode("u8"), arraySize);
+        return visit(arrayType, self);
+      },
+      visitDefinedType(definedType, { self }) {
+        parentName = pascalCase(definedType.name);
+        const manifest = visit(definedType.type, self);
+        parentName = null;
+        const traits = ["BorshSerialize", "BorshDeserialize", "Clone", "Debug", "Eq", "PartialEq"];
+        if (isNode(definedType.type, "enumTypeNode") && isScalarEnum(definedType.type)) {
+          traits.push("Copy", "PartialOrd", "Hash", "FromPrimitive");
+          manifest.imports.add(["num_derive::FromPrimitive"]);
+        }
+        const nestedStructs = manifest.nestedStructs.map(
+          (struct) => `#[derive(${traits.join(", ")})]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+${struct}`
+        );
+        if (!isNode(definedType.type, ["enumTypeNode", "structTypeNode"])) {
+          if (nestedStructs.length > 0) {
+            manifest.imports.add(["borsh::BorshSerialize", "borsh::BorshDeserialize"]);
+          }
+          return {
+            ...manifest,
+            nestedStructs,
+            type: `pub type ${pascalCase(definedType.name)} = ${manifest.type}`
+          };
+        }
+        manifest.imports.add(["borsh::BorshSerialize", "borsh::BorshDeserialize"]);
+        return {
+          ...manifest,
+          nestedStructs,
+          type: `#[derive(${traits.join(", ")})]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+${manifest.type}`
+        };
+      },
+      visitDefinedTypeLink(node) {
+        const pascalCaseDefinedType = pascalCase(node.name);
+        const importFrom = getImportFrom(node);
+        return {
+          imports: new ImportMap().add(`${importFrom}::${pascalCaseDefinedType}`),
+          nestedStructs: [],
+          type: pascalCaseDefinedType
+        };
+      },
+      visitEnumEmptyVariantType(enumEmptyVariantType) {
+        const name = pascalCase(enumEmptyVariantType.name);
+        return {
+          imports: new ImportMap(),
+          nestedStructs: [],
+          type: `${name},`
+        };
+      },
+      visitEnumStructVariantType(enumStructVariantType, { self }) {
+        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 = pascalCase(originalParentName) + name;
+        const typeManifest = visit(enumStructVariantType.struct, self);
+        inlineStruct = false;
+        parentName = originalParentName;
+        return {
+          ...typeManifest,
+          type: `${name} ${typeManifest.type},`
+        };
+      },
+      visitEnumTupleVariantType(enumTupleVariantType, { self }) {
+        const name = pascalCase(enumTupleVariantType.name);
+        const originalParentName = parentName;
+        if (!originalParentName) {
+          throw new Error("Enum struct variant type must have a parent name.");
+        }
+        parentName = pascalCase(originalParentName) + name;
+        const childManifest = visit(enumTupleVariantType.tuple, self);
+        parentName = originalParentName;
+        let derive = "";
+        if (childManifest.type === "(Pubkey)") {
+          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]\n';
+        } else if (childManifest.type === "(Vec<Pubkey>)") {
+          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<Vec<serde_with::DisplayFromStr>>"))]\n';
+        }
+        return {
+          ...childManifest,
+          type: `${derive}${name}${childManifest.type},`
+        };
+      },
+      visitEnumType(enumType, { self }) {
+        const originalParentName = parentName;
+        if (!originalParentName) {
+          throw new Error("Enum type must have a parent name.");
+        }
+        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 ${pascalCase(originalParentName)} {
+${variantNames}
+}`
+        };
+      },
+      visitFixedSizeType(fixedSizeType, { self }) {
+        parentSize = fixedSizeType.size;
+        const manifest = visit(fixedSizeType.type, self);
+        parentSize = null;
+        return manifest;
+      },
+      visitMapType(mapType, { 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 {
+          ...mergedManifest,
+          type: `HashMap<${key.type}, ${value.type}>`
+        };
+      },
+      visitNumberType(numberType) {
+        if (numberType.endian !== "le") {
+          throw new Error("Number endianness not supported by Borsh");
+        }
+        if (numberType.format === "shortU16") {
+          return {
+            imports: new ImportMap().add("solana_program::short_vec::ShortU16"),
+            nestedStructs: [],
+            type: "ShortU16"
+          };
+        }
+        return {
+          imports: new ImportMap(),
+          nestedStructs: [],
+          type: numberType.format
+        };
+      },
+      visitOptionType(optionType, { self }) {
+        const childManifest = visit(optionType.item, self);
+        const optionPrefix = resolveNestedTypeNode(optionType.prefix);
+        if (optionPrefix.format === "u8" && optionPrefix.endian === "le") {
+          return {
+            ...childManifest,
+            type: `Option<${childManifest.type}>`
+          };
+        }
+        throw new Error("Option size not supported by Borsh");
+      },
+      visitPublicKeyType() {
+        return {
+          imports: new ImportMap().add("solana_program::pubkey::Pubkey"),
+          nestedStructs: [],
+          type: "Pubkey"
+        };
+      },
+      visitRemainderOptionType(node) {
+        throw new CodamaError(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
+      },
+      visitSetType(setType, { self }) {
+        const childManifest = visit(setType.item, self);
+        childManifest.imports.add("std::collections::HashSet");
+        return {
+          ...childManifest,
+          type: `HashSet<${childManifest.type}>`
+        };
+      },
+      visitSizePrefixType(sizePrefixType, { self }) {
+        parentSize = resolveNestedTypeNode(sizePrefixType.prefix);
+        const manifest = visit(sizePrefixType.type, self);
+        parentSize = null;
+        return manifest;
+      },
+      visitStringType() {
+        if (!parentSize) {
+          return {
+            imports: new ImportMap().add(`kaigan::types::RemainderStr`),
+            nestedStructs: [],
+            type: `RemainderStr`
+          };
+        }
+        if (typeof parentSize === "number") {
+          return {
+            imports: new ImportMap(),
+            nestedStructs: [],
+            type: `[u8; ${parentSize}]`
+          };
+        }
+        if (isNode(parentSize, "numberTypeNode") && parentSize.endian === "le") {
+          switch (parentSize.format) {
+            case "u32":
+              return {
+                imports: new ImportMap(),
+                nestedStructs: [],
+                type: "String"
+              };
+            case "u8":
+            case "u16":
+            case "u64": {
+              const prefix = parentSize.format.toUpperCase();
+              return {
+                imports: new ImportMap().add(`kaigan::types::${prefix}PrefixString`),
+                nestedStructs: [],
+                type: `${prefix}PrefixString`
+              };
+            }
+            default:
+              throw new Error(`'String size not supported: ${parentSize.format}`);
+          }
+        }
+        throw new Error("String size not supported by Borsh");
+      },
+      visitStructFieldType(structFieldType, { self }) {
+        const originalParentName = parentName;
+        const originalInlineStruct = inlineStruct;
+        const originalNestedStruct = nestedStruct;
+        if (!originalParentName) {
+          throw new Error("Struct field type must have a parent name.");
+        }
+        parentName = pascalCase(originalParentName) + pascalCase(structFieldType.name);
+        nestedStruct = true;
+        inlineStruct = false;
+        const fieldManifest = visit(structFieldType.type, self);
+        parentName = originalParentName;
+        inlineStruct = originalInlineStruct;
+        nestedStruct = originalNestedStruct;
+        const fieldName = snakeCase(structFieldType.name);
+        const docblock = rustDocblock(structFieldType.docs);
+        const resolvedNestedType = resolveNestedTypeNode(structFieldType.type);
+        let derive = "";
+        if (fieldManifest.type === "Pubkey") {
+          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]\n';
+        } else if (fieldManifest.type === "Vec<Pubkey>") {
+          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<Vec<serde_with::DisplayFromStr>>"))]\n';
+        } else if (isNode(resolvedNestedType, "arrayTypeNode") && isNode(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32 || isNode(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && isNode(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
+          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::Bytes>"))]\n';
+        }
+        return {
+          ...fieldManifest,
+          type: inlineStruct ? `${docblock}${derive}${fieldName}: ${fieldManifest.type},` : `${docblock}${derive}pub ${fieldName}: ${fieldManifest.type},`
+        };
+      },
+      visitStructType(structType, { self }) {
+        const originalParentName = parentName;
+        if (!originalParentName) {
+          throw new Error("Struct type must have a parent name.");
+        }
+        const fields = structType.fields.map((field) => visit(field, self));
+        const fieldTypes = fields.map((field) => field.type).join("\n");
+        const mergedManifest = mergeManifests(fields);
+        if (nestedStruct) {
+          return {
+            ...mergedManifest,
+            nestedStructs: [
+              ...mergedManifest.nestedStructs,
+              `pub struct ${pascalCase(originalParentName)} {
+${fieldTypes}
+}`
+            ],
+            type: pascalCase(originalParentName)
+          };
+        }
+        if (inlineStruct) {
+          return { ...mergedManifest, type: `{
+${fieldTypes}
+}` };
+        }
+        return {
+          ...mergedManifest,
+          type: `pub struct ${pascalCase(originalParentName)} {
+${fieldTypes}
+}`
+        };
+      },
+      visitTupleType(tupleType, { self }) {
+        const items = tupleType.items.map((item) => visit(item, self));
+        const mergedManifest = mergeManifests(items);
+        return {
+          ...mergedManifest,
+          type: `(${items.map((item) => item.type).join(", ")})`
+        };
+      },
+      visitZeroableOptionType(node) {
+        throw new CodamaError(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
+      }
+    })
+  );
+}
+function mergeManifests(manifests) {
+  return {
+    imports: new ImportMap().mergeWith(...manifests.map((td) => td.imports)),
+    nestedStructs: manifests.flatMap((m) => m.nestedStructs)
+  };
+}
+function renderValueNode(value, getImportFrom, useStr = false) {
+  return visit(value, renderValueNodeVisitor(getImportFrom, useStr));
+}
+function renderValueNodeVisitor(getImportFrom, useStr = false) {
+  return {
+    visitArrayValue(node) {
+      const list = node.items.map((v) => visit(v, this));
+      return {
+        imports: new ImportMap().mergeWith(...list.map((c) => c.imports)),
+        render: `[${list.map((c) => c.render).join(", ")}]`
+      };
+    },
+    visitBooleanValue(node) {
+      return {
+        imports: new ImportMap(),
+        render: JSON.stringify(node.boolean)
+      };
+    },
+    visitBytesValue(node) {
+      const bytes = getBytesFromBytesValueNode(node);
+      const numbers = Array.from(bytes).map(numberValueNode);
+      return visit(arrayValueNode(numbers), this);
+    },
+    visitConstantValue(node) {
+      if (isNode(node.value, "bytesValueNode")) {
+        return visit(node.value, this);
+      }
+      if (isNode(node.type, "stringTypeNode") && isNode(node.value, "stringValueNode")) {
+        return visit(bytesValueNode(node.type.encoding, node.value.string), this);
+      }
+      if (isNode(node.type, "numberTypeNode") && isNode(node.value, "numberValueNode")) {
+        const numberManifest = visit(node.value, this);
+        const { format, endian } = node.type;
+        const byteFunction = endian === "le" ? "to_le_bytes" : "to_be_bytes";
+        numberManifest.render = `${numberManifest.render}${format}.${byteFunction}()`;
+        return numberManifest;
+      }
+      throw new Error("Unsupported constant value type.");
+    },
+    visitEnumValue(node) {
+      const imports = new ImportMap();
+      const enumName = pascalCase(node.enum.name);
+      const variantName = pascalCase(node.variant);
+      const importFrom = getImportFrom(node.enum);
+      imports.add(`${importFrom}::${enumName}`);
+      if (!node.value) {
+        return { imports, render: `${enumName}::${variantName}` };
+      }
+      const enumValue = visit(node.value, this);
+      const fields = enumValue.render;
+      return {
+        imports: imports.mergeWith(enumValue.imports),
+        render: `${enumName}::${variantName} ${fields}`
+      };
+    },
+    visitMapEntryValue(node) {
+      const mapKey = visit(node.key, this);
+      const mapValue = visit(node.value, this);
+      return {
+        imports: mapKey.imports.mergeWith(mapValue.imports),
+        render: `[${mapKey.render}, ${mapValue.render}]`
+      };
+    },
+    visitMapValue(node) {
+      const map = node.entries.map((entry) => visit(entry, this));
+      const imports = new ImportMap().add("std::collection::HashMap");
+      return {
+        imports: imports.mergeWith(...map.map((c) => c.imports)),
+        render: `HashMap::from([${map.map((c) => c.render).join(", ")}])`
+      };
+    },
+    visitNoneValue() {
+      return {
+        imports: new ImportMap(),
+        render: "None"
+      };
+    },
+    visitNumberValue(node) {
+      return {
+        imports: new ImportMap(),
+        render: node.number.toString()
+      };
+    },
+    visitPublicKeyValue(node) {
+      return {
+        imports: new ImportMap().add("solana_program::pubkey"),
+        render: `pubkey!("${node.publicKey}")`
+      };
+    },
+    visitSetValue(node) {
+      const set = node.items.map((v) => visit(v, this));
+      const imports = new ImportMap().add("std::collection::HashSet");
+      return {
+        imports: imports.mergeWith(...set.map((c) => c.imports)),
+        render: `HashSet::from([${set.map((c) => c.render).join(", ")}])`
+      };
+    },
+    visitSomeValue(node) {
+      const child = visit(node.value, this);
+      return {
+        ...child,
+        render: `Some(${child.render})`
+      };
+    },
+    visitStringValue(node) {
+      return {
+        imports: new ImportMap(),
+        render: useStr ? `${JSON.stringify(node.string)}` : `String::from(${JSON.stringify(node.string)})`
+      };
+    },
+    visitStructFieldValue(node) {
+      const structValue = visit(node.value, this);
+      return {
+        imports: structValue.imports,
+        render: `${node.name}: ${structValue.render}`
+      };
+    },
+    visitStructValue(node) {
+      const struct = node.fields.map((field) => visit(field, this));
+      return {
+        imports: new ImportMap().mergeWith(...struct.map((c) => c.imports)),
+        render: `{ ${struct.map((c) => c.render).join(", ")} }`
+      };
+    },
+    visitTupleValue(node) {
+      const tuple = node.items.map((v) => visit(v, this));
+      return {
+        imports: new ImportMap().mergeWith(...tuple.map((c) => c.imports)),
+        render: `(${tuple.map((c) => c.render).join(", ")})`
+      };
+    }
+  };
+}
+
+// src/getRenderMapVisitor.ts
+function getRenderMapVisitor(options = {}) {
+  const linkables = new LinkableDictionary();
+  let program = null;
+  const renderParentInstructions = options.renderParentInstructions ?? false;
+  const dependencyMap = options.dependencyMap ?? {};
+  const getImportFrom = getImportFromFactory(options.linkOverrides ?? {});
+  const typeManifestVisitor = getTypeManifestVisitor({ getImportFrom });
+  return pipe(
+    staticVisitor(
+      () => new RenderMap(),
+      ["rootNode", "programNode", "instructionNode", "accountNode", "definedTypeNode"]
+    ),
+    (v) => extendVisitor(v, {
+      visitAccount(node) {
+        const typeManifest = visit(node, typeManifestVisitor);
+        const seedsImports = new ImportMap();
+        const pda = node.pda ? linkables.get(node.pda) : void 0;
+        const pdaSeeds = pda?.seeds ?? [];
+        const seeds = pdaSeeds.map((seed) => {
+          if (isNode(seed, "variablePdaSeedNode")) {
+            const seedManifest2 = visit(seed.type, typeManifestVisitor);
+            seedsImports.mergeWith(seedManifest2.imports);
+            const resolvedType2 = resolveNestedTypeNode(seed.type);
+            return { ...seed, resolvedType: resolvedType2, typeManifest: seedManifest2 };
+          }
+          if (isNode(seed.value, "programIdValueNode")) {
+            return seed;
+          }
+          const seedManifest = visit(seed.type, typeManifestVisitor);
+          const valueManifest = renderValueNode(seed.value, getImportFrom, true);
+          seedsImports.mergeWith(valueManifest.imports);
+          const resolvedType = resolveNestedTypeNode(seed.type);
+          return { ...seed, resolvedType, typeManifest: seedManifest, valueManifest };
+        });
+        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 new RenderMap().add(
+          `accounts/${snakeCase(node.name)}.rs`,
+          render("accountsPage.njk", {
+            account: node,
+            constantSeeds,
+            hasVariableSeeds,
+            imports: imports.remove(`generatedAccounts::${pascalCase(node.name)}`).toString(dependencyMap),
+            pda,
+            program,
+            seeds,
+            typeManifest
+          })
+        );
+      },
+      visitDefinedType(node) {
+        const typeManifest = visit(node, typeManifestVisitor);
+        const imports = new ImportMap().mergeWithManifest(typeManifest);
+        return new RenderMap().add(
+          `types/${snakeCase(node.name)}.rs`,
+          render("definedTypesPage.njk", {
+            definedType: node,
+            imports: imports.remove(`generatedTypes::${pascalCase(node.name)}`).toString(dependencyMap),
+            typeManifest
+          })
+        );
+      },
+      visitInstruction(node) {
+        const imports = new ImportMap();
+        imports.add(["borsh::BorshDeserialize", "borsh::BorshSerialize"]);
+        const accountsAndArgsConflicts = getConflictsForInstructionAccountsAndArgs(node);
+        if (accountsAndArgsConflicts.length > 0) {
+          logWarn(
+            `[Rust] Accounts and args of instruction [${node.name}] have the following conflicting attributes [${accountsAndArgsConflicts.join(", ")}]. Thus, the conflicting arguments will be suffixed with "_arg". You may want to rename the conflicting attributes.`
+          );
+        }
+        const instructionArgs = [];
+        let hasArgs = false;
+        let hasOptional = false;
+        node.arguments.forEach((argument) => {
+          const argumentVisitor = getTypeManifestVisitor({
+            getImportFrom,
+            nestedStruct: true,
+            parentName: `${pascalCase(node.name)}InstructionData`
+          });
+          const manifest = visit(argument.type, argumentVisitor);
+          imports.mergeWith(manifest.imports);
+          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(
+              argument.defaultValue,
+              getImportFrom
+            );
+            imports.mergeWith(argImports);
+            renderValue = value;
+          }
+          hasArgs = hasArgs || argument.defaultValueStrategy !== "omitted";
+          hasOptional = hasOptional || hasDefaultValue && argument.defaultValueStrategy !== "omitted";
+          const name = accountsAndArgsConflicts.includes(argument.name) ? `${argument.name}_arg` : argument.name;
+          instructionArgs.push({
+            default: hasDefaultValue && argument.defaultValueStrategy === "omitted",
+            innerOptionType,
+            name,
+            optional: hasDefaultValue && argument.defaultValueStrategy !== "omitted",
+            type: manifest.type,
+            value: renderValue
+          });
+        });
+        const struct = structTypeNodeFromInstructionArgumentNodes(node.arguments);
+        const structVisitor = getTypeManifestVisitor({
+          getImportFrom,
+          parentName: `${pascalCase(node.name)}InstructionData`
+        });
+        const typeManifest = visit(struct, structVisitor);
+        return new RenderMap().add(
+          `instructions/${snakeCase(node.name)}.rs`,
+          render("instructionsPage.njk", {
+            hasArgs,
+            hasOptional,
+            imports: imports.remove(`generatedInstructions::${pascalCase(node.name)}`).toString(dependencyMap),
+            instruction: node,
+            instructionArgs,
+            program,
+            typeManifest
+          })
+        );
+      },
+      visitProgram(node, { self }) {
+        program = node;
+        const renderMap = new RenderMap().mergeWith(...node.accounts.map((account) => visit(account, self))).mergeWith(...node.definedTypes.map((type) => visit(type, self))).mergeWith(
+          ...getAllInstructionsWithSubs(node, {
+            leavesOnly: !renderParentInstructions
+          }).map((ix) => visit(ix, self))
+        );
+        if (node.errors.length > 0) {
+          renderMap.add(
+            `errors/${snakeCase(node.name)}.rs`,
+            render("errorsPage.njk", {
+              errors: node.errors,
+              imports: new ImportMap().toString(dependencyMap),
+              program: node
+            })
+          );
+        }
+        program = null;
+        return renderMap;
+      },
+      visitRoot(node, { self }) {
+        const programsToExport = getAllPrograms(node);
+        const accountsToExport = getAllAccounts(node);
+        const instructionsToExport = getAllInstructionsWithSubs(node, {
+          leavesOnly: !renderParentInstructions
+        });
+        const definedTypesToExport = getAllDefinedTypes(node);
+        const hasAnythingToExport = programsToExport.length > 0 || accountsToExport.length > 0 || instructionsToExport.length > 0 || definedTypesToExport.length > 0;
+        const ctx = {
+          accountsToExport,
+          definedTypesToExport,
+          hasAnythingToExport,
+          instructionsToExport,
+          programsToExport,
+          root: node
+        };
+        const map = new RenderMap();
+        if (programsToExport.length > 0) {
+          map.add("programs.rs", render("programsMod.njk", ctx)).add(
+            "errors/mod.rs",
+            render("errorsMod.njk", ctx)
+          );
+        }
+        if (accountsToExport.length > 0) {
+          map.add("accounts/mod.rs", render("accountsMod.njk", ctx));
+        }
+        if (instructionsToExport.length > 0) {
+          map.add("instructions/mod.rs", render("instructionsMod.njk", ctx));
+        }
+        if (definedTypesToExport.length > 0) {
+          map.add("types/mod.rs", render("definedTypesMod.njk", ctx));
+        }
+        return map.add("mod.rs", render("rootMod.njk", ctx)).mergeWith(...getAllPrograms(node).map((p) => visit(p, self)));
+      }
+    }),
+    (v) => recordLinkablesVisitor(v, linkables)
+  );
+}
+function getConflictsForInstructionAccountsAndArgs(instruction) {
+  const allNames = [
+    ...instruction.accounts.map((account) => account.name),
+    ...instruction.arguments.map((argument) => argument.name)
+  ];
+  const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
+  return [...new Set(duplicates)];
+}
+function renderVisitor(path, options = {}) {
+  return rootNodeVisitor((root) => {
+    if (options.deleteFolderBeforeRendering ?? true) {
+      deleteDirectory(path);
+    }
+    visit(root, writeRenderMapVisitor(getRenderMapVisitor(options), path));
+    if (options.formatCode) {
+      if (options.crateFolder) {
+        const toolchain = options.toolchain ?? "+stable";
+        runFormatter("cargo", [toolchain, "fmt", "--manifest-path", `${options.crateFolder}/Cargo.toml`]);
+      } else {
+        logWarn("No crate folder specified, skipping formatting.");
+      }
+    }
+  });
+}
+function runFormatter(cmd, args) {
+  const { stdout, stderr, error } = spawnSync(cmd, args);
+  if (error?.message?.includes("ENOENT")) {
+    logWarn(`Could not find ${cmd}, skipping formatting.`);
+    return;
+  }
+  if (stdout.length > 0) {
+    logWarn(`(cargo-fmt) ${stdout || error}`);
+  }
+  if (stderr.length > 0) {
+    logError(`(cargo-fmt) ${stderr || error}`);
+  }
+}
+
+export { ImportMap, getRenderMapVisitor, getTypeManifestVisitor, renderVisitor };
+//# sourceMappingURL=index.node.mjs.map
+//# sourceMappingURL=index.node.mjs.map