codama-renderers-dart 0.5.1 → 0.5.3

package/dist/index.node.cjs

@@ -84,9 +84,83 @@ function setEmptyCollection(record, key) {
 function pascalCase(str) {
   return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toUpperCase());
 }
+var DART_RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "abstract",
+  "as",
+  "assert",
+  "async",
+  "augment",
+  "await",
+  "base",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "covariant",
+  "default",
+  "deferred",
+  "do",
+  "dynamic",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "extension",
+  "external",
+  "factory",
+  "false",
+  "final",
+  "finally",
+  "for",
+  "get",
+  "hide",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "interface",
+  "is",
+  "late",
+  "library",
+  "mixin",
+  "native",
+  "new",
+  "null",
+  "of",
+  "on",
+  "operator",
+  "part",
+  "required",
+  "rethrow",
+  "return",
+  "sealed",
+  "set",
+  "show",
+  "static",
+  "super",
+  "switch",
+  "sync",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typedef",
+  "var",
+  "void",
+  "when",
+  "while",
+  "with",
+  "yield"
+]);
+function escapeDartIdentifier(name) {
+  return DART_RESERVED_WORDS.has(name) ? `${name}_` : name;
+}
 function camelCase(str) {
   const pascal = pascalCase(str);
-  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  const cased = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  return escapeDartIdentifier(cased);
 }
 function snakeCase(str) {
   return str.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").replace(/^_/, "").replace(/_+/g, "_").toLowerCase();
@@ -674,7 +748,7 @@ function getTypeManifestVisitor(input) {
         encoder: fragment`${use(
           "getArrayEncoder",
           "solanaCodecsDataStructures"
-        )}<${itemType}>(${itemEncoder}${encoderSizeExpr})`,
+        )}(${itemEncoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getArrayDecoder",
           "solanaCodecsDataStructures"
@@ -730,18 +804,28 @@ function getTypeManifestVisitor(input) {
         typeFragment.imports.mergeWith(m.type.imports);
       }
       const encoderListStr = encoderList.map((e) => e.content).join(", ");
+      const decoderListStr = decoderList.map((d) => d.content).join(", ");
+      let tupleEncoderFn = "getTupleEncoder";
+      let tupleDecoderFn = "getTupleDecoder";
+      let tupleEncoderArgs = `[${encoderListStr}]`;
+      let tupleDecoderArgs = `[${decoderListStr}]`;
+      if (itemManifests.length === 2) {
+        tupleEncoderFn = "getTuple2Encoder";
+        tupleDecoderFn = "getTuple2Decoder";
+        tupleEncoderArgs = encoderListStr;
+        tupleDecoderArgs = decoderListStr;
+      }
       const encoderFrag = fragment`${use(
-        "getTupleEncoder",
+        tupleEncoderFn,
         "solanaCodecsDataStructures"
-      )}([${fragmentFromString(encoderListStr)}])`;
+      )}(${tupleEncoderArgs})`;
       for (const e of encoderList) {
         encoderFrag.imports.mergeWith(e.imports);
       }
-      const decoderListStr = decoderList.map((d) => d.content).join(", ");
       const decoderFrag = fragment`${use(
-        "getTupleDecoder",
+        tupleDecoderFn,
         "solanaCodecsDataStructures"
-      )}([${fragmentFromString(decoderListStr)}])`;
+      )}(${tupleDecoderArgs})`;
       for (const d of decoderList) {
         decoderFrag.imports.mergeWith(d.imports);
       }
@@ -828,7 +912,10 @@ function getTypeManifestVisitor(input) {
         encoder: fragment`${use(
           "getNullableEncoder",
           "solanaCodecsDataStructures"
-        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.encoder}${fragmentFromString(prefixExpr)}${fragmentFromString(noneValueExpr)})`,
+        )}<${fragmentFromString(itemTypeStr)}>(${use(
+          "transformEncoder",
+          "solanaCodecsCore"
+        )}(${itemManifest.encoder}, (${fragmentFromString(itemTypeStr)} value) => value)${fragmentFromString(prefixExpr)}${fragmentFromString(noneValueExpr)})`,
         decoder: fragment`${use(
           "getNullableDecoder",
           "solanaCodecsDataStructures"
@@ -1589,6 +1676,10 @@ ${dataCtorInitializers}` : ""};`;
   const accountNames = new Set(accounts.map((a) => camelCase(a.name)));
   const hasProgramAddressCollision = argNames.has("programAddress") || accountNames.has("programAddress");
   const instrProgramParam = hasProgramAddressCollision ? "instructionProgramAddress" : "programAddress";
+  let instructionDataLocal = "instructionData";
+  while (argNames.has(instructionDataLocal) || accountNames.has(instructionDataLocal)) {
+    instructionDataLocal = `${instructionDataLocal}_`;
+  }
   const accountParams = accounts.map((acc) => {
     const fieldName = camelCase(acc.name);
     const isRequired = !(acc.isOptional ?? false);
@@ -1697,7 +1788,7 @@ Instruction ${fragmentFromString(instrFnName)}({
 ${fragmentFromString(accountParams)}
 ${fragmentFromString(argParams)}
 }) {
-  final instructionData = ${fragmentFromString(dataClassName)}(
+  final ${instructionDataLocal} = ${fragmentFromString(dataClassName)}(
 ${fragmentFromString(dataConstruction)}
   );
 
@@ -1706,7 +1797,7 @@ ${fragmentFromString(dataConstruction)}
     accounts: [
 ${fragmentFromString(accountMetas)}
     ],
-    data: ${fragmentFromString(dataEncoderName)}().encode(instructionData),
+    data: ${fragmentFromString(dataEncoderName)}().encode(${instructionDataLocal}),
   );
 }`);
   parts.push(fragment`
@@ -2130,6 +2221,7 @@ function getDataEnumPageFragment(node, variants, scope) {
   const decoderVariants = [];
   const encodeCases = [];
   const decodeCases = [];
+  let pageHasListEnums = false;
   const allVariantManifests = [];
   for (let i = 0; i < variants.length; i++) {
     const variant = variants[i];
@@ -2177,10 +2269,14 @@ function getDataEnumPageFragment(node, variants, scope) {
       const ctorSignature = fields.length === 0 ? `  const ${variantClassName}();` : `  const ${variantClassName}({
 ${ctorParams}
   });`;
-      const eqChecks = fields.length === 0 ? "true" : fields.map((f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`).join(" &&\n          ");
-      const hashExpression = getHashExpression(
-        fields.map((f) => camelCase(f.name))
-      );
+      const eqChecks = fields.length === 0 ? "true" : fields.map((f, index) => {
+        const fieldName = camelCase(f.name);
+        return isListManifest(fieldManifests[index].manifest) ? `_listEquals(${fieldName}, other.${fieldName})` : `${fieldName} == other.${fieldName}`;
+      }).join(" &&\n          ");
+      const hashExpression = getValueHashExpression(fields, fieldManifests);
+      if (fieldManifests.some(({ manifest }) => isListManifest(manifest))) {
+        pageHasListEnums = true;
+      }
       const toStringFields = fields.map((f) => `${camelCase(f.name)}: $${camelCase(f.name)}`).join(", ");
       variantClasses.push(`final class ${variantClassName} extends ${typeName} {
 ${ctorSignature}
@@ -2286,7 +2382,7 @@ sealed class ${fragmentFromString(typeName)} {
   const ${fragmentFromString(typeName)}();
 }
 
-${fragmentFromString(variantClasses.join("\n\n"))}
+${fragmentFromString(variantClasses.join("\n\n"))}${pageHasListEnums ? LIST_VALUE_HELPERS : ""}
 
 Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
   return transformEncoder<Map<String, Object?>, ${fragmentFromString(typeName)}>(
@@ -2329,6 +2425,7 @@ function getStructPageFragment(node, scope) {
   const structNode = node.type;
   if (structNode.kind !== "structTypeNode") return emptyFragment();
   const fields = structNode.fields ?? [];
+  let pageHasListStructs = false;
   const fieldManifests = fields.map((f) => ({
     field: f,
     manifest: visitorsCore.visit(f.type, scope.typeManifestVisitor)
@@ -2340,10 +2437,13 @@ function getStructPageFragment(node, scope) {
   const ctorSignature = fields.length === 0 ? `  const ${typeName}();` : `  const ${typeName}({
 ${ctorParams}
   });`;
-  const eqChecks = fields.length === 0 ? "true" : fields.map(
-    (f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`
-  ).join(" &&\n          ");
-  fields.length === 0 ? "runtimeType" : fields.map((f) => camelCase(f.name)).join(", ");
+  const eqChecks = fields.length === 0 ? "true" : fieldManifests.map(({ field: f, manifest }, index) => {
+    const fieldName = camelCase(f.name);
+    return isListManifest(manifest) ? `_listEquals(${fieldName}, other.${fieldName})` : `${fieldName} == other.${fieldName}`;
+  }).join(" &&\n          ");
+  if (fieldManifests.some(({ manifest }) => isListManifest(manifest))) {
+    pageHasListStructs = true;
+  }
   const toStringFields = fields.map(
     (f) => `${camelCase(f.name)}: $${camelCase(f.name)}`
   ).join(", ");
@@ -2393,12 +2493,14 @@ ${fragmentFromString(fieldDecls)}
           ${fragmentFromString(eqChecks)};
 
   @override
-  int get hashCode => ${fragmentFromString(getHashExpression(fields.map((f) => camelCase(f.name))))};
+  int get hashCode => ${fragmentFromString(
+    getValueHashExpression(fields, fieldManifests)
+  )};
 
   @override
   String toString() => '${fragmentFromString(typeName)}(${fragmentFromString(toStringFields)})';
 }
-
+${pageHasListStructs ? LIST_VALUE_HELPERS : ""}
 Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
   final structEncoder = getStructEncoder(<(String, Encoder<Object?>)>[
 ${fragmentFromString(encFields)}
@@ -2464,6 +2566,56 @@ Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragme
   return combineCodec(${fragmentFromString(encoderName)}(), ${fragmentFromString(decoderName)}());
 }`;
 }
+function isListManifest(manifest) {
+  return manifest.type.content.startsWith("List<") || manifest.type.content === "Uint8List";
+}
+var LIST_VALUE_HELPERS = `
+bool _listEquals<T>(List<T>? a, List<T>? b) {
+  if (identical(a, b)) return true;
+  if (a == null || b == null) return a == b;
+  if (a.length != b.length) return false;
+  for (var i = 0; i < a.length; i++) {
+    final left = a[i];
+    final right = b[i];
+    if (left is List<Object?> && right is List<Object?>) {
+      if (!_listEquals(left, right)) return false;
+    } else if (left != right) {
+      return false;
+    }
+  }
+  return true;
+}
+
+Object? _deepHash(Object? value) {
+  if (value is List<Object?>) {
+    return Object.hashAll(value.map(_deepHash));
+  }
+  return value;
+}
+
+int _listHashCode<T>(List<T>? a) {
+  if (a == null) return 0;
+  return Object.hashAll(a.map(_deepHash));
+}
+`;
+function getValueHashExpression(fields, fieldManifests) {
+  const fieldNames = fields.map(
+    (f) => camelCase(f.name)
+  );
+  const hasListFields = fieldManifests.some(
+    ({ manifest }) => isListManifest(manifest)
+  );
+  if (!hasListFields) {
+    return getHashExpression(fieldNames);
+  }
+  if (fieldNames.length === 1) {
+    return `_listHashCode(${fieldNames[0]})`;
+  }
+  const hashArgs = fields.map(
+    (f, index) => isListManifest(fieldManifests[index].manifest) ? `_listHashCode(${camelCase(f.name)})` : camelCase(f.name)
+  );
+  return `Object.hash(${hashArgs.join(", ")})`;
+}
 function getHashExpression(fields) {
   if (fields.length === 0) return "runtimeType.hashCode";
   if (fields.length === 1) return `${fields[0]}.hashCode`;