codama-renderers-dart 0.2.0

package/src/fragments/errorPage.ts

@@ -0,0 +1,82 @@
+import type { ErrorNode, ProgramNode } from "@codama/nodes";
+
+import type { Fragment } from "../utils/fragment.js";
+import {
+  emptyFragment,
+  fragment,
+  fragmentFromString,
+  mergeFragments,
+  use,
+} from "../utils/fragment.js";
+import type { RenderScope } from "../utils/options.js";
+import { camelCase, pascalCase, screamingSnakeCase } from "../utils/nameTransformers.js";
+
+/**
+ * Generate a full Dart file for a program's errors.
+ */
+export function getErrorPageFragment(
+  programNode: ProgramNode,
+  scope: RenderScope,
+): Fragment {
+  const errors = programNode.errors ?? [];
+  if (errors.length === 0) return emptyFragment();
+
+  const programName = programNode.name as string;
+
+  // Error code constants
+  const errorConstants = errors
+    .map((err) => {
+      const constName = scope.nameApi.errorConstant(
+        programName,
+        err.name as string,
+      );
+      const hexCode = `0x${err.code.toString(16)}`;
+      const docs = err.docs?.length
+        ? err.docs.map((d) => `/// ${d}`).join("\n") + "\n"
+        : "";
+      const message = err.message ? `/// Message: "${err.message}"\n` : "";
+      return `${docs}${message}const int ${constName} = ${hexCode}; // ${err.code}`;
+    })
+    .join("\n\n");
+
+  // Error message map
+  const messageEntries = errors
+    .map((err) => {
+      const constName = scope.nameApi.errorConstant(
+        programName,
+        err.name as string,
+      );
+      const message = err.message ?? err.name as string;
+      return `    ${constName}: '${escapeString(message)}',`;
+    })
+    .join("\n");
+
+  const errorMessageFnName = scope.nameApi.errorMessageFunction(programName);
+  const isErrorFnName = `is${pascalCase(programName)}Error`;
+
+  return fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint, constant_identifier_names
+
+/// Error codes for the ${fragmentFromString(pascalCase(programName))} program.
+
+${fragmentFromString(errorConstants)}
+
+/// Map of error codes to human-readable messages.
+const Map<int, String> _${fragmentFromString(camelCase(programName))}ErrorMessages = {
+${fragmentFromString(messageEntries)}
+};
+
+/// Get the error message for a ${fragmentFromString(pascalCase(programName))} program error code.
+String? ${fragmentFromString(errorMessageFnName)}(int code) {
+  return _${fragmentFromString(camelCase(programName))}ErrorMessages[code];
+}
+
+/// Check if an error code belongs to the ${fragmentFromString(pascalCase(programName))} program.
+bool ${fragmentFromString(isErrorFnName)}(int code) {
+  return _${fragmentFromString(camelCase(programName))}ErrorMessages.containsKey(code);
+}`;
+}
+
+function escapeString(str: string): string {
+  return str.replace(/'/g, "\\'").replace(/\n/g, "\\n");
+}

package/src/fragments/index.ts

@@ -0,0 +1,8 @@
+export * from "./accountPage.js";
+export * from "./discriminatorConstants.js";
+export * from "./errorPage.js";
+export * from "./indexPage.js";
+export * from "./instructionPage.js";
+export * from "./pdaPage.js";
+export * from "./programPage.js";
+export * from "./typePage.js";

package/src/fragments/indexPage.ts

@@ -0,0 +1,44 @@
+import type { Fragment } from "../utils/fragment.js";
+import { fragmentFromString } from "../utils/fragment.js";
+
+/**
+ * Generate a barrel export Dart file that exports all files in a category.
+ */
+export function getIndexPageFragment(
+  fileNames: string[],
+  relativePath: string = "",
+): Fragment {
+  if (fileNames.length === 0) {
+    return fragmentFromString(
+      "// Auto-generated. Do not edit.\n// ignore_for_file: type=lint\n",
+    );
+  }
+
+  const exports = fileNames
+    .sort()
+    .map((f) => {
+      const path = relativePath ? `${relativePath}/${f}` : f;
+      return `export '${path}';`;
+    })
+    .join("\n");
+
+  return fragmentFromString(
+    `// Auto-generated. Do not edit.\n// ignore_for_file: type=lint\n\n${exports}\n`,
+  );
+}
+
+/**
+ * Generate the root barrel export file.
+ */
+export function getRootIndexPageFragment(
+  categories: string[],
+): Fragment {
+  const exports = categories
+    .sort()
+    .map((cat) => `export '${cat}/${cat}.dart';`)
+    .join("\n");
+
+  return fragmentFromString(
+    `// Auto-generated. Do not edit.\n// ignore_for_file: type=lint\n\n${exports}\n`,
+  );
+}

package/src/fragments/instructionPage.ts

@@ -0,0 +1,306 @@
+import type {
+  InstructionAccountNode,
+  InstructionArgumentNode,
+  InstructionNode,
+} from "@codama/nodes";
+import { visit } from "@codama/visitors-core";
+
+import type { Fragment } from "../utils/fragment.js";
+import {
+  emptyFragment,
+  fragment,
+  fragmentFromString,
+  mergeFragments,
+  use,
+} from "../utils/fragment.js";
+import type { RenderScope } from "../utils/options.js";
+import { camelCase, pascalCase } from "../utils/nameTransformers.js";
+import { getDiscriminatorConstantsFragment } from "./discriminatorConstants.js";
+
+/**
+ * Generate a full Dart file for an instruction.
+ */
+export function getInstructionPageFragment(
+  node: InstructionNode,
+  scope: RenderScope,
+): Fragment {
+  const name = node.name as string;
+  const typeName = scope.nameApi.dataType(name);
+  const instrFnName = scope.nameApi.instructionFunction(name);
+  const parseFnName = scope.nameApi.instructionParseFunction(name);
+
+  const accounts = node.accounts ?? [];
+  const args = (node.arguments ?? []).filter(
+    (arg) => !isDiscriminatorArg(arg, node),
+  );
+  const allArgs = node.arguments ?? [];
+
+  // Build the instruction data class
+  const dataClassName = `${typeName}InstructionData`;
+
+  // Visit each arg type once and collect manifests for reuse
+  const allArgManifests = allArgs.map((arg) => ({
+    arg,
+    manifest: visit(arg.type, scope.typeManifestVisitor),
+  }));
+
+  // Data fields (non-discriminator arguments)
+  const dataFieldDecls = allArgManifests
+    .map(({ arg, manifest }) => {
+      const fieldName = camelCase(arg.name as string);
+      return `  final ${manifest.type.content} ${fieldName};`;
+    })
+    .join("\n");
+
+  const dataCtorParams = allArgManifests
+    .map(({ arg }) => {
+      const fieldName = camelCase(arg.name as string);
+      if (isDiscriminatorArg(arg, node)) {
+        return `    this.${fieldName} = ${getDiscriminatorDefault(arg, node)},`;
+      }
+      return `    required this.${fieldName},`;
+    })
+    .join("\n");
+
+  // Encoder/decoder for instruction data
+  const encFields = allArgManifests
+    .map(({ arg, manifest }) => {
+      return `    ('${arg.name as string}', ${manifest.encoder.content}),`;
+    })
+    .join("\n");
+
+  const decFields = allArgManifests
+    .map(({ arg, manifest }) => {
+      return `    ('${arg.name as string}', ${manifest.decoder.content}),`;
+    })
+    .join("\n");
+
+  const toMapFields = allArgs
+    .map(
+      (arg) =>
+        `      '${arg.name as string}': value.${camelCase(arg.name as string)},`,
+    )
+    .join("\n");
+
+  const fromMapFields = allArgManifests
+    .map(({ arg, manifest }) => {
+      const typeStr = manifest.type.content;
+      const isNullable = typeStr.endsWith("?");
+      const accessor = isNullable ? `map['${arg.name as string}']` : `map['${arg.name as string}']!`;
+      return `      ${camelCase(arg.name as string)}: ${accessor} as ${typeStr},`;
+    })
+    .join("\n");
+
+  const dataEncoderName = `get${typeName}InstructionDataEncoder`;
+  const dataDecoderName = `get${typeName}InstructionDataDecoder`;
+  const dataCodecName = `get${typeName}InstructionDataCodec`;
+
+  // Build the instruction builder function
+  const accountParams = accounts
+    .map((acc) => {
+      const fieldName = camelCase(acc.name as string);
+      const isRequired = !(acc.isOptional ?? false);
+      return isRequired
+        ? `  required Address ${fieldName},`
+        : `  Address? ${fieldName},`;
+    })
+    .join("\n");
+
+  // Build argParams using manifests from the allArgManifests (filtered to non-discriminator args)
+  const argManifestMap = new Map(allArgManifests.map(({ arg, manifest }) => [arg, manifest]));
+  const argParams = args
+    .map((arg) => {
+      const manifest = argManifestMap.get(arg)!;
+      const fieldName = camelCase(arg.name as string);
+      const hasDefault = arg.defaultValue != null;
+      if (hasDefault) {
+        return `  ${manifest.type.content}? ${fieldName},`;
+      }
+      return `  required ${manifest.type.content} ${fieldName},`;
+    })
+    .join("\n");
+
+  // Account metas
+  const accountMetas = accounts
+    .map((acc) => {
+      const fieldName = camelCase(acc.name as string);
+      const role = getAccountRole(acc);
+      const isOptional = acc.isOptional ?? false;
+      if (isOptional) {
+        return `    if (${fieldName} != null) AccountMeta(address: ${fieldName}, role: ${role}),`;
+      }
+      return `    AccountMeta(address: ${fieldName}, role: ${role}),`;
+    })
+    .join("\n");
+
+  // Instruction data construction
+  const dataConstruction = allArgs
+    .map((arg) => {
+      const fieldName = camelCase(arg.name as string);
+      if (isDiscriminatorArg(arg, node)) {
+        return ""; // Use default
+      }
+      return `      ${fieldName}: ${fieldName}${arg.defaultValue != null ? ` ?? ${getDefaultValue(arg)}` : ""},`;
+    })
+    .filter(Boolean)
+    .join("\n");
+
+  // Discriminator
+  const discFragment = getDiscriminatorConstantsFragment(node, scope);
+
+  const parts: Fragment[] = [
+    fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Uint8List", "dartTypedData")}
+${use("immutable", "meta")}
+${use("Encoder", "solanaCodecsCore")}
+${use("Decoder", "solanaCodecsCore")}
+${use("Codec", "solanaCodecsCore")}
+${use("combineCodec", "solanaCodecsCore")}
+${use("transformEncoder", "solanaCodecsCore")}
+${use("transformDecoder", "solanaCodecsCore")}
+${use("getStructEncoder", "solanaCodecsDataStructures")}
+${use("getStructDecoder", "solanaCodecsDataStructures")}
+${use("Address", "solanaAddresses")}
+${use("Instruction", "solanaInstructions")}
+${use("AccountMeta", "solanaInstructions")}
+${use("AccountRole", "solanaInstructions")}`,
+  ];
+
+  if (discFragment.content) parts.push(discFragment);
+
+  // Data class
+  parts.push(fragment`
+@immutable
+class ${fragmentFromString(dataClassName)} {
+  const ${fragmentFromString(dataClassName)}({
+${fragmentFromString(dataCtorParams)}
+  });
+
+${fragmentFromString(dataFieldDecls)}
+}`);
+
+  // Data encoder/decoder/codec
+  parts.push(fragment`
+Encoder<${fragmentFromString(dataClassName)}> ${fragmentFromString(dataEncoderName)}() {
+  final structEncoder = getStructEncoder(<(String, Encoder<Object?>)>[
+${fragmentFromString(encFields)}
+  ]);
+
+  return transformEncoder(
+    structEncoder,
+    (${fragmentFromString(dataClassName)} value) => <String, Object?>{
+${fragmentFromString(toMapFields)}
+    },
+  );
+}
+
+Decoder<${fragmentFromString(dataClassName)}> ${fragmentFromString(dataDecoderName)}() {
+  final structDecoder = getStructDecoder(<(String, Decoder<Object?>)>[
+${fragmentFromString(decFields)}
+  ]);
+
+  return transformDecoder(
+    structDecoder,
+    (Map<String, Object?> map, Uint8List bytes, int offset) => ${fragmentFromString(dataClassName)}(
+${fragmentFromString(fromMapFields)}
+    ),
+  );
+}
+
+Codec<${fragmentFromString(dataClassName)}, ${fragmentFromString(dataClassName)}> ${fragmentFromString(dataCodecName)}() {
+  return combineCodec(${fragmentFromString(dataEncoderName)}(), ${fragmentFromString(dataDecoderName)}());
+}`);
+
+  // Instruction builder
+  parts.push(fragment`
+/// Creates a [${fragmentFromString(typeName)}] instruction.
+Instruction ${fragmentFromString(instrFnName)}({
+  required Address programAddress,
+${fragmentFromString(accountParams)}
+${fragmentFromString(argParams)}
+}) {
+  final data = ${fragmentFromString(dataClassName)}(
+${fragmentFromString(dataConstruction)}
+  );
+
+  return Instruction(
+    programAddress: programAddress,
+    accounts: [
+${fragmentFromString(accountMetas)}
+    ],
+    data: ${fragmentFromString(dataEncoderName)}().encode(data),
+  );
+}`);
+
+  // Parse function
+  parts.push(fragment`
+/// Parses a [${fragmentFromString(typeName)}] instruction from raw instruction data.
+${fragmentFromString(dataClassName)} ${fragmentFromString(parseFnName)}(Instruction instruction) {
+  return ${fragmentFromString(dataDecoderName)}().decode(instruction.data!);
+}`);
+
+  const result = mergeFragments(parts, (cs) => cs.join("\n"));
+
+  // Merge arg type manifest imports (encoder, decoder, type) into the result
+  for (const { manifest } of allArgManifests) {
+    result.imports.mergeWith(manifest.encoder.imports);
+    result.imports.mergeWith(manifest.decoder.imports);
+    result.imports.mergeWith(manifest.type.imports);
+  }
+
+  return result;
+}
+
+function getAccountRole(acc: InstructionAccountNode): string {
+  const isSigner = acc.isSigner === true || acc.isSigner === "either";
+  const isWritable = acc.isWritable ?? false;
+
+  if (isSigner && isWritable) return "AccountRole.writableSigner";
+  if (isSigner) return "AccountRole.readonlySigner";
+  if (isWritable) return "AccountRole.writable";
+  return "AccountRole.readonly";
+}
+
+function isDiscriminatorArg(
+  arg: InstructionArgumentNode,
+  node: InstructionNode,
+): boolean {
+  const discriminators = node.discriminators ?? [];
+  return discriminators.some(
+    (d) =>
+      d.kind === "fieldDiscriminatorNode" && d.name === arg.name,
+  );
+}
+
+function getDiscriminatorDefault(
+  arg: InstructionArgumentNode,
+  _node: InstructionNode,
+): string {
+  if (arg.defaultValue) {
+    if (arg.defaultValue.kind === "numberValueNode") {
+      return String(arg.defaultValue.number);
+    }
+  }
+  return "0";
+}
+
+function getDefaultValue(arg: InstructionArgumentNode): string {
+  if (!arg.defaultValue) return "null";
+  const dv = arg.defaultValue;
+  switch (dv.kind) {
+    case "numberValueNode":
+      return String(dv.number);
+    case "booleanValueNode":
+      return String(dv.boolean);
+    case "stringValueNode":
+      return `'${dv.string}'`;
+    case "publicKeyValueNode":
+      return `Address('${dv.publicKey}')`;
+    case "noneValueNode":
+      return "null";
+    default:
+      return "null";
+  }
+}

package/src/fragments/pdaPage.ts

@@ -0,0 +1,128 @@
+import type { PdaNode } from "@codama/nodes";
+import { visit } from "@codama/visitors-core";
+
+import type { Fragment } from "../utils/fragment.js";
+import {
+  fragment,
+  fragmentFromString,
+  mergeFragments,
+  use,
+} from "../utils/fragment.js";
+import type { RenderScope } from "../utils/options.js";
+import { camelCase, pascalCase } from "../utils/nameTransformers.js";
+
+/**
+ * Generate a full Dart file for a PDA.
+ */
+export function getPdaPageFragment(
+  node: PdaNode,
+  scope: RenderScope,
+): Fragment {
+  const name = node.name as string;
+  const findFnName = scope.nameApi.pdaFindFunction(name);
+  const seedsClassName = `${pascalCase(name)}Seeds`;
+
+  const seeds = node.seeds ?? [];
+
+  // Separate variable seeds from constant seeds
+  const variableSeeds = seeds.filter(
+    (s) => s.kind === "variablePdaSeedNode",
+  );
+  const constantSeeds = seeds.filter(
+    (s) => s.kind === "constantPdaSeedNode",
+  );
+
+  // Build seeds class if there are variable seeds
+  const hasSeedsClass = variableSeeds.length > 0;
+
+  const seedFieldDecls = variableSeeds
+    .map((s) => {
+      if (s.kind !== "variablePdaSeedNode") return "";
+      const manifest = visit(s.type, scope.typeManifestVisitor);
+      return `  final ${manifest.type.content} ${camelCase(s.name as string)};`;
+    })
+    .join("\n");
+
+  const seedCtorParams = variableSeeds
+    .map((s) => {
+      if (s.kind !== "variablePdaSeedNode") return "";
+      return `    required this.${camelCase(s.name as string)},`;
+    })
+    .join("\n");
+
+  // Build the seed bytes list
+  const seedBytesList: string[] = [];
+  for (const seed of seeds) {
+    if (seed.kind === "constantPdaSeedNode") {
+      if (seed.value.kind === "bytesValueNode") {
+        seedBytesList.push(`    ...${bytesValueToDart(seed.value.data)},`);
+      } else if (seed.value.kind === "stringValueNode") {
+        seedBytesList.push(`    ...utf8.encode('${seed.value.string}'),`);
+      } else if (seed.value.kind === "publicKeyValueNode") {
+        seedBytesList.push(`    ...getAddressEncoder().encode(Address('${seed.value.publicKey}')),`);
+      } else if (seed.value.kind === "numberValueNode") {
+        const manifest = visit(seed.type, scope.typeManifestVisitor);
+        seedBytesList.push(`    ...${manifest.encoder.content}.encode(${seed.value.number}),`);
+      }
+    } else if (seed.kind === "variablePdaSeedNode") {
+      const manifest = visit(seed.type, scope.typeManifestVisitor);
+      seedBytesList.push(
+        `    ...${manifest.encoder.content}.encode(seeds.${camelCase(seed.name as string)}),`,
+      );
+    }
+  }
+
+  // Program address parameter
+  const programIdParam = node.programId
+    ? `Address programAddress = const Address('${node.programId}')`
+    : "required Address programAddress";
+
+  const parts: Fragment[] = [
+    fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Uint8List", "dartTypedData")}
+${use("immutable", "meta")}
+${use("Address", "solanaAddresses")}
+${use("getAddressEncoder", "solanaAddresses")}`,
+  ];
+
+  if (hasSeedsClass) {
+    parts.push(fragment`
+@immutable
+class ${fragmentFromString(seedsClassName)} {
+  const ${fragmentFromString(seedsClassName)}({
+${fragmentFromString(seedCtorParams)}
+  });
+
+${fragmentFromString(seedFieldDecls)}
+}`);
+  }
+
+  const seedsParam = hasSeedsClass ? `  required ${seedsClassName} seeds,` : "";
+
+  parts.push(fragment`
+/// Finds the program derived address for [${fragmentFromString(pascalCase(name))}].
+Future<(Address, int)> ${fragmentFromString(findFnName)}({
+${fragmentFromString(seedsParam)}
+  ${fragmentFromString(programIdParam)},
+}) async {
+  final seedBytes = <int>[
+${fragmentFromString(seedBytesList.join("\n"))}
+  ];
+
+  // TODO: Call getProgramDerivedAddress with seedBytes and programAddress
+  throw UnimplementedError('PDA derivation not yet implemented');
+}`);
+
+  return mergeFragments(parts, (cs) => cs.join("\n"));
+}
+
+function bytesValueToDart(hex: string): string {
+  const clean = hex.replace(/^0x/, "");
+  const pairs: string[] = [];
+  for (let i = 0; i < clean.length; i += 2) {
+    pairs.push(`0x${clean.slice(i, i + 2)}`);
+  }
+  return `[${pairs.join(", ")}]`;
+}

package/src/fragments/programPage.ts

@@ -0,0 +1,63 @@
+import type { ProgramNode } from "@codama/nodes";
+
+import type { Fragment } from "../utils/fragment.js";
+import {
+  emptyFragment,
+  fragment,
+  fragmentFromString,
+  mergeFragments,
+  use,
+} from "../utils/fragment.js";
+import type { RenderScope } from "../utils/options.js";
+import { camelCase, pascalCase } from "../utils/nameTransformers.js";
+
+/**
+ * Generate a full Dart file for a program.
+ */
+export function getProgramPageFragment(
+  node: ProgramNode,
+  scope: RenderScope,
+): Fragment {
+  const name = node.name as string;
+  const addressConstName = scope.nameApi.programAddressConstant(name);
+
+  const parts: Fragment[] = [
+    fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+${use("Address", "solanaAddresses")}
+
+/// The address of the ${fragmentFromString(pascalCase(name))} program.
+const ${fragmentFromString(addressConstName)} = Address('${fragmentFromString(node.publicKey)}');`,
+  ];
+
+  // Account identifier enum
+  const accounts = node.accounts ?? [];
+  if (accounts.length > 0) {
+    const accountVariants = accounts
+      .map((acc) => `  ${camelCase(acc.name as string)},`)
+      .join("\n");
+
+    parts.push(fragment`
+/// Known accounts for the ${fragmentFromString(pascalCase(name))} program.
+enum ${fragmentFromString(pascalCase(name))}Account {
+${fragmentFromString(accountVariants)}
+}`);
+  }
+
+  // Instruction identifier enum
+  const instructions = node.instructions ?? [];
+  if (instructions.length > 0) {
+    const instrVariants = instructions
+      .map((instr) => `  ${camelCase(instr.name as string)},`)
+      .join("\n");
+
+    parts.push(fragment`
+/// Known instructions for the ${fragmentFromString(pascalCase(name))} program.
+enum ${fragmentFromString(pascalCase(name))}Instruction {
+${fragmentFromString(instrVariants)}
+}`);
+  }
+
+  return mergeFragments(parts, (cs) => cs.join("\n"));
+}