@codama/renderers-js 1.4.3 → 1.5.1

package/dist/index.react-native.mjs

@@ -697,11 +697,15 @@ function getAccountTypeFragment(scope) {
   const accountNode = getLastNodeFromPath4(accountPath);
   if (customAccountData.has(accountNode.name)) return;
   return getTypeWithCodecFragment({
+    codecDocs: [`Gets the codec for {@link ${nameApi.dataType(accountNode.name)}} account data.`],
+    decoderDocs: [`Gets the decoder for {@link ${nameApi.dataType(accountNode.name)}} account data.`],
+    encoderDocs: [`Gets the encoder for {@link ${nameApi.dataArgsType(accountNode.name)}} account data.`],
     manifest: typeManifest2,
     name: accountNode.name,
     nameApi,
     node: resolveNestedTypeNode(accountNode.data),
-    size: scope.size
+    size: scope.size,
+    typeDocs: accountNode.docs
   });
 }
 
@@ -1115,39 +1119,39 @@ function getInstructionInputDefaultFragment(scope) {
     }
     return fragment`args.${inputName} = ${renderedValue};`;
   };
+  const expectTransactionSigner = use("expectTransactionSigner", "shared");
+  const expectSome = use("expectSome", "shared");
+  const expectAddress = use("expectAddress", "shared");
+  const expectProgramDerivedAddress = use("expectProgramDerivedAddress", "shared");
+  const addressType = use("type Address", "solanaAddresses");
   switch (defaultValue.kind) {
     case "accountValueNode":
       const name = camelCase6(defaultValue.name);
       if (input.kind === "instructionAccountNode" && input.resolvedIsSigner && !input.isSigner) {
-        return pipe5(
-          defaultFragment(`expectTransactionSigner(accounts.${name}.value).address`),
-          (f) => addFragmentImports(f, "shared", ["expectTransactionSigner"])
-        );
+        return defaultFragment(fragment`${expectTransactionSigner}(accounts.${name}.value).address`);
       }
       if (input.kind === "instructionAccountNode") {
-        return pipe5(
-          defaultFragment(`expectSome(accounts.${name}.value)`),
-          (f) => addFragmentImports(f, "shared", ["expectSome"])
-        );
+        return defaultFragment(fragment`${expectSome}(accounts.${name}.value)`);
       }
-      return pipe5(
-        defaultFragment(`expectAddress(accounts.${name}.value)`),
-        (f) => addFragmentImports(f, "shared", ["expectAddress"])
-      );
+      return defaultFragment(fragment`${expectAddress}(accounts.${name}.value)`);
     case "pdaValueNode":
+      let pdaProgramValue;
+      if (isNode8(defaultValue.programId, "accountValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(accounts.${camelCase6(defaultValue.programId.name)}.value)`;
+      }
+      if (isNode8(defaultValue.programId, "argumentValueNode")) {
+        pdaProgramValue = fragment`${expectAddress}(args.${camelCase6(defaultValue.programId.name)})`;
+      }
       if (isNode8(defaultValue.pda, "pdaNode")) {
-        const pdaProgram = defaultValue.pda.programId ? pipe5(
-          fragment`'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`,
-          (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
-        ) : fragment`programAddress`;
+        let pdaProgram = fragment`programAddress`;
+        if (pdaProgramValue) {
+          pdaProgram = pdaProgramValue;
+        } else if (defaultValue.pda.programId) {
+          pdaProgram = fragment`'${defaultValue.pda.programId}' as ${addressType}<'${defaultValue.pda.programId}'>`;
+        }
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
           if (isNode8(seed, "constantPdaSeedNode") && isNode8(seed.value, "programIdValueNode")) {
-            return [
-              pipe5(
-                fragment`getAddressEncoder().encode(${pdaProgram})`,
-                (f) => addFragmentImports(f, "solanaAddresses", ["getAddressEncoder"])
-              )
-            ];
+            return [fragment`${use("getAddressEncoder", "solanaAddresses")}().encode(${pdaProgram})`];
           }
           if (isNode8(seed, "constantPdaSeedNode") && !isNode8(seed.value, "programIdValueNode")) {
             const typeManifest2 = visit4(seed.type, typeManifestVisitor);
@@ -1160,18 +1164,12 @@ function getInstructionInputDefaultFragment(scope) {
             if (!valueSeed) return [];
             if (isNode8(valueSeed, "accountValueNode")) {
               return [
-                pipe5(
-                  fragment`${typeManifest2.encoder}.encode(expectAddress(accounts.${camelCase6(valueSeed.name)}.value))`,
-                  (f) => addFragmentImports(f, "shared", ["expectAddress"])
-                )
+                fragment`${typeManifest2.encoder}.encode(${expectAddress}(accounts.${camelCase6(valueSeed.name)}.value))`
               ];
             }
             if (isNode8(valueSeed, "argumentValueNode")) {
               return [
-                pipe5(
-                  fragment`${typeManifest2.encoder}.encode(expectSome(args.${camelCase6(valueSeed.name)}))`,
-                  (f) => addFragmentImports(f, "shared", ["expectSome"])
-                )
+                fragment`${typeManifest2.encoder}.encode(${expectSome}(args.${camelCase6(valueSeed.name)}))`
               ];
             }
             const valueManifest2 = visit4(valueSeed, typeManifestVisitor);
@@ -1179,29 +1177,21 @@ function getInstructionInputDefaultFragment(scope) {
           }
           return [];
         });
-        return pipe5(
-          mergeFragments([pdaProgram, ...pdaSeeds2], ([p, ...s]) => {
-            const programAddress2 = p === "programAddress" ? p : `programAddress: ${p}`;
-            return `await getProgramDerivedAddress({ ${programAddress2}, seeds: [${s.join(", ")}] })`;
-          }),
-          (f) => addFragmentImports(f, "solanaAddresses", ["getProgramDerivedAddress"]),
-          (f) => mapFragmentContent4(f, (c) => defaultFragment(c).content)
+        const getProgramDerivedAddress = use("getProgramDerivedAddress", "solanaAddresses");
+        const programAddress2 = pdaProgram.content === "programAddress" ? pdaProgram : fragment`programAddress: ${pdaProgram}`;
+        const seeds = mergeFragments(pdaSeeds2, (s) => s.join(", "));
+        return defaultFragment(
+          fragment`await ${getProgramDerivedAddress}({ ${programAddress2}, seeds: [${seeds}] })`
         );
       }
-      const pdaFunction = nameApi.pdaFindFunction(defaultValue.pda.name);
+      const pdaFunction = use(nameApi.pdaFindFunction(defaultValue.pda.name), getImportFrom(defaultValue.pda));
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
         if (isNode8(seed.value, "accountValueNode")) {
-          return pipe5(
-            fragment`${seed.name}: expectAddress(accounts.${camelCase6(seed.value.name)}.value)`,
-            (f) => addFragmentImports(f, "shared", ["expectAddress"])
-          );
+          return fragment`${seed.name}: ${expectAddress}(accounts.${camelCase6(seed.value.name)}.value)`;
         }
         if (isNode8(seed.value, "argumentValueNode")) {
-          return pipe5(
-            fragment`${seed.name}: expectSome(args.${camelCase6(seed.value.name)})`,
-            (f) => addFragmentImports(f, "shared", ["expectSome"])
-          );
+          return fragment`${seed.name}: ${expectSome}(args.${camelCase6(seed.value.name)})`;
         }
         return pipe5(
           visit4(seed.value, typeManifestVisitor).value,
@@ -1213,49 +1203,38 @@ function getInstructionInputDefaultFragment(scope) {
         (f) => mapFragmentContent4(f, (c) => `{ ${c} }`)
       );
       if (pdaSeeds.length > 0) {
-        pdaArgs.push(pdaSeedsFragment.content);
+        pdaArgs.push(pdaSeedsFragment);
       }
-      const module = getImportFrom(defaultValue.pda);
-      return pipe5(
-        defaultFragment(`await ${pdaFunction}(${pdaArgs.join(", ")})`),
-        (f) => mergeFragmentImports(f, [pdaSeedsFragment.imports]),
-        (f) => addFragmentImports(f, module, [pdaFunction])
-      );
+      if (pdaProgramValue) {
+        pdaArgs.push(fragment`{ programAddress: ${pdaProgramValue} }`);
+      }
+      return defaultFragment(fragment`await ${pdaFunction}(${mergeFragments(pdaArgs, (c) => c.join(", "))})`);
     case "publicKeyValueNode":
-      return pipe5(
-        defaultFragment(`'${defaultValue.publicKey}' as Address<'${defaultValue.publicKey}'>`),
-        (f) => addFragmentImports(f, "solanaAddresses", ["type Address"])
+      return defaultFragment(
+        fragment`'${defaultValue.publicKey}' as ${addressType}<'${defaultValue.publicKey}'>`
       );
     case "programLinkNode":
-      const programAddress = nameApi.programAddressConstant(defaultValue.name);
-      return pipe5(
-        defaultFragment(programAddress, false),
-        (f) => addFragmentImports(f, getImportFrom(defaultValue), [programAddress])
-      );
+      const programAddress = use(nameApi.programAddressConstant(defaultValue.name), getImportFrom(defaultValue));
+      return defaultFragment(programAddress, false);
     case "programIdValueNode":
       if (optionalAccountStrategy === "programId" && input.kind === "instructionAccountNode" && input.isOptional) {
         return fragment``;
       }
-      return defaultFragment("programAddress", false);
+      return defaultFragment(fragment`programAddress`, false);
     case "identityValueNode":
     case "payerValueNode":
       return fragment``;
     case "accountBumpValueNode":
-      return pipe5(
-        defaultFragment(`expectProgramDerivedAddress(accounts.${camelCase6(defaultValue.name)}.value)[1]`),
-        (f) => addFragmentImports(f, "shared", ["expectProgramDerivedAddress"])
+      return defaultFragment(
+        fragment`${expectProgramDerivedAddress}(accounts.${camelCase6(defaultValue.name)}.value)[1]`
       );
     case "argumentValueNode":
-      return pipe5(
-        defaultFragment(`expectSome(args.${camelCase6(defaultValue.name)})`),
-        (f) => addFragmentImports(f, "shared", ["expectSome"])
-      );
+      return defaultFragment(fragment`${expectSome}(args.${camelCase6(defaultValue.name)})`);
     case "resolverValueNode":
-      const resolverFunction = nameApi.resolverFunction(defaultValue.name);
+      const resolverFunction = use(nameApi.resolverFunction(defaultValue.name), getImportFrom(defaultValue));
       const resolverAwait = useAsync && asyncResolvers.includes(defaultValue.name) ? "await " : "";
       return pipe5(
-        defaultFragment(`${resolverAwait}${resolverFunction}(resolverScope)`),
-        (f) => addFragmentImports(f, getImportFrom(defaultValue), [resolverFunction]),
+        defaultFragment(fragment`${resolverAwait}${resolverFunction}(resolverScope)`),
         (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
       );
     case "conditionalValueNode":
@@ -1281,10 +1260,10 @@ function getInstructionInputDefaultFragment(scope) {
       let condition = "true";
       if (isNode8(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
-        const module2 = getImportFrom(defaultValue.condition);
+        const module = getImportFrom(defaultValue.condition);
         conditionalFragment = pipe5(
           conditionalFragment,
-          (f) => addFragmentImports(f, module2, [conditionalResolverFunction]),
+          (f) => addFragmentImports(f, module, [conditionalResolverFunction]),
           (f) => addFragmentFeatures(f, ["instruction:resolverScopeVariable"])
         );
         const conditionalResolverAwait = useAsync && asyncResolvers.includes(defaultValue.condition.name) ? "await " : "";
@@ -1319,7 +1298,7 @@ ${ifTrueRenderer ? ifTrueRenderer.content : ifFalseRenderer?.content}
       );
     default:
       const valueManifest = visit4(defaultValue, typeManifestVisitor).value;
-      return pipe5(valueManifest, (f) => mapFragmentContent4(f, (c) => defaultFragment(c).content));
+      return defaultFragment(valueManifest);
   }
 }
 function renderNestedInstructionDefault(scope) {