codama-renderers-dart 0.5.0 → 0.5.1

package/src/utils/normalizeRootNode.ts

@@ -0,0 +1,76 @@
+import type { RootNode } from "@codama/nodes";
+
+/**
+ * Normalizes a serialized Codama root before it reaches Codama's visitors.
+ *
+ * Codama constructors materialize empty child collections, while generated
+ * JSON commonly omits them. Pina intentionally omits those empty fields, so
+ * restore only the structural defaults required by Codama traversal. This is
+ * a copy: callers retain their original parsed IDL unchanged.
+ */
+export function normalizeRootNode(root: RootNode): RootNode {
+  return normalizeNode(root) as RootNode;
+}
+
+function normalizeNode(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(normalizeNode);
+  }
+
+  if (!isRecord(value)) {
+    return value;
+  }
+
+  const normalized = Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [key, normalizeNode(child)]),
+  ) as Record<string, unknown>;
+
+  switch (normalized.kind) {
+    case "rootNode":
+      setEmptyCollection(normalized, "additionalPrograms");
+      break;
+    case "programNode":
+      setEmptyCollection(normalized, "accounts");
+      setEmptyCollection(normalized, "constants");
+      setEmptyCollection(normalized, "definedTypes");
+      setEmptyCollection(normalized, "errors");
+      setEmptyCollection(normalized, "events");
+      setEmptyCollection(normalized, "instructions");
+      setEmptyCollection(normalized, "pdas");
+      break;
+    case "instructionNode":
+      setEmptyCollection(normalized, "accounts");
+      setEmptyCollection(normalized, "arguments");
+      break;
+    case "pdaNode":
+      setEmptyCollection(normalized, "seeds");
+      break;
+    case "structTypeNode":
+      setEmptyCollection(normalized, "fields");
+      break;
+    case "enumTypeNode":
+      setEmptyCollection(normalized, "variants");
+      break;
+    case "tupleTypeNode":
+      setEmptyCollection(normalized, "items");
+      break;
+    case "hiddenPrefixTypeNode":
+      setEmptyCollection(normalized, "prefix");
+      break;
+    case "hiddenSuffixTypeNode":
+      setEmptyCollection(normalized, "suffix");
+      break;
+  }
+
+  return normalized;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function setEmptyCollection(record: Record<string, unknown>, key: string): void {
+  if (record[key] === undefined) {
+    record[key] = [];
+  }
+}

package/src/utils/valueNodes.ts

@@ -0,0 +1,87 @@
+import type {
+  InstructionInputValueNode,
+  ValueNode,
+} from "@codama/nodes";
+
+import type { Fragment } from "./fragment.js";
+import { fragment, fragmentFromString, use } from "./fragment.js";
+import { WELL_KNOWN_ADDRESSES } from "./wellKnownAddresses.js";
+
+type RenderableValueNode = InstructionInputValueNode | ValueNode;
+
+/**
+ * Render a standalone Codama value as a Dart expression.
+ *
+ * Contextual instruction values need resolver state and are deliberately
+ * rejected here. Defaults and discriminators must be deterministic at code
+ * generation time so generated encoders cannot silently choose a different
+ * wire value.
+ */
+export function getDartValueFragment(
+  value: RenderableValueNode,
+  dartType?: string,
+): Fragment {
+  switch (value.kind) {
+    case "numberValueNode":
+      return fragmentFromString(
+        dartType === "BigInt"
+          ? `BigInt.from(${value.number})`
+          : String(value.number),
+      );
+    case "booleanValueNode":
+      return fragmentFromString(String(value.boolean));
+    case "stringValueNode":
+      return fragmentFromString(toDartStringLiteral(value.string));
+    case "noneValueNode":
+      return fragmentFromString("null");
+    case "bytesValueNode": {
+      if (value.encoding !== "base16") {
+        throw new Error(
+          `Unsupported deterministic bytes encoding: ${value.encoding}`,
+        );
+      }
+      const clean = value.data.replace(/^0x/, "");
+      if (clean.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(clean)) {
+        throw new Error(`Invalid hexadecimal bytes value: ${value.data}`);
+      }
+      const bytes = clean.match(/.{2}/g)?.map((byte) => `0x${byte}`) ?? [];
+      return fragment`${use("Uint8List", "dartTypedData")}.fromList([${fragmentFromString(bytes.join(", "))}])`;
+    }
+    case "publicKeyValueNode": {
+      const wellKnownName = WELL_KNOWN_ADDRESSES.get(value.publicKey);
+      return wellKnownName
+        ? fragment`${use(wellKnownName, "solanaAddresses")}`
+        : fragment`${use("Address", "solanaAddresses")}(${fragmentFromString(toDartStringLiteral(value.publicKey))})`;
+    }
+    default:
+      throw new Error(
+        `Unsupported deterministic Dart value node: ${value.kind}`,
+      );
+  }
+}
+
+/** Return whether a rendered standalone value is valid in a const initializer. */
+export function isConstDartValueNode(value: RenderableValueNode): boolean {
+  switch (value.kind) {
+    case "numberValueNode":
+    case "booleanValueNode":
+    case "stringValueNode":
+    case "noneValueNode":
+    case "publicKeyValueNode":
+      return true;
+    default:
+      return false;
+  }
+}
+
+function toDartStringLiteral(value: string): string {
+  return `'${value
+    .replaceAll("\\", "\\\\")
+    .replaceAll("\n", "\\n")
+    .replaceAll("\r", "\\r")
+    .replaceAll("\t", "\\t")
+    .replaceAll("\b", "\\b")
+    .replaceAll("\f", "\\f")
+    .replaceAll("$", "\\$")
+    .replaceAll("'", "\\'")}'`;
+}

package/src/visitors/getRenderMapVisitor.ts

@@ -86,7 +86,7 @@ export function getRenderMapVisitor(
         visitRoot(node: RootNode, { self }) {
           const programMaps = [
             visit(node.program, self),
-            ...node.additionalPrograms.map((p) => visit(p, self)),
+            ...(node.additionalPrograms ?? []).map((p) => visit(p, self)),
           ];
 
           const mergedProgramMap = mergeRenderMaps(programMaps);

package/src/visitors/getTypeManifestVisitor.ts

@@ -228,13 +228,18 @@ export function getTypeManifestVisitor(input: {
       const itemManifest = visit(node.item, self);
       const encoderSizeExpr = getArraySizeExpression(node, "Encoder");
       const decoderSizeExpr = getArraySizeExpression(node, "Decoder");
+      const itemType = fragmentFromString(itemManifest.type.content);
+      const itemEncoder = fragment`${use(
+        "transformEncoder",
+        "solanaCodecsCore",
+      )}(${itemManifest.encoder}, (${itemType} value) => value)`;
 
       return {
         type: fragment`List<${itemManifest.type}>`,
         encoder: fragment`${use(
           "getArrayEncoder",
           "solanaCodecsDataStructures",
-        )}(${itemManifest.encoder}${encoderSizeExpr})`,
+        )}<${itemType}>(${itemEncoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getArrayDecoder",
           "solanaCodecsDataStructures",
@@ -286,7 +291,7 @@ export function getTypeManifestVisitor(input: {
     },
 
     visitTupleType(node: TupleTypeNode, { self }) {
-      const itemManifests = node.items.map((item) => visit(item, self));
+      const itemManifests = (node.items ?? []).map((item) => visit(item, self));
       const typeList = itemManifests
         .map((m) => m.type.content)
         .join(", ");
@@ -327,8 +332,9 @@ export function getTypeManifestVisitor(input: {
     },
 
     visitStructType(node: StructTypeNode, { self }) {
-      const fields = node.fields.map((f) => visit(f, self));
-      const fieldNames = node.fields.map((f) => f.name as string);
+      const nodeFields = node.fields ?? [];
+      const fields = nodeFields.map((f) => visit(f, self));
+      const fieldNames = nodeFields.map((f) => f.name as string);
 
       // Type: Map<String, Object?> (for inline structs without a name)
       const typeStr = "Map<String, Object?>";
@@ -371,7 +377,7 @@ export function getTypeManifestVisitor(input: {
 
     visitEnumType(node: EnumTypeNode, { self }) {
       // Check if this is a scalar enum (all empty variants)
-      const isScalar = node.variants.every(
+      const isScalar = (node.variants ?? []).every(
         (v) => v.kind === "enumEmptyVariantTypeNode",
       );
 
@@ -498,7 +504,7 @@ export function getTypeManifestVisitor(input: {
         encoder: fragment`${use(
           "fixEncoderSize",
           "solanaCodecsCore",
-        )}(${innerManifest.encoder}, ${fragmentFromString(String(node.size))})`,
+        )}(${innerManifest.encoder}, ${fragmentFromString(String(node.size))}, allowTruncation: false)`,
         decoder: fragment`${use(
           "fixDecoderSize",
           "solanaCodecsCore",
@@ -549,7 +555,7 @@ export function getTypeManifestVisitor(input: {
 
     visitHiddenPrefixType(node: HiddenPrefixTypeNode, { self }) {
       const innerManifest = visit(node.type, self);
-      const prefixes = node.prefix.map((p) => getHiddenAffixManifest(p, self));
+      const prefixes = (node.prefix ?? []).map((p) => getHiddenAffixManifest(p, self));
       const prefixEncoders = prefixes
         .map((p) => p.encoder.content)
         .join(", ");
@@ -584,7 +590,7 @@ export function getTypeManifestVisitor(input: {
 
     visitHiddenSuffixType(node: HiddenSuffixTypeNode, { self }) {
       const innerManifest = visit(node.type, self);
-      const suffixes = node.suffix.map((s) => getHiddenAffixManifest(s, self));
+      const suffixes = (node.suffix ?? []).map((s) => getHiddenAffixManifest(s, self));
       const suffixEncoders = suffixes
         .map((s) => s.encoder.content)
         .join(", ");

package/src/visitors/renderVisitor.ts

@@ -9,6 +9,7 @@ import type { Fragment } from "../utils/fragment.js";
 import type { RenderOptions } from "../utils/options.js";
 import { DartImportMap, DART_EXTERNAL_PACKAGE_MAP } from "../utils/importMap.js";
 import { formatDartDirectory } from "../utils/formatCode.js";
+import { normalizeRootNode } from "../utils/normalizeRootNode.js";
 import { getRenderMapVisitor } from "./getRenderMapVisitor.js";
 
 /**
@@ -29,6 +30,8 @@ export function renderVisitor(
   } = options;
 
   return rootNodeVisitor((root: RootNode) => {
+    const normalizedRoot = normalizeRootNode(root);
+
     // 1. Optionally delete the output directory
     if (deleteFolderBeforeRendering && existsSync(outputDir)) {
       deleteDirectory(outputDir);
@@ -36,7 +39,7 @@ export function renderVisitor(
 
     // 2. Build the render map
     const renderMap = visit(
-      root,
+      normalizedRoot,
       getRenderMapVisitor({ nameApi, dependencyMap }),
     );