codama-renderers-dart 0.4.3 → 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ifiok Jr.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.browser.cjs

@@ -50,7 +50,7 @@ function createDartNameApi() {
     errorConstant: (programName, errorName) => `${camelCase(programName)}Error${pascalCase(errorName)}`,
     errorMessageFunction: (name) => `get${pascalCase(name)}ErrorMessage`,
     enumVariant: (name) => camelCase(name),
-    sealedClassVariant: (_parentName, variantName) => pascalCase(variantName),
+    sealedClassVariant: (parentName, variantName) => `${pascalCase(parentName)}${pascalCase(variantName)}`,
     isTypeFunction: (name) => `is${pascalCase(name)}`,
     fileName: (name) => snakeCase(name),
     discriminatorConstant: (name) => `${camelCase(name)}Discriminator`
@@ -124,11 +124,16 @@ var DartImportMap = class {
     const uris = /* @__PURE__ */ new Set();
     for (const module of this._imports) {
       if (module in internalMap) {
-        uris.add(internalMap[module]);
+        const uri = internalMap[module];
+        if (uri) {
+          uris.add(uri);
+        }
       } else if (module in DART_EXTERNAL_PACKAGE_MAP) {
         uris.add(DART_EXTERNAL_PACKAGE_MAP[module]);
-      } else {
+      } else if (isRawDartImportUri(module)) {
         uris.add(module);
+      } else {
+        throw new Error(`Unresolved Dart import module "${module}"`);
       }
     }
     return [...uris].sort((a, b) => {
@@ -157,6 +162,9 @@ var DartImportMap = class {
     return lines.join("\n");
   }
 };
+function isRawDartImportUri(module) {
+  return module.startsWith("dart:") || module.startsWith("package:") || module.endsWith(".dart") && !module.includes(":");
+}
 
 // src/utils/fragment.ts
 function fragment(strings, ...values) {
@@ -248,10 +256,10 @@ var WELL_KNOWN_ADDRESSES = /* @__PURE__ */ new Map([
   ["Sysvar1111111111111111111111111111111111111", "sysvarOwnerAddress"],
   // SPL programs
   ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", "tokenProgramAddress"],
-  ["TokenzQdBNb4qyze1S1U9AHB8MGXmNK1REkTPT5Z3Y", "token2022ProgramAddress"],
-  ["ATokenGPvbdGVxr1b2hvZbsiqW5xWH25ef7s3c8BnQKu", "associatedTokenProgramAddress"],
-  ["Memo1UhkJRfRhVq1sR7Y7Nto1s3J2mXTT3L6Wk4K2m6", "memoProgramAddress"],
-  ["MemoSq4gqABXKKYWVqKkV3m3kb1cTR7F2UMy9r6kFNK", "memoLegacyProgramAddress"],
+  ["TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb", "token2022ProgramAddress"],
+  ["ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", "associatedTokenProgramAddress"],
+  ["MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr", "memoProgramAddress"],
+  ["Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo", "memoLegacyProgramAddress"],
   // Metaplex programs
   ["metaqbxxU9qX8rZXkmUJ7haCrXXz2W1PSUq1Rn3E1od", "tokenMetadataProgramAddress"],
   ["BGUMAp9V1mQ2KV8t34L5u3gZsXYZaYDBdKkc1xYk1qA1", "mplBubblegumProgramAddress"],
@@ -406,17 +414,18 @@ function getTypeManifestVisitor(input) {
     },
     visitArrayType(node, { self }) {
       const itemManifest = visitorsCore.visit(node.item, self);
-      const sizeExpr = getArraySizeExpression(node);
+      const encoderSizeExpr = getArraySizeExpression(node, "Encoder");
+      const decoderSizeExpr = getArraySizeExpression(node, "Decoder");
       return {
         type: fragment`List<${itemManifest.type}>`,
         encoder: fragment`${use(
           "getArrayEncoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.encoder}${sizeExpr})`,
+        )}(${itemManifest.encoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getArrayDecoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.decoder}${sizeExpr})`,
+        )}(${itemManifest.decoder}${decoderSizeExpr})`,
         value: emptyTypeManifest().value,
         isEnum: false
       };
@@ -424,34 +433,36 @@ function getTypeManifestVisitor(input) {
     visitMapType(node, { self }) {
       const keyManifest = visitorsCore.visit(node.key, self);
       const valueManifest = visitorsCore.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
       };
     },
     visitSetType(node, { self }) {
       const itemManifest = visitorsCore.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
       };
@@ -627,9 +638,10 @@ function getTypeManifestVisitor(input) {
       const bigIntFormats = /* @__PURE__ */ new Set(["u64", "u128", "i64", "i128"]);
       let prefixManifest;
       if (node.prefix.kind === "numberTypeNode" && bigIntFormats.has(node.prefix.format)) {
+        const codecName = getNumberCodecName(node.prefix.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 = visitorsCore.visit(node.prefix, self);
@@ -816,7 +828,7 @@ function getNumberCodecExpression(format, codecType) {
   const name = getNumberCodecName(format);
   return `get${name}${codecType}()`;
 }
-function getArraySizeExpression(node) {
+function getArraySizeExpression(node, codecType) {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
@@ -829,13 +841,13 @@ function getArraySizeExpression(node) {
       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 getMapSizeExpression(node) {
+function getMapSizeExpression(node, codecType) {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
@@ -848,13 +860,13 @@ function getMapSizeExpression(node) {
       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) {
+function getSetSizeExpression(node, codecType) {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
@@ -867,7 +879,7 @@ function getSetSizeExpression(node) {
       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 "";
@@ -1238,7 +1250,7 @@ function getInstructionPageFragment(node, scope) {
     const manifest = argManifestMap.get(arg);
     const fieldName = camelCase(arg.name);
     const typeStr = manifest.type.content;
-    const hasDefault = arg.defaultValue != null;
+    const hasDefault = arg.defaultValue != null && arg.defaultValue.kind !== "accountBumpValueNode";
     if (hasDefault) {
       const nullableType = typeStr.endsWith("?") ? typeStr : `${typeStr}?`;
       return `  ${nullableType} ${fieldName},`;
@@ -1259,7 +1271,9 @@ function getInstructionPageFragment(node, scope) {
     if (isDiscriminatorArg(arg, node)) {
       return "";
     }
-    return `      ${fieldName}: ${fieldName}${arg.defaultValue != null ? ` ?? ${getDefaultValue(arg)}` : ""},`;
+    const typeStr2 = argManifestMap.get(arg)?.type.content;
+    const skipDefault = arg.defaultValue?.kind === "accountBumpValueNode";
+    return `      ${fieldName}: ${fieldName}${arg.defaultValue != null && !skipDefault ? ` ?? ${getDefaultValue(arg, typeStr2)}` : ""},`;
   }).filter(Boolean).join("\n");
   const discFragment = getDiscriminatorConstantsFragment(node, scope);
   const parts = [
@@ -1393,12 +1407,13 @@ function isConstDefaultValue(defaultValue) {
       return false;
   }
 }
-function getDefaultValue(arg) {
+function getDefaultValue(arg, typeStr) {
   if (!arg.defaultValue) return "null";
+  const isBigInt = typeStr === "BigInt";
   const dv = arg.defaultValue;
   switch (dv.kind) {
     case "numberValueNode":
-      return String(dv.number);
+      return isBigInt ? `BigInt.from(${dv.number})` : String(dv.number);
     case "booleanValueNode":
       return String(dv.boolean);
     case "stringValueNode":
@@ -1538,8 +1553,6 @@ function bytesValueToDart(hex) {
   }
   return `[${pairs.join(", ")}]`;
 }
-
-// src/fragments/programPage.ts
 function getProgramPageFragment(node, scope) {
   const name = node.name;
   const addressConstName = scope.nameApi.programAddressConstant(name);
@@ -1571,17 +1584,146 @@ enum ${fragmentFromString(pascalCase(name))}Account {
 ${fragmentFromString(accountVariants)}
 }`);
   }
-  const instructions = node.instructions ?? [];
+  const instructions = nodes.getAllInstructionsWithSubs(node);
   if (instructions.length > 0) {
+    const programName = pascalCase(name);
+    const instructionEnum = `${programName}Instruction`;
     const instrVariants = instructions.map((instr) => `  ${camelCase(instr.name)},`).join("\n");
     parts.push(fragment`
-/// Known instructions for the ${fragmentFromString(pascalCase(name))} program.
-enum ${fragmentFromString(pascalCase(name))}Instruction {
+/// Known instructions for the ${fragmentFromString(programName)} program.
+enum ${fragmentFromString(instructionEnum)} {
 ${fragmentFromString(instrVariants)}
 }`);
+    const identifiableInstructions = instructions.map((instruction) => ({
+      instruction,
+      condition: getInstructionDiscriminatorCondition(instruction, scope)
+    })).filter(({ condition }) => condition !== null);
+    if (identifiableInstructions.length > 0) {
+      const identifyBranches = identifiableInstructions.map(
+        ({ instruction, condition }) => fragment`  if (${condition}) {
+    return ${fragmentFromString(instructionEnum)}.${fragmentFromString(camelCase(instruction.name))};
+  }`
+      );
+      const parsedBase = `Parsed${programName}Instruction`;
+      const parsedClasses = instructions.map((instruction) => {
+        const instructionName = pascalCase(instruction.name);
+        const variant = camelCase(instruction.name);
+        const parsedClass = `Parsed${instructionName}`;
+        const dataClass = `${instructionName}InstructionData`;
+        return fragment`/// A parsed ${fragmentFromString(instructionName)} instruction.
+final class ${fragmentFromString(parsedClass)} extends ${fragmentFromString(parsedBase)} {
+  const ${fragmentFromString(parsedClass)}({required this.data})
+      : super(${fragmentFromString(instructionEnum)}.${fragmentFromString(variant)});
+
+  final ${use(dataClass, "../instructions/instructions.dart")} data;
+}`;
+      });
+      const parseBranches = instructions.map((instruction) => {
+        const instructionName = pascalCase(instruction.name);
+        const variant = camelCase(instruction.name);
+        const parsedClass = `Parsed${instructionName}`;
+        const parseFunction = scope.nameApi.instructionParseFunction(
+          instruction.name
+        );
+        return fragment`    ${fragmentFromString(instructionEnum)}.${fragmentFromString(variant)} => ${fragmentFromString(parsedClass)}(
+      data: ${use(parseFunction, "../instructions/instructions.dart")}(instruction),
+    ),`;
+      });
+      parts.push(fragment`
+/// Identifies the type of a ${fragmentFromString(programName)} instruction.
+${fragmentFromString(instructionEnum)} identify${fragmentFromString(programName)}Instruction(
+  ${use("Uint8List", "dartTypedData")} data,
+) {
+${mergeFragments(identifyBranches, (cs) => cs.join("\n"))}
+
+  throw ${use("SolanaError", "solanaErrors")}(
+    ${use("SolanaErrorCode", "solanaErrors")}.programClientsFailedToIdentifyInstruction,
+    {
+      'instructionData': data,
+      'programName': '${fragmentFromString(name)}',
+    },
+  );
+}
+
+/// A parsed instruction from the ${fragmentFromString(programName)} program.
+sealed class ${fragmentFromString(parsedBase)} {
+  const ${fragmentFromString(parsedBase)}(this.instructionType);
+
+  final ${fragmentFromString(instructionEnum)} instructionType;
+}
+
+${mergeFragments(parsedClasses, (cs) => cs.join("\n\n"))}
+
+/// Parses a ${fragmentFromString(programName)} instruction.
+${fragmentFromString(parsedBase)} parse${fragmentFromString(programName)}Instruction(
+  ${use("Instruction", "solanaInstructions")} instruction,
+) {
+  return switch (identify${fragmentFromString(programName)}Instruction(
+    instruction.data ?? Uint8List(0),
+  )) {
+${mergeFragments(parseBranches, (cs) => cs.join("\n"))}
+  };
+}`);
+    }
   }
   return mergeFragments(parts, (cs) => cs.join("\n"));
 }
+function getInstructionDiscriminatorCondition(instruction, scope) {
+  const discriminators = instruction.discriminators ?? [];
+  if (discriminators.length === 0) return null;
+  const conditions = discriminators.map((discriminator) => {
+    switch (discriminator.kind) {
+      case "sizeDiscriminatorNode":
+        return fragment`data.length == ${discriminator.size}`;
+      case "constantDiscriminatorNode": {
+        const manifest = visitorsCore.visit(
+          discriminator.constant.type,
+          scope.typeManifestVisitor
+        );
+        const value = getValueFragment(
+          discriminator.constant.value,
+          manifest.type.content
+        );
+        if (value === null) return null;
+        return fragment`${use("containsBytes", "solanaCodecsCore")}(data, ${manifest.encoder}.encode(${value}), ${discriminator.offset})`;
+      }
+      case "fieldDiscriminatorNode": {
+        const argument = (instruction.arguments ?? []).find(
+          (candidate) => candidate.name === discriminator.name
+        );
+        if (argument?.defaultValue == null) return null;
+        const manifest = visitorsCore.visit(argument.type, scope.typeManifestVisitor);
+        const value = getValueFragment(
+          argument.defaultValue,
+          manifest.type.content
+        );
+        if (value === null) return null;
+        return fragment`${use("containsBytes", "solanaCodecsCore")}(data, ${manifest.encoder}.encode(${value}), ${discriminator.offset})`;
+      }
+    }
+  });
+  if (conditions.some((condition) => condition === null)) return null;
+  return mergeFragments(conditions, (cs) => cs.join(" && "));
+}
+function getValueFragment(value, dartType) {
+  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(`'${value.string.replaceAll("'", "\\'")}'`);
+    case "bytesValueNode": {
+      const clean = value.data.replace(/^0x/, "");
+      const bytes = clean.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
+      return fragment`${use("Uint8List", "dartTypedData")}.fromList([${fragmentFromString(bytes.join(", "))}])`;
+    }
+    default:
+      return null;
+  }
+}
 function getTypePageFragment(node, scope) {
   const name = node.name;
   scope.nameApi.dataType(name);
@@ -1664,6 +1806,7 @@ function getDataEnumPageFragment(node, scope) {
   const allVariantManifests = [];
   for (let i = 0; i < enumNode.variants.length; i++) {
     const variant = enumNode.variants[i];
+    const variantName = pascalCase(variant.name);
     const variantClassName = scope.nameApi.sealedClassVariant(
       name,
       variant.name
@@ -1680,7 +1823,7 @@ function getDataEnumPageFragment(node, scope) {
   int get hashCode => runtimeType.hashCode;
 
   @override
-  String toString() => '${typeName}.${variantClassName}()';
+  String toString() => '${typeName}.${variantName}()';
 }`);
       encoderVariants.push(
         `(${i}, getStructEncoder(<(String, Encoder<Object?>)>[]))`
@@ -1727,7 +1870,7 @@ ${fieldDecls}
   int get hashCode => ${hashExpression};
 
   @override
-  String toString() => '${typeName}.${variantClassName}(${toStringFields})';
+  String toString() => '${typeName}.${variantName}(${toStringFields})';
 }`);
       const encFields = fieldManifests.map(({ field: f, manifest }) => {
         return `('${f.name}', ${manifest.encoder.content})`;
@@ -1776,7 +1919,7 @@ ${fieldDecls}
   int get hashCode => value.hashCode;
 
   @override
-  String toString() => '${typeName}.${variantClassName}($value)';
+  String toString() => '${typeName}.${variantName}($value)';
 }`);
         encoderVariants.push(
           `(${i}, transformEncoder<${manifest.type.content}, Map<String, Object?>>(${manifest.encoder.content}, (Map<String, Object?> map) => map['value']! as ${manifest.type.content}))`
@@ -2220,7 +2363,7 @@ function renderVisitor(outputDir, options = {}) {
     );
     const typePathMap = {};
     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;
       }
@@ -2234,7 +2377,10 @@ function renderVisitor(outputDir, options = {}) {
       const fileDir = path.dirname(filePath);
       const internalMap = {};
       for (const [key, typePath] of Object.entries(typePathMap)) {
-        if (typePath === filePath) continue;
+        if (typePath === filePath) {
+          internalMap[key] = "";
+          continue;
+        }
         let rel = path.posix.relative(fileDir, typePath);
         if (!rel.startsWith(".")) {
           rel = `./${rel}`;