codama-renderers-dart 0.4.3 → 0.5.1

package/src/visitors/getTypeManifestVisitor.ts

@@ -226,18 +226,24 @@ export function getTypeManifestVisitor(input: {
 
     visitArrayType(node: ArrayTypeNode, { self }) {
       const itemManifest = visit(node.item, self);
-      const sizeExpr = getArraySizeExpression(node);
+      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}${sizeExpr})`,
+        )}<${itemType}>(${itemEncoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getArrayDecoder",
           "solanaCodecsDataStructures",
-        )}(${itemManifest.decoder}${sizeExpr})`,
+        )}(${itemManifest.decoder}${decoderSizeExpr})`,
         value: emptyTypeManifest().value,
         isEnum: false,
       };
@@ -246,18 +252,19 @@ export function getTypeManifestVisitor(input: {
     visitMapType(node: MapTypeNode, { self }) {
       const keyManifest = visit(node.key, self);
       const valueManifest = visit(node.value, self);
-      const sizeExpr = getMapSizeExpression(node);
+      const encoderSizeExpr = getMapSizeExpression(node, "Encoder");
+      const decoderSizeExpr = getMapSizeExpression(node, "Decoder");
 
       return {
         type: fragment`Map<${keyManifest.type}, ${valueManifest.type}>`,
         encoder: fragment`${use(
           "getMapEncoder",
           "solanaCodecsDataStructures",
-        )}(${keyManifest.encoder}, ${valueManifest.encoder}${sizeExpr})`,
+        )}(${keyManifest.encoder}, ${valueManifest.encoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getMapDecoder",
           "solanaCodecsDataStructures",
-        )}(${keyManifest.decoder}, ${valueManifest.decoder}${sizeExpr})`,
+        )}(${keyManifest.decoder}, ${valueManifest.decoder}${decoderSizeExpr})`,
         value: emptyTypeManifest().value,
         isEnum: false,
       };
@@ -265,25 +272,26 @@ export function getTypeManifestVisitor(input: {
 
     visitSetType(node: SetTypeNode, { self }) {
       const itemManifest = visit(node.item, self);
-      const sizeExpr = getSetSizeExpression(node);
+      const encoderSizeExpr = getSetSizeExpression(node, "Encoder");
+      const decoderSizeExpr = getSetSizeExpression(node, "Decoder");
 
       return {
         type: fragment`Set<${itemManifest.type}>`,
         encoder: fragment`${use(
           "getSetEncoder",
           "solanaCodecsDataStructures",
-        )}(${itemManifest.encoder}${sizeExpr})`,
+        )}(${itemManifest.encoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getSetDecoder",
           "solanaCodecsDataStructures",
-        )}(${itemManifest.decoder}${sizeExpr})`,
+        )}(${itemManifest.decoder}${decoderSizeExpr})`,
         value: emptyTypeManifest().value,
         isEnum: false,
       };
     },
 
     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(", ");
@@ -324,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?>";
@@ -368,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",
       );
 
@@ -495,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",
@@ -509,20 +518,21 @@ export function getTypeManifestVisitor(input: {
       const innerManifest = visit(node.type, self);
 
       // The Dart addEncoderSizePrefix / addDecoderSizePrefix APIs require
-      // Encoder<num> / Decoder<num> for the prefix. BigInt-width number types
-      // (u64, u128, i64, i128) return Encoder<BigInt> which is incompatible.
-      // When the IDL specifies such a prefix, substitute u32 which is wide
-      // enough for any realistic size prefix and satisfies the num constraint.
+      // Encoder<num> / Decoder<num> for the prefix, but BigInt-width number
+      // types (u64, u128, i64, i128) return Encoder<BigInt> which is
+      // incompatible. Transform the BigInt codec to int so it satisfies the
+      // num constraint while preserving the on-chain byte width (e.g. the
+      // system program's bincode u64 string-length prefix).
       const bigIntFormats = new Set(["u64", "u128", "i64", "i128"]);
       let prefixManifest;
       if (
         node.prefix.kind === "numberTypeNode" &&
         bigIntFormats.has((node.prefix as any).format)
       ) {
-        // Use u32 encoder/decoder instead of the oversized type.
+        const codecName = getNumberCodecName((node.prefix as any).format);
         prefixManifest = {
-          encoder: fragment`${use("getU32Encoder", "solanaCodecsNumbers")}()`,
-          decoder: fragment`${use("getU32Decoder", "solanaCodecsNumbers")}()`,
+          encoder: fragment`transformEncoder(${use(`get${codecName}Encoder`, "solanaCodecsNumbers")}(), (size) => BigInt.from(size))`,
+          decoder: fragment`transformDecoder(${use(`get${codecName}Decoder`, "solanaCodecsNumbers")}(), (size, _, __) => size.toInt())`,
         };
       } else {
         prefixManifest = visit(node.prefix, self);
@@ -545,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(", ");
@@ -580,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(", ");
@@ -757,7 +767,10 @@ function getNumberCodecExpression(
   return `get${name}${codecType}()`;
 }
 
-function getArraySizeExpression(node: ArrayTypeNode): string {
+function getArraySizeExpression(
+  node: ArrayTypeNode,
+  codecType: "Encoder" | "Decoder",
+): string {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
@@ -770,14 +783,17 @@ function getArraySizeExpression(node: ArrayTypeNode): string {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return ""; // Default
       }
-      return `, size: PrefixedArraySize(get${getNumberCodecName(resolvedPrefix.format)}Encoder())`;
+      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
     }
     default:
       return "";
   }
 }
 
-function getMapSizeExpression(node: MapTypeNode): string {
+function getMapSizeExpression(
+  node: MapTypeNode,
+  codecType: "Encoder" | "Decoder",
+): string {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
@@ -790,14 +806,17 @@ function getMapSizeExpression(node: MapTypeNode): string {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(get${getNumberCodecName(resolvedPrefix.format)}Encoder())`;
+      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
     }
     default:
       return "";
   }
 }
 
-function getSetSizeExpression(node: SetTypeNode): string {
+function getSetSizeExpression(
+  node: SetTypeNode,
+  codecType: "Encoder" | "Decoder",
+): string {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
@@ -810,7 +829,7 @@ function getSetSizeExpression(node: SetTypeNode): string {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(get${getNumberCodecName(resolvedPrefix.format)}Encoder())`;
+      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
     }
     default:
       return "";

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,14 +39,14 @@ export function renderVisitor(
 
     // 2. Build the render map
     const renderMap = visit(
-      root,
+      normalizedRoot,
       getRenderMapVisitor({ nameApi, dependencyMap }),
     );
 
     // 3. Build a map of definedType module keys to their render map paths
     const typePathMap: Record<string, string> = {};
     for (const renderPath of renderMap.keys()) {
-      const match = renderPath.match(/^(?:.*\/)?types\/([a-z_]+)\.dart$/);
+      const match = renderPath.match(/^(?:.*\/)?types\/([a-z0-9_]+)\.dart$/);
       if (match) {
         typePathMap[`definedType:${match[1]}`] = renderPath;
       }
@@ -63,8 +66,12 @@ export function renderVisitor(
       const fileDir = dirname(filePath);
       const internalMap: Record<string, string> = {};
       for (const [key, typePath] of Object.entries(typePathMap)) {
-        // Don't import yourself
-        if (typePath === filePath) continue;
+        // Keep the key resolved without generating a self-import.
+        if (typePath === filePath) {
+          internalMap[key] = "";
+          continue;
+        }
+
         let rel = posix.relative(fileDir, typePath);
         if (!rel.startsWith(".")) {
           rel = `./${rel}`;