@codama/renderers-js 1.5.4 → 1.6.0

package/dist/index.browser.mjs

@@ -1,10 +1,12 @@
 import { camelCase, pascalCase, snakeCase, titleCase, kebabCase, capitalize, REGISTERED_TYPE_NODE_KINDS, REGISTERED_VALUE_NODE_KINDS, isNodeFilter, resolveNestedTypeNode, structTypeNodeFromInstructionArgumentNodes, isNode, isScalarEnum, structTypeNode, structFieldTypeNode, getAllPrograms, getAllPdas, getAllAccounts, getAllInstructionsWithSubs, getAllDefinedTypes, definedTypeLinkNode, definedTypeNode, isDataEnum, accountValueNode, argumentValueNode, parseOptionalAccountStrategy, VALUE_NODES, getAllInstructionArguments, constantDiscriminatorNode, constantValueNodeFromBytes, constantValueNode, assertIsNode } from '@codama/nodes';
-import { setFragmentContent, mapFragmentContent, createRenderMap, mergeRenderMaps, deleteDirectory, writeRenderMap, createFragmentTemplate, mapRenderMapContentAsync, joinPath, fileExists, readJson, writeFile } from '@codama/renderers-core';
+import { setFragmentContent, mapFragmentContent, createRenderMap, mergeRenderMaps, deleteDirectory, mapRenderMapContentAsync, writeRenderMap, createFragmentTemplate, joinPath, fileExists, readJson, writeFile } from '@codama/renderers-core';
 import { NodeStack, pipe, staticVisitor, extendVisitor, visit, findLastNodeFromPath, recordNodeStackVisitor, LinkableDictionary, getResolvedInstructionInputsVisitor, getByteSizeVisitor, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor, findProgramNodeFromPath, getLastNodeFromPath, findInstructionNodeFromPath, deduplicateInstructionDependencies } from '@codama/visitors-core';
 import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder, getBase64Decoder } from '@solana/codecs-strings';
-import { format } from 'prettier';
+import 'prettier';
+import * as babelPlugin from 'prettier/plugins/babel';
 import * as estreePlugin from 'prettier/plugins/estree';
 import * as typeScriptPlugin from 'prettier/plugins/typescript';
+import { format } from 'prettier/standalone';
 import { CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND, logWarn, CODAMA_ERROR__RENDERERS__MISSING_DEPENDENCY_VERSIONS } from '@codama/errors';
 import { subset, minVersion, lt } from 'semver';
 
@@ -188,6 +190,7 @@ var DEFAULT_NAME_TRANSFORMERS = {
   programInstructionsEnum: (name) => `${pascalCase(name)}Instruction`,
   programInstructionsEnumVariant: (name) => `${pascalCase(name)}`,
   programInstructionsIdentifierFunction: (name) => `identify${pascalCase(name)}Instruction`,
+  programInstructionsParseFunction: (name) => `parse${pascalCase(name)}Instruction`,
   programInstructionsParsedUnionType: (name) => `Parsed${pascalCase(name)}Instruction`,
   programIsErrorFunction: (name) => `is${pascalCase(name)}Error`,
   resolverFunction: (name) => `${camelCase(name)}`
@@ -384,25 +387,17 @@ var getDefinedTypeNodesToExtract = (nodes, parsedCustomDataOptions) => nodes.fla
   ];
 });
 var DEFAULT_PRETTIER_OPTIONS = {
-  arrowParens: "always",
-  parser: "typescript",
-  plugins: [estreePlugin, typeScriptPlugin],
-  printWidth: 80,
-  semi: true,
-  singleQuote: true,
-  tabWidth: 2,
-  trailingComma: "es5",
-  useTabs: false
+  plugins: [estreePlugin, typeScriptPlugin, babelPlugin]
 };
-async function formatCode(renderMap, options) {
+async function getCodeFormatter(options) {
   const shouldFormatCode = options.formatCode ?? true;
-  if (!shouldFormatCode) return renderMap;
+  if (!shouldFormatCode) return (code) => Promise.resolve(code);
   const prettierOptions = {
     ...DEFAULT_PRETTIER_OPTIONS,
     ...await resolvePrettierOptions(options.packageFolder),
     ...options.prettierOptions
   };
-  return await mapRenderMapContentAsync(renderMap, (code) => format(code, prettierOptions));
+  return (code, filepath) => format(code, { ...prettierOptions, filepath });
 }
 async function resolvePrettierOptions(packageFolder) {
   {
@@ -466,7 +461,7 @@ var DEFAULT_DEPENDENCY_VERSIONS = {
   "@solana/rpc-types": "^5.0.0",
   "@solana/signers": "^5.0.0"
 };
-function syncPackageJson(renderMap, options) {
+async function syncPackageJson(renderMap, formatCode, options) {
   const shouldSyncPackageJson = options.syncPackageJson ?? false;
   const packageFolder = options.packageFolder;
   if (!packageFolder) {
@@ -490,10 +485,10 @@ function syncPackageJson(renderMap, options) {
   }
   if (fileExists(packageJsonPath)) {
     const packageJson = updateExistingPackageJson(readJson(packageJsonPath), usedDependencies);
-    writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+    await writePackageJson(packageJson, packageJsonPath, formatCode);
   } else {
     const packageJson = createNewPackageJson(usedDependencies);
-    writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+    await writePackageJson(packageJson, packageJsonPath, formatCode);
   }
 }
 function createNewPackageJson(dependencyVersions) {
@@ -621,6 +616,11 @@ function updateDependency(dependencyGroup, dependency, requiredRange) {
   if (!shouldUpdateRange(dependency, currentRange, requiredRange)) return;
   dependencyGroup[dependency] = requiredRange;
 }
+async function writePackageJson(packageJson, packageJsonPath, formatCode) {
+  const packageJsonContent = JSON.stringify(packageJson, null, 2) + "\n";
+  const formattedContent = await formatCode(packageJsonContent, packageJsonPath);
+  writeFile(packageJsonPath, formattedContent);
+}
 
 // src/fragments/accountFetchHelpers.ts
 function getAccountFetchHelpersFragment(scope) {
@@ -2088,7 +2088,8 @@ function getProgramInstructionsFragment(scope) {
     [
       getProgramInstructionsEnumFragment(scopeWithInstructions),
       getProgramInstructionsIdentifierFunctionFragment(scopeWithInstructions),
-      getProgramInstructionsParsedUnionTypeFragment(scopeWithInstructions)
+      getProgramInstructionsParsedUnionTypeFragment(scopeWithInstructions),
+      getProgramInstructionsParseFunctionFragment(scopeWithInstructions)
     ],
     (c) => c.join("\n\n")
   );
@@ -2157,6 +2158,39 @@ function getProgramInstructionsParsedUnionTypeFragment(scope) {
     (c) => c.join("\n")
   );
 }
+function getProgramInstructionsParseFunctionFragment(scope) {
+  const { programNode, nameApi, allInstructions } = scope;
+  const instructionsWithDiscriminators = allInstructions.filter(
+    (instruction) => (instruction.discriminators ?? []).length > 0
+  );
+  if (instructionsWithDiscriminators.length === 0) return;
+  const programInstructionsEnum = nameApi.programInstructionsEnum(programNode.name);
+  const programInstructionsIdentifierFunction = nameApi.programInstructionsIdentifierFunction(programNode.name);
+  const programInstructionsParsedUnionType = nameApi.programInstructionsParsedUnionType(programNode.name);
+  const parseFunction = nameApi.programInstructionsParseFunction(programNode.name);
+  const switchCases = mergeFragments(
+    allInstructions.map((instruction) => {
+      const enumVariant = nameApi.programInstructionsEnumVariant(instruction.name);
+      const parseFunction2 = use(nameApi.instructionParseFunction(instruction.name), "generatedInstructions");
+      const assertIsInstructionWithAccounts = use("assertIsInstructionWithAccounts", "solanaInstructions");
+      const hasAccounts = instruction.accounts.length > 0;
+      const assertionsCode = hasAccounts ? fragment`${assertIsInstructionWithAccounts}(instruction);\n` : fragment``;
+      return fragment`case ${programInstructionsEnum}.${enumVariant}: { ${assertionsCode}return { instructionType: ${programInstructionsEnum}.${enumVariant}, ...${parseFunction2}(instruction) }; }`;
+    }),
+    (c) => c.join("\n")
+  );
+  return fragment`
+        export function ${parseFunction}<TProgram extends string>(
+            instruction: ${use("type Instruction", "solanaInstructions")}<TProgram> 
+                & ${use("type InstructionWithData", "solanaInstructions")}<${use("type ReadonlyUint8Array", "solanaCodecsCore")}>
+        ): ${programInstructionsParsedUnionType}<TProgram> {
+            const instructionType = ${programInstructionsIdentifierFunction}(instruction);
+            switch (instructionType) {
+                ${switchCases}
+                default: throw new Error("Unrecognized instruction type: " + instructionType);
+            }
+        }`;
+}
 
 // src/fragments/programPage.ts
 function getProgramPageFragment(scope) {
@@ -3202,8 +3236,9 @@ function renderVisitor(path, options = {}) {
       deleteDirectory(path);
     }
     let renderMap = visit(root, getRenderMapVisitor(options));
-    renderMap = await formatCode(renderMap, options);
-    syncPackageJson(renderMap, options);
+    const formatCode = await getCodeFormatter(options);
+    renderMap = await mapRenderMapContentAsync(renderMap, formatCode);
+    await syncPackageJson(renderMap, formatCode, options);
     writeRenderMap(renderMap, path);
   });
 }