Latest Threat Research:SANDWORM_MODE: Shai-Hulud-Style npm Worm Hijacks CI Workflows and Poisons AI Toolchains.Details →
@codama/visitors
Advanced tools
@codama/visitors - npm Package Compare versions
+304
-419
@@ -1,67 +0,16 @@ | ||
| "use strict"; | ||
| var __defProp = Object.defineProperty; | ||
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
| var __getOwnPropNames = Object.getOwnPropertyNames; | ||
| var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
| var __export = (target, all) => { | ||
| for (var name in all) | ||
| __defProp(target, name, { get: all[name], enumerable: true }); | ||
| }; | ||
| var __copyProps = (to, from, except, desc) => { | ||
| if (from && typeof from === "object" || typeof from === "function") { | ||
| for (let key of __getOwnPropNames(from)) | ||
| if (!__hasOwnProp.call(to, key) && key !== except) | ||
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
| } | ||
| return to; | ||
| }; | ||
| var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default")); | ||
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
| 'use strict'; | ||
| var visitorsCore = require('@codama/visitors-core'); | ||
| var errors = require('@codama/errors'); | ||
| var nodes = require('@codama/nodes'); | ||
| // src/index.ts | ||
| var index_exports = {}; | ||
| __export(index_exports, { | ||
| addPdasVisitor: () => addPdasVisitor, | ||
| createSubInstructionsFromEnumArgsVisitor: () => createSubInstructionsFromEnumArgsVisitor, | ||
| deduplicateIdenticalDefinedTypesVisitor: () => deduplicateIdenticalDefinedTypesVisitor, | ||
| fillDefaultPdaSeedValuesVisitor: () => fillDefaultPdaSeedValuesVisitor, | ||
| flattenInstructionArguments: () => flattenInstructionArguments, | ||
| flattenInstructionDataArgumentsVisitor: () => flattenInstructionDataArgumentsVisitor, | ||
| flattenStruct: () => flattenStruct, | ||
| flattenStructVisitor: () => flattenStructVisitor, | ||
| getCommonInstructionAccountDefaultRules: () => getCommonInstructionAccountDefaultRules, | ||
| getDefinedTypeHistogramVisitor: () => getDefinedTypeHistogramVisitor, | ||
| setAccountDiscriminatorFromFieldVisitor: () => setAccountDiscriminatorFromFieldVisitor, | ||
| setFixedAccountSizesVisitor: () => setFixedAccountSizesVisitor, | ||
| setInstructionAccountDefaultValuesVisitor: () => setInstructionAccountDefaultValuesVisitor, | ||
| setInstructionDiscriminatorsVisitor: () => setInstructionDiscriminatorsVisitor, | ||
| setNumberWrappersVisitor: () => setNumberWrappersVisitor, | ||
| setStructDefaultValuesVisitor: () => setStructDefaultValuesVisitor, | ||
| transformDefinedTypesIntoAccountsVisitor: () => transformDefinedTypesIntoAccountsVisitor, | ||
| transformU8ArraysToBytesVisitor: () => transformU8ArraysToBytesVisitor, | ||
| unwrapDefinedTypesVisitor: () => unwrapDefinedTypesVisitor, | ||
| unwrapInstructionArgsDefinedTypesVisitor: () => unwrapInstructionArgsDefinedTypesVisitor, | ||
| unwrapTupleEnumWithSingleStructVisitor: () => unwrapTupleEnumWithSingleStructVisitor, | ||
| unwrapTypeDefinedLinksVisitor: () => unwrapTypeDefinedLinksVisitor, | ||
| updateAccountsVisitor: () => updateAccountsVisitor, | ||
| updateDefinedTypesVisitor: () => updateDefinedTypesVisitor, | ||
| updateErrorsVisitor: () => updateErrorsVisitor, | ||
| updateInstructionsVisitor: () => updateInstructionsVisitor, | ||
| updateProgramsVisitor: () => updateProgramsVisitor | ||
| }); | ||
| module.exports = __toCommonJS(index_exports); | ||
| __reExport(index_exports, require("@codama/visitors-core"), module.exports); | ||
| // src/addPdasVisitor.ts | ||
| var import_errors = require("@codama/errors"); | ||
| var import_nodes = require("@codama/nodes"); | ||
| var import_visitors_core = require("@codama/visitors-core"); | ||
| function addPdasVisitor(pdas) { | ||
| return (0, import_visitors_core.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(pdas).map(([uncasedProgramName, newPdas]) => { | ||
| const programName = (0, import_nodes.camelCase)(uncasedProgramName); | ||
| const programName = nodes.camelCase(uncasedProgramName); | ||
| return { | ||
| select: `[programNode]${programName}`, | ||
| transform: (node) => { | ||
| (0, import_nodes.assertIsNode)(node, "programNode"); | ||
| nodes.assertIsNode(node, "programNode"); | ||
| const existingPdaNames = new Set(node.pdas.map((pda) => pda.name)); | ||
@@ -71,3 +20,3 @@ const newPdaNames = new Set(newPdas.map((pda) => pda.name)); | ||
| if (overlappingPdaNames.size > 0) { | ||
| throw new import_errors.CodamaError(import_errors.CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, { | ||
| duplicatedPdaNames: [...overlappingPdaNames], | ||
@@ -78,5 +27,5 @@ program: node, | ||
| } | ||
| return (0, import_nodes.programNode)({ | ||
| return nodes.programNode({ | ||
| ...node, | ||
| pdas: [...node.pdas, ...newPdas.map(({ name, seeds, docs }) => (0, import_nodes.pdaNode)({ docs, name, seeds }))] | ||
| pdas: [...node.pdas, ...newPdas.map(({ name, seeds, docs }) => nodes.pdaNode({ docs, name, seeds }))] | ||
| }); | ||
@@ -88,19 +37,9 @@ } | ||
| } | ||
| // src/createSubInstructionsFromEnumArgsVisitor.ts | ||
| var import_errors3 = require("@codama/errors"); | ||
| var import_nodes3 = require("@codama/nodes"); | ||
| var import_visitors_core3 = require("@codama/visitors-core"); | ||
| // src/flattenInstructionDataArgumentsVisitor.ts | ||
| var import_errors2 = require("@codama/errors"); | ||
| var import_nodes2 = require("@codama/nodes"); | ||
| var import_visitors_core2 = require("@codama/visitors-core"); | ||
| function flattenInstructionDataArgumentsVisitor() { | ||
| return (0, import_visitors_core2.bottomUpTransformerVisitor)([ | ||
| return visitorsCore.bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[instructionNode]", | ||
| transform: (instruction) => { | ||
| (0, import_nodes2.assertIsNode)(instruction, "instructionNode"); | ||
| return (0, import_nodes2.instructionNode)({ | ||
| nodes.assertIsNode(instruction, "instructionNode"); | ||
| return nodes.instructionNode({ | ||
| ...instruction, | ||
@@ -113,8 +52,8 @@ arguments: flattenInstructionArguments(instruction.arguments) | ||
| } | ||
| var flattenInstructionArguments = (nodes, options = "*") => { | ||
| const camelCaseOptions = options === "*" ? options : options.map(import_nodes2.camelCase); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes((0, import_nodes2.camelCase)(node.name)); | ||
| const inlinedArguments = nodes.flatMap((node) => { | ||
| if ((0, import_nodes2.isNode)(node.type, "structTypeNode") && shouldInline(node)) { | ||
| return node.type.fields.map((field) => (0, import_nodes2.instructionArgumentNode)({ ...field })); | ||
| var flattenInstructionArguments = (nodes$1, options = "*") => { | ||
| const camelCaseOptions = options === "*" ? options : options.map(nodes.camelCase); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes(nodes.camelCase(node.name)); | ||
| const inlinedArguments = nodes$1.flatMap((node) => { | ||
| if (nodes.isNode(node.type, "structTypeNode") && shouldInline(node)) { | ||
| return node.type.fields.map((field) => nodes.instructionArgumentNode({ ...field })); | ||
| } | ||
@@ -128,7 +67,7 @@ return node; | ||
| if (hasConflictingNames) { | ||
| throw new import_errors2.CodamaError(import_errors2.CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
| }); | ||
| } | ||
| return hasConflictingNames ? nodes : inlinedArguments; | ||
| return hasConflictingNames ? nodes$1 : inlinedArguments; | ||
| }; | ||
@@ -138,4 +77,4 @@ | ||
| function createSubInstructionsFromEnumArgsVisitor(map) { | ||
| const linkables = new import_visitors_core3.LinkableDictionary(); | ||
| const visitor = (0, import_visitors_core3.bottomUpTransformerVisitor)( | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const visitor = visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -145,9 +84,9 @@ ([selector, argNameInput]) => ({ | ||
| transform: (node, stack) => { | ||
| (0, import_nodes3.assertIsNode)(node, "instructionNode"); | ||
| nodes.assertIsNode(node, "instructionNode"); | ||
| const argFields = node.arguments; | ||
| const argName = (0, import_nodes3.camelCase)(argNameInput); | ||
| const argName = nodes.camelCase(argNameInput); | ||
| const argFieldIndex = argFields.findIndex((field) => field.name === argName); | ||
| const argField = argFieldIndex >= 0 ? argFields[argFieldIndex] : null; | ||
| if (!argField) { | ||
| throw new import_errors3.CodamaError(import_errors3.CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -159,10 +98,10 @@ instruction: node, | ||
| let argType; | ||
| if ((0, import_nodes3.isNode)(argField.type, "enumTypeNode")) { | ||
| if (nodes.isNode(argField.type, "enumTypeNode")) { | ||
| argType = argField.type; | ||
| } else if ((0, import_nodes3.isNode)(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| } else if (nodes.isNode(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| const linkedType = linkables.get([...stack.getPath(), argField.type])?.type; | ||
| (0, import_nodes3.assertIsNode)(linkedType, "enumTypeNode"); | ||
| nodes.assertIsNode(linkedType, "enumTypeNode"); | ||
| argType = linkedType; | ||
| } else { | ||
| throw new import_errors3.CodamaError(import_errors3.CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -174,15 +113,15 @@ instruction: node, | ||
| const subInstructions = argType.variants.map((variant, index) => { | ||
| const subName = (0, import_nodes3.camelCase)(`${node.name} ${variant.name}`); | ||
| const subName = nodes.camelCase(`${node.name} ${variant.name}`); | ||
| const subFields = argFields.slice(0, argFieldIndex); | ||
| subFields.push( | ||
| (0, import_nodes3.instructionArgumentNode)({ | ||
| defaultValue: (0, import_nodes3.numberValueNode)(index), | ||
| nodes.instructionArgumentNode({ | ||
| defaultValue: nodes.numberValueNode(index), | ||
| defaultValueStrategy: "omitted", | ||
| name: `${subName}Discriminator`, | ||
| type: (0, import_nodes3.numberTypeNode)("u8") | ||
| type: nodes.numberTypeNode("u8") | ||
| }) | ||
| ); | ||
| if ((0, import_nodes3.isNode)(variant, "enumStructVariantTypeNode")) { | ||
| if (nodes.isNode(variant, "enumStructVariantTypeNode")) { | ||
| subFields.push( | ||
| (0, import_nodes3.instructionArgumentNode)({ | ||
| nodes.instructionArgumentNode({ | ||
| ...argField, | ||
@@ -192,5 +131,5 @@ type: variant.struct | ||
| ); | ||
| } else if ((0, import_nodes3.isNode)(variant, "enumTupleVariantTypeNode")) { | ||
| } else if (nodes.isNode(variant, "enumTupleVariantTypeNode")) { | ||
| subFields.push( | ||
| (0, import_nodes3.instructionArgumentNode)({ | ||
| nodes.instructionArgumentNode({ | ||
| ...argField, | ||
@@ -202,3 +141,3 @@ type: variant.tuple | ||
| subFields.push(...argFields.slice(argFieldIndex + 1)); | ||
| return (0, import_nodes3.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -209,3 +148,3 @@ arguments: flattenInstructionArguments(subFields), | ||
| }); | ||
| return (0, import_nodes3.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -218,12 +157,8 @@ subInstructions: [...node.subInstructions ?? [], ...subInstructions] | ||
| ); | ||
| return (0, import_visitors_core3.pipe)(visitor, (v) => (0, import_visitors_core3.recordLinkablesOnFirstVisitVisitor)(v, linkables)); | ||
| return visitorsCore.pipe(visitor, (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/deduplicateIdenticalDefinedTypesVisitor.ts | ||
| var import_nodes4 = require("@codama/nodes"); | ||
| var import_visitors_core4 = require("@codama/visitors-core"); | ||
| function deduplicateIdenticalDefinedTypesVisitor() { | ||
| return (0, import_visitors_core4.rootNodeVisitor)((root) => { | ||
| return visitorsCore.rootNodeVisitor((root) => { | ||
| const typeMap = /* @__PURE__ */ new Map(); | ||
| const allPrograms = (0, import_nodes4.getAllPrograms)(root); | ||
| const allPrograms = nodes.getAllPrograms(root); | ||
| allPrograms.forEach((program) => { | ||
@@ -241,5 +176,5 @@ program.definedTypes.forEach((type) => { | ||
| }); | ||
| const hashVisitor = (0, import_visitors_core4.getUniqueHashStringVisitor)({ removeDocs: true }); | ||
| const hashVisitor = visitorsCore.getUniqueHashStringVisitor({ removeDocs: true }); | ||
| typeMap.forEach((list, name) => { | ||
| const types = list.map((item) => (0, import_visitors_core4.visit)(item.type, hashVisitor)); | ||
| const types = list.map((item) => visitorsCore.visit(item.type, hashVisitor)); | ||
| const typesAreEqual = types.every((type, _, arr) => type === arr[0]); | ||
@@ -256,4 +191,4 @@ if (!typesAreEqual) { | ||
| if (deleteSelectors.length > 0) { | ||
| const newRoot = (0, import_visitors_core4.visit)(root, (0, import_visitors_core4.deleteNodesVisitor)(deleteSelectors)); | ||
| (0, import_nodes4.assertIsNode)(newRoot, "rootNode"); | ||
| const newRoot = visitorsCore.visit(root, visitorsCore.deleteNodesVisitor(deleteSelectors)); | ||
| nodes.assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -264,20 +199,15 @@ } | ||
| } | ||
| // src/fillDefaultPdaSeedValuesVisitor.ts | ||
| var import_errors4 = require("@codama/errors"); | ||
| var import_nodes5 = require("@codama/nodes"); | ||
| var import_visitors_core5 = require("@codama/visitors-core"); | ||
| function fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, strictMode = false) { | ||
| const instruction = (0, import_visitors_core5.getLastNodeFromPath)(instructionPath); | ||
| return (0, import_visitors_core5.pipe)( | ||
| (0, import_visitors_core5.identityVisitor)({ keys: import_nodes5.INSTRUCTION_INPUT_VALUE_NODES }), | ||
| (v) => (0, import_visitors_core5.extendVisitor)(v, { | ||
| const instruction = visitorsCore.getLastNodeFromPath(instructionPath); | ||
| return visitorsCore.pipe( | ||
| visitorsCore.identityVisitor({ keys: nodes.INSTRUCTION_INPUT_VALUE_NODES }), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitPdaValue(node, { next }) { | ||
| const visitedNode = next(node); | ||
| (0, import_nodes5.assertIsNode)(visitedNode, "pdaValueNode"); | ||
| const foundPda = (0, import_nodes5.isNode)(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| nodes.assertIsNode(visitedNode, "pdaValueNode"); | ||
| const foundPda = nodes.isNode(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| if (!foundPda) return visitedNode; | ||
| const seeds = addDefaultSeedValuesFromPdaWhenMissing(instruction, foundPda, visitedNode.seeds); | ||
| if (strictMode && !allSeedsAreValid(instruction, foundPda, seeds)) { | ||
| throw new import_errors4.CodamaError(import_errors4.CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| instruction, | ||
@@ -289,3 +219,3 @@ instructionName: instruction.name, | ||
| } | ||
| return (0, import_nodes5.pdaValueNode)(visitedNode.pda, seeds); | ||
| return nodes.pdaValueNode(visitedNode.pda, seeds); | ||
| } | ||
@@ -304,10 +234,10 @@ }) | ||
| return pda.seeds.flatMap((seed) => { | ||
| if (!(0, import_nodes5.isNode)(seed, "variablePdaSeedNode")) return []; | ||
| if (!nodes.isNode(seed, "variablePdaSeedNode")) return []; | ||
| const hasMatchingAccount = instruction.accounts.some((a) => a.name === seed.name); | ||
| if ((0, import_nodes5.isNode)(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| return [(0, import_nodes5.pdaSeedValueNode)(seed.name, (0, import_nodes5.accountValueNode)(seed.name))]; | ||
| if (nodes.isNode(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| return [nodes.pdaSeedValueNode(seed.name, nodes.accountValueNode(seed.name))]; | ||
| } | ||
| const hasMatchingArgument = (0, import_nodes5.getAllInstructionArguments)(instruction).some((a) => a.name === seed.name); | ||
| const hasMatchingArgument = nodes.getAllInstructionArguments(instruction).some((a) => a.name === seed.name); | ||
| if (hasMatchingArgument) { | ||
| return [(0, import_nodes5.pdaSeedValueNode)(seed.name, (0, import_nodes5.argumentValueNode)(seed.name))]; | ||
| return [nodes.pdaSeedValueNode(seed.name, nodes.argumentValueNode(seed.name))]; | ||
| } | ||
@@ -318,10 +248,10 @@ return []; | ||
| function allSeedsAreValid(instruction, foundPda, seeds) { | ||
| const hasAllVariableSeeds = foundPda.seeds.filter((0, import_nodes5.isNodeFilter)("variablePdaSeedNode")).length === seeds.length; | ||
| const hasAllVariableSeeds = foundPda.seeds.filter(nodes.isNodeFilter("variablePdaSeedNode")).length === seeds.length; | ||
| const allAccountsName = instruction.accounts.map((a) => a.name); | ||
| const allArgumentsName = (0, import_nodes5.getAllInstructionArguments)(instruction).map((a) => a.name); | ||
| const allArgumentsName = nodes.getAllInstructionArguments(instruction).map((a) => a.name); | ||
| const validSeeds = seeds.every((seed) => { | ||
| if ((0, import_nodes5.isNode)(seed.value, "accountValueNode")) { | ||
| if (nodes.isNode(seed.value, "accountValueNode")) { | ||
| return allAccountsName.includes(seed.value.name); | ||
| } | ||
| if ((0, import_nodes5.isNode)(seed.value, "argumentValueNode")) { | ||
| if (nodes.isNode(seed.value, "argumentValueNode")) { | ||
| return allArgumentsName.includes(seed.value.name); | ||
@@ -333,9 +263,4 @@ } | ||
| } | ||
| // src/flattenStructVisitor.ts | ||
| var import_errors5 = require("@codama/errors"); | ||
| var import_nodes6 = require("@codama/nodes"); | ||
| var import_visitors_core6 = require("@codama/visitors-core"); | ||
| function flattenStructVisitor(map) { | ||
| return (0, import_visitors_core6.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -350,7 +275,7 @@ ([stack, options]) => ({ | ||
| var flattenStruct = (node, options = "*") => { | ||
| (0, import_nodes6.assertIsNode)(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(import_nodes6.camelCase); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes((0, import_nodes6.camelCase)(field.name)); | ||
| nodes.assertIsNode(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(nodes.camelCase); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes(nodes.camelCase(field.name)); | ||
| const inlinedFields = node.fields.flatMap((field) => { | ||
| if ((0, import_nodes6.isNode)(field.type, "structTypeNode") && shouldInline(field)) { | ||
| if (nodes.isNode(field.type, "structTypeNode") && shouldInline(field)) { | ||
| return field.type.fields; | ||
@@ -365,11 +290,8 @@ } | ||
| if (hasConflictingNames) { | ||
| throw new import_errors5.CodamaError(import_errors5.CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
| }); | ||
| } | ||
| return hasConflictingNames ? node : (0, import_nodes6.structTypeNode)(inlinedFields); | ||
| return hasConflictingNames ? node : nodes.structTypeNode(inlinedFields); | ||
| }; | ||
| // src/getDefinedTypeHistogramVisitor.ts | ||
| var import_visitors_core7 = require("@codama/visitors-core"); | ||
| function mergeHistograms(histograms) { | ||
@@ -394,11 +316,11 @@ const result = {}; | ||
| function getDefinedTypeHistogramVisitor() { | ||
| const stack = new import_visitors_core7.NodeStack(); | ||
| const stack = new visitorsCore.NodeStack(); | ||
| let mode = null; | ||
| let stackLevel = 0; | ||
| return (0, import_visitors_core7.pipe)( | ||
| (0, import_visitors_core7.mergeVisitor)( | ||
| return visitorsCore.pipe( | ||
| visitorsCore.mergeVisitor( | ||
| () => ({}), | ||
| (_, histograms) => mergeHistograms(histograms) | ||
| ), | ||
| (v) => (0, import_visitors_core7.interceptVisitor)(v, (node, next) => { | ||
| (v) => visitorsCore.interceptVisitor(v, (node, next) => { | ||
| stackLevel += 1; | ||
@@ -409,7 +331,7 @@ const newNode = next(node); | ||
| }), | ||
| (v) => (0, import_visitors_core7.extendVisitor)(v, { | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitAccount(node, { self }) { | ||
| mode = "account"; | ||
| stackLevel = 0; | ||
| const histogram = (0, import_visitors_core7.visit)(node.data, self); | ||
| const histogram = visitorsCore.visit(node.data, self); | ||
| mode = null; | ||
@@ -421,3 +343,3 @@ return histogram; | ||
| stackLevel = 0; | ||
| const histogram = (0, import_visitors_core7.visit)(node.type, self); | ||
| const histogram = visitorsCore.visit(node.type, self); | ||
| mode = null; | ||
@@ -427,3 +349,3 @@ return histogram; | ||
| visitDefinedTypeLink(node) { | ||
| const program = (0, import_visitors_core7.findProgramNodeFromPath)(stack.getPath()); | ||
| const program = visitorsCore.findProgramNodeFromPath(stack.getPath()); | ||
| const key = program ? `${program.name}.${node.name}` : node.name; | ||
@@ -443,19 +365,14 @@ return { | ||
| stackLevel = 0; | ||
| const dataHistograms = node.arguments.map((arg) => (0, import_visitors_core7.visit)(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => (0, import_visitors_core7.visit)(arg, self)); | ||
| const dataHistograms = node.arguments.map((arg) => visitorsCore.visit(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => visitorsCore.visit(arg, self)); | ||
| mode = null; | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => (0, import_visitors_core7.visit)(ix, self)); | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => visitorsCore.visit(ix, self)); | ||
| return mergeHistograms([...dataHistograms, ...extraHistograms, ...subHistograms]); | ||
| } | ||
| }), | ||
| (v) => (0, import_visitors_core7.recordNodeStackVisitor)(v, stack) | ||
| (v) => visitorsCore.recordNodeStackVisitor(v, stack) | ||
| ); | ||
| } | ||
| // src/setAccountDiscriminatorFromFieldVisitor.ts | ||
| var import_errors6 = require("@codama/errors"); | ||
| var import_nodes7 = require("@codama/nodes"); | ||
| var import_visitors_core8 = require("@codama/visitors-core"); | ||
| function setAccountDiscriminatorFromFieldVisitor(map) { | ||
| return (0, import_visitors_core8.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -465,7 +382,7 @@ ([selector, { field, value, offset }]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes7.assertIsNode)(node, "accountNode"); | ||
| const accountData = (0, import_nodes7.resolveNestedTypeNode)(node.data); | ||
| nodes.assertIsNode(node, "accountNode"); | ||
| const accountData = nodes.resolveNestedTypeNode(node.data); | ||
| const fieldIndex = accountData.fields.findIndex((f) => f.name === field); | ||
| if (fieldIndex < 0) { | ||
| throw new import_errors6.CodamaError(import_errors6.CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| account: node, | ||
@@ -477,9 +394,9 @@ missingField: field, | ||
| const fieldNode = accountData.fields[fieldIndex]; | ||
| return (0, import_nodes7.accountNode)({ | ||
| return nodes.accountNode({ | ||
| ...node, | ||
| data: (0, import_nodes7.transformNestedTypeNode)( | ||
| data: nodes.transformNestedTypeNode( | ||
| node.data, | ||
| () => (0, import_nodes7.structTypeNode)([ | ||
| () => nodes.structTypeNode([ | ||
| ...accountData.fields.slice(0, fieldIndex), | ||
| (0, import_nodes7.structFieldTypeNode)({ | ||
| nodes.structFieldTypeNode({ | ||
| ...fieldNode, | ||
@@ -492,3 +409,3 @@ defaultValue: value, | ||
| ), | ||
| discriminators: [(0, import_nodes7.fieldDiscriminatorNode)(field, offset), ...node.discriminators ?? []] | ||
| discriminators: [nodes.fieldDiscriminatorNode(field, offset), ...node.discriminators ?? []] | ||
| }); | ||
@@ -500,17 +417,13 @@ } | ||
| } | ||
| // src/setFixedAccountSizesVisitor.ts | ||
| var import_nodes8 = require("@codama/nodes"); | ||
| var import_visitors_core9 = require("@codama/visitors-core"); | ||
| function setFixedAccountSizesVisitor() { | ||
| const linkables = new import_visitors_core9.LinkableDictionary(); | ||
| const visitor = (0, import_visitors_core9.topDownTransformerVisitor)( | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const visitor = visitorsCore.topDownTransformerVisitor( | ||
| [ | ||
| { | ||
| select: (path) => (0, import_visitors_core9.isNodePath)(path, "accountNode") && (0, import_visitors_core9.getLastNodeFromPath)(path).size === void 0, | ||
| select: (path) => visitorsCore.isNodePath(path, "accountNode") && visitorsCore.getLastNodeFromPath(path).size === void 0, | ||
| transform: (node, stack) => { | ||
| (0, import_nodes8.assertIsNode)(node, "accountNode"); | ||
| const size = (0, import_visitors_core9.visit)(node.data, (0, import_visitors_core9.getByteSizeVisitor)(linkables, { stack })); | ||
| nodes.assertIsNode(node, "accountNode"); | ||
| const size = visitorsCore.visit(node.data, visitorsCore.getByteSizeVisitor(linkables, { stack })); | ||
| if (size === null) return node; | ||
| return (0, import_nodes8.accountNode)({ ...node, size }); | ||
| return nodes.accountNode({ ...node, size }); | ||
| } | ||
@@ -521,12 +434,8 @@ } | ||
| ); | ||
| return (0, import_visitors_core9.pipe)(visitor, (v) => (0, import_visitors_core9.recordLinkablesOnFirstVisitVisitor)(v, linkables)); | ||
| return visitorsCore.pipe(visitor, (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/setInstructionAccountDefaultValuesVisitor.ts | ||
| var import_nodes9 = require("@codama/nodes"); | ||
| var import_visitors_core10 = require("@codama/visitors-core"); | ||
| var getCommonInstructionAccountDefaultRules = () => [ | ||
| { | ||
| account: /^(payer|feePayer)$/, | ||
| defaultValue: (0, import_nodes9.payerValueNode)(), | ||
| defaultValue: nodes.payerValueNode(), | ||
| ignoreIfOptional: true | ||
@@ -536,3 +445,3 @@ }, | ||
| account: /^(authority)$/, | ||
| defaultValue: (0, import_nodes9.identityValueNode)(), | ||
| defaultValue: nodes.identityValueNode(), | ||
| ignoreIfOptional: true | ||
@@ -542,3 +451,3 @@ }, | ||
| account: /^(programId)$/, | ||
| defaultValue: (0, import_nodes9.programIdValueNode)(), | ||
| defaultValue: nodes.programIdValueNode(), | ||
| ignoreIfOptional: true | ||
@@ -548,3 +457,3 @@ }, | ||
| account: /^(systemProgram|splSystemProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("11111111111111111111111111111111", "splSystem"), | ||
| defaultValue: nodes.publicKeyValueNode("11111111111111111111111111111111", "splSystem"), | ||
| ignoreIfOptional: true | ||
@@ -554,3 +463,3 @@ }, | ||
| account: /^(tokenProgram|splTokenProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", "splToken"), | ||
| defaultValue: nodes.publicKeyValueNode("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", "splToken"), | ||
| ignoreIfOptional: true | ||
@@ -560,3 +469,3 @@ }, | ||
| account: /^(ataProgram|splAtaProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", "splAssociatedToken"), | ||
| defaultValue: nodes.publicKeyValueNode("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", "splAssociatedToken"), | ||
| ignoreIfOptional: true | ||
@@ -566,3 +475,3 @@ }, | ||
| account: /^(tokenMetadataProgram|mplTokenMetadataProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s", "mplTokenMetadata"), | ||
| defaultValue: nodes.publicKeyValueNode("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s", "mplTokenMetadata"), | ||
| ignoreIfOptional: true | ||
@@ -572,3 +481,3 @@ }, | ||
| account: /^(tokenAuth|mplTokenAuth|authorization|mplAuthorization|auth|mplAuth)RulesProgram$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3rboVmgg", "mplTokenAuthRules"), | ||
| defaultValue: nodes.publicKeyValueNode("auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3rboVmgg", "mplTokenAuthRules"), | ||
| ignoreIfOptional: true | ||
@@ -578,3 +487,3 @@ }, | ||
| account: /^(candyMachineProgram|mplCandyMachineProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR", "mplCandyMachine"), | ||
| defaultValue: nodes.publicKeyValueNode("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR", "mplCandyMachine"), | ||
| ignoreIfOptional: true | ||
@@ -584,3 +493,3 @@ }, | ||
| account: /^(candyGuardProgram|mplCandyGuardProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g", "mplCandyGuard"), | ||
| defaultValue: nodes.publicKeyValueNode("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g", "mplCandyGuard"), | ||
| ignoreIfOptional: true | ||
@@ -590,3 +499,3 @@ }, | ||
| account: /^(clockSysvar|sysvarClock)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarC1ock11111111111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarC1ock11111111111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -596,3 +505,3 @@ }, | ||
| account: /^(epochScheduleSysvar|sysvarEpochSchedule)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarEpochSchedu1e111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarEpochSchedu1e111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -602,3 +511,3 @@ }, | ||
| account: /^(instructions?Sysvar|sysvarInstructions?)(Account)?$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("Sysvar1nstructions1111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("Sysvar1nstructions1111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -608,3 +517,3 @@ }, | ||
| account: /^(recentBlockhashesSysvar|sysvarRecentBlockhashes)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarRecentB1ockHashes11111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarRecentB1ockHashes11111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -614,3 +523,3 @@ }, | ||
| account: /^(rent|rentSysvar|sysvarRent)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarRent111111111111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarRent111111111111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -620,3 +529,3 @@ }, | ||
| account: /^(rewardsSysvar|sysvarRewards)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarRewards111111111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarRewards111111111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -626,3 +535,3 @@ }, | ||
| account: /^(slotHashesSysvar|sysvarSlotHashes)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarS1otHashes111111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarS1otHashes111111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -632,3 +541,3 @@ }, | ||
| account: /^(slotHistorySysvar|sysvarSlotHistory)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarS1otHistory11111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarS1otHistory11111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -638,3 +547,3 @@ }, | ||
| account: /^(stakeHistorySysvar|sysvarStakeHistory)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarStakeHistory1111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarStakeHistory1111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -644,3 +553,3 @@ }, | ||
| account: /^(mplCoreProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d", "mplCore"), | ||
| defaultValue: nodes.publicKeyValueNode("CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d", "mplCore"), | ||
| ignoreIfOptional: true | ||
@@ -650,4 +559,4 @@ } | ||
| function setInstructionAccountDefaultValuesVisitor(rules) { | ||
| const linkables = new import_visitors_core10.LinkableDictionary(); | ||
| const stack = new import_visitors_core10.NodeStack(); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const stack = new visitorsCore.NodeStack(); | ||
| const sortedRules = rules.sort((a, b) => { | ||
@@ -661,11 +570,11 @@ const ia = "instruction" in a; | ||
| return sortedRules.find((rule) => { | ||
| if ("instruction" in rule && rule.instruction && (0, import_nodes9.camelCase)(rule.instruction) !== instruction.name) { | ||
| if ("instruction" in rule && rule.instruction && nodes.camelCase(rule.instruction) !== instruction.name) { | ||
| return false; | ||
| } | ||
| return typeof rule.account === "string" ? (0, import_nodes9.camelCase)(rule.account) === account.name : rule.account.test(account.name); | ||
| return typeof rule.account === "string" ? nodes.camelCase(rule.account) === account.name : rule.account.test(account.name); | ||
| }); | ||
| } | ||
| return (0, import_visitors_core10.pipe)( | ||
| (0, import_visitors_core10.nonNullableIdentityVisitor)({ keys: ["rootNode", "programNode", "instructionNode"] }), | ||
| (v) => (0, import_visitors_core10.extendVisitor)(v, { | ||
| return visitorsCore.pipe( | ||
| visitorsCore.nonNullableIdentityVisitor({ keys: ["rootNode", "programNode", "instructionNode"] }), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitInstruction(node) { | ||
@@ -682,3 +591,3 @@ const instructionPath = stack.getPath("instructionNode"); | ||
| ...account, | ||
| defaultValue: (0, import_visitors_core10.visit)( | ||
| defaultValue: visitorsCore.visit( | ||
| rule.defaultValue, | ||
@@ -692,3 +601,3 @@ fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, true) | ||
| }); | ||
| return (0, import_nodes9.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -699,12 +608,8 @@ accounts: instructionAccounts | ||
| }), | ||
| (v) => (0, import_visitors_core10.recordNodeStackVisitor)(v, stack), | ||
| (v) => (0, import_visitors_core10.recordLinkablesOnFirstVisitVisitor)(v, linkables) | ||
| (v) => visitorsCore.recordNodeStackVisitor(v, stack), | ||
| (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/setInstructionDiscriminatorsVisitor.ts | ||
| var import_nodes10 = require("@codama/nodes"); | ||
| var import_visitors_core11 = require("@codama/visitors-core"); | ||
| function setInstructionDiscriminatorsVisitor(map) { | ||
| return (0, import_visitors_core11.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -714,4 +619,4 @@ ([selector, discriminator]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes10.assertIsNode)(node, "instructionNode"); | ||
| const discriminatorArgument = (0, import_nodes10.instructionArgumentNode)({ | ||
| nodes.assertIsNode(node, "instructionNode"); | ||
| const discriminatorArgument = nodes.instructionArgumentNode({ | ||
| defaultValue: discriminator.value, | ||
@@ -721,9 +626,9 @@ defaultValueStrategy: discriminator.strategy ?? "omitted", | ||
| name: discriminator.name ?? "discriminator", | ||
| type: discriminator.type ?? (0, import_nodes10.numberTypeNode)("u8") | ||
| type: discriminator.type ?? nodes.numberTypeNode("u8") | ||
| }); | ||
| return (0, import_nodes10.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
| arguments: [discriminatorArgument, ...node.arguments], | ||
| discriminators: [ | ||
| (0, import_nodes10.fieldDiscriminatorNode)(discriminator.name ?? "discriminator"), | ||
| nodes.fieldDiscriminatorNode(discriminator.name ?? "discriminator"), | ||
| ...node.discriminators ?? [] | ||
@@ -737,9 +642,4 @@ ] | ||
| } | ||
| // src/setNumberWrappersVisitor.ts | ||
| var import_errors7 = require("@codama/errors"); | ||
| var import_nodes11 = require("@codama/nodes"); | ||
| var import_visitors_core12 = require("@codama/visitors-core"); | ||
| function setNumberWrappersVisitor(map) { | ||
| return (0, import_visitors_core12.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -749,12 +649,12 @@ ([selectorStack, wrapper]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes11.assertIsNestedTypeNode)(node, "numberTypeNode"); | ||
| nodes.assertIsNestedTypeNode(node, "numberTypeNode"); | ||
| switch (wrapper.kind) { | ||
| case "DateTime": | ||
| return (0, import_nodes11.dateTimeTypeNode)(node); | ||
| return nodes.dateTimeTypeNode(node); | ||
| case "SolAmount": | ||
| return (0, import_nodes11.solAmountTypeNode)(node); | ||
| return nodes.solAmountTypeNode(node); | ||
| case "Amount": | ||
| return (0, import_nodes11.amountTypeNode)(node, wrapper.decimals, wrapper.unit); | ||
| return nodes.amountTypeNode(node, wrapper.decimals, wrapper.unit); | ||
| default: | ||
| throw new import_errors7.CodamaError(import_errors7.CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| } | ||
@@ -766,11 +666,7 @@ } | ||
| } | ||
| // src/setStructDefaultValuesVisitor.ts | ||
| var import_nodes12 = require("@codama/nodes"); | ||
| var import_visitors_core13 = require("@codama/visitors-core"); | ||
| function setStructDefaultValuesVisitor(map) { | ||
| return (0, import_visitors_core13.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([stack, defaultValues]) => { | ||
| const camelCasedDefaultValues = Object.fromEntries( | ||
| Object.entries(defaultValues).map(([key, value]) => [(0, import_nodes12.camelCase)(key), value]) | ||
| Object.entries(defaultValues).map(([key, value]) => [nodes.camelCase(key), value]) | ||
| ); | ||
@@ -781,3 +677,3 @@ return [ | ||
| transform: (node) => { | ||
| (0, import_nodes12.assertIsNode)(node, "structTypeNode"); | ||
| nodes.assertIsNode(node, "structTypeNode"); | ||
| const fields = node.fields.map((field) => { | ||
@@ -787,3 +683,3 @@ const defaultValue = camelCasedDefaultValues[field.name]; | ||
| if (defaultValue === null) { | ||
| return (0, import_nodes12.structFieldTypeNode)({ | ||
| return nodes.structFieldTypeNode({ | ||
| ...field, | ||
@@ -794,3 +690,3 @@ defaultValue: void 0, | ||
| } | ||
| return (0, import_nodes12.structFieldTypeNode)({ | ||
| return nodes.structFieldTypeNode({ | ||
| ...field, | ||
@@ -801,3 +697,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }); | ||
| return (0, import_nodes12.structTypeNode)(fields); | ||
| return nodes.structTypeNode(fields); | ||
| } | ||
@@ -808,3 +704,3 @@ }, | ||
| transform: (node) => { | ||
| (0, import_nodes12.assertIsNode)(node, "instructionNode"); | ||
| nodes.assertIsNode(node, "instructionNode"); | ||
| const transformArguments = (arg) => { | ||
@@ -814,3 +710,3 @@ const defaultValue = camelCasedDefaultValues[arg.name]; | ||
| if (defaultValue === null) { | ||
| return (0, import_nodes12.instructionArgumentNode)({ | ||
| return nodes.instructionArgumentNode({ | ||
| ...arg, | ||
@@ -821,3 +717,3 @@ defaultValue: void 0, | ||
| } | ||
| return (0, import_nodes12.instructionArgumentNode)({ | ||
| return nodes.instructionArgumentNode({ | ||
| ...arg, | ||
@@ -828,3 +724,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }; | ||
| return (0, import_nodes12.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -840,10 +736,6 @@ arguments: node.arguments.map(transformArguments), | ||
| } | ||
| // src/transformDefinedTypesIntoAccountsVisitor.ts | ||
| var import_nodes13 = require("@codama/nodes"); | ||
| var import_visitors_core14 = require("@codama/visitors-core"); | ||
| function transformDefinedTypesIntoAccountsVisitor(definedTypes) { | ||
| return (0, import_visitors_core14.pipe)( | ||
| (0, import_visitors_core14.nonNullableIdentityVisitor)({ keys: ["rootNode", "programNode"] }), | ||
| (v) => (0, import_visitors_core14.extendVisitor)(v, { | ||
| return visitorsCore.pipe( | ||
| visitorsCore.nonNullableIdentityVisitor({ keys: ["rootNode", "programNode"] }), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitProgram(program) { | ||
@@ -853,4 +745,4 @@ const typesToExtract = program.definedTypes.filter((node) => definedTypes.includes(node.name)); | ||
| const newAccounts = typesToExtract.map((node) => { | ||
| (0, import_nodes13.assertIsNode)(node.type, "structTypeNode"); | ||
| return (0, import_nodes13.accountNode)({ | ||
| nodes.assertIsNode(node.type, "structTypeNode"); | ||
| return nodes.accountNode({ | ||
| ...node, | ||
@@ -862,3 +754,3 @@ data: node.type, | ||
| }); | ||
| return (0, import_nodes13.programNode)({ | ||
| return nodes.programNode({ | ||
| ...program, | ||
@@ -872,21 +764,17 @@ accounts: [...program.accounts, ...newAccounts], | ||
| } | ||
| // src/transformU8ArraysToBytesVisitor.ts | ||
| var import_nodes14 = require("@codama/nodes"); | ||
| var import_visitors_core15 = require("@codama/visitors-core"); | ||
| function transformU8ArraysToBytesVisitor(sizes = "*") { | ||
| const hasRequiredSize = (count) => { | ||
| if (!(0, import_nodes14.isNode)(count, "fixedCountNode")) return false; | ||
| if (!nodes.isNode(count, "fixedCountNode")) return false; | ||
| return sizes === "*" || sizes.includes(count.value); | ||
| }; | ||
| return (0, import_visitors_core15.pipe)( | ||
| (0, import_visitors_core15.nonNullableIdentityVisitor)(), | ||
| (v) => (0, import_visitors_core15.extendVisitor)(v, { | ||
| return visitorsCore.pipe( | ||
| visitorsCore.nonNullableIdentityVisitor(), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitArrayType(node, { self }) { | ||
| const child = (0, import_visitors_core15.visit)(node.item, self); | ||
| (0, import_nodes14.assertIsNode)(child, import_nodes14.TYPE_NODES); | ||
| if ((0, import_nodes14.isNode)(child, "numberTypeNode") && child.format === "u8" && (0, import_nodes14.isNode)(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| return (0, import_nodes14.fixedSizeTypeNode)((0, import_nodes14.bytesTypeNode)(), node.count.value); | ||
| const child = visitorsCore.visit(node.item, self); | ||
| nodes.assertIsNode(child, nodes.TYPE_NODES); | ||
| if (nodes.isNode(child, "numberTypeNode") && child.format === "u8" && nodes.isNode(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| return nodes.fixedSizeTypeNode(nodes.bytesTypeNode(), node.count.value); | ||
| } | ||
| return (0, import_nodes14.arrayTypeNode)(child, node.count); | ||
| return nodes.arrayTypeNode(child, node.count); | ||
| } | ||
@@ -896,13 +784,9 @@ }) | ||
| } | ||
| // src/unwrapDefinedTypesVisitor.ts | ||
| var import_nodes15 = require("@codama/nodes"); | ||
| var import_visitors_core16 = require("@codama/visitors-core"); | ||
| function unwrapDefinedTypesVisitor(typesToInline = "*") { | ||
| const linkables = new import_visitors_core16.LinkableDictionary(); | ||
| const stack = new import_visitors_core16.NodeStack(); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const stack = new visitorsCore.NodeStack(); | ||
| const typesToInlineCamelCased = (typesToInline === "*" ? [] : typesToInline).map((fullPath) => { | ||
| if (!fullPath.includes(".")) return (0, import_nodes15.camelCase)(fullPath); | ||
| if (!fullPath.includes(".")) return nodes.camelCase(fullPath); | ||
| const [programName, typeName] = fullPath.split("."); | ||
| return `${(0, import_nodes15.camelCase)(programName)}.${(0, import_nodes15.camelCase)(typeName)}`; | ||
| return `${nodes.camelCase(programName)}.${nodes.camelCase(typeName)}`; | ||
| }); | ||
@@ -915,7 +799,7 @@ const shouldInline = (typeName, programName) => { | ||
| }; | ||
| return (0, import_visitors_core16.pipe)( | ||
| (0, import_visitors_core16.nonNullableIdentityVisitor)(), | ||
| (v) => (0, import_visitors_core16.extendVisitor)(v, { | ||
| return visitorsCore.pipe( | ||
| visitorsCore.nonNullableIdentityVisitor(), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitDefinedTypeLink(linkType, { self }) { | ||
| const programName = linkType.program?.name ?? (0, import_visitors_core16.findProgramNodeFromPath)(stack.getPath())?.name; | ||
| const programName = linkType.program?.name ?? visitorsCore.findProgramNodeFromPath(stack.getPath())?.name; | ||
| if (!shouldInline(linkType.name, programName)) { | ||
@@ -925,5 +809,5 @@ return linkType; | ||
| const definedTypePath = linkables.getPathOrThrow(stack.getPath("definedTypeLinkNode")); | ||
| const definedType = (0, import_visitors_core16.getLastNodeFromPath)(definedTypePath); | ||
| const definedType = visitorsCore.getLastNodeFromPath(definedTypePath); | ||
| stack.pushPath(definedTypePath); | ||
| const result = (0, import_visitors_core16.visit)(definedType.type, self); | ||
| const result = visitorsCore.visit(definedType.type, self); | ||
| stack.popPath(); | ||
@@ -933,33 +817,29 @@ return result; | ||
| visitProgram(program, { self }) { | ||
| return (0, import_nodes15.programNode)({ | ||
| return nodes.programNode({ | ||
| ...program, | ||
| accounts: program.accounts.map((account) => (0, import_visitors_core16.visit)(account, self)).filter((0, import_nodes15.assertIsNodeFilter)("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => (0, import_visitors_core16.visit)(type, self)).filter((0, import_nodes15.assertIsNodeFilter)("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => (0, import_visitors_core16.visit)(instruction, self)).filter((0, import_nodes15.assertIsNodeFilter)("instructionNode")) | ||
| accounts: program.accounts.map((account) => visitorsCore.visit(account, self)).filter(nodes.assertIsNodeFilter("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => visitorsCore.visit(type, self)).filter(nodes.assertIsNodeFilter("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => visitorsCore.visit(instruction, self)).filter(nodes.assertIsNodeFilter("instructionNode")) | ||
| }); | ||
| } | ||
| }), | ||
| (v) => (0, import_visitors_core16.recordNodeStackVisitor)(v, stack), | ||
| (v) => (0, import_visitors_core16.recordLinkablesOnFirstVisitVisitor)(v, linkables) | ||
| (v) => visitorsCore.recordNodeStackVisitor(v, stack), | ||
| (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/unwrapInstructionArgsDefinedTypesVisitor.ts | ||
| var import_nodes16 = require("@codama/nodes"); | ||
| var import_visitors_core17 = require("@codama/visitors-core"); | ||
| function unwrapInstructionArgsDefinedTypesVisitor() { | ||
| return (0, import_visitors_core17.rootNodeVisitor)((root) => { | ||
| const histogram = (0, import_visitors_core17.visit)(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new import_visitors_core17.LinkableDictionary(); | ||
| (0, import_visitors_core17.visit)(root, (0, import_visitors_core17.getRecordLinkablesVisitor)(linkables)); | ||
| return visitorsCore.rootNodeVisitor((root) => { | ||
| const histogram = visitorsCore.visit(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| visitorsCore.visit(root, visitorsCore.getRecordLinkablesVisitor(linkables)); | ||
| const definedTypesToInline = Object.keys(histogram).filter((key) => (histogram[key].total ?? 0) === 1 && (histogram[key].directlyAsInstructionArgs ?? 0) === 1).filter((key) => { | ||
| const names = key.split("."); | ||
| const link = names.length == 2 ? (0, import_nodes16.definedTypeLinkNode)(names[1], names[0]) : (0, import_nodes16.definedTypeLinkNode)(key); | ||
| const link = names.length == 2 ? nodes.definedTypeLinkNode(names[1], names[0]) : nodes.definedTypeLinkNode(key); | ||
| const found = linkables.get([link]); | ||
| return found && !(0, import_nodes16.isNode)(found.type, "enumTypeNode"); | ||
| return found && !nodes.isNode(found.type, "enumTypeNode"); | ||
| }); | ||
| if (definedTypesToInline.length > 0) { | ||
| const inlineVisitor = unwrapDefinedTypesVisitor(definedTypesToInline); | ||
| const newRoot = (0, import_visitors_core17.visit)(root, inlineVisitor); | ||
| (0, import_nodes16.assertIsNode)(newRoot, "rootNode"); | ||
| const newRoot = visitorsCore.visit(root, inlineVisitor); | ||
| nodes.assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -970,35 +850,31 @@ } | ||
| } | ||
| // src/unwrapTupleEnumWithSingleStructVisitor.ts | ||
| var import_nodes17 = require("@codama/nodes"); | ||
| var import_visitors_core18 = require("@codama/visitors-core"); | ||
| function unwrapTupleEnumWithSingleStructVisitor(enumsOrVariantsToUnwrap = "*") { | ||
| const selectorFunctions = enumsOrVariantsToUnwrap === "*" ? [() => true] : enumsOrVariantsToUnwrap.map((selector) => (0, import_visitors_core18.getNodeSelectorFunction)(selector)); | ||
| const shouldUnwrap = (stack) => selectorFunctions.some((selector) => selector(stack.getPath(import_nodes17.REGISTERED_NODE_KINDS))); | ||
| return (0, import_visitors_core18.rootNodeVisitor)((root) => { | ||
| const selectorFunctions = enumsOrVariantsToUnwrap === "*" ? [() => true] : enumsOrVariantsToUnwrap.map((selector) => visitorsCore.getNodeSelectorFunction(selector)); | ||
| const shouldUnwrap = (stack) => selectorFunctions.some((selector) => selector(stack.getPath(nodes.REGISTERED_NODE_KINDS))); | ||
| return visitorsCore.rootNodeVisitor((root) => { | ||
| const typesToPotentiallyUnwrap = []; | ||
| const definedTypes = new Map( | ||
| (0, import_nodes17.getAllDefinedTypes)(root).map((definedType) => [definedType.name, definedType]) | ||
| nodes.getAllDefinedTypes(root).map((definedType) => [definedType.name, definedType]) | ||
| ); | ||
| let newRoot = (0, import_visitors_core18.visit)( | ||
| let newRoot = visitorsCore.visit( | ||
| root, | ||
| (0, import_visitors_core18.bottomUpTransformerVisitor)([ | ||
| visitorsCore.bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[enumTupleVariantTypeNode]", | ||
| transform: (node, stack) => { | ||
| (0, import_nodes17.assertIsNode)(node, "enumTupleVariantTypeNode"); | ||
| nodes.assertIsNode(node, "enumTupleVariantTypeNode"); | ||
| if (!shouldUnwrap(stack)) return node; | ||
| const tupleNode = (0, import_nodes17.resolveNestedTypeNode)(node.tuple); | ||
| const tupleNode = nodes.resolveNestedTypeNode(node.tuple); | ||
| if (tupleNode.items.length !== 1) return node; | ||
| let item = tupleNode.items[0]; | ||
| if ((0, import_nodes17.isNode)(item, "definedTypeLinkNode")) { | ||
| if (nodes.isNode(item, "definedTypeLinkNode")) { | ||
| const definedType = definedTypes.get(item.name); | ||
| if (!definedType) return node; | ||
| if (!(0, import_nodes17.isNode)(definedType.type, "structTypeNode")) return node; | ||
| if (!nodes.isNode(definedType.type, "structTypeNode")) return node; | ||
| typesToPotentiallyUnwrap.push(item.name); | ||
| item = definedType.type; | ||
| } | ||
| if (!(0, import_nodes17.isNode)(item, "structTypeNode")) return node; | ||
| const nestedStruct = (0, import_nodes17.transformNestedTypeNode)(node.tuple, () => item); | ||
| return (0, import_nodes17.enumStructVariantTypeNode)(node.name, nestedStruct); | ||
| if (!nodes.isNode(item, "structTypeNode")) return node; | ||
| const nestedStruct = nodes.transformNestedTypeNode(node.tuple, () => item); | ||
| return nodes.enumStructVariantTypeNode(node.name, nestedStruct); | ||
| } | ||
@@ -1008,17 +884,14 @@ } | ||
| ); | ||
| (0, import_nodes17.assertIsNode)(newRoot, "rootNode"); | ||
| const histogram = (0, import_visitors_core18.visit)(newRoot, getDefinedTypeHistogramVisitor()); | ||
| nodes.assertIsNode(newRoot, "rootNode"); | ||
| const histogram = visitorsCore.visit(newRoot, getDefinedTypeHistogramVisitor()); | ||
| const typesToUnwrap = typesToPotentiallyUnwrap.filter( | ||
| (type) => !histogram[type] || histogram[type].total === 0 | ||
| ); | ||
| newRoot = (0, import_visitors_core18.visit)(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| (0, import_nodes17.assertIsNode)(newRoot, "rootNode"); | ||
| newRoot = visitorsCore.visit(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| nodes.assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
| }); | ||
| } | ||
| // src/unwrapTypeDefinedLinksVisitor.ts | ||
| var import_visitors_core19 = require("@codama/visitors-core"); | ||
| function unwrapTypeDefinedLinksVisitor(definedLinksType) { | ||
| const linkables = new import_visitors_core19.LinkableDictionary(); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const transformers = definedLinksType.map((selector) => ({ | ||
@@ -1031,18 +904,11 @@ select: ["[definedTypeLinkNode]", selector], | ||
| })); | ||
| return (0, import_visitors_core19.pipe)((0, import_visitors_core19.bottomUpTransformerVisitor)(transformers), (v) => (0, import_visitors_core19.recordLinkablesOnFirstVisitVisitor)(v, linkables)); | ||
| return visitorsCore.pipe(visitorsCore.bottomUpTransformerVisitor(transformers), (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/updateAccountsVisitor.ts | ||
| var import_nodes19 = require("@codama/nodes"); | ||
| var import_visitors_core20 = require("@codama/visitors-core"); | ||
| // src/renameHelpers.ts | ||
| var import_nodes18 = require("@codama/nodes"); | ||
| function renameStructNode(node, map) { | ||
| return (0, import_nodes18.structTypeNode)( | ||
| node.fields.map((field) => map[field.name] ? (0, import_nodes18.structFieldTypeNode)({ ...field, name: map[field.name] }) : field) | ||
| return nodes.structTypeNode( | ||
| node.fields.map((field) => map[field.name] ? nodes.structFieldTypeNode({ ...field, name: map[field.name] }) : field) | ||
| ); | ||
| } | ||
| function renameEnumNode(node, map) { | ||
| return (0, import_nodes18.enumTypeNode)( | ||
| return nodes.enumTypeNode( | ||
| node.variants.map((variant) => map[variant.name] ? renameEnumVariant(variant, map[variant.name]) : variant), | ||
@@ -1053,9 +919,9 @@ { ...node } | ||
| function renameEnumVariant(variant, newName) { | ||
| if ((0, import_nodes18.isNode)(variant, "enumStructVariantTypeNode")) { | ||
| return (0, import_nodes18.enumStructVariantTypeNode)(newName, variant.struct); | ||
| if (nodes.isNode(variant, "enumStructVariantTypeNode")) { | ||
| return nodes.enumStructVariantTypeNode(newName, variant.struct); | ||
| } | ||
| if ((0, import_nodes18.isNode)(variant, "enumTupleVariantTypeNode")) { | ||
| return (0, import_nodes18.enumTupleVariantTypeNode)(newName, variant.tuple); | ||
| if (nodes.isNode(variant, "enumTupleVariantTypeNode")) { | ||
| return nodes.enumTupleVariantTypeNode(newName, variant.tuple); | ||
| } | ||
| return (0, import_nodes18.enumEmptyVariantTypeNode)(newName); | ||
| return nodes.enumEmptyVariantTypeNode(newName); | ||
| } | ||
@@ -1065,5 +931,5 @@ | ||
| function updateAccountsVisitor(map) { | ||
| return (0, import_visitors_core20.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? (0, import_nodes19.camelCase)(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? nodes.camelCase(updates.name) : void 0; | ||
| const pdasToUpsert = []; | ||
@@ -1074,5 +940,5 @@ const transformers = [ | ||
| transform: (node, stack) => { | ||
| (0, import_nodes19.assertIsNode)(node, "accountNode"); | ||
| nodes.assertIsNode(node, "accountNode"); | ||
| if ("delete" in updates) return null; | ||
| const programNode6 = (0, import_visitors_core20.findProgramNodeFromPath)(stack.getPath()); | ||
| const programNode6 = visitorsCore.findProgramNodeFromPath(stack.getPath()); | ||
| const { seeds, pda, ...assignableUpdates } = updates; | ||
@@ -1083,3 +949,3 @@ let newPda = node.pda; | ||
| pdasToUpsert.push({ | ||
| pda: (0, import_nodes19.pdaNode)({ name: pda.name, seeds }), | ||
| pda: nodes.pdaNode({ name: pda.name, seeds }), | ||
| program: programNode6.name | ||
@@ -1091,16 +957,16 @@ }); | ||
| pdasToUpsert.push({ | ||
| pda: (0, import_nodes19.pdaNode)({ name: node.pda.name, seeds }), | ||
| pda: nodes.pdaNode({ name: node.pda.name, seeds }), | ||
| program: programNode6.name | ||
| }); | ||
| } else if (seeds !== void 0) { | ||
| newPda = (0, import_nodes19.pdaLinkNode)(newName ?? node.name); | ||
| newPda = nodes.pdaLinkNode(newName ?? node.name); | ||
| pdasToUpsert.push({ | ||
| pda: (0, import_nodes19.pdaNode)({ name: newName ?? node.name, seeds }), | ||
| pda: nodes.pdaNode({ name: newName ?? node.name, seeds }), | ||
| program: programNode6.name | ||
| }); | ||
| } | ||
| return (0, import_nodes19.accountNode)({ | ||
| return nodes.accountNode({ | ||
| ...node, | ||
| ...assignableUpdates, | ||
| data: (0, import_nodes19.transformNestedTypeNode)( | ||
| data: nodes.transformNestedTypeNode( | ||
| node.data, | ||
@@ -1116,3 +982,3 @@ (struct) => renameStructNode(struct, updates.data ?? {}) | ||
| transform: (node) => { | ||
| (0, import_nodes19.assertIsNode)(node, "programNode"); | ||
| nodes.assertIsNode(node, "programNode"); | ||
| const pdasToUpsertForProgram = pdasToUpsert.filter((p) => p.program === node.name).map((p) => p.pda); | ||
@@ -1126,3 +992,3 @@ if (pdasToUpsertForProgram.length === 0) return node; | ||
| const newPdas = [...node.pdas.map((p) => pdasToUpdate.get(p.name) ?? p), ...pdasToCreate]; | ||
| return (0, import_nodes19.programNode)({ ...node, pdas: newPdas }); | ||
| return nodes.programNode({ ...node, pdas: newPdas }); | ||
| } | ||
@@ -1136,4 +1002,4 @@ } | ||
| transform: (node) => { | ||
| (0, import_nodes19.assertIsNode)(node, "accountLinkNode"); | ||
| return (0, import_nodes19.accountLinkNode)(newName); | ||
| nodes.assertIsNode(node, "accountLinkNode"); | ||
| return nodes.accountLinkNode(newName); | ||
| } | ||
@@ -1144,4 +1010,4 @@ }, | ||
| transform: (node) => { | ||
| (0, import_nodes19.assertIsNode)(node, "pdaNode"); | ||
| return (0, import_nodes19.pdaNode)({ name: newName, seeds: node.seeds }); | ||
| nodes.assertIsNode(node, "pdaNode"); | ||
| return nodes.pdaNode({ name: newName, seeds: node.seeds }); | ||
| } | ||
@@ -1152,4 +1018,4 @@ }, | ||
| transform: (node) => { | ||
| (0, import_nodes19.assertIsNode)(node, "pdaLinkNode"); | ||
| return (0, import_nodes19.pdaLinkNode)(newName); | ||
| nodes.assertIsNode(node, "pdaLinkNode"); | ||
| return nodes.pdaLinkNode(newName); | ||
| } | ||
@@ -1163,10 +1029,6 @@ } | ||
| } | ||
| // src/updateDefinedTypesVisitor.ts | ||
| var import_nodes20 = require("@codama/nodes"); | ||
| var import_visitors_core21 = require("@codama/visitors-core"); | ||
| function updateDefinedTypesVisitor(map) { | ||
| return (0, import_visitors_core21.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? (0, import_nodes20.camelCase)(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? nodes.camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1176,3 +1038,3 @@ { | ||
| transform: (node) => { | ||
| (0, import_nodes20.assertIsNode)(node, "definedTypeNode"); | ||
| nodes.assertIsNode(node, "definedTypeNode"); | ||
| if ("delete" in updates) { | ||
@@ -1183,8 +1045,8 @@ return null; | ||
| let newType = node.type; | ||
| if ((0, import_nodes20.isNode)(node.type, "structTypeNode")) { | ||
| if (nodes.isNode(node.type, "structTypeNode")) { | ||
| newType = renameStructNode(node.type, dataUpdates ?? {}); | ||
| } else if ((0, import_nodes20.isNode)(node.type, "enumTypeNode")) { | ||
| } else if (nodes.isNode(node.type, "enumTypeNode")) { | ||
| newType = renameEnumNode(node.type, dataUpdates ?? {}); | ||
| } | ||
| return (0, import_nodes20.definedTypeNode)({ | ||
| return nodes.definedTypeNode({ | ||
| ...node, | ||
@@ -1202,4 +1064,4 @@ ...otherUpdates, | ||
| transform: (node) => { | ||
| (0, import_nodes20.assertIsNode)(node, "definedTypeLinkNode"); | ||
| return (0, import_nodes20.definedTypeLinkNode)(newName); | ||
| nodes.assertIsNode(node, "definedTypeLinkNode"); | ||
| return nodes.definedTypeLinkNode(newName); | ||
| } | ||
@@ -1212,8 +1074,4 @@ }); | ||
| } | ||
| // src/updateErrorsVisitor.ts | ||
| var import_nodes21 = require("@codama/nodes"); | ||
| var import_visitors_core22 = require("@codama/visitors-core"); | ||
| function updateErrorsVisitor(map) { | ||
| return (0, import_visitors_core22.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -1223,5 +1081,5 @@ ([name, updates]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes21.assertIsNode)(node, "errorNode"); | ||
| nodes.assertIsNode(node, "errorNode"); | ||
| if ("delete" in updates) return null; | ||
| return (0, import_nodes21.errorNode)({ ...node, ...updates }); | ||
| return nodes.errorNode({ ...node, ...updates }); | ||
| } | ||
@@ -1232,9 +1090,5 @@ }) | ||
| } | ||
| // src/updateInstructionsVisitor.ts | ||
| var import_nodes22 = require("@codama/nodes"); | ||
| var import_visitors_core23 = require("@codama/visitors-core"); | ||
| function updateInstructionsVisitor(map) { | ||
| const linkables = new import_visitors_core23.LinkableDictionary(); | ||
| const stack = new import_visitors_core23.NodeStack(); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const stack = new visitorsCore.NodeStack(); | ||
| const transformers = Object.entries(map).map( | ||
@@ -1244,3 +1098,3 @@ ([selector, updates]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes22.assertIsNode)(node, "instructionNode"); | ||
| nodes.assertIsNode(node, "instructionNode"); | ||
| if ("delete" in updates) { | ||
@@ -1255,3 +1109,3 @@ return null; | ||
| ); | ||
| return (0, import_nodes22.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -1266,6 +1120,6 @@ ...metadataUpdates, | ||
| ); | ||
| return (0, import_visitors_core23.pipe)( | ||
| (0, import_visitors_core23.bottomUpTransformerVisitor)(transformers), | ||
| (v) => (0, import_visitors_core23.recordNodeStackVisitor)(v, stack), | ||
| (v) => (0, import_visitors_core23.recordLinkablesOnFirstVisitVisitor)(v, linkables) | ||
| return visitorsCore.pipe( | ||
| visitorsCore.bottomUpTransformerVisitor(transformers), | ||
| (v) => visitorsCore.recordNodeStackVisitor(v, stack), | ||
| (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
@@ -1281,7 +1135,7 @@ } | ||
| if (!defaultValue) { | ||
| return (0, import_nodes22.instructionAccountNode)(acountWithoutDefault); | ||
| return nodes.instructionAccountNode(acountWithoutDefault); | ||
| } | ||
| return (0, import_nodes22.instructionAccountNode)({ | ||
| return nodes.instructionAccountNode({ | ||
| ...acountWithoutDefault, | ||
| defaultValue: (0, import_visitors_core23.visit)(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| defaultValue: visitorsCore.visit(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| }); | ||
@@ -1295,3 +1149,3 @@ } | ||
| usedArguments.add(node.name); | ||
| return (0, import_nodes22.instructionArgumentNode)({ | ||
| return nodes.instructionArgumentNode({ | ||
| ...node, | ||
@@ -1310,3 +1164,3 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| usedArguments.add(node.name); | ||
| return (0, import_nodes22.instructionArgumentNode)({ | ||
| return nodes.instructionArgumentNode({ | ||
| ...node, | ||
@@ -1324,4 +1178,4 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| const { type } = argUpdate; | ||
| (0, import_nodes22.assertIsNode)(type, import_nodes22.TYPE_NODES); | ||
| return (0, import_nodes22.instructionArgumentNode)({ | ||
| nodes.assertIsNode(type, nodes.TYPE_NODES); | ||
| return nodes.instructionArgumentNode({ | ||
| defaultValue: argUpdate.defaultValue ?? void 0, | ||
@@ -1337,10 +1191,6 @@ defaultValueStrategy: argUpdate.defaultValueStrategy ?? void 0, | ||
| } | ||
| // src/updateProgramsVisitor.ts | ||
| var import_nodes23 = require("@codama/nodes"); | ||
| var import_visitors_core24 = require("@codama/visitors-core"); | ||
| function updateProgramsVisitor(map) { | ||
| return (0, import_visitors_core24.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([name, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? (0, import_nodes23.camelCase)(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? nodes.camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1350,5 +1200,5 @@ { | ||
| transform: (node) => { | ||
| (0, import_nodes23.assertIsNode)(node, "programNode"); | ||
| nodes.assertIsNode(node, "programNode"); | ||
| if ("delete" in updates) return null; | ||
| return (0, import_nodes23.programNode)({ ...node, ...updates }); | ||
| return nodes.programNode({ ...node, ...updates }); | ||
| } | ||
@@ -1361,4 +1211,4 @@ } | ||
| transform: (node) => { | ||
| (0, import_nodes23.assertIsNode)(node, "programLinkNode"); | ||
| return (0, import_nodes23.programLinkNode)(newName); | ||
| nodes.assertIsNode(node, "programLinkNode"); | ||
| return nodes.programLinkNode(newName); | ||
| } | ||
@@ -1371,2 +1221,37 @@ }); | ||
| } | ||
| exports.addPdasVisitor = addPdasVisitor; | ||
| exports.createSubInstructionsFromEnumArgsVisitor = createSubInstructionsFromEnumArgsVisitor; | ||
| exports.deduplicateIdenticalDefinedTypesVisitor = deduplicateIdenticalDefinedTypesVisitor; | ||
| exports.fillDefaultPdaSeedValuesVisitor = fillDefaultPdaSeedValuesVisitor; | ||
| exports.flattenInstructionArguments = flattenInstructionArguments; | ||
| exports.flattenInstructionDataArgumentsVisitor = flattenInstructionDataArgumentsVisitor; | ||
| exports.flattenStruct = flattenStruct; | ||
| exports.flattenStructVisitor = flattenStructVisitor; | ||
| exports.getCommonInstructionAccountDefaultRules = getCommonInstructionAccountDefaultRules; | ||
| exports.getDefinedTypeHistogramVisitor = getDefinedTypeHistogramVisitor; | ||
| exports.setAccountDiscriminatorFromFieldVisitor = setAccountDiscriminatorFromFieldVisitor; | ||
| exports.setFixedAccountSizesVisitor = setFixedAccountSizesVisitor; | ||
| exports.setInstructionAccountDefaultValuesVisitor = setInstructionAccountDefaultValuesVisitor; | ||
| exports.setInstructionDiscriminatorsVisitor = setInstructionDiscriminatorsVisitor; | ||
| exports.setNumberWrappersVisitor = setNumberWrappersVisitor; | ||
| exports.setStructDefaultValuesVisitor = setStructDefaultValuesVisitor; | ||
| exports.transformDefinedTypesIntoAccountsVisitor = transformDefinedTypesIntoAccountsVisitor; | ||
| exports.transformU8ArraysToBytesVisitor = transformU8ArraysToBytesVisitor; | ||
| exports.unwrapDefinedTypesVisitor = unwrapDefinedTypesVisitor; | ||
| exports.unwrapInstructionArgsDefinedTypesVisitor = unwrapInstructionArgsDefinedTypesVisitor; | ||
| exports.unwrapTupleEnumWithSingleStructVisitor = unwrapTupleEnumWithSingleStructVisitor; | ||
| exports.unwrapTypeDefinedLinksVisitor = unwrapTypeDefinedLinksVisitor; | ||
| exports.updateAccountsVisitor = updateAccountsVisitor; | ||
| exports.updateDefinedTypesVisitor = updateDefinedTypesVisitor; | ||
| exports.updateErrorsVisitor = updateErrorsVisitor; | ||
| exports.updateInstructionsVisitor = updateInstructionsVisitor; | ||
| exports.updateProgramsVisitor = updateProgramsVisitor; | ||
| Object.keys(visitorsCore).forEach(function (k) { | ||
| if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { | ||
| enumerable: true, | ||
| get: function () { return visitorsCore[k]; } | ||
| }); | ||
| }); | ||
| //# sourceMappingURL=index.browser.cjs.map | ||
| //# sourceMappingURL=index.browser.cjs.map |
+187
-488
@@ -0,8 +1,7 @@ | ||
| import { bottomUpTransformerVisitor, LinkableDictionary, pipe, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor, getUniqueHashStringVisitor, visit, deleteNodesVisitor, getLastNodeFromPath, identityVisitor, extendVisitor, NodeStack, mergeVisitor, interceptVisitor, findProgramNodeFromPath, recordNodeStackVisitor, topDownTransformerVisitor, isNodePath, getByteSizeVisitor, nonNullableIdentityVisitor, getRecordLinkablesVisitor, getNodeSelectorFunction } from '@codama/visitors-core'; | ||
| export * from '@codama/visitors-core'; | ||
| import { CodamaError, CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER } from '@codama/errors'; | ||
| import { payerValueNode, identityValueNode, programIdValueNode, publicKeyValueNode, camelCase, assertIsNode, programNode, pdaNode, instructionNode, isNode, instructionArgumentNode, numberTypeNode, numberValueNode, getAllPrograms, INSTRUCTION_INPUT_VALUE_NODES, pdaValueNode, pdaSeedValueNode, accountValueNode, getAllInstructionArguments, argumentValueNode, isNodeFilter, structTypeNode, resolveNestedTypeNode, accountNode, fieldDiscriminatorNode, transformNestedTypeNode, structFieldTypeNode, assertIsNestedTypeNode, amountTypeNode, solAmountTypeNode, dateTimeTypeNode, TYPE_NODES, fixedSizeTypeNode, bytesTypeNode, arrayTypeNode, assertIsNodeFilter, definedTypeLinkNode, getAllDefinedTypes, enumStructVariantTypeNode, accountLinkNode, pdaLinkNode, errorNode, instructionAccountNode, programLinkNode, REGISTERED_NODE_KINDS, definedTypeNode, enumTypeNode, enumTupleVariantTypeNode, enumEmptyVariantTypeNode } from '@codama/nodes'; | ||
| // src/index.ts | ||
| export * from "@codama/visitors-core"; | ||
| // src/addPdasVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, CodamaError } from "@codama/errors"; | ||
| import { assertIsNode, camelCase, pdaNode, programNode } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor } from "@codama/visitors-core"; | ||
| function addPdasVisitor(pdas) { | ||
@@ -35,37 +34,8 @@ return bottomUpTransformerVisitor( | ||
| } | ||
| // src/createSubInstructionsFromEnumArgsVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, CodamaError as CodamaError3 } from "@codama/errors"; | ||
| import { | ||
| assertIsNode as assertIsNode3, | ||
| camelCase as camelCase3, | ||
| instructionArgumentNode as instructionArgumentNode2, | ||
| instructionNode as instructionNode2, | ||
| isNode as isNode2, | ||
| numberTypeNode, | ||
| numberValueNode | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor3, | ||
| LinkableDictionary, | ||
| pipe, | ||
| recordLinkablesOnFirstVisitVisitor | ||
| } from "@codama/visitors-core"; | ||
| // src/flattenInstructionDataArgumentsVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, CodamaError as CodamaError2 } from "@codama/errors"; | ||
| import { | ||
| assertIsNode as assertIsNode2, | ||
| camelCase as camelCase2, | ||
| instructionArgumentNode, | ||
| instructionNode, | ||
| isNode | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor2 } from "@codama/visitors-core"; | ||
| function flattenInstructionDataArgumentsVisitor() { | ||
| return bottomUpTransformerVisitor2([ | ||
| return bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[instructionNode]", | ||
| transform: (instruction) => { | ||
| assertIsNode2(instruction, "instructionNode"); | ||
| assertIsNode(instruction, "instructionNode"); | ||
| return instructionNode({ | ||
@@ -80,4 +50,4 @@ ...instruction, | ||
| var flattenInstructionArguments = (nodes, options = "*") => { | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase2); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes(camelCase2(node.name)); | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes(camelCase(node.name)); | ||
| const inlinedArguments = nodes.flatMap((node) => { | ||
@@ -94,3 +64,3 @@ if (isNode(node.type, "structTypeNode") && shouldInline(node)) { | ||
| if (hasConflictingNames) { | ||
| throw new CodamaError2(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
@@ -105,3 +75,3 @@ }); | ||
| const linkables = new LinkableDictionary(); | ||
| const visitor = bottomUpTransformerVisitor3( | ||
| const visitor = bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -111,9 +81,9 @@ ([selector, argNameInput]) => ({ | ||
| transform: (node, stack) => { | ||
| assertIsNode3(node, "instructionNode"); | ||
| assertIsNode(node, "instructionNode"); | ||
| const argFields = node.arguments; | ||
| const argName = camelCase3(argNameInput); | ||
| const argName = camelCase(argNameInput); | ||
| const argFieldIndex = argFields.findIndex((field) => field.name === argName); | ||
| const argField = argFieldIndex >= 0 ? argFields[argFieldIndex] : null; | ||
| if (!argField) { | ||
| throw new CodamaError3(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -125,10 +95,10 @@ instruction: node, | ||
| let argType; | ||
| if (isNode2(argField.type, "enumTypeNode")) { | ||
| if (isNode(argField.type, "enumTypeNode")) { | ||
| argType = argField.type; | ||
| } else if (isNode2(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| } else if (isNode(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| const linkedType = linkables.get([...stack.getPath(), argField.type])?.type; | ||
| assertIsNode3(linkedType, "enumTypeNode"); | ||
| assertIsNode(linkedType, "enumTypeNode"); | ||
| argType = linkedType; | ||
| } else { | ||
| throw new CodamaError3(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -140,6 +110,6 @@ instruction: node, | ||
| const subInstructions = argType.variants.map((variant, index) => { | ||
| const subName = camelCase3(`${node.name} ${variant.name}`); | ||
| const subName = camelCase(`${node.name} ${variant.name}`); | ||
| const subFields = argFields.slice(0, argFieldIndex); | ||
| subFields.push( | ||
| instructionArgumentNode2({ | ||
| instructionArgumentNode({ | ||
| defaultValue: numberValueNode(index), | ||
@@ -151,5 +121,5 @@ defaultValueStrategy: "omitted", | ||
| ); | ||
| if (isNode2(variant, "enumStructVariantTypeNode")) { | ||
| if (isNode(variant, "enumStructVariantTypeNode")) { | ||
| subFields.push( | ||
| instructionArgumentNode2({ | ||
| instructionArgumentNode({ | ||
| ...argField, | ||
@@ -159,5 +129,5 @@ type: variant.struct | ||
| ); | ||
| } else if (isNode2(variant, "enumTupleVariantTypeNode")) { | ||
| } else if (isNode(variant, "enumTupleVariantTypeNode")) { | ||
| subFields.push( | ||
| instructionArgumentNode2({ | ||
| instructionArgumentNode({ | ||
| ...argField, | ||
@@ -169,3 +139,3 @@ type: variant.tuple | ||
| subFields.push(...argFields.slice(argFieldIndex + 1)); | ||
| return instructionNode2({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -176,3 +146,3 @@ arguments: flattenInstructionArguments(subFields), | ||
| }); | ||
| return instructionNode2({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -187,11 +157,2 @@ subInstructions: [...node.subInstructions ?? [], ...subInstructions] | ||
| } | ||
| // src/deduplicateIdenticalDefinedTypesVisitor.ts | ||
| import { assertIsNode as assertIsNode4, getAllPrograms } from "@codama/nodes"; | ||
| import { | ||
| deleteNodesVisitor, | ||
| getUniqueHashStringVisitor, | ||
| rootNodeVisitor, | ||
| visit | ||
| } from "@codama/visitors-core"; | ||
| function deduplicateIdenticalDefinedTypesVisitor() { | ||
@@ -228,3 +189,3 @@ return rootNodeVisitor((root) => { | ||
| const newRoot = visit(root, deleteNodesVisitor(deleteSelectors)); | ||
| assertIsNode4(newRoot, "rootNode"); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -235,25 +196,5 @@ } | ||
| } | ||
| // src/fillDefaultPdaSeedValuesVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, CodamaError as CodamaError4 } from "@codama/errors"; | ||
| import { | ||
| accountValueNode, | ||
| argumentValueNode, | ||
| assertIsNode as assertIsNode5, | ||
| getAllInstructionArguments, | ||
| INSTRUCTION_INPUT_VALUE_NODES, | ||
| isNode as isNode3, | ||
| isNodeFilter, | ||
| pdaSeedValueNode, | ||
| pdaValueNode | ||
| } from "@codama/nodes"; | ||
| import { | ||
| extendVisitor, | ||
| getLastNodeFromPath, | ||
| identityVisitor, | ||
| pipe as pipe2 | ||
| } from "@codama/visitors-core"; | ||
| function fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, strictMode = false) { | ||
| const instruction = getLastNodeFromPath(instructionPath); | ||
| return pipe2( | ||
| return pipe( | ||
| identityVisitor({ keys: INSTRUCTION_INPUT_VALUE_NODES }), | ||
@@ -263,8 +204,8 @@ (v) => extendVisitor(v, { | ||
| const visitedNode = next(node); | ||
| assertIsNode5(visitedNode, "pdaValueNode"); | ||
| const foundPda = isNode3(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| assertIsNode(visitedNode, "pdaValueNode"); | ||
| const foundPda = isNode(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| if (!foundPda) return visitedNode; | ||
| const seeds = addDefaultSeedValuesFromPdaWhenMissing(instruction, foundPda, visitedNode.seeds); | ||
| if (strictMode && !allSeedsAreValid(instruction, foundPda, seeds)) { | ||
| throw new CodamaError4(CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| instruction, | ||
@@ -290,5 +231,5 @@ instructionName: instruction.name, | ||
| return pda.seeds.flatMap((seed) => { | ||
| if (!isNode3(seed, "variablePdaSeedNode")) return []; | ||
| if (!isNode(seed, "variablePdaSeedNode")) return []; | ||
| const hasMatchingAccount = instruction.accounts.some((a) => a.name === seed.name); | ||
| if (isNode3(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| if (isNode(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| return [pdaSeedValueNode(seed.name, accountValueNode(seed.name))]; | ||
@@ -308,6 +249,6 @@ } | ||
| const validSeeds = seeds.every((seed) => { | ||
| if (isNode3(seed.value, "accountValueNode")) { | ||
| if (isNode(seed.value, "accountValueNode")) { | ||
| return allAccountsName.includes(seed.value.name); | ||
| } | ||
| if (isNode3(seed.value, "argumentValueNode")) { | ||
| if (isNode(seed.value, "argumentValueNode")) { | ||
| return allArgumentsName.includes(seed.value.name); | ||
@@ -319,14 +260,4 @@ } | ||
| } | ||
| // src/flattenStructVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES as CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES2, CodamaError as CodamaError5 } from "@codama/errors"; | ||
| import { | ||
| assertIsNode as assertIsNode6, | ||
| camelCase as camelCase4, | ||
| isNode as isNode4, | ||
| structTypeNode | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor4 } from "@codama/visitors-core"; | ||
| function flattenStructVisitor(map) { | ||
| return bottomUpTransformerVisitor4( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -341,7 +272,7 @@ ([stack, options]) => ({ | ||
| var flattenStruct = (node, options = "*") => { | ||
| assertIsNode6(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase4); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes(camelCase4(field.name)); | ||
| assertIsNode(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes(camelCase(field.name)); | ||
| const inlinedFields = node.fields.flatMap((field) => { | ||
| if (isNode4(field.type, "structTypeNode") && shouldInline(field)) { | ||
| if (isNode(field.type, "structTypeNode") && shouldInline(field)) { | ||
| return field.type.fields; | ||
@@ -356,3 +287,3 @@ } | ||
| if (hasConflictingNames) { | ||
| throw new CodamaError5(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES2, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
@@ -363,14 +294,2 @@ }); | ||
| }; | ||
| // src/getDefinedTypeHistogramVisitor.ts | ||
| import { | ||
| extendVisitor as extendVisitor2, | ||
| findProgramNodeFromPath, | ||
| interceptVisitor, | ||
| mergeVisitor, | ||
| NodeStack, | ||
| pipe as pipe3, | ||
| recordNodeStackVisitor, | ||
| visit as visit2 | ||
| } from "@codama/visitors-core"; | ||
| function mergeHistograms(histograms) { | ||
@@ -398,3 +317,3 @@ const result = {}; | ||
| let stackLevel = 0; | ||
| return pipe3( | ||
| return pipe( | ||
| mergeVisitor( | ||
@@ -410,7 +329,7 @@ () => ({}), | ||
| }), | ||
| (v) => extendVisitor2(v, { | ||
| (v) => extendVisitor(v, { | ||
| visitAccount(node, { self }) { | ||
| mode = "account"; | ||
| stackLevel = 0; | ||
| const histogram = visit2(node.data, self); | ||
| const histogram = visit(node.data, self); | ||
| mode = null; | ||
@@ -422,3 +341,3 @@ return histogram; | ||
| stackLevel = 0; | ||
| const histogram = visit2(node.type, self); | ||
| const histogram = visit(node.type, self); | ||
| mode = null; | ||
@@ -443,6 +362,6 @@ return histogram; | ||
| stackLevel = 0; | ||
| const dataHistograms = node.arguments.map((arg) => visit2(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => visit2(arg, self)); | ||
| const dataHistograms = node.arguments.map((arg) => visit(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => visit(arg, self)); | ||
| mode = null; | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => visit2(ix, self)); | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => visit(ix, self)); | ||
| return mergeHistograms([...dataHistograms, ...extraHistograms, ...subHistograms]); | ||
@@ -454,17 +373,4 @@ } | ||
| } | ||
| // src/setAccountDiscriminatorFromFieldVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, CodamaError as CodamaError6 } from "@codama/errors"; | ||
| import { | ||
| accountNode, | ||
| assertIsNode as assertIsNode7, | ||
| fieldDiscriminatorNode, | ||
| resolveNestedTypeNode, | ||
| structFieldTypeNode, | ||
| structTypeNode as structTypeNode2, | ||
| transformNestedTypeNode | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor5 } from "@codama/visitors-core"; | ||
| function setAccountDiscriminatorFromFieldVisitor(map) { | ||
| return bottomUpTransformerVisitor5( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -474,7 +380,7 @@ ([selector, { field, value, offset }]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode7(node, "accountNode"); | ||
| assertIsNode(node, "accountNode"); | ||
| const accountData = resolveNestedTypeNode(node.data); | ||
| const fieldIndex = accountData.fields.findIndex((f) => f.name === field); | ||
| if (fieldIndex < 0) { | ||
| throw new CodamaError6(CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| account: node, | ||
@@ -490,3 +396,3 @@ missingField: field, | ||
| node.data, | ||
| () => structTypeNode2([ | ||
| () => structTypeNode([ | ||
| ...accountData.fields.slice(0, fieldIndex), | ||
@@ -508,26 +414,13 @@ structFieldTypeNode({ | ||
| } | ||
| // src/setFixedAccountSizesVisitor.ts | ||
| import { accountNode as accountNode2, assertIsNode as assertIsNode8 } from "@codama/nodes"; | ||
| import { | ||
| getByteSizeVisitor, | ||
| getLastNodeFromPath as getLastNodeFromPath2, | ||
| isNodePath, | ||
| LinkableDictionary as LinkableDictionary3, | ||
| pipe as pipe4, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor2, | ||
| topDownTransformerVisitor, | ||
| visit as visit3 | ||
| } from "@codama/visitors-core"; | ||
| function setFixedAccountSizesVisitor() { | ||
| const linkables = new LinkableDictionary3(); | ||
| const linkables = new LinkableDictionary(); | ||
| const visitor = topDownTransformerVisitor( | ||
| [ | ||
| { | ||
| select: (path) => isNodePath(path, "accountNode") && getLastNodeFromPath2(path).size === void 0, | ||
| select: (path) => isNodePath(path, "accountNode") && getLastNodeFromPath(path).size === void 0, | ||
| transform: (node, stack) => { | ||
| assertIsNode8(node, "accountNode"); | ||
| const size = visit3(node.data, getByteSizeVisitor(linkables, { stack })); | ||
| assertIsNode(node, "accountNode"); | ||
| const size = visit(node.data, getByteSizeVisitor(linkables, { stack })); | ||
| if (size === null) return node; | ||
| return accountNode2({ ...node, size }); | ||
| return accountNode({ ...node, size }); | ||
| } | ||
@@ -538,24 +431,4 @@ } | ||
| ); | ||
| return pipe4(visitor, (v) => recordLinkablesOnFirstVisitVisitor2(v, linkables)); | ||
| return pipe(visitor, (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/setInstructionAccountDefaultValuesVisitor.ts | ||
| import { | ||
| camelCase as camelCase5, | ||
| identityValueNode, | ||
| instructionNode as instructionNode3, | ||
| payerValueNode, | ||
| programIdValueNode, | ||
| publicKeyValueNode | ||
| } from "@codama/nodes"; | ||
| import { | ||
| extendVisitor as extendVisitor3, | ||
| LinkableDictionary as LinkableDictionary4, | ||
| NodeStack as NodeStack2, | ||
| nonNullableIdentityVisitor, | ||
| pipe as pipe5, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor3, | ||
| recordNodeStackVisitor as recordNodeStackVisitor2, | ||
| visit as visit4 | ||
| } from "@codama/visitors-core"; | ||
| var getCommonInstructionAccountDefaultRules = () => [ | ||
@@ -664,4 +537,4 @@ { | ||
| function setInstructionAccountDefaultValuesVisitor(rules) { | ||
| const linkables = new LinkableDictionary4(); | ||
| const stack = new NodeStack2(); | ||
| const linkables = new LinkableDictionary(); | ||
| const stack = new NodeStack(); | ||
| const sortedRules = rules.sort((a, b) => { | ||
@@ -675,11 +548,11 @@ const ia = "instruction" in a; | ||
| return sortedRules.find((rule) => { | ||
| if ("instruction" in rule && rule.instruction && camelCase5(rule.instruction) !== instruction.name) { | ||
| if ("instruction" in rule && rule.instruction && camelCase(rule.instruction) !== instruction.name) { | ||
| return false; | ||
| } | ||
| return typeof rule.account === "string" ? camelCase5(rule.account) === account.name : rule.account.test(account.name); | ||
| return typeof rule.account === "string" ? camelCase(rule.account) === account.name : rule.account.test(account.name); | ||
| }); | ||
| } | ||
| return pipe5( | ||
| return pipe( | ||
| nonNullableIdentityVisitor({ keys: ["rootNode", "programNode", "instructionNode"] }), | ||
| (v) => extendVisitor3(v, { | ||
| (v) => extendVisitor(v, { | ||
| visitInstruction(node) { | ||
@@ -696,3 +569,3 @@ const instructionPath = stack.getPath("instructionNode"); | ||
| ...account, | ||
| defaultValue: visit4( | ||
| defaultValue: visit( | ||
| rule.defaultValue, | ||
@@ -706,3 +579,3 @@ fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, true) | ||
| }); | ||
| return instructionNode3({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -713,18 +586,8 @@ accounts: instructionAccounts | ||
| }), | ||
| (v) => recordNodeStackVisitor2(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor3(v, linkables) | ||
| (v) => recordNodeStackVisitor(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/setInstructionDiscriminatorsVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode9, | ||
| fieldDiscriminatorNode as fieldDiscriminatorNode2, | ||
| instructionArgumentNode as instructionArgumentNode3, | ||
| instructionNode as instructionNode4, | ||
| numberTypeNode as numberTypeNode2 | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor6 } from "@codama/visitors-core"; | ||
| function setInstructionDiscriminatorsVisitor(map) { | ||
| return bottomUpTransformerVisitor6( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -734,4 +597,4 @@ ([selector, discriminator]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode9(node, "instructionNode"); | ||
| const discriminatorArgument = instructionArgumentNode3({ | ||
| assertIsNode(node, "instructionNode"); | ||
| const discriminatorArgument = instructionArgumentNode({ | ||
| defaultValue: discriminator.value, | ||
@@ -741,9 +604,9 @@ defaultValueStrategy: discriminator.strategy ?? "omitted", | ||
| name: discriminator.name ?? "discriminator", | ||
| type: discriminator.type ?? numberTypeNode2("u8") | ||
| type: discriminator.type ?? numberTypeNode("u8") | ||
| }); | ||
| return instructionNode4({ | ||
| return instructionNode({ | ||
| ...node, | ||
| arguments: [discriminatorArgument, ...node.arguments], | ||
| discriminators: [ | ||
| fieldDiscriminatorNode2(discriminator.name ?? "discriminator"), | ||
| fieldDiscriminatorNode(discriminator.name ?? "discriminator"), | ||
| ...node.discriminators ?? [] | ||
@@ -757,9 +620,4 @@ ] | ||
| } | ||
| // src/setNumberWrappersVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, CodamaError as CodamaError7 } from "@codama/errors"; | ||
| import { amountTypeNode, assertIsNestedTypeNode, dateTimeTypeNode, solAmountTypeNode } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor7 } from "@codama/visitors-core"; | ||
| function setNumberWrappersVisitor(map) { | ||
| return bottomUpTransformerVisitor7( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -778,3 +636,3 @@ ([selectorStack, wrapper]) => ({ | ||
| default: | ||
| throw new CodamaError7(CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| } | ||
@@ -786,18 +644,7 @@ } | ||
| } | ||
| // src/setStructDefaultValuesVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode10, | ||
| camelCase as camelCase6, | ||
| instructionArgumentNode as instructionArgumentNode4, | ||
| instructionNode as instructionNode5, | ||
| structFieldTypeNode as structFieldTypeNode2, | ||
| structTypeNode as structTypeNode3 | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor8 } from "@codama/visitors-core"; | ||
| function setStructDefaultValuesVisitor(map) { | ||
| return bottomUpTransformerVisitor8( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([stack, defaultValues]) => { | ||
| const camelCasedDefaultValues = Object.fromEntries( | ||
| Object.entries(defaultValues).map(([key, value]) => [camelCase6(key), value]) | ||
| Object.entries(defaultValues).map(([key, value]) => [camelCase(key), value]) | ||
| ); | ||
@@ -808,3 +655,3 @@ return [ | ||
| transform: (node) => { | ||
| assertIsNode10(node, "structTypeNode"); | ||
| assertIsNode(node, "structTypeNode"); | ||
| const fields = node.fields.map((field) => { | ||
@@ -814,3 +661,3 @@ const defaultValue = camelCasedDefaultValues[field.name]; | ||
| if (defaultValue === null) { | ||
| return structFieldTypeNode2({ | ||
| return structFieldTypeNode({ | ||
| ...field, | ||
@@ -821,3 +668,3 @@ defaultValue: void 0, | ||
| } | ||
| return structFieldTypeNode2({ | ||
| return structFieldTypeNode({ | ||
| ...field, | ||
@@ -828,3 +675,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }); | ||
| return structTypeNode3(fields); | ||
| return structTypeNode(fields); | ||
| } | ||
@@ -835,3 +682,3 @@ }, | ||
| transform: (node) => { | ||
| assertIsNode10(node, "instructionNode"); | ||
| assertIsNode(node, "instructionNode"); | ||
| const transformArguments = (arg) => { | ||
@@ -841,3 +688,3 @@ const defaultValue = camelCasedDefaultValues[arg.name]; | ||
| if (defaultValue === null) { | ||
| return instructionArgumentNode4({ | ||
| return instructionArgumentNode({ | ||
| ...arg, | ||
@@ -848,3 +695,3 @@ defaultValue: void 0, | ||
| } | ||
| return instructionArgumentNode4({ | ||
| return instructionArgumentNode({ | ||
| ...arg, | ||
@@ -855,3 +702,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }; | ||
| return instructionNode5({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -867,10 +714,6 @@ arguments: node.arguments.map(transformArguments), | ||
| } | ||
| // src/transformDefinedTypesIntoAccountsVisitor.ts | ||
| import { accountNode as accountNode3, assertIsNode as assertIsNode11, programNode as programNode2 } from "@codama/nodes"; | ||
| import { extendVisitor as extendVisitor4, nonNullableIdentityVisitor as nonNullableIdentityVisitor2, pipe as pipe6 } from "@codama/visitors-core"; | ||
| function transformDefinedTypesIntoAccountsVisitor(definedTypes) { | ||
| return pipe6( | ||
| nonNullableIdentityVisitor2({ keys: ["rootNode", "programNode"] }), | ||
| (v) => extendVisitor4(v, { | ||
| return pipe( | ||
| nonNullableIdentityVisitor({ keys: ["rootNode", "programNode"] }), | ||
| (v) => extendVisitor(v, { | ||
| visitProgram(program) { | ||
@@ -880,4 +723,4 @@ const typesToExtract = program.definedTypes.filter((node) => definedTypes.includes(node.name)); | ||
| const newAccounts = typesToExtract.map((node) => { | ||
| assertIsNode11(node.type, "structTypeNode"); | ||
| return accountNode3({ | ||
| assertIsNode(node.type, "structTypeNode"); | ||
| return accountNode({ | ||
| ...node, | ||
@@ -889,3 +732,3 @@ data: node.type, | ||
| }); | ||
| return programNode2({ | ||
| return programNode({ | ||
| ...program, | ||
@@ -899,25 +742,14 @@ accounts: [...program.accounts, ...newAccounts], | ||
| } | ||
| // src/transformU8ArraysToBytesVisitor.ts | ||
| import { | ||
| arrayTypeNode, | ||
| assertIsNode as assertIsNode12, | ||
| bytesTypeNode, | ||
| fixedSizeTypeNode, | ||
| isNode as isNode5, | ||
| TYPE_NODES | ||
| } from "@codama/nodes"; | ||
| import { extendVisitor as extendVisitor5, nonNullableIdentityVisitor as nonNullableIdentityVisitor3, pipe as pipe7, visit as visit5 } from "@codama/visitors-core"; | ||
| function transformU8ArraysToBytesVisitor(sizes = "*") { | ||
| const hasRequiredSize = (count) => { | ||
| if (!isNode5(count, "fixedCountNode")) return false; | ||
| if (!isNode(count, "fixedCountNode")) return false; | ||
| return sizes === "*" || sizes.includes(count.value); | ||
| }; | ||
| return pipe7( | ||
| nonNullableIdentityVisitor3(), | ||
| (v) => extendVisitor5(v, { | ||
| return pipe( | ||
| nonNullableIdentityVisitor(), | ||
| (v) => extendVisitor(v, { | ||
| visitArrayType(node, { self }) { | ||
| const child = visit5(node.item, self); | ||
| assertIsNode12(child, TYPE_NODES); | ||
| if (isNode5(child, "numberTypeNode") && child.format === "u8" && isNode5(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| const child = visit(node.item, self); | ||
| assertIsNode(child, TYPE_NODES); | ||
| if (isNode(child, "numberTypeNode") && child.format === "u8" && isNode(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| return fixedSizeTypeNode(bytesTypeNode(), node.count.value); | ||
@@ -930,24 +762,9 @@ } | ||
| } | ||
| // src/unwrapDefinedTypesVisitor.ts | ||
| import { assertIsNodeFilter, camelCase as camelCase7, programNode as programNode3 } from "@codama/nodes"; | ||
| import { | ||
| extendVisitor as extendVisitor6, | ||
| findProgramNodeFromPath as findProgramNodeFromPath2, | ||
| getLastNodeFromPath as getLastNodeFromPath3, | ||
| LinkableDictionary as LinkableDictionary5, | ||
| NodeStack as NodeStack3, | ||
| nonNullableIdentityVisitor as nonNullableIdentityVisitor4, | ||
| pipe as pipe8, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor4, | ||
| recordNodeStackVisitor as recordNodeStackVisitor3, | ||
| visit as visit6 | ||
| } from "@codama/visitors-core"; | ||
| function unwrapDefinedTypesVisitor(typesToInline = "*") { | ||
| const linkables = new LinkableDictionary5(); | ||
| const stack = new NodeStack3(); | ||
| const linkables = new LinkableDictionary(); | ||
| const stack = new NodeStack(); | ||
| const typesToInlineCamelCased = (typesToInline === "*" ? [] : typesToInline).map((fullPath) => { | ||
| if (!fullPath.includes(".")) return camelCase7(fullPath); | ||
| if (!fullPath.includes(".")) return camelCase(fullPath); | ||
| const [programName, typeName] = fullPath.split("."); | ||
| return `${camelCase7(programName)}.${camelCase7(typeName)}`; | ||
| return `${camelCase(programName)}.${camelCase(typeName)}`; | ||
| }); | ||
@@ -960,7 +777,7 @@ const shouldInline = (typeName, programName) => { | ||
| }; | ||
| return pipe8( | ||
| nonNullableIdentityVisitor4(), | ||
| (v) => extendVisitor6(v, { | ||
| return pipe( | ||
| nonNullableIdentityVisitor(), | ||
| (v) => extendVisitor(v, { | ||
| visitDefinedTypeLink(linkType, { self }) { | ||
| const programName = linkType.program?.name ?? findProgramNodeFromPath2(stack.getPath())?.name; | ||
| const programName = linkType.program?.name ?? findProgramNodeFromPath(stack.getPath())?.name; | ||
| if (!shouldInline(linkType.name, programName)) { | ||
@@ -970,5 +787,5 @@ return linkType; | ||
| const definedTypePath = linkables.getPathOrThrow(stack.getPath("definedTypeLinkNode")); | ||
| const definedType = getLastNodeFromPath3(definedTypePath); | ||
| const definedType = getLastNodeFromPath(definedTypePath); | ||
| stack.pushPath(definedTypePath); | ||
| const result = visit6(definedType.type, self); | ||
| const result = visit(definedType.type, self); | ||
| stack.popPath(); | ||
@@ -978,23 +795,19 @@ return result; | ||
| visitProgram(program, { self }) { | ||
| return programNode3({ | ||
| return programNode({ | ||
| ...program, | ||
| accounts: program.accounts.map((account) => visit6(account, self)).filter(assertIsNodeFilter("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => visit6(type, self)).filter(assertIsNodeFilter("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => visit6(instruction, self)).filter(assertIsNodeFilter("instructionNode")) | ||
| accounts: program.accounts.map((account) => visit(account, self)).filter(assertIsNodeFilter("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => visit(type, self)).filter(assertIsNodeFilter("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => visit(instruction, self)).filter(assertIsNodeFilter("instructionNode")) | ||
| }); | ||
| } | ||
| }), | ||
| (v) => recordNodeStackVisitor3(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor4(v, linkables) | ||
| (v) => recordNodeStackVisitor(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/unwrapInstructionArgsDefinedTypesVisitor.ts | ||
| import { assertIsNode as assertIsNode13, definedTypeLinkNode, isNode as isNode6 } from "@codama/nodes"; | ||
| import { getRecordLinkablesVisitor, LinkableDictionary as LinkableDictionary6, rootNodeVisitor as rootNodeVisitor2, visit as visit7 } from "@codama/visitors-core"; | ||
| function unwrapInstructionArgsDefinedTypesVisitor() { | ||
| return rootNodeVisitor2((root) => { | ||
| const histogram = visit7(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new LinkableDictionary6(); | ||
| visit7(root, getRecordLinkablesVisitor(linkables)); | ||
| return rootNodeVisitor((root) => { | ||
| const histogram = visit(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new LinkableDictionary(); | ||
| visit(root, getRecordLinkablesVisitor(linkables)); | ||
| const definedTypesToInline = Object.keys(histogram).filter((key) => (histogram[key].total ?? 0) === 1 && (histogram[key].directlyAsInstructionArgs ?? 0) === 1).filter((key) => { | ||
@@ -1004,8 +817,8 @@ const names = key.split("."); | ||
| const found = linkables.get([link]); | ||
| return found && !isNode6(found.type, "enumTypeNode"); | ||
| return found && !isNode(found.type, "enumTypeNode"); | ||
| }); | ||
| if (definedTypesToInline.length > 0) { | ||
| const inlineVisitor = unwrapDefinedTypesVisitor(definedTypesToInline); | ||
| const newRoot = visit7(root, inlineVisitor); | ||
| assertIsNode13(newRoot, "rootNode"); | ||
| const newRoot = visit(root, inlineVisitor); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -1016,23 +829,6 @@ } | ||
| } | ||
| // src/unwrapTupleEnumWithSingleStructVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode14, | ||
| enumStructVariantTypeNode, | ||
| getAllDefinedTypes, | ||
| isNode as isNode7, | ||
| REGISTERED_NODE_KINDS, | ||
| resolveNestedTypeNode as resolveNestedTypeNode2, | ||
| transformNestedTypeNode as transformNestedTypeNode2 | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor9, | ||
| getNodeSelectorFunction, | ||
| rootNodeVisitor as rootNodeVisitor3, | ||
| visit as visit8 | ||
| } from "@codama/visitors-core"; | ||
| function unwrapTupleEnumWithSingleStructVisitor(enumsOrVariantsToUnwrap = "*") { | ||
| const selectorFunctions = enumsOrVariantsToUnwrap === "*" ? [() => true] : enumsOrVariantsToUnwrap.map((selector) => getNodeSelectorFunction(selector)); | ||
| const shouldUnwrap = (stack) => selectorFunctions.some((selector) => selector(stack.getPath(REGISTERED_NODE_KINDS))); | ||
| return rootNodeVisitor3((root) => { | ||
| return rootNodeVisitor((root) => { | ||
| const typesToPotentiallyUnwrap = []; | ||
@@ -1042,22 +838,22 @@ const definedTypes = new Map( | ||
| ); | ||
| let newRoot = visit8( | ||
| let newRoot = visit( | ||
| root, | ||
| bottomUpTransformerVisitor9([ | ||
| bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[enumTupleVariantTypeNode]", | ||
| transform: (node, stack) => { | ||
| assertIsNode14(node, "enumTupleVariantTypeNode"); | ||
| assertIsNode(node, "enumTupleVariantTypeNode"); | ||
| if (!shouldUnwrap(stack)) return node; | ||
| const tupleNode = resolveNestedTypeNode2(node.tuple); | ||
| const tupleNode = resolveNestedTypeNode(node.tuple); | ||
| if (tupleNode.items.length !== 1) return node; | ||
| let item = tupleNode.items[0]; | ||
| if (isNode7(item, "definedTypeLinkNode")) { | ||
| if (isNode(item, "definedTypeLinkNode")) { | ||
| const definedType = definedTypes.get(item.name); | ||
| if (!definedType) return node; | ||
| if (!isNode7(definedType.type, "structTypeNode")) return node; | ||
| if (!isNode(definedType.type, "structTypeNode")) return node; | ||
| typesToPotentiallyUnwrap.push(item.name); | ||
| item = definedType.type; | ||
| } | ||
| if (!isNode7(item, "structTypeNode")) return node; | ||
| const nestedStruct = transformNestedTypeNode2(node.tuple, () => item); | ||
| if (!isNode(item, "structTypeNode")) return node; | ||
| const nestedStruct = transformNestedTypeNode(node.tuple, () => item); | ||
| return enumStructVariantTypeNode(node.name, nestedStruct); | ||
@@ -1068,22 +864,14 @@ } | ||
| ); | ||
| assertIsNode14(newRoot, "rootNode"); | ||
| const histogram = visit8(newRoot, getDefinedTypeHistogramVisitor()); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| const histogram = visit(newRoot, getDefinedTypeHistogramVisitor()); | ||
| const typesToUnwrap = typesToPotentiallyUnwrap.filter( | ||
| (type) => !histogram[type] || histogram[type].total === 0 | ||
| ); | ||
| newRoot = visit8(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| assertIsNode14(newRoot, "rootNode"); | ||
| newRoot = visit(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
| }); | ||
| } | ||
| // src/unwrapTypeDefinedLinksVisitor.ts | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor10, | ||
| LinkableDictionary as LinkableDictionary7, | ||
| pipe as pipe9, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor5 | ||
| } from "@codama/visitors-core"; | ||
| function unwrapTypeDefinedLinksVisitor(definedLinksType) { | ||
| const linkables = new LinkableDictionary7(); | ||
| const linkables = new LinkableDictionary(); | ||
| const transformers = definedLinksType.map((selector) => ({ | ||
@@ -1096,34 +884,7 @@ select: ["[definedTypeLinkNode]", selector], | ||
| })); | ||
| return pipe9(bottomUpTransformerVisitor10(transformers), (v) => recordLinkablesOnFirstVisitVisitor5(v, linkables)); | ||
| return pipe(bottomUpTransformerVisitor(transformers), (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/updateAccountsVisitor.ts | ||
| import { | ||
| accountLinkNode, | ||
| accountNode as accountNode4, | ||
| assertIsNode as assertIsNode15, | ||
| camelCase as camelCase8, | ||
| pdaLinkNode, | ||
| pdaNode as pdaNode2, | ||
| programNode as programNode4, | ||
| transformNestedTypeNode as transformNestedTypeNode3 | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor11, | ||
| findProgramNodeFromPath as findProgramNodeFromPath3 | ||
| } from "@codama/visitors-core"; | ||
| // src/renameHelpers.ts | ||
| import { | ||
| enumEmptyVariantTypeNode, | ||
| enumStructVariantTypeNode as enumStructVariantTypeNode2, | ||
| enumTupleVariantTypeNode, | ||
| enumTypeNode, | ||
| isNode as isNode8, | ||
| structFieldTypeNode as structFieldTypeNode3, | ||
| structTypeNode as structTypeNode4 | ||
| } from "@codama/nodes"; | ||
| function renameStructNode(node, map) { | ||
| return structTypeNode4( | ||
| node.fields.map((field) => map[field.name] ? structFieldTypeNode3({ ...field, name: map[field.name] }) : field) | ||
| return structTypeNode( | ||
| node.fields.map((field) => map[field.name] ? structFieldTypeNode({ ...field, name: map[field.name] }) : field) | ||
| ); | ||
@@ -1138,6 +899,6 @@ } | ||
| function renameEnumVariant(variant, newName) { | ||
| if (isNode8(variant, "enumStructVariantTypeNode")) { | ||
| return enumStructVariantTypeNode2(newName, variant.struct); | ||
| if (isNode(variant, "enumStructVariantTypeNode")) { | ||
| return enumStructVariantTypeNode(newName, variant.struct); | ||
| } | ||
| if (isNode8(variant, "enumTupleVariantTypeNode")) { | ||
| if (isNode(variant, "enumTupleVariantTypeNode")) { | ||
| return enumTupleVariantTypeNode(newName, variant.tuple); | ||
@@ -1150,5 +911,5 @@ } | ||
| function updateAccountsVisitor(map) { | ||
| return bottomUpTransformerVisitor11( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase8(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase(updates.name) : void 0; | ||
| const pdasToUpsert = []; | ||
@@ -1159,5 +920,5 @@ const transformers = [ | ||
| transform: (node, stack) => { | ||
| assertIsNode15(node, "accountNode"); | ||
| assertIsNode(node, "accountNode"); | ||
| if ("delete" in updates) return null; | ||
| const programNode6 = findProgramNodeFromPath3(stack.getPath()); | ||
| const programNode6 = findProgramNodeFromPath(stack.getPath()); | ||
| const { seeds, pda, ...assignableUpdates } = updates; | ||
@@ -1168,3 +929,3 @@ let newPda = node.pda; | ||
| pdasToUpsert.push({ | ||
| pda: pdaNode2({ name: pda.name, seeds }), | ||
| pda: pdaNode({ name: pda.name, seeds }), | ||
| program: programNode6.name | ||
@@ -1176,3 +937,3 @@ }); | ||
| pdasToUpsert.push({ | ||
| pda: pdaNode2({ name: node.pda.name, seeds }), | ||
| pda: pdaNode({ name: node.pda.name, seeds }), | ||
| program: programNode6.name | ||
@@ -1183,10 +944,10 @@ }); | ||
| pdasToUpsert.push({ | ||
| pda: pdaNode2({ name: newName ?? node.name, seeds }), | ||
| pda: pdaNode({ name: newName ?? node.name, seeds }), | ||
| program: programNode6.name | ||
| }); | ||
| } | ||
| return accountNode4({ | ||
| return accountNode({ | ||
| ...node, | ||
| ...assignableUpdates, | ||
| data: transformNestedTypeNode3( | ||
| data: transformNestedTypeNode( | ||
| node.data, | ||
@@ -1202,3 +963,3 @@ (struct) => renameStructNode(struct, updates.data ?? {}) | ||
| transform: (node) => { | ||
| assertIsNode15(node, "programNode"); | ||
| assertIsNode(node, "programNode"); | ||
| const pdasToUpsertForProgram = pdasToUpsert.filter((p) => p.program === node.name).map((p) => p.pda); | ||
@@ -1212,3 +973,3 @@ if (pdasToUpsertForProgram.length === 0) return node; | ||
| const newPdas = [...node.pdas.map((p) => pdasToUpdate.get(p.name) ?? p), ...pdasToCreate]; | ||
| return programNode4({ ...node, pdas: newPdas }); | ||
| return programNode({ ...node, pdas: newPdas }); | ||
| } | ||
@@ -1222,3 +983,3 @@ } | ||
| transform: (node) => { | ||
| assertIsNode15(node, "accountLinkNode"); | ||
| assertIsNode(node, "accountLinkNode"); | ||
| return accountLinkNode(newName); | ||
@@ -1230,4 +991,4 @@ } | ||
| transform: (node) => { | ||
| assertIsNode15(node, "pdaNode"); | ||
| return pdaNode2({ name: newName, seeds: node.seeds }); | ||
| assertIsNode(node, "pdaNode"); | ||
| return pdaNode({ name: newName, seeds: node.seeds }); | ||
| } | ||
@@ -1238,3 +999,3 @@ }, | ||
| transform: (node) => { | ||
| assertIsNode15(node, "pdaLinkNode"); | ||
| assertIsNode(node, "pdaLinkNode"); | ||
| return pdaLinkNode(newName); | ||
@@ -1249,16 +1010,6 @@ } | ||
| } | ||
| // src/updateDefinedTypesVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode16, | ||
| camelCase as camelCase9, | ||
| definedTypeLinkNode as definedTypeLinkNode2, | ||
| definedTypeNode, | ||
| isNode as isNode9 | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor12 } from "@codama/visitors-core"; | ||
| function updateDefinedTypesVisitor(map) { | ||
| return bottomUpTransformerVisitor12( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase9(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1268,3 +1019,3 @@ { | ||
| transform: (node) => { | ||
| assertIsNode16(node, "definedTypeNode"); | ||
| assertIsNode(node, "definedTypeNode"); | ||
| if ("delete" in updates) { | ||
@@ -1275,5 +1026,5 @@ return null; | ||
| let newType = node.type; | ||
| if (isNode9(node.type, "structTypeNode")) { | ||
| if (isNode(node.type, "structTypeNode")) { | ||
| newType = renameStructNode(node.type, dataUpdates ?? {}); | ||
| } else if (isNode9(node.type, "enumTypeNode")) { | ||
| } else if (isNode(node.type, "enumTypeNode")) { | ||
| newType = renameEnumNode(node.type, dataUpdates ?? {}); | ||
@@ -1294,4 +1045,4 @@ } | ||
| transform: (node) => { | ||
| assertIsNode16(node, "definedTypeLinkNode"); | ||
| return definedTypeLinkNode2(newName); | ||
| assertIsNode(node, "definedTypeLinkNode"); | ||
| return definedTypeLinkNode(newName); | ||
| } | ||
@@ -1304,8 +1055,4 @@ }); | ||
| } | ||
| // src/updateErrorsVisitor.ts | ||
| import { assertIsNode as assertIsNode17, errorNode } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor13 } from "@codama/visitors-core"; | ||
| function updateErrorsVisitor(map) { | ||
| return bottomUpTransformerVisitor13( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -1315,3 +1062,3 @@ ([name, updates]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode17(node, "errorNode"); | ||
| assertIsNode(node, "errorNode"); | ||
| if ("delete" in updates) return null; | ||
@@ -1324,23 +1071,5 @@ return errorNode({ ...node, ...updates }); | ||
| } | ||
| // src/updateInstructionsVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode18, | ||
| instructionAccountNode, | ||
| instructionArgumentNode as instructionArgumentNode5, | ||
| instructionNode as instructionNode6, | ||
| TYPE_NODES as TYPE_NODES2 | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor14, | ||
| LinkableDictionary as LinkableDictionary8, | ||
| NodeStack as NodeStack5, | ||
| pipe as pipe10, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor6, | ||
| recordNodeStackVisitor as recordNodeStackVisitor4, | ||
| visit as visit9 | ||
| } from "@codama/visitors-core"; | ||
| function updateInstructionsVisitor(map) { | ||
| const linkables = new LinkableDictionary8(); | ||
| const stack = new NodeStack5(); | ||
| const linkables = new LinkableDictionary(); | ||
| const stack = new NodeStack(); | ||
| const transformers = Object.entries(map).map( | ||
@@ -1350,3 +1079,3 @@ ([selector, updates]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode18(node, "instructionNode"); | ||
| assertIsNode(node, "instructionNode"); | ||
| if ("delete" in updates) { | ||
@@ -1361,3 +1090,3 @@ return null; | ||
| ); | ||
| return instructionNode6({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -1372,6 +1101,6 @@ ...metadataUpdates, | ||
| ); | ||
| return pipe10( | ||
| bottomUpTransformerVisitor14(transformers), | ||
| (v) => recordNodeStackVisitor4(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor6(v, linkables) | ||
| return pipe( | ||
| bottomUpTransformerVisitor(transformers), | ||
| (v) => recordNodeStackVisitor(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
@@ -1391,3 +1120,3 @@ } | ||
| ...acountWithoutDefault, | ||
| defaultValue: visit9(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| defaultValue: visit(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| }); | ||
@@ -1401,3 +1130,3 @@ } | ||
| usedArguments.add(node.name); | ||
| return instructionArgumentNode5({ | ||
| return instructionArgumentNode({ | ||
| ...node, | ||
@@ -1416,3 +1145,3 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| usedArguments.add(node.name); | ||
| return instructionArgumentNode5({ | ||
| return instructionArgumentNode({ | ||
| ...node, | ||
@@ -1430,4 +1159,4 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| const { type } = argUpdate; | ||
| assertIsNode18(type, TYPE_NODES2); | ||
| return instructionArgumentNode5({ | ||
| assertIsNode(type, TYPE_NODES); | ||
| return instructionArgumentNode({ | ||
| defaultValue: argUpdate.defaultValue ?? void 0, | ||
@@ -1443,10 +1172,6 @@ defaultValueStrategy: argUpdate.defaultValueStrategy ?? void 0, | ||
| } | ||
| // src/updateProgramsVisitor.ts | ||
| import { assertIsNode as assertIsNode19, camelCase as camelCase10, programLinkNode, programNode as programNode5 } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor15 } from "@codama/visitors-core"; | ||
| function updateProgramsVisitor(map) { | ||
| return bottomUpTransformerVisitor15( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([name, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase10(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1456,5 +1181,5 @@ { | ||
| transform: (node) => { | ||
| assertIsNode19(node, "programNode"); | ||
| assertIsNode(node, "programNode"); | ||
| if ("delete" in updates) return null; | ||
| return programNode5({ ...node, ...updates }); | ||
| return programNode({ ...node, ...updates }); | ||
| } | ||
@@ -1467,3 +1192,3 @@ } | ||
| transform: (node) => { | ||
| assertIsNode19(node, "programLinkNode"); | ||
| assertIsNode(node, "programLinkNode"); | ||
| return programLinkNode(newName); | ||
@@ -1477,31 +1202,5 @@ } | ||
| } | ||
| export { | ||
| addPdasVisitor, | ||
| createSubInstructionsFromEnumArgsVisitor, | ||
| deduplicateIdenticalDefinedTypesVisitor, | ||
| fillDefaultPdaSeedValuesVisitor, | ||
| flattenInstructionArguments, | ||
| flattenInstructionDataArgumentsVisitor, | ||
| flattenStruct, | ||
| flattenStructVisitor, | ||
| getCommonInstructionAccountDefaultRules, | ||
| getDefinedTypeHistogramVisitor, | ||
| setAccountDiscriminatorFromFieldVisitor, | ||
| setFixedAccountSizesVisitor, | ||
| setInstructionAccountDefaultValuesVisitor, | ||
| setInstructionDiscriminatorsVisitor, | ||
| setNumberWrappersVisitor, | ||
| setStructDefaultValuesVisitor, | ||
| transformDefinedTypesIntoAccountsVisitor, | ||
| transformU8ArraysToBytesVisitor, | ||
| unwrapDefinedTypesVisitor, | ||
| unwrapInstructionArgsDefinedTypesVisitor, | ||
| unwrapTupleEnumWithSingleStructVisitor, | ||
| unwrapTypeDefinedLinksVisitor, | ||
| updateAccountsVisitor, | ||
| updateDefinedTypesVisitor, | ||
| updateErrorsVisitor, | ||
| updateInstructionsVisitor, | ||
| updateProgramsVisitor | ||
| }; | ||
| export { addPdasVisitor, createSubInstructionsFromEnumArgsVisitor, deduplicateIdenticalDefinedTypesVisitor, fillDefaultPdaSeedValuesVisitor, flattenInstructionArguments, flattenInstructionDataArgumentsVisitor, flattenStruct, flattenStructVisitor, getCommonInstructionAccountDefaultRules, getDefinedTypeHistogramVisitor, setAccountDiscriminatorFromFieldVisitor, setFixedAccountSizesVisitor, setInstructionAccountDefaultValuesVisitor, setInstructionDiscriminatorsVisitor, setNumberWrappersVisitor, setStructDefaultValuesVisitor, transformDefinedTypesIntoAccountsVisitor, transformU8ArraysToBytesVisitor, unwrapDefinedTypesVisitor, unwrapInstructionArgsDefinedTypesVisitor, unwrapTupleEnumWithSingleStructVisitor, unwrapTypeDefinedLinksVisitor, updateAccountsVisitor, updateDefinedTypesVisitor, updateErrorsVisitor, updateInstructionsVisitor, updateProgramsVisitor }; | ||
| //# sourceMappingURL=index.browser.mjs.map | ||
| //# sourceMappingURL=index.browser.mjs.map |
+303
-449
@@ -1,67 +0,16 @@ | ||
| "use strict"; | ||
| var __defProp = Object.defineProperty; | ||
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
| var __getOwnPropNames = Object.getOwnPropertyNames; | ||
| var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
| var __export = (target, all) => { | ||
| for (var name in all) | ||
| __defProp(target, name, { get: all[name], enumerable: true }); | ||
| }; | ||
| var __copyProps = (to, from, except, desc) => { | ||
| if (from && typeof from === "object" || typeof from === "function") { | ||
| for (let key of __getOwnPropNames(from)) | ||
| if (!__hasOwnProp.call(to, key) && key !== except) | ||
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
| } | ||
| return to; | ||
| }; | ||
| var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default")); | ||
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
| 'use strict'; | ||
| var visitorsCore = require('@codama/visitors-core'); | ||
| var errors = require('@codama/errors'); | ||
| var nodes = require('@codama/nodes'); | ||
| // src/index.ts | ||
| var index_exports = {}; | ||
| __export(index_exports, { | ||
| addPdasVisitor: () => addPdasVisitor, | ||
| createSubInstructionsFromEnumArgsVisitor: () => createSubInstructionsFromEnumArgsVisitor, | ||
| deduplicateIdenticalDefinedTypesVisitor: () => deduplicateIdenticalDefinedTypesVisitor, | ||
| fillDefaultPdaSeedValuesVisitor: () => fillDefaultPdaSeedValuesVisitor, | ||
| flattenInstructionArguments: () => flattenInstructionArguments, | ||
| flattenInstructionDataArgumentsVisitor: () => flattenInstructionDataArgumentsVisitor, | ||
| flattenStruct: () => flattenStruct, | ||
| flattenStructVisitor: () => flattenStructVisitor, | ||
| getCommonInstructionAccountDefaultRules: () => getCommonInstructionAccountDefaultRules, | ||
| getDefinedTypeHistogramVisitor: () => getDefinedTypeHistogramVisitor, | ||
| setAccountDiscriminatorFromFieldVisitor: () => setAccountDiscriminatorFromFieldVisitor, | ||
| setFixedAccountSizesVisitor: () => setFixedAccountSizesVisitor, | ||
| setInstructionAccountDefaultValuesVisitor: () => setInstructionAccountDefaultValuesVisitor, | ||
| setInstructionDiscriminatorsVisitor: () => setInstructionDiscriminatorsVisitor, | ||
| setNumberWrappersVisitor: () => setNumberWrappersVisitor, | ||
| setStructDefaultValuesVisitor: () => setStructDefaultValuesVisitor, | ||
| transformDefinedTypesIntoAccountsVisitor: () => transformDefinedTypesIntoAccountsVisitor, | ||
| transformU8ArraysToBytesVisitor: () => transformU8ArraysToBytesVisitor, | ||
| unwrapDefinedTypesVisitor: () => unwrapDefinedTypesVisitor, | ||
| unwrapInstructionArgsDefinedTypesVisitor: () => unwrapInstructionArgsDefinedTypesVisitor, | ||
| unwrapTupleEnumWithSingleStructVisitor: () => unwrapTupleEnumWithSingleStructVisitor, | ||
| unwrapTypeDefinedLinksVisitor: () => unwrapTypeDefinedLinksVisitor, | ||
| updateAccountsVisitor: () => updateAccountsVisitor, | ||
| updateDefinedTypesVisitor: () => updateDefinedTypesVisitor, | ||
| updateErrorsVisitor: () => updateErrorsVisitor, | ||
| updateInstructionsVisitor: () => updateInstructionsVisitor, | ||
| updateProgramsVisitor: () => updateProgramsVisitor | ||
| }); | ||
| module.exports = __toCommonJS(index_exports); | ||
| __reExport(index_exports, require("@codama/visitors-core"), module.exports); | ||
| // src/addPdasVisitor.ts | ||
| var import_errors = require("@codama/errors"); | ||
| var import_nodes = require("@codama/nodes"); | ||
| var import_visitors_core = require("@codama/visitors-core"); | ||
| function addPdasVisitor(pdas) { | ||
| return (0, import_visitors_core.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(pdas).map(([uncasedProgramName, newPdas]) => { | ||
| const programName = (0, import_nodes.camelCase)(uncasedProgramName); | ||
| const programName = nodes.camelCase(uncasedProgramName); | ||
| return { | ||
| select: `[programNode]${programName}`, | ||
| transform: (node) => { | ||
| (0, import_nodes.assertIsNode)(node, "programNode"); | ||
| nodes.assertIsNode(node, "programNode"); | ||
| const existingPdaNames = new Set(node.pdas.map((pda) => pda.name)); | ||
@@ -71,3 +20,3 @@ const newPdaNames = new Set(newPdas.map((pda) => pda.name)); | ||
| if (overlappingPdaNames.size > 0) { | ||
| throw new import_errors.CodamaError(import_errors.CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, { | ||
| duplicatedPdaNames: [...overlappingPdaNames], | ||
@@ -78,5 +27,5 @@ program: node, | ||
| } | ||
| return (0, import_nodes.programNode)({ | ||
| return nodes.programNode({ | ||
| ...node, | ||
| pdas: [...node.pdas, ...newPdas.map(({ name, seeds, docs }) => (0, import_nodes.pdaNode)({ docs, name, seeds }))] | ||
| pdas: [...node.pdas, ...newPdas.map(({ name, seeds, docs }) => nodes.pdaNode({ docs, name, seeds }))] | ||
| }); | ||
@@ -88,19 +37,9 @@ } | ||
| } | ||
| // src/createSubInstructionsFromEnumArgsVisitor.ts | ||
| var import_errors3 = require("@codama/errors"); | ||
| var import_nodes3 = require("@codama/nodes"); | ||
| var import_visitors_core3 = require("@codama/visitors-core"); | ||
| // src/flattenInstructionDataArgumentsVisitor.ts | ||
| var import_errors2 = require("@codama/errors"); | ||
| var import_nodes2 = require("@codama/nodes"); | ||
| var import_visitors_core2 = require("@codama/visitors-core"); | ||
| function flattenInstructionDataArgumentsVisitor() { | ||
| return (0, import_visitors_core2.bottomUpTransformerVisitor)([ | ||
| return visitorsCore.bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[instructionNode]", | ||
| transform: (instruction) => { | ||
| (0, import_nodes2.assertIsNode)(instruction, "instructionNode"); | ||
| return (0, import_nodes2.instructionNode)({ | ||
| nodes.assertIsNode(instruction, "instructionNode"); | ||
| return nodes.instructionNode({ | ||
| ...instruction, | ||
@@ -113,8 +52,8 @@ arguments: flattenInstructionArguments(instruction.arguments) | ||
| } | ||
| var flattenInstructionArguments = (nodes, options = "*") => { | ||
| const camelCaseOptions = options === "*" ? options : options.map(import_nodes2.camelCase); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes((0, import_nodes2.camelCase)(node.name)); | ||
| const inlinedArguments = nodes.flatMap((node) => { | ||
| if ((0, import_nodes2.isNode)(node.type, "structTypeNode") && shouldInline(node)) { | ||
| return node.type.fields.map((field) => (0, import_nodes2.instructionArgumentNode)({ ...field })); | ||
| var flattenInstructionArguments = (nodes$1, options = "*") => { | ||
| const camelCaseOptions = options === "*" ? options : options.map(nodes.camelCase); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes(nodes.camelCase(node.name)); | ||
| const inlinedArguments = nodes$1.flatMap((node) => { | ||
| if (nodes.isNode(node.type, "structTypeNode") && shouldInline(node)) { | ||
| return node.type.fields.map((field) => nodes.instructionArgumentNode({ ...field })); | ||
| } | ||
@@ -128,7 +67,7 @@ return node; | ||
| if (hasConflictingNames) { | ||
| throw new import_errors2.CodamaError(import_errors2.CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
| }); | ||
| } | ||
| return hasConflictingNames ? nodes : inlinedArguments; | ||
| return hasConflictingNames ? nodes$1 : inlinedArguments; | ||
| }; | ||
@@ -138,4 +77,4 @@ | ||
| function createSubInstructionsFromEnumArgsVisitor(map) { | ||
| const linkables = new import_visitors_core3.LinkableDictionary(); | ||
| const visitor = (0, import_visitors_core3.bottomUpTransformerVisitor)( | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const visitor = visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -145,9 +84,9 @@ ([selector, argNameInput]) => ({ | ||
| transform: (node, stack) => { | ||
| (0, import_nodes3.assertIsNode)(node, "instructionNode"); | ||
| nodes.assertIsNode(node, "instructionNode"); | ||
| const argFields = node.arguments; | ||
| const argName = (0, import_nodes3.camelCase)(argNameInput); | ||
| const argName = nodes.camelCase(argNameInput); | ||
| const argFieldIndex = argFields.findIndex((field) => field.name === argName); | ||
| const argField = argFieldIndex >= 0 ? argFields[argFieldIndex] : null; | ||
| if (!argField) { | ||
| throw new import_errors3.CodamaError(import_errors3.CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -159,10 +98,10 @@ instruction: node, | ||
| let argType; | ||
| if ((0, import_nodes3.isNode)(argField.type, "enumTypeNode")) { | ||
| if (nodes.isNode(argField.type, "enumTypeNode")) { | ||
| argType = argField.type; | ||
| } else if ((0, import_nodes3.isNode)(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| } else if (nodes.isNode(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| const linkedType = linkables.get([...stack.getPath(), argField.type])?.type; | ||
| (0, import_nodes3.assertIsNode)(linkedType, "enumTypeNode"); | ||
| nodes.assertIsNode(linkedType, "enumTypeNode"); | ||
| argType = linkedType; | ||
| } else { | ||
| throw new import_errors3.CodamaError(import_errors3.CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -174,15 +113,15 @@ instruction: node, | ||
| const subInstructions = argType.variants.map((variant, index) => { | ||
| const subName = (0, import_nodes3.camelCase)(`${node.name} ${variant.name}`); | ||
| const subName = nodes.camelCase(`${node.name} ${variant.name}`); | ||
| const subFields = argFields.slice(0, argFieldIndex); | ||
| subFields.push( | ||
| (0, import_nodes3.instructionArgumentNode)({ | ||
| defaultValue: (0, import_nodes3.numberValueNode)(index), | ||
| nodes.instructionArgumentNode({ | ||
| defaultValue: nodes.numberValueNode(index), | ||
| defaultValueStrategy: "omitted", | ||
| name: `${subName}Discriminator`, | ||
| type: (0, import_nodes3.numberTypeNode)("u8") | ||
| type: nodes.numberTypeNode("u8") | ||
| }) | ||
| ); | ||
| if ((0, import_nodes3.isNode)(variant, "enumStructVariantTypeNode")) { | ||
| if (nodes.isNode(variant, "enumStructVariantTypeNode")) { | ||
| subFields.push( | ||
| (0, import_nodes3.instructionArgumentNode)({ | ||
| nodes.instructionArgumentNode({ | ||
| ...argField, | ||
@@ -192,5 +131,5 @@ type: variant.struct | ||
| ); | ||
| } else if ((0, import_nodes3.isNode)(variant, "enumTupleVariantTypeNode")) { | ||
| } else if (nodes.isNode(variant, "enumTupleVariantTypeNode")) { | ||
| subFields.push( | ||
| (0, import_nodes3.instructionArgumentNode)({ | ||
| nodes.instructionArgumentNode({ | ||
| ...argField, | ||
@@ -202,3 +141,3 @@ type: variant.tuple | ||
| subFields.push(...argFields.slice(argFieldIndex + 1)); | ||
| return (0, import_nodes3.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -209,3 +148,3 @@ arguments: flattenInstructionArguments(subFields), | ||
| }); | ||
| return (0, import_nodes3.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -218,12 +157,8 @@ subInstructions: [...node.subInstructions ?? [], ...subInstructions] | ||
| ); | ||
| return (0, import_visitors_core3.pipe)(visitor, (v) => (0, import_visitors_core3.recordLinkablesOnFirstVisitVisitor)(v, linkables)); | ||
| return visitorsCore.pipe(visitor, (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/deduplicateIdenticalDefinedTypesVisitor.ts | ||
| var import_nodes4 = require("@codama/nodes"); | ||
| var import_visitors_core4 = require("@codama/visitors-core"); | ||
| function deduplicateIdenticalDefinedTypesVisitor() { | ||
| return (0, import_visitors_core4.rootNodeVisitor)((root) => { | ||
| return visitorsCore.rootNodeVisitor((root) => { | ||
| const typeMap = /* @__PURE__ */ new Map(); | ||
| const allPrograms = (0, import_nodes4.getAllPrograms)(root); | ||
| const allPrograms = nodes.getAllPrograms(root); | ||
| allPrograms.forEach((program) => { | ||
@@ -241,5 +176,5 @@ program.definedTypes.forEach((type) => { | ||
| }); | ||
| const hashVisitor = (0, import_visitors_core4.getUniqueHashStringVisitor)({ removeDocs: true }); | ||
| const hashVisitor = visitorsCore.getUniqueHashStringVisitor({ removeDocs: true }); | ||
| typeMap.forEach((list, name) => { | ||
| const types = list.map((item) => (0, import_visitors_core4.visit)(item.type, hashVisitor)); | ||
| const types = list.map((item) => visitorsCore.visit(item.type, hashVisitor)); | ||
| const typesAreEqual = types.every((type, _, arr) => type === arr[0]); | ||
@@ -256,4 +191,4 @@ if (!typesAreEqual) { | ||
| if (deleteSelectors.length > 0) { | ||
| const newRoot = (0, import_visitors_core4.visit)(root, (0, import_visitors_core4.deleteNodesVisitor)(deleteSelectors)); | ||
| (0, import_nodes4.assertIsNode)(newRoot, "rootNode"); | ||
| const newRoot = visitorsCore.visit(root, visitorsCore.deleteNodesVisitor(deleteSelectors)); | ||
| nodes.assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -264,20 +199,15 @@ } | ||
| } | ||
| // src/fillDefaultPdaSeedValuesVisitor.ts | ||
| var import_errors4 = require("@codama/errors"); | ||
| var import_nodes5 = require("@codama/nodes"); | ||
| var import_visitors_core5 = require("@codama/visitors-core"); | ||
| function fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, strictMode = false) { | ||
| const instruction = (0, import_visitors_core5.getLastNodeFromPath)(instructionPath); | ||
| return (0, import_visitors_core5.pipe)( | ||
| (0, import_visitors_core5.identityVisitor)({ keys: import_nodes5.INSTRUCTION_INPUT_VALUE_NODES }), | ||
| (v) => (0, import_visitors_core5.extendVisitor)(v, { | ||
| const instruction = visitorsCore.getLastNodeFromPath(instructionPath); | ||
| return visitorsCore.pipe( | ||
| visitorsCore.identityVisitor({ keys: nodes.INSTRUCTION_INPUT_VALUE_NODES }), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitPdaValue(node, { next }) { | ||
| const visitedNode = next(node); | ||
| (0, import_nodes5.assertIsNode)(visitedNode, "pdaValueNode"); | ||
| const foundPda = (0, import_nodes5.isNode)(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| nodes.assertIsNode(visitedNode, "pdaValueNode"); | ||
| const foundPda = nodes.isNode(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| if (!foundPda) return visitedNode; | ||
| const seeds = addDefaultSeedValuesFromPdaWhenMissing(instruction, foundPda, visitedNode.seeds); | ||
| if (strictMode && !allSeedsAreValid(instruction, foundPda, seeds)) { | ||
| throw new import_errors4.CodamaError(import_errors4.CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| instruction, | ||
@@ -289,3 +219,3 @@ instructionName: instruction.name, | ||
| } | ||
| return (0, import_nodes5.pdaValueNode)(visitedNode.pda, seeds); | ||
| return nodes.pdaValueNode(visitedNode.pda, seeds); | ||
| } | ||
@@ -304,10 +234,10 @@ }) | ||
| return pda.seeds.flatMap((seed) => { | ||
| if (!(0, import_nodes5.isNode)(seed, "variablePdaSeedNode")) return []; | ||
| if (!nodes.isNode(seed, "variablePdaSeedNode")) return []; | ||
| const hasMatchingAccount = instruction.accounts.some((a) => a.name === seed.name); | ||
| if ((0, import_nodes5.isNode)(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| return [(0, import_nodes5.pdaSeedValueNode)(seed.name, (0, import_nodes5.accountValueNode)(seed.name))]; | ||
| if (nodes.isNode(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| return [nodes.pdaSeedValueNode(seed.name, nodes.accountValueNode(seed.name))]; | ||
| } | ||
| const hasMatchingArgument = (0, import_nodes5.getAllInstructionArguments)(instruction).some((a) => a.name === seed.name); | ||
| const hasMatchingArgument = nodes.getAllInstructionArguments(instruction).some((a) => a.name === seed.name); | ||
| if (hasMatchingArgument) { | ||
| return [(0, import_nodes5.pdaSeedValueNode)(seed.name, (0, import_nodes5.argumentValueNode)(seed.name))]; | ||
| return [nodes.pdaSeedValueNode(seed.name, nodes.argumentValueNode(seed.name))]; | ||
| } | ||
@@ -318,10 +248,10 @@ return []; | ||
| function allSeedsAreValid(instruction, foundPda, seeds) { | ||
| const hasAllVariableSeeds = foundPda.seeds.filter((0, import_nodes5.isNodeFilter)("variablePdaSeedNode")).length === seeds.length; | ||
| const hasAllVariableSeeds = foundPda.seeds.filter(nodes.isNodeFilter("variablePdaSeedNode")).length === seeds.length; | ||
| const allAccountsName = instruction.accounts.map((a) => a.name); | ||
| const allArgumentsName = (0, import_nodes5.getAllInstructionArguments)(instruction).map((a) => a.name); | ||
| const allArgumentsName = nodes.getAllInstructionArguments(instruction).map((a) => a.name); | ||
| const validSeeds = seeds.every((seed) => { | ||
| if ((0, import_nodes5.isNode)(seed.value, "accountValueNode")) { | ||
| if (nodes.isNode(seed.value, "accountValueNode")) { | ||
| return allAccountsName.includes(seed.value.name); | ||
| } | ||
| if ((0, import_nodes5.isNode)(seed.value, "argumentValueNode")) { | ||
| if (nodes.isNode(seed.value, "argumentValueNode")) { | ||
| return allArgumentsName.includes(seed.value.name); | ||
@@ -333,9 +263,4 @@ } | ||
| } | ||
| // src/flattenStructVisitor.ts | ||
| var import_errors5 = require("@codama/errors"); | ||
| var import_nodes6 = require("@codama/nodes"); | ||
| var import_visitors_core6 = require("@codama/visitors-core"); | ||
| function flattenStructVisitor(map) { | ||
| return (0, import_visitors_core6.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -350,7 +275,7 @@ ([stack, options]) => ({ | ||
| var flattenStruct = (node, options = "*") => { | ||
| (0, import_nodes6.assertIsNode)(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(import_nodes6.camelCase); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes((0, import_nodes6.camelCase)(field.name)); | ||
| nodes.assertIsNode(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(nodes.camelCase); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes(nodes.camelCase(field.name)); | ||
| const inlinedFields = node.fields.flatMap((field) => { | ||
| if ((0, import_nodes6.isNode)(field.type, "structTypeNode") && shouldInline(field)) { | ||
| if (nodes.isNode(field.type, "structTypeNode") && shouldInline(field)) { | ||
| return field.type.fields; | ||
@@ -365,11 +290,8 @@ } | ||
| if (hasConflictingNames) { | ||
| throw new import_errors5.CodamaError(import_errors5.CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
| }); | ||
| } | ||
| return hasConflictingNames ? node : (0, import_nodes6.structTypeNode)(inlinedFields); | ||
| return hasConflictingNames ? node : nodes.structTypeNode(inlinedFields); | ||
| }; | ||
| // src/getDefinedTypeHistogramVisitor.ts | ||
| var import_visitors_core7 = require("@codama/visitors-core"); | ||
| function mergeHistograms(histograms) { | ||
@@ -394,11 +316,11 @@ const result = {}; | ||
| function getDefinedTypeHistogramVisitor() { | ||
| const stack = new import_visitors_core7.NodeStack(); | ||
| const stack = new visitorsCore.NodeStack(); | ||
| let mode = null; | ||
| let stackLevel = 0; | ||
| return (0, import_visitors_core7.pipe)( | ||
| (0, import_visitors_core7.mergeVisitor)( | ||
| return visitorsCore.pipe( | ||
| visitorsCore.mergeVisitor( | ||
| () => ({}), | ||
| (_, histograms) => mergeHistograms(histograms) | ||
| ), | ||
| (v) => (0, import_visitors_core7.interceptVisitor)(v, (node, next) => { | ||
| (v) => visitorsCore.interceptVisitor(v, (node, next) => { | ||
| stackLevel += 1; | ||
@@ -409,7 +331,7 @@ const newNode = next(node); | ||
| }), | ||
| (v) => (0, import_visitors_core7.extendVisitor)(v, { | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitAccount(node, { self }) { | ||
| mode = "account"; | ||
| stackLevel = 0; | ||
| const histogram = (0, import_visitors_core7.visit)(node.data, self); | ||
| const histogram = visitorsCore.visit(node.data, self); | ||
| mode = null; | ||
@@ -421,3 +343,3 @@ return histogram; | ||
| stackLevel = 0; | ||
| const histogram = (0, import_visitors_core7.visit)(node.type, self); | ||
| const histogram = visitorsCore.visit(node.type, self); | ||
| mode = null; | ||
@@ -427,3 +349,3 @@ return histogram; | ||
| visitDefinedTypeLink(node) { | ||
| const program = (0, import_visitors_core7.findProgramNodeFromPath)(stack.getPath()); | ||
| const program = visitorsCore.findProgramNodeFromPath(stack.getPath()); | ||
| const key = program ? `${program.name}.${node.name}` : node.name; | ||
@@ -443,19 +365,14 @@ return { | ||
| stackLevel = 0; | ||
| const dataHistograms = node.arguments.map((arg) => (0, import_visitors_core7.visit)(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => (0, import_visitors_core7.visit)(arg, self)); | ||
| const dataHistograms = node.arguments.map((arg) => visitorsCore.visit(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => visitorsCore.visit(arg, self)); | ||
| mode = null; | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => (0, import_visitors_core7.visit)(ix, self)); | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => visitorsCore.visit(ix, self)); | ||
| return mergeHistograms([...dataHistograms, ...extraHistograms, ...subHistograms]); | ||
| } | ||
| }), | ||
| (v) => (0, import_visitors_core7.recordNodeStackVisitor)(v, stack) | ||
| (v) => visitorsCore.recordNodeStackVisitor(v, stack) | ||
| ); | ||
| } | ||
| // src/setAccountDiscriminatorFromFieldVisitor.ts | ||
| var import_errors6 = require("@codama/errors"); | ||
| var import_nodes7 = require("@codama/nodes"); | ||
| var import_visitors_core8 = require("@codama/visitors-core"); | ||
| function setAccountDiscriminatorFromFieldVisitor(map) { | ||
| return (0, import_visitors_core8.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -465,7 +382,7 @@ ([selector, { field, value, offset }]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes7.assertIsNode)(node, "accountNode"); | ||
| const accountData = (0, import_nodes7.resolveNestedTypeNode)(node.data); | ||
| nodes.assertIsNode(node, "accountNode"); | ||
| const accountData = nodes.resolveNestedTypeNode(node.data); | ||
| const fieldIndex = accountData.fields.findIndex((f) => f.name === field); | ||
| if (fieldIndex < 0) { | ||
| throw new import_errors6.CodamaError(import_errors6.CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| account: node, | ||
@@ -477,9 +394,9 @@ missingField: field, | ||
| const fieldNode = accountData.fields[fieldIndex]; | ||
| return (0, import_nodes7.accountNode)({ | ||
| return nodes.accountNode({ | ||
| ...node, | ||
| data: (0, import_nodes7.transformNestedTypeNode)( | ||
| data: nodes.transformNestedTypeNode( | ||
| node.data, | ||
| () => (0, import_nodes7.structTypeNode)([ | ||
| () => nodes.structTypeNode([ | ||
| ...accountData.fields.slice(0, fieldIndex), | ||
| (0, import_nodes7.structFieldTypeNode)({ | ||
| nodes.structFieldTypeNode({ | ||
| ...fieldNode, | ||
@@ -492,3 +409,3 @@ defaultValue: value, | ||
| ), | ||
| discriminators: [(0, import_nodes7.fieldDiscriminatorNode)(field, offset), ...node.discriminators ?? []] | ||
| discriminators: [nodes.fieldDiscriminatorNode(field, offset), ...node.discriminators ?? []] | ||
| }); | ||
@@ -500,17 +417,13 @@ } | ||
| } | ||
| // src/setFixedAccountSizesVisitor.ts | ||
| var import_nodes8 = require("@codama/nodes"); | ||
| var import_visitors_core9 = require("@codama/visitors-core"); | ||
| function setFixedAccountSizesVisitor() { | ||
| const linkables = new import_visitors_core9.LinkableDictionary(); | ||
| const visitor = (0, import_visitors_core9.topDownTransformerVisitor)( | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const visitor = visitorsCore.topDownTransformerVisitor( | ||
| [ | ||
| { | ||
| select: (path) => (0, import_visitors_core9.isNodePath)(path, "accountNode") && (0, import_visitors_core9.getLastNodeFromPath)(path).size === void 0, | ||
| select: (path) => visitorsCore.isNodePath(path, "accountNode") && visitorsCore.getLastNodeFromPath(path).size === void 0, | ||
| transform: (node, stack) => { | ||
| (0, import_nodes8.assertIsNode)(node, "accountNode"); | ||
| const size = (0, import_visitors_core9.visit)(node.data, (0, import_visitors_core9.getByteSizeVisitor)(linkables, { stack })); | ||
| nodes.assertIsNode(node, "accountNode"); | ||
| const size = visitorsCore.visit(node.data, visitorsCore.getByteSizeVisitor(linkables, { stack })); | ||
| if (size === null) return node; | ||
| return (0, import_nodes8.accountNode)({ ...node, size }); | ||
| return nodes.accountNode({ ...node, size }); | ||
| } | ||
@@ -521,12 +434,8 @@ } | ||
| ); | ||
| return (0, import_visitors_core9.pipe)(visitor, (v) => (0, import_visitors_core9.recordLinkablesOnFirstVisitVisitor)(v, linkables)); | ||
| return visitorsCore.pipe(visitor, (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/setInstructionAccountDefaultValuesVisitor.ts | ||
| var import_nodes9 = require("@codama/nodes"); | ||
| var import_visitors_core10 = require("@codama/visitors-core"); | ||
| var getCommonInstructionAccountDefaultRules = () => [ | ||
| { | ||
| account: /^(payer|feePayer)$/, | ||
| defaultValue: (0, import_nodes9.payerValueNode)(), | ||
| defaultValue: nodes.payerValueNode(), | ||
| ignoreIfOptional: true | ||
@@ -536,3 +445,3 @@ }, | ||
| account: /^(authority)$/, | ||
| defaultValue: (0, import_nodes9.identityValueNode)(), | ||
| defaultValue: nodes.identityValueNode(), | ||
| ignoreIfOptional: true | ||
@@ -542,3 +451,3 @@ }, | ||
| account: /^(programId)$/, | ||
| defaultValue: (0, import_nodes9.programIdValueNode)(), | ||
| defaultValue: nodes.programIdValueNode(), | ||
| ignoreIfOptional: true | ||
@@ -548,3 +457,3 @@ }, | ||
| account: /^(systemProgram|splSystemProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("11111111111111111111111111111111", "splSystem"), | ||
| defaultValue: nodes.publicKeyValueNode("11111111111111111111111111111111", "splSystem"), | ||
| ignoreIfOptional: true | ||
@@ -554,3 +463,3 @@ }, | ||
| account: /^(tokenProgram|splTokenProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", "splToken"), | ||
| defaultValue: nodes.publicKeyValueNode("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", "splToken"), | ||
| ignoreIfOptional: true | ||
@@ -560,3 +469,3 @@ }, | ||
| account: /^(ataProgram|splAtaProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", "splAssociatedToken"), | ||
| defaultValue: nodes.publicKeyValueNode("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", "splAssociatedToken"), | ||
| ignoreIfOptional: true | ||
@@ -566,3 +475,3 @@ }, | ||
| account: /^(tokenMetadataProgram|mplTokenMetadataProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s", "mplTokenMetadata"), | ||
| defaultValue: nodes.publicKeyValueNode("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s", "mplTokenMetadata"), | ||
| ignoreIfOptional: true | ||
@@ -572,3 +481,3 @@ }, | ||
| account: /^(tokenAuth|mplTokenAuth|authorization|mplAuthorization|auth|mplAuth)RulesProgram$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3rboVmgg", "mplTokenAuthRules"), | ||
| defaultValue: nodes.publicKeyValueNode("auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3rboVmgg", "mplTokenAuthRules"), | ||
| ignoreIfOptional: true | ||
@@ -578,3 +487,3 @@ }, | ||
| account: /^(candyMachineProgram|mplCandyMachineProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR", "mplCandyMachine"), | ||
| defaultValue: nodes.publicKeyValueNode("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR", "mplCandyMachine"), | ||
| ignoreIfOptional: true | ||
@@ -584,3 +493,3 @@ }, | ||
| account: /^(candyGuardProgram|mplCandyGuardProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g", "mplCandyGuard"), | ||
| defaultValue: nodes.publicKeyValueNode("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g", "mplCandyGuard"), | ||
| ignoreIfOptional: true | ||
@@ -590,3 +499,3 @@ }, | ||
| account: /^(clockSysvar|sysvarClock)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarC1ock11111111111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarC1ock11111111111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -596,3 +505,3 @@ }, | ||
| account: /^(epochScheduleSysvar|sysvarEpochSchedule)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarEpochSchedu1e111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarEpochSchedu1e111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -602,3 +511,3 @@ }, | ||
| account: /^(instructions?Sysvar|sysvarInstructions?)(Account)?$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("Sysvar1nstructions1111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("Sysvar1nstructions1111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -608,3 +517,3 @@ }, | ||
| account: /^(recentBlockhashesSysvar|sysvarRecentBlockhashes)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarRecentB1ockHashes11111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarRecentB1ockHashes11111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -614,3 +523,3 @@ }, | ||
| account: /^(rent|rentSysvar|sysvarRent)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarRent111111111111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarRent111111111111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -620,3 +529,3 @@ }, | ||
| account: /^(rewardsSysvar|sysvarRewards)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarRewards111111111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarRewards111111111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -626,3 +535,3 @@ }, | ||
| account: /^(slotHashesSysvar|sysvarSlotHashes)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarS1otHashes111111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarS1otHashes111111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -632,3 +541,3 @@ }, | ||
| account: /^(slotHistorySysvar|sysvarSlotHistory)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarS1otHistory11111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarS1otHistory11111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -638,3 +547,3 @@ }, | ||
| account: /^(stakeHistorySysvar|sysvarStakeHistory)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("SysvarStakeHistory1111111111111111111111111"), | ||
| defaultValue: nodes.publicKeyValueNode("SysvarStakeHistory1111111111111111111111111"), | ||
| ignoreIfOptional: true | ||
@@ -644,3 +553,3 @@ }, | ||
| account: /^(mplCoreProgram)$/, | ||
| defaultValue: (0, import_nodes9.publicKeyValueNode)("CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d", "mplCore"), | ||
| defaultValue: nodes.publicKeyValueNode("CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d", "mplCore"), | ||
| ignoreIfOptional: true | ||
@@ -650,4 +559,4 @@ } | ||
| function setInstructionAccountDefaultValuesVisitor(rules) { | ||
| const linkables = new import_visitors_core10.LinkableDictionary(); | ||
| const stack = new import_visitors_core10.NodeStack(); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const stack = new visitorsCore.NodeStack(); | ||
| const sortedRules = rules.sort((a, b) => { | ||
@@ -661,11 +570,11 @@ const ia = "instruction" in a; | ||
| return sortedRules.find((rule) => { | ||
| if ("instruction" in rule && rule.instruction && (0, import_nodes9.camelCase)(rule.instruction) !== instruction.name) { | ||
| if ("instruction" in rule && rule.instruction && nodes.camelCase(rule.instruction) !== instruction.name) { | ||
| return false; | ||
| } | ||
| return typeof rule.account === "string" ? (0, import_nodes9.camelCase)(rule.account) === account.name : rule.account.test(account.name); | ||
| return typeof rule.account === "string" ? nodes.camelCase(rule.account) === account.name : rule.account.test(account.name); | ||
| }); | ||
| } | ||
| return (0, import_visitors_core10.pipe)( | ||
| (0, import_visitors_core10.nonNullableIdentityVisitor)({ keys: ["rootNode", "programNode", "instructionNode"] }), | ||
| (v) => (0, import_visitors_core10.extendVisitor)(v, { | ||
| return visitorsCore.pipe( | ||
| visitorsCore.nonNullableIdentityVisitor({ keys: ["rootNode", "programNode", "instructionNode"] }), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitInstruction(node) { | ||
@@ -682,3 +591,3 @@ const instructionPath = stack.getPath("instructionNode"); | ||
| ...account, | ||
| defaultValue: (0, import_visitors_core10.visit)( | ||
| defaultValue: visitorsCore.visit( | ||
| rule.defaultValue, | ||
@@ -692,3 +601,3 @@ fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, true) | ||
| }); | ||
| return (0, import_nodes9.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -699,12 +608,8 @@ accounts: instructionAccounts | ||
| }), | ||
| (v) => (0, import_visitors_core10.recordNodeStackVisitor)(v, stack), | ||
| (v) => (0, import_visitors_core10.recordLinkablesOnFirstVisitVisitor)(v, linkables) | ||
| (v) => visitorsCore.recordNodeStackVisitor(v, stack), | ||
| (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/setInstructionDiscriminatorsVisitor.ts | ||
| var import_nodes10 = require("@codama/nodes"); | ||
| var import_visitors_core11 = require("@codama/visitors-core"); | ||
| function setInstructionDiscriminatorsVisitor(map) { | ||
| return (0, import_visitors_core11.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -714,4 +619,4 @@ ([selector, discriminator]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes10.assertIsNode)(node, "instructionNode"); | ||
| const discriminatorArgument = (0, import_nodes10.instructionArgumentNode)({ | ||
| nodes.assertIsNode(node, "instructionNode"); | ||
| const discriminatorArgument = nodes.instructionArgumentNode({ | ||
| defaultValue: discriminator.value, | ||
@@ -721,9 +626,9 @@ defaultValueStrategy: discriminator.strategy ?? "omitted", | ||
| name: discriminator.name ?? "discriminator", | ||
| type: discriminator.type ?? (0, import_nodes10.numberTypeNode)("u8") | ||
| type: discriminator.type ?? nodes.numberTypeNode("u8") | ||
| }); | ||
| return (0, import_nodes10.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
| arguments: [discriminatorArgument, ...node.arguments], | ||
| discriminators: [ | ||
| (0, import_nodes10.fieldDiscriminatorNode)(discriminator.name ?? "discriminator"), | ||
| nodes.fieldDiscriminatorNode(discriminator.name ?? "discriminator"), | ||
| ...node.discriminators ?? [] | ||
@@ -737,9 +642,4 @@ ] | ||
| } | ||
| // src/setNumberWrappersVisitor.ts | ||
| var import_errors7 = require("@codama/errors"); | ||
| var import_nodes11 = require("@codama/nodes"); | ||
| var import_visitors_core12 = require("@codama/visitors-core"); | ||
| function setNumberWrappersVisitor(map) { | ||
| return (0, import_visitors_core12.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -749,12 +649,12 @@ ([selectorStack, wrapper]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes11.assertIsNestedTypeNode)(node, "numberTypeNode"); | ||
| nodes.assertIsNestedTypeNode(node, "numberTypeNode"); | ||
| switch (wrapper.kind) { | ||
| case "DateTime": | ||
| return (0, import_nodes11.dateTimeTypeNode)(node); | ||
| return nodes.dateTimeTypeNode(node); | ||
| case "SolAmount": | ||
| return (0, import_nodes11.solAmountTypeNode)(node); | ||
| return nodes.solAmountTypeNode(node); | ||
| case "Amount": | ||
| return (0, import_nodes11.amountTypeNode)(node, wrapper.decimals, wrapper.unit); | ||
| return nodes.amountTypeNode(node, wrapper.decimals, wrapper.unit); | ||
| default: | ||
| throw new import_errors7.CodamaError(import_errors7.CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| throw new errors.CodamaError(errors.CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| } | ||
@@ -766,11 +666,7 @@ } | ||
| } | ||
| // src/setStructDefaultValuesVisitor.ts | ||
| var import_nodes12 = require("@codama/nodes"); | ||
| var import_visitors_core13 = require("@codama/visitors-core"); | ||
| function setStructDefaultValuesVisitor(map) { | ||
| return (0, import_visitors_core13.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([stack, defaultValues]) => { | ||
| const camelCasedDefaultValues = Object.fromEntries( | ||
| Object.entries(defaultValues).map(([key, value]) => [(0, import_nodes12.camelCase)(key), value]) | ||
| Object.entries(defaultValues).map(([key, value]) => [nodes.camelCase(key), value]) | ||
| ); | ||
@@ -781,3 +677,3 @@ return [ | ||
| transform: (node) => { | ||
| (0, import_nodes12.assertIsNode)(node, "structTypeNode"); | ||
| nodes.assertIsNode(node, "structTypeNode"); | ||
| const fields = node.fields.map((field) => { | ||
@@ -787,3 +683,3 @@ const defaultValue = camelCasedDefaultValues[field.name]; | ||
| if (defaultValue === null) { | ||
| return (0, import_nodes12.structFieldTypeNode)({ | ||
| return nodes.structFieldTypeNode({ | ||
| ...field, | ||
@@ -794,3 +690,3 @@ defaultValue: void 0, | ||
| } | ||
| return (0, import_nodes12.structFieldTypeNode)({ | ||
| return nodes.structFieldTypeNode({ | ||
| ...field, | ||
@@ -801,3 +697,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }); | ||
| return (0, import_nodes12.structTypeNode)(fields); | ||
| return nodes.structTypeNode(fields); | ||
| } | ||
@@ -808,3 +704,3 @@ }, | ||
| transform: (node) => { | ||
| (0, import_nodes12.assertIsNode)(node, "instructionNode"); | ||
| nodes.assertIsNode(node, "instructionNode"); | ||
| const transformArguments = (arg) => { | ||
@@ -814,3 +710,3 @@ const defaultValue = camelCasedDefaultValues[arg.name]; | ||
| if (defaultValue === null) { | ||
| return (0, import_nodes12.instructionArgumentNode)({ | ||
| return nodes.instructionArgumentNode({ | ||
| ...arg, | ||
@@ -821,3 +717,3 @@ defaultValue: void 0, | ||
| } | ||
| return (0, import_nodes12.instructionArgumentNode)({ | ||
| return nodes.instructionArgumentNode({ | ||
| ...arg, | ||
@@ -828,3 +724,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }; | ||
| return (0, import_nodes12.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -840,10 +736,6 @@ arguments: node.arguments.map(transformArguments), | ||
| } | ||
| // src/transformDefinedTypesIntoAccountsVisitor.ts | ||
| var import_nodes13 = require("@codama/nodes"); | ||
| var import_visitors_core14 = require("@codama/visitors-core"); | ||
| function transformDefinedTypesIntoAccountsVisitor(definedTypes) { | ||
| return (0, import_visitors_core14.pipe)( | ||
| (0, import_visitors_core14.nonNullableIdentityVisitor)({ keys: ["rootNode", "programNode"] }), | ||
| (v) => (0, import_visitors_core14.extendVisitor)(v, { | ||
| return visitorsCore.pipe( | ||
| visitorsCore.nonNullableIdentityVisitor({ keys: ["rootNode", "programNode"] }), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitProgram(program) { | ||
@@ -853,4 +745,4 @@ const typesToExtract = program.definedTypes.filter((node) => definedTypes.includes(node.name)); | ||
| const newAccounts = typesToExtract.map((node) => { | ||
| (0, import_nodes13.assertIsNode)(node.type, "structTypeNode"); | ||
| return (0, import_nodes13.accountNode)({ | ||
| nodes.assertIsNode(node.type, "structTypeNode"); | ||
| return nodes.accountNode({ | ||
| ...node, | ||
@@ -862,3 +754,3 @@ data: node.type, | ||
| }); | ||
| return (0, import_nodes13.programNode)({ | ||
| return nodes.programNode({ | ||
| ...program, | ||
@@ -872,21 +764,17 @@ accounts: [...program.accounts, ...newAccounts], | ||
| } | ||
| // src/transformU8ArraysToBytesVisitor.ts | ||
| var import_nodes14 = require("@codama/nodes"); | ||
| var import_visitors_core15 = require("@codama/visitors-core"); | ||
| function transformU8ArraysToBytesVisitor(sizes = "*") { | ||
| const hasRequiredSize = (count) => { | ||
| if (!(0, import_nodes14.isNode)(count, "fixedCountNode")) return false; | ||
| if (!nodes.isNode(count, "fixedCountNode")) return false; | ||
| return sizes === "*" || sizes.includes(count.value); | ||
| }; | ||
| return (0, import_visitors_core15.pipe)( | ||
| (0, import_visitors_core15.nonNullableIdentityVisitor)(), | ||
| (v) => (0, import_visitors_core15.extendVisitor)(v, { | ||
| return visitorsCore.pipe( | ||
| visitorsCore.nonNullableIdentityVisitor(), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitArrayType(node, { self }) { | ||
| const child = (0, import_visitors_core15.visit)(node.item, self); | ||
| (0, import_nodes14.assertIsNode)(child, import_nodes14.TYPE_NODES); | ||
| if ((0, import_nodes14.isNode)(child, "numberTypeNode") && child.format === "u8" && (0, import_nodes14.isNode)(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| return (0, import_nodes14.fixedSizeTypeNode)((0, import_nodes14.bytesTypeNode)(), node.count.value); | ||
| const child = visitorsCore.visit(node.item, self); | ||
| nodes.assertIsNode(child, nodes.TYPE_NODES); | ||
| if (nodes.isNode(child, "numberTypeNode") && child.format === "u8" && nodes.isNode(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| return nodes.fixedSizeTypeNode(nodes.bytesTypeNode(), node.count.value); | ||
| } | ||
| return (0, import_nodes14.arrayTypeNode)(child, node.count); | ||
| return nodes.arrayTypeNode(child, node.count); | ||
| } | ||
@@ -896,13 +784,9 @@ }) | ||
| } | ||
| // src/unwrapDefinedTypesVisitor.ts | ||
| var import_nodes15 = require("@codama/nodes"); | ||
| var import_visitors_core16 = require("@codama/visitors-core"); | ||
| function unwrapDefinedTypesVisitor(typesToInline = "*") { | ||
| const linkables = new import_visitors_core16.LinkableDictionary(); | ||
| const stack = new import_visitors_core16.NodeStack(); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const stack = new visitorsCore.NodeStack(); | ||
| const typesToInlineCamelCased = (typesToInline === "*" ? [] : typesToInline).map((fullPath) => { | ||
| if (!fullPath.includes(".")) return (0, import_nodes15.camelCase)(fullPath); | ||
| if (!fullPath.includes(".")) return nodes.camelCase(fullPath); | ||
| const [programName, typeName] = fullPath.split("."); | ||
| return `${(0, import_nodes15.camelCase)(programName)}.${(0, import_nodes15.camelCase)(typeName)}`; | ||
| return `${nodes.camelCase(programName)}.${nodes.camelCase(typeName)}`; | ||
| }); | ||
@@ -915,7 +799,7 @@ const shouldInline = (typeName, programName) => { | ||
| }; | ||
| return (0, import_visitors_core16.pipe)( | ||
| (0, import_visitors_core16.nonNullableIdentityVisitor)(), | ||
| (v) => (0, import_visitors_core16.extendVisitor)(v, { | ||
| return visitorsCore.pipe( | ||
| visitorsCore.nonNullableIdentityVisitor(), | ||
| (v) => visitorsCore.extendVisitor(v, { | ||
| visitDefinedTypeLink(linkType, { self }) { | ||
| const programName = linkType.program?.name ?? (0, import_visitors_core16.findProgramNodeFromPath)(stack.getPath())?.name; | ||
| const programName = linkType.program?.name ?? visitorsCore.findProgramNodeFromPath(stack.getPath())?.name; | ||
| if (!shouldInline(linkType.name, programName)) { | ||
@@ -925,5 +809,5 @@ return linkType; | ||
| const definedTypePath = linkables.getPathOrThrow(stack.getPath("definedTypeLinkNode")); | ||
| const definedType = (0, import_visitors_core16.getLastNodeFromPath)(definedTypePath); | ||
| const definedType = visitorsCore.getLastNodeFromPath(definedTypePath); | ||
| stack.pushPath(definedTypePath); | ||
| const result = (0, import_visitors_core16.visit)(definedType.type, self); | ||
| const result = visitorsCore.visit(definedType.type, self); | ||
| stack.popPath(); | ||
@@ -933,33 +817,29 @@ return result; | ||
| visitProgram(program, { self }) { | ||
| return (0, import_nodes15.programNode)({ | ||
| return nodes.programNode({ | ||
| ...program, | ||
| accounts: program.accounts.map((account) => (0, import_visitors_core16.visit)(account, self)).filter((0, import_nodes15.assertIsNodeFilter)("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => (0, import_visitors_core16.visit)(type, self)).filter((0, import_nodes15.assertIsNodeFilter)("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => (0, import_visitors_core16.visit)(instruction, self)).filter((0, import_nodes15.assertIsNodeFilter)("instructionNode")) | ||
| accounts: program.accounts.map((account) => visitorsCore.visit(account, self)).filter(nodes.assertIsNodeFilter("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => visitorsCore.visit(type, self)).filter(nodes.assertIsNodeFilter("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => visitorsCore.visit(instruction, self)).filter(nodes.assertIsNodeFilter("instructionNode")) | ||
| }); | ||
| } | ||
| }), | ||
| (v) => (0, import_visitors_core16.recordNodeStackVisitor)(v, stack), | ||
| (v) => (0, import_visitors_core16.recordLinkablesOnFirstVisitVisitor)(v, linkables) | ||
| (v) => visitorsCore.recordNodeStackVisitor(v, stack), | ||
| (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/unwrapInstructionArgsDefinedTypesVisitor.ts | ||
| var import_nodes16 = require("@codama/nodes"); | ||
| var import_visitors_core17 = require("@codama/visitors-core"); | ||
| function unwrapInstructionArgsDefinedTypesVisitor() { | ||
| return (0, import_visitors_core17.rootNodeVisitor)((root) => { | ||
| const histogram = (0, import_visitors_core17.visit)(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new import_visitors_core17.LinkableDictionary(); | ||
| (0, import_visitors_core17.visit)(root, (0, import_visitors_core17.getRecordLinkablesVisitor)(linkables)); | ||
| return visitorsCore.rootNodeVisitor((root) => { | ||
| const histogram = visitorsCore.visit(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| visitorsCore.visit(root, visitorsCore.getRecordLinkablesVisitor(linkables)); | ||
| const definedTypesToInline = Object.keys(histogram).filter((key) => (histogram[key].total ?? 0) === 1 && (histogram[key].directlyAsInstructionArgs ?? 0) === 1).filter((key) => { | ||
| const names = key.split("."); | ||
| const link = names.length == 2 ? (0, import_nodes16.definedTypeLinkNode)(names[1], names[0]) : (0, import_nodes16.definedTypeLinkNode)(key); | ||
| const link = names.length == 2 ? nodes.definedTypeLinkNode(names[1], names[0]) : nodes.definedTypeLinkNode(key); | ||
| const found = linkables.get([link]); | ||
| return found && !(0, import_nodes16.isNode)(found.type, "enumTypeNode"); | ||
| return found && !nodes.isNode(found.type, "enumTypeNode"); | ||
| }); | ||
| if (definedTypesToInline.length > 0) { | ||
| const inlineVisitor = unwrapDefinedTypesVisitor(definedTypesToInline); | ||
| const newRoot = (0, import_visitors_core17.visit)(root, inlineVisitor); | ||
| (0, import_nodes16.assertIsNode)(newRoot, "rootNode"); | ||
| const newRoot = visitorsCore.visit(root, inlineVisitor); | ||
| nodes.assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -970,35 +850,31 @@ } | ||
| } | ||
| // src/unwrapTupleEnumWithSingleStructVisitor.ts | ||
| var import_nodes17 = require("@codama/nodes"); | ||
| var import_visitors_core18 = require("@codama/visitors-core"); | ||
| function unwrapTupleEnumWithSingleStructVisitor(enumsOrVariantsToUnwrap = "*") { | ||
| const selectorFunctions = enumsOrVariantsToUnwrap === "*" ? [() => true] : enumsOrVariantsToUnwrap.map((selector) => (0, import_visitors_core18.getNodeSelectorFunction)(selector)); | ||
| const shouldUnwrap = (stack) => selectorFunctions.some((selector) => selector(stack.getPath(import_nodes17.REGISTERED_NODE_KINDS))); | ||
| return (0, import_visitors_core18.rootNodeVisitor)((root) => { | ||
| const selectorFunctions = enumsOrVariantsToUnwrap === "*" ? [() => true] : enumsOrVariantsToUnwrap.map((selector) => visitorsCore.getNodeSelectorFunction(selector)); | ||
| const shouldUnwrap = (stack) => selectorFunctions.some((selector) => selector(stack.getPath(nodes.REGISTERED_NODE_KINDS))); | ||
| return visitorsCore.rootNodeVisitor((root) => { | ||
| const typesToPotentiallyUnwrap = []; | ||
| const definedTypes = new Map( | ||
| (0, import_nodes17.getAllDefinedTypes)(root).map((definedType) => [definedType.name, definedType]) | ||
| nodes.getAllDefinedTypes(root).map((definedType) => [definedType.name, definedType]) | ||
| ); | ||
| let newRoot = (0, import_visitors_core18.visit)( | ||
| let newRoot = visitorsCore.visit( | ||
| root, | ||
| (0, import_visitors_core18.bottomUpTransformerVisitor)([ | ||
| visitorsCore.bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[enumTupleVariantTypeNode]", | ||
| transform: (node, stack) => { | ||
| (0, import_nodes17.assertIsNode)(node, "enumTupleVariantTypeNode"); | ||
| nodes.assertIsNode(node, "enumTupleVariantTypeNode"); | ||
| if (!shouldUnwrap(stack)) return node; | ||
| const tupleNode = (0, import_nodes17.resolveNestedTypeNode)(node.tuple); | ||
| const tupleNode = nodes.resolveNestedTypeNode(node.tuple); | ||
| if (tupleNode.items.length !== 1) return node; | ||
| let item = tupleNode.items[0]; | ||
| if ((0, import_nodes17.isNode)(item, "definedTypeLinkNode")) { | ||
| if (nodes.isNode(item, "definedTypeLinkNode")) { | ||
| const definedType = definedTypes.get(item.name); | ||
| if (!definedType) return node; | ||
| if (!(0, import_nodes17.isNode)(definedType.type, "structTypeNode")) return node; | ||
| if (!nodes.isNode(definedType.type, "structTypeNode")) return node; | ||
| typesToPotentiallyUnwrap.push(item.name); | ||
| item = definedType.type; | ||
| } | ||
| if (!(0, import_nodes17.isNode)(item, "structTypeNode")) return node; | ||
| const nestedStruct = (0, import_nodes17.transformNestedTypeNode)(node.tuple, () => item); | ||
| return (0, import_nodes17.enumStructVariantTypeNode)(node.name, nestedStruct); | ||
| if (!nodes.isNode(item, "structTypeNode")) return node; | ||
| const nestedStruct = nodes.transformNestedTypeNode(node.tuple, () => item); | ||
| return nodes.enumStructVariantTypeNode(node.name, nestedStruct); | ||
| } | ||
@@ -1008,17 +884,14 @@ } | ||
| ); | ||
| (0, import_nodes17.assertIsNode)(newRoot, "rootNode"); | ||
| const histogram = (0, import_visitors_core18.visit)(newRoot, getDefinedTypeHistogramVisitor()); | ||
| nodes.assertIsNode(newRoot, "rootNode"); | ||
| const histogram = visitorsCore.visit(newRoot, getDefinedTypeHistogramVisitor()); | ||
| const typesToUnwrap = typesToPotentiallyUnwrap.filter( | ||
| (type) => !histogram[type] || histogram[type].total === 0 | ||
| ); | ||
| newRoot = (0, import_visitors_core18.visit)(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| (0, import_nodes17.assertIsNode)(newRoot, "rootNode"); | ||
| newRoot = visitorsCore.visit(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| nodes.assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
| }); | ||
| } | ||
| // src/unwrapTypeDefinedLinksVisitor.ts | ||
| var import_visitors_core19 = require("@codama/visitors-core"); | ||
| function unwrapTypeDefinedLinksVisitor(definedLinksType) { | ||
| const linkables = new import_visitors_core19.LinkableDictionary(); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const transformers = definedLinksType.map((selector) => ({ | ||
@@ -1031,18 +904,11 @@ select: ["[definedTypeLinkNode]", selector], | ||
| })); | ||
| return (0, import_visitors_core19.pipe)((0, import_visitors_core19.bottomUpTransformerVisitor)(transformers), (v) => (0, import_visitors_core19.recordLinkablesOnFirstVisitVisitor)(v, linkables)); | ||
| return visitorsCore.pipe(visitorsCore.bottomUpTransformerVisitor(transformers), (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/updateAccountsVisitor.ts | ||
| var import_nodes19 = require("@codama/nodes"); | ||
| var import_visitors_core20 = require("@codama/visitors-core"); | ||
| // src/renameHelpers.ts | ||
| var import_nodes18 = require("@codama/nodes"); | ||
| function renameStructNode(node, map) { | ||
| return (0, import_nodes18.structTypeNode)( | ||
| node.fields.map((field) => map[field.name] ? (0, import_nodes18.structFieldTypeNode)({ ...field, name: map[field.name] }) : field) | ||
| return nodes.structTypeNode( | ||
| node.fields.map((field) => map[field.name] ? nodes.structFieldTypeNode({ ...field, name: map[field.name] }) : field) | ||
| ); | ||
| } | ||
| function renameEnumNode(node, map) { | ||
| return (0, import_nodes18.enumTypeNode)( | ||
| return nodes.enumTypeNode( | ||
| node.variants.map((variant) => map[variant.name] ? renameEnumVariant(variant, map[variant.name]) : variant), | ||
@@ -1053,9 +919,9 @@ { ...node } | ||
| function renameEnumVariant(variant, newName) { | ||
| if ((0, import_nodes18.isNode)(variant, "enumStructVariantTypeNode")) { | ||
| return (0, import_nodes18.enumStructVariantTypeNode)(newName, variant.struct); | ||
| if (nodes.isNode(variant, "enumStructVariantTypeNode")) { | ||
| return nodes.enumStructVariantTypeNode(newName, variant.struct); | ||
| } | ||
| if ((0, import_nodes18.isNode)(variant, "enumTupleVariantTypeNode")) { | ||
| return (0, import_nodes18.enumTupleVariantTypeNode)(newName, variant.tuple); | ||
| if (nodes.isNode(variant, "enumTupleVariantTypeNode")) { | ||
| return nodes.enumTupleVariantTypeNode(newName, variant.tuple); | ||
| } | ||
| return (0, import_nodes18.enumEmptyVariantTypeNode)(newName); | ||
| return nodes.enumEmptyVariantTypeNode(newName); | ||
| } | ||
@@ -1065,5 +931,5 @@ | ||
| function updateAccountsVisitor(map) { | ||
| return (0, import_visitors_core20.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? (0, import_nodes19.camelCase)(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? nodes.camelCase(updates.name) : void 0; | ||
| const pdasToUpsert = []; | ||
@@ -1074,5 +940,5 @@ const transformers = [ | ||
| transform: (node, stack) => { | ||
| (0, import_nodes19.assertIsNode)(node, "accountNode"); | ||
| nodes.assertIsNode(node, "accountNode"); | ||
| if ("delete" in updates) return null; | ||
| const programNode6 = (0, import_visitors_core20.findProgramNodeFromPath)(stack.getPath()); | ||
| const programNode6 = visitorsCore.findProgramNodeFromPath(stack.getPath()); | ||
| const { seeds, pda, ...assignableUpdates } = updates; | ||
@@ -1083,3 +949,3 @@ let newPda = node.pda; | ||
| pdasToUpsert.push({ | ||
| pda: (0, import_nodes19.pdaNode)({ name: pda.name, seeds }), | ||
| pda: nodes.pdaNode({ name: pda.name, seeds }), | ||
| program: programNode6.name | ||
@@ -1091,16 +957,16 @@ }); | ||
| pdasToUpsert.push({ | ||
| pda: (0, import_nodes19.pdaNode)({ name: node.pda.name, seeds }), | ||
| pda: nodes.pdaNode({ name: node.pda.name, seeds }), | ||
| program: programNode6.name | ||
| }); | ||
| } else if (seeds !== void 0) { | ||
| newPda = (0, import_nodes19.pdaLinkNode)(newName ?? node.name); | ||
| newPda = nodes.pdaLinkNode(newName ?? node.name); | ||
| pdasToUpsert.push({ | ||
| pda: (0, import_nodes19.pdaNode)({ name: newName ?? node.name, seeds }), | ||
| pda: nodes.pdaNode({ name: newName ?? node.name, seeds }), | ||
| program: programNode6.name | ||
| }); | ||
| } | ||
| return (0, import_nodes19.accountNode)({ | ||
| return nodes.accountNode({ | ||
| ...node, | ||
| ...assignableUpdates, | ||
| data: (0, import_nodes19.transformNestedTypeNode)( | ||
| data: nodes.transformNestedTypeNode( | ||
| node.data, | ||
@@ -1116,3 +982,3 @@ (struct) => renameStructNode(struct, updates.data ?? {}) | ||
| transform: (node) => { | ||
| (0, import_nodes19.assertIsNode)(node, "programNode"); | ||
| nodes.assertIsNode(node, "programNode"); | ||
| const pdasToUpsertForProgram = pdasToUpsert.filter((p) => p.program === node.name).map((p) => p.pda); | ||
@@ -1126,3 +992,3 @@ if (pdasToUpsertForProgram.length === 0) return node; | ||
| const newPdas = [...node.pdas.map((p) => pdasToUpdate.get(p.name) ?? p), ...pdasToCreate]; | ||
| return (0, import_nodes19.programNode)({ ...node, pdas: newPdas }); | ||
| return nodes.programNode({ ...node, pdas: newPdas }); | ||
| } | ||
@@ -1136,4 +1002,4 @@ } | ||
| transform: (node) => { | ||
| (0, import_nodes19.assertIsNode)(node, "accountLinkNode"); | ||
| return (0, import_nodes19.accountLinkNode)(newName); | ||
| nodes.assertIsNode(node, "accountLinkNode"); | ||
| return nodes.accountLinkNode(newName); | ||
| } | ||
@@ -1144,4 +1010,4 @@ }, | ||
| transform: (node) => { | ||
| (0, import_nodes19.assertIsNode)(node, "pdaNode"); | ||
| return (0, import_nodes19.pdaNode)({ name: newName, seeds: node.seeds }); | ||
| nodes.assertIsNode(node, "pdaNode"); | ||
| return nodes.pdaNode({ name: newName, seeds: node.seeds }); | ||
| } | ||
@@ -1152,4 +1018,4 @@ }, | ||
| transform: (node) => { | ||
| (0, import_nodes19.assertIsNode)(node, "pdaLinkNode"); | ||
| return (0, import_nodes19.pdaLinkNode)(newName); | ||
| nodes.assertIsNode(node, "pdaLinkNode"); | ||
| return nodes.pdaLinkNode(newName); | ||
| } | ||
@@ -1163,10 +1029,6 @@ } | ||
| } | ||
| // src/updateDefinedTypesVisitor.ts | ||
| var import_nodes20 = require("@codama/nodes"); | ||
| var import_visitors_core21 = require("@codama/visitors-core"); | ||
| function updateDefinedTypesVisitor(map) { | ||
| return (0, import_visitors_core21.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? (0, import_nodes20.camelCase)(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? nodes.camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1176,3 +1038,3 @@ { | ||
| transform: (node) => { | ||
| (0, import_nodes20.assertIsNode)(node, "definedTypeNode"); | ||
| nodes.assertIsNode(node, "definedTypeNode"); | ||
| if ("delete" in updates) { | ||
@@ -1183,8 +1045,8 @@ return null; | ||
| let newType = node.type; | ||
| if ((0, import_nodes20.isNode)(node.type, "structTypeNode")) { | ||
| if (nodes.isNode(node.type, "structTypeNode")) { | ||
| newType = renameStructNode(node.type, dataUpdates ?? {}); | ||
| } else if ((0, import_nodes20.isNode)(node.type, "enumTypeNode")) { | ||
| } else if (nodes.isNode(node.type, "enumTypeNode")) { | ||
| newType = renameEnumNode(node.type, dataUpdates ?? {}); | ||
| } | ||
| return (0, import_nodes20.definedTypeNode)({ | ||
| return nodes.definedTypeNode({ | ||
| ...node, | ||
@@ -1202,4 +1064,4 @@ ...otherUpdates, | ||
| transform: (node) => { | ||
| (0, import_nodes20.assertIsNode)(node, "definedTypeLinkNode"); | ||
| return (0, import_nodes20.definedTypeLinkNode)(newName); | ||
| nodes.assertIsNode(node, "definedTypeLinkNode"); | ||
| return nodes.definedTypeLinkNode(newName); | ||
| } | ||
@@ -1212,8 +1074,4 @@ }); | ||
| } | ||
| // src/updateErrorsVisitor.ts | ||
| var import_nodes21 = require("@codama/nodes"); | ||
| var import_visitors_core22 = require("@codama/visitors-core"); | ||
| function updateErrorsVisitor(map) { | ||
| return (0, import_visitors_core22.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -1223,5 +1081,5 @@ ([name, updates]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes21.assertIsNode)(node, "errorNode"); | ||
| nodes.assertIsNode(node, "errorNode"); | ||
| if ("delete" in updates) return null; | ||
| return (0, import_nodes21.errorNode)({ ...node, ...updates }); | ||
| return nodes.errorNode({ ...node, ...updates }); | ||
| } | ||
@@ -1232,9 +1090,5 @@ }) | ||
| } | ||
| // src/updateInstructionsVisitor.ts | ||
| var import_nodes22 = require("@codama/nodes"); | ||
| var import_visitors_core23 = require("@codama/visitors-core"); | ||
| function updateInstructionsVisitor(map) { | ||
| const linkables = new import_visitors_core23.LinkableDictionary(); | ||
| const stack = new import_visitors_core23.NodeStack(); | ||
| const linkables = new visitorsCore.LinkableDictionary(); | ||
| const stack = new visitorsCore.NodeStack(); | ||
| const transformers = Object.entries(map).map( | ||
@@ -1244,3 +1098,3 @@ ([selector, updates]) => ({ | ||
| transform: (node) => { | ||
| (0, import_nodes22.assertIsNode)(node, "instructionNode"); | ||
| nodes.assertIsNode(node, "instructionNode"); | ||
| if ("delete" in updates) { | ||
@@ -1255,3 +1109,3 @@ return null; | ||
| ); | ||
| return (0, import_nodes22.instructionNode)({ | ||
| return nodes.instructionNode({ | ||
| ...node, | ||
@@ -1266,6 +1120,6 @@ ...metadataUpdates, | ||
| ); | ||
| return (0, import_visitors_core23.pipe)( | ||
| (0, import_visitors_core23.bottomUpTransformerVisitor)(transformers), | ||
| (v) => (0, import_visitors_core23.recordNodeStackVisitor)(v, stack), | ||
| (v) => (0, import_visitors_core23.recordLinkablesOnFirstVisitVisitor)(v, linkables) | ||
| return visitorsCore.pipe( | ||
| visitorsCore.bottomUpTransformerVisitor(transformers), | ||
| (v) => visitorsCore.recordNodeStackVisitor(v, stack), | ||
| (v) => visitorsCore.recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
@@ -1281,7 +1135,7 @@ } | ||
| if (!defaultValue) { | ||
| return (0, import_nodes22.instructionAccountNode)(acountWithoutDefault); | ||
| return nodes.instructionAccountNode(acountWithoutDefault); | ||
| } | ||
| return (0, import_nodes22.instructionAccountNode)({ | ||
| return nodes.instructionAccountNode({ | ||
| ...acountWithoutDefault, | ||
| defaultValue: (0, import_visitors_core23.visit)(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| defaultValue: visitorsCore.visit(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| }); | ||
@@ -1295,3 +1149,3 @@ } | ||
| usedArguments.add(node.name); | ||
| return (0, import_nodes22.instructionArgumentNode)({ | ||
| return nodes.instructionArgumentNode({ | ||
| ...node, | ||
@@ -1310,3 +1164,3 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| usedArguments.add(node.name); | ||
| return (0, import_nodes22.instructionArgumentNode)({ | ||
| return nodes.instructionArgumentNode({ | ||
| ...node, | ||
@@ -1324,4 +1178,4 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| const { type } = argUpdate; | ||
| (0, import_nodes22.assertIsNode)(type, import_nodes22.TYPE_NODES); | ||
| return (0, import_nodes22.instructionArgumentNode)({ | ||
| nodes.assertIsNode(type, nodes.TYPE_NODES); | ||
| return nodes.instructionArgumentNode({ | ||
| defaultValue: argUpdate.defaultValue ?? void 0, | ||
@@ -1337,10 +1191,6 @@ defaultValueStrategy: argUpdate.defaultValueStrategy ?? void 0, | ||
| } | ||
| // src/updateProgramsVisitor.ts | ||
| var import_nodes23 = require("@codama/nodes"); | ||
| var import_visitors_core24 = require("@codama/visitors-core"); | ||
| function updateProgramsVisitor(map) { | ||
| return (0, import_visitors_core24.bottomUpTransformerVisitor)( | ||
| return visitorsCore.bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([name, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? (0, import_nodes23.camelCase)(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? nodes.camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1350,5 +1200,5 @@ { | ||
| transform: (node) => { | ||
| (0, import_nodes23.assertIsNode)(node, "programNode"); | ||
| nodes.assertIsNode(node, "programNode"); | ||
| if ("delete" in updates) return null; | ||
| return (0, import_nodes23.programNode)({ ...node, ...updates }); | ||
| return nodes.programNode({ ...node, ...updates }); | ||
| } | ||
@@ -1361,4 +1211,4 @@ } | ||
| transform: (node) => { | ||
| (0, import_nodes23.assertIsNode)(node, "programLinkNode"); | ||
| return (0, import_nodes23.programLinkNode)(newName); | ||
| nodes.assertIsNode(node, "programLinkNode"); | ||
| return nodes.programLinkNode(newName); | ||
| } | ||
@@ -1371,33 +1221,37 @@ }); | ||
| } | ||
| // Annotate the CommonJS export names for ESM import in node: | ||
| 0 && (module.exports = { | ||
| addPdasVisitor, | ||
| createSubInstructionsFromEnumArgsVisitor, | ||
| deduplicateIdenticalDefinedTypesVisitor, | ||
| fillDefaultPdaSeedValuesVisitor, | ||
| flattenInstructionArguments, | ||
| flattenInstructionDataArgumentsVisitor, | ||
| flattenStruct, | ||
| flattenStructVisitor, | ||
| getCommonInstructionAccountDefaultRules, | ||
| getDefinedTypeHistogramVisitor, | ||
| setAccountDiscriminatorFromFieldVisitor, | ||
| setFixedAccountSizesVisitor, | ||
| setInstructionAccountDefaultValuesVisitor, | ||
| setInstructionDiscriminatorsVisitor, | ||
| setNumberWrappersVisitor, | ||
| setStructDefaultValuesVisitor, | ||
| transformDefinedTypesIntoAccountsVisitor, | ||
| transformU8ArraysToBytesVisitor, | ||
| unwrapDefinedTypesVisitor, | ||
| unwrapInstructionArgsDefinedTypesVisitor, | ||
| unwrapTupleEnumWithSingleStructVisitor, | ||
| unwrapTypeDefinedLinksVisitor, | ||
| updateAccountsVisitor, | ||
| updateDefinedTypesVisitor, | ||
| updateErrorsVisitor, | ||
| updateInstructionsVisitor, | ||
| updateProgramsVisitor, | ||
| ...require("@codama/visitors-core") | ||
| exports.addPdasVisitor = addPdasVisitor; | ||
| exports.createSubInstructionsFromEnumArgsVisitor = createSubInstructionsFromEnumArgsVisitor; | ||
| exports.deduplicateIdenticalDefinedTypesVisitor = deduplicateIdenticalDefinedTypesVisitor; | ||
| exports.fillDefaultPdaSeedValuesVisitor = fillDefaultPdaSeedValuesVisitor; | ||
| exports.flattenInstructionArguments = flattenInstructionArguments; | ||
| exports.flattenInstructionDataArgumentsVisitor = flattenInstructionDataArgumentsVisitor; | ||
| exports.flattenStruct = flattenStruct; | ||
| exports.flattenStructVisitor = flattenStructVisitor; | ||
| exports.getCommonInstructionAccountDefaultRules = getCommonInstructionAccountDefaultRules; | ||
| exports.getDefinedTypeHistogramVisitor = getDefinedTypeHistogramVisitor; | ||
| exports.setAccountDiscriminatorFromFieldVisitor = setAccountDiscriminatorFromFieldVisitor; | ||
| exports.setFixedAccountSizesVisitor = setFixedAccountSizesVisitor; | ||
| exports.setInstructionAccountDefaultValuesVisitor = setInstructionAccountDefaultValuesVisitor; | ||
| exports.setInstructionDiscriminatorsVisitor = setInstructionDiscriminatorsVisitor; | ||
| exports.setNumberWrappersVisitor = setNumberWrappersVisitor; | ||
| exports.setStructDefaultValuesVisitor = setStructDefaultValuesVisitor; | ||
| exports.transformDefinedTypesIntoAccountsVisitor = transformDefinedTypesIntoAccountsVisitor; | ||
| exports.transformU8ArraysToBytesVisitor = transformU8ArraysToBytesVisitor; | ||
| exports.unwrapDefinedTypesVisitor = unwrapDefinedTypesVisitor; | ||
| exports.unwrapInstructionArgsDefinedTypesVisitor = unwrapInstructionArgsDefinedTypesVisitor; | ||
| exports.unwrapTupleEnumWithSingleStructVisitor = unwrapTupleEnumWithSingleStructVisitor; | ||
| exports.unwrapTypeDefinedLinksVisitor = unwrapTypeDefinedLinksVisitor; | ||
| exports.updateAccountsVisitor = updateAccountsVisitor; | ||
| exports.updateDefinedTypesVisitor = updateDefinedTypesVisitor; | ||
| exports.updateErrorsVisitor = updateErrorsVisitor; | ||
| exports.updateInstructionsVisitor = updateInstructionsVisitor; | ||
| exports.updateProgramsVisitor = updateProgramsVisitor; | ||
| Object.keys(visitorsCore).forEach(function (k) { | ||
| if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { | ||
| enumerable: true, | ||
| get: function () { return visitorsCore[k]; } | ||
| }); | ||
| }); | ||
| //# sourceMappingURL=index.node.cjs.map | ||
| //# sourceMappingURL=index.node.cjs.map |
+187
-488
@@ -0,8 +1,7 @@ | ||
| import { bottomUpTransformerVisitor, LinkableDictionary, pipe, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor, getUniqueHashStringVisitor, visit, deleteNodesVisitor, getLastNodeFromPath, identityVisitor, extendVisitor, NodeStack, mergeVisitor, interceptVisitor, findProgramNodeFromPath, recordNodeStackVisitor, topDownTransformerVisitor, isNodePath, getByteSizeVisitor, nonNullableIdentityVisitor, getRecordLinkablesVisitor, getNodeSelectorFunction } from '@codama/visitors-core'; | ||
| export * from '@codama/visitors-core'; | ||
| import { CodamaError, CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER } from '@codama/errors'; | ||
| import { payerValueNode, identityValueNode, programIdValueNode, publicKeyValueNode, camelCase, assertIsNode, programNode, pdaNode, instructionNode, isNode, instructionArgumentNode, numberTypeNode, numberValueNode, getAllPrograms, INSTRUCTION_INPUT_VALUE_NODES, pdaValueNode, pdaSeedValueNode, accountValueNode, getAllInstructionArguments, argumentValueNode, isNodeFilter, structTypeNode, resolveNestedTypeNode, accountNode, fieldDiscriminatorNode, transformNestedTypeNode, structFieldTypeNode, assertIsNestedTypeNode, amountTypeNode, solAmountTypeNode, dateTimeTypeNode, TYPE_NODES, fixedSizeTypeNode, bytesTypeNode, arrayTypeNode, assertIsNodeFilter, definedTypeLinkNode, getAllDefinedTypes, enumStructVariantTypeNode, accountLinkNode, pdaLinkNode, errorNode, instructionAccountNode, programLinkNode, REGISTERED_NODE_KINDS, definedTypeNode, enumTypeNode, enumTupleVariantTypeNode, enumEmptyVariantTypeNode } from '@codama/nodes'; | ||
| // src/index.ts | ||
| export * from "@codama/visitors-core"; | ||
| // src/addPdasVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, CodamaError } from "@codama/errors"; | ||
| import { assertIsNode, camelCase, pdaNode, programNode } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor } from "@codama/visitors-core"; | ||
| function addPdasVisitor(pdas) { | ||
@@ -35,37 +34,8 @@ return bottomUpTransformerVisitor( | ||
| } | ||
| // src/createSubInstructionsFromEnumArgsVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, CodamaError as CodamaError3 } from "@codama/errors"; | ||
| import { | ||
| assertIsNode as assertIsNode3, | ||
| camelCase as camelCase3, | ||
| instructionArgumentNode as instructionArgumentNode2, | ||
| instructionNode as instructionNode2, | ||
| isNode as isNode2, | ||
| numberTypeNode, | ||
| numberValueNode | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor3, | ||
| LinkableDictionary, | ||
| pipe, | ||
| recordLinkablesOnFirstVisitVisitor | ||
| } from "@codama/visitors-core"; | ||
| // src/flattenInstructionDataArgumentsVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, CodamaError as CodamaError2 } from "@codama/errors"; | ||
| import { | ||
| assertIsNode as assertIsNode2, | ||
| camelCase as camelCase2, | ||
| instructionArgumentNode, | ||
| instructionNode, | ||
| isNode | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor2 } from "@codama/visitors-core"; | ||
| function flattenInstructionDataArgumentsVisitor() { | ||
| return bottomUpTransformerVisitor2([ | ||
| return bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[instructionNode]", | ||
| transform: (instruction) => { | ||
| assertIsNode2(instruction, "instructionNode"); | ||
| assertIsNode(instruction, "instructionNode"); | ||
| return instructionNode({ | ||
@@ -80,4 +50,4 @@ ...instruction, | ||
| var flattenInstructionArguments = (nodes, options = "*") => { | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase2); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes(camelCase2(node.name)); | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes(camelCase(node.name)); | ||
| const inlinedArguments = nodes.flatMap((node) => { | ||
@@ -94,3 +64,3 @@ if (isNode(node.type, "structTypeNode") && shouldInline(node)) { | ||
| if (hasConflictingNames) { | ||
| throw new CodamaError2(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
@@ -105,3 +75,3 @@ }); | ||
| const linkables = new LinkableDictionary(); | ||
| const visitor = bottomUpTransformerVisitor3( | ||
| const visitor = bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -111,9 +81,9 @@ ([selector, argNameInput]) => ({ | ||
| transform: (node, stack) => { | ||
| assertIsNode3(node, "instructionNode"); | ||
| assertIsNode(node, "instructionNode"); | ||
| const argFields = node.arguments; | ||
| const argName = camelCase3(argNameInput); | ||
| const argName = camelCase(argNameInput); | ||
| const argFieldIndex = argFields.findIndex((field) => field.name === argName); | ||
| const argField = argFieldIndex >= 0 ? argFields[argFieldIndex] : null; | ||
| if (!argField) { | ||
| throw new CodamaError3(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -125,10 +95,10 @@ instruction: node, | ||
| let argType; | ||
| if (isNode2(argField.type, "enumTypeNode")) { | ||
| if (isNode(argField.type, "enumTypeNode")) { | ||
| argType = argField.type; | ||
| } else if (isNode2(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| } else if (isNode(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| const linkedType = linkables.get([...stack.getPath(), argField.type])?.type; | ||
| assertIsNode3(linkedType, "enumTypeNode"); | ||
| assertIsNode(linkedType, "enumTypeNode"); | ||
| argType = linkedType; | ||
| } else { | ||
| throw new CodamaError3(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -140,6 +110,6 @@ instruction: node, | ||
| const subInstructions = argType.variants.map((variant, index) => { | ||
| const subName = camelCase3(`${node.name} ${variant.name}`); | ||
| const subName = camelCase(`${node.name} ${variant.name}`); | ||
| const subFields = argFields.slice(0, argFieldIndex); | ||
| subFields.push( | ||
| instructionArgumentNode2({ | ||
| instructionArgumentNode({ | ||
| defaultValue: numberValueNode(index), | ||
@@ -151,5 +121,5 @@ defaultValueStrategy: "omitted", | ||
| ); | ||
| if (isNode2(variant, "enumStructVariantTypeNode")) { | ||
| if (isNode(variant, "enumStructVariantTypeNode")) { | ||
| subFields.push( | ||
| instructionArgumentNode2({ | ||
| instructionArgumentNode({ | ||
| ...argField, | ||
@@ -159,5 +129,5 @@ type: variant.struct | ||
| ); | ||
| } else if (isNode2(variant, "enumTupleVariantTypeNode")) { | ||
| } else if (isNode(variant, "enumTupleVariantTypeNode")) { | ||
| subFields.push( | ||
| instructionArgumentNode2({ | ||
| instructionArgumentNode({ | ||
| ...argField, | ||
@@ -169,3 +139,3 @@ type: variant.tuple | ||
| subFields.push(...argFields.slice(argFieldIndex + 1)); | ||
| return instructionNode2({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -176,3 +146,3 @@ arguments: flattenInstructionArguments(subFields), | ||
| }); | ||
| return instructionNode2({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -187,11 +157,2 @@ subInstructions: [...node.subInstructions ?? [], ...subInstructions] | ||
| } | ||
| // src/deduplicateIdenticalDefinedTypesVisitor.ts | ||
| import { assertIsNode as assertIsNode4, getAllPrograms } from "@codama/nodes"; | ||
| import { | ||
| deleteNodesVisitor, | ||
| getUniqueHashStringVisitor, | ||
| rootNodeVisitor, | ||
| visit | ||
| } from "@codama/visitors-core"; | ||
| function deduplicateIdenticalDefinedTypesVisitor() { | ||
@@ -228,3 +189,3 @@ return rootNodeVisitor((root) => { | ||
| const newRoot = visit(root, deleteNodesVisitor(deleteSelectors)); | ||
| assertIsNode4(newRoot, "rootNode"); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -235,25 +196,5 @@ } | ||
| } | ||
| // src/fillDefaultPdaSeedValuesVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, CodamaError as CodamaError4 } from "@codama/errors"; | ||
| import { | ||
| accountValueNode, | ||
| argumentValueNode, | ||
| assertIsNode as assertIsNode5, | ||
| getAllInstructionArguments, | ||
| INSTRUCTION_INPUT_VALUE_NODES, | ||
| isNode as isNode3, | ||
| isNodeFilter, | ||
| pdaSeedValueNode, | ||
| pdaValueNode | ||
| } from "@codama/nodes"; | ||
| import { | ||
| extendVisitor, | ||
| getLastNodeFromPath, | ||
| identityVisitor, | ||
| pipe as pipe2 | ||
| } from "@codama/visitors-core"; | ||
| function fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, strictMode = false) { | ||
| const instruction = getLastNodeFromPath(instructionPath); | ||
| return pipe2( | ||
| return pipe( | ||
| identityVisitor({ keys: INSTRUCTION_INPUT_VALUE_NODES }), | ||
@@ -263,8 +204,8 @@ (v) => extendVisitor(v, { | ||
| const visitedNode = next(node); | ||
| assertIsNode5(visitedNode, "pdaValueNode"); | ||
| const foundPda = isNode3(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| assertIsNode(visitedNode, "pdaValueNode"); | ||
| const foundPda = isNode(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| if (!foundPda) return visitedNode; | ||
| const seeds = addDefaultSeedValuesFromPdaWhenMissing(instruction, foundPda, visitedNode.seeds); | ||
| if (strictMode && !allSeedsAreValid(instruction, foundPda, seeds)) { | ||
| throw new CodamaError4(CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| instruction, | ||
@@ -290,5 +231,5 @@ instructionName: instruction.name, | ||
| return pda.seeds.flatMap((seed) => { | ||
| if (!isNode3(seed, "variablePdaSeedNode")) return []; | ||
| if (!isNode(seed, "variablePdaSeedNode")) return []; | ||
| const hasMatchingAccount = instruction.accounts.some((a) => a.name === seed.name); | ||
| if (isNode3(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| if (isNode(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| return [pdaSeedValueNode(seed.name, accountValueNode(seed.name))]; | ||
@@ -308,6 +249,6 @@ } | ||
| const validSeeds = seeds.every((seed) => { | ||
| if (isNode3(seed.value, "accountValueNode")) { | ||
| if (isNode(seed.value, "accountValueNode")) { | ||
| return allAccountsName.includes(seed.value.name); | ||
| } | ||
| if (isNode3(seed.value, "argumentValueNode")) { | ||
| if (isNode(seed.value, "argumentValueNode")) { | ||
| return allArgumentsName.includes(seed.value.name); | ||
@@ -319,14 +260,4 @@ } | ||
| } | ||
| // src/flattenStructVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES as CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES2, CodamaError as CodamaError5 } from "@codama/errors"; | ||
| import { | ||
| assertIsNode as assertIsNode6, | ||
| camelCase as camelCase4, | ||
| isNode as isNode4, | ||
| structTypeNode | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor4 } from "@codama/visitors-core"; | ||
| function flattenStructVisitor(map) { | ||
| return bottomUpTransformerVisitor4( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -341,7 +272,7 @@ ([stack, options]) => ({ | ||
| var flattenStruct = (node, options = "*") => { | ||
| assertIsNode6(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase4); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes(camelCase4(field.name)); | ||
| assertIsNode(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes(camelCase(field.name)); | ||
| const inlinedFields = node.fields.flatMap((field) => { | ||
| if (isNode4(field.type, "structTypeNode") && shouldInline(field)) { | ||
| if (isNode(field.type, "structTypeNode") && shouldInline(field)) { | ||
| return field.type.fields; | ||
@@ -356,3 +287,3 @@ } | ||
| if (hasConflictingNames) { | ||
| throw new CodamaError5(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES2, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
@@ -363,14 +294,2 @@ }); | ||
| }; | ||
| // src/getDefinedTypeHistogramVisitor.ts | ||
| import { | ||
| extendVisitor as extendVisitor2, | ||
| findProgramNodeFromPath, | ||
| interceptVisitor, | ||
| mergeVisitor, | ||
| NodeStack, | ||
| pipe as pipe3, | ||
| recordNodeStackVisitor, | ||
| visit as visit2 | ||
| } from "@codama/visitors-core"; | ||
| function mergeHistograms(histograms) { | ||
@@ -398,3 +317,3 @@ const result = {}; | ||
| let stackLevel = 0; | ||
| return pipe3( | ||
| return pipe( | ||
| mergeVisitor( | ||
@@ -410,7 +329,7 @@ () => ({}), | ||
| }), | ||
| (v) => extendVisitor2(v, { | ||
| (v) => extendVisitor(v, { | ||
| visitAccount(node, { self }) { | ||
| mode = "account"; | ||
| stackLevel = 0; | ||
| const histogram = visit2(node.data, self); | ||
| const histogram = visit(node.data, self); | ||
| mode = null; | ||
@@ -422,3 +341,3 @@ return histogram; | ||
| stackLevel = 0; | ||
| const histogram = visit2(node.type, self); | ||
| const histogram = visit(node.type, self); | ||
| mode = null; | ||
@@ -443,6 +362,6 @@ return histogram; | ||
| stackLevel = 0; | ||
| const dataHistograms = node.arguments.map((arg) => visit2(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => visit2(arg, self)); | ||
| const dataHistograms = node.arguments.map((arg) => visit(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => visit(arg, self)); | ||
| mode = null; | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => visit2(ix, self)); | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => visit(ix, self)); | ||
| return mergeHistograms([...dataHistograms, ...extraHistograms, ...subHistograms]); | ||
@@ -454,17 +373,4 @@ } | ||
| } | ||
| // src/setAccountDiscriminatorFromFieldVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, CodamaError as CodamaError6 } from "@codama/errors"; | ||
| import { | ||
| accountNode, | ||
| assertIsNode as assertIsNode7, | ||
| fieldDiscriminatorNode, | ||
| resolveNestedTypeNode, | ||
| structFieldTypeNode, | ||
| structTypeNode as structTypeNode2, | ||
| transformNestedTypeNode | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor5 } from "@codama/visitors-core"; | ||
| function setAccountDiscriminatorFromFieldVisitor(map) { | ||
| return bottomUpTransformerVisitor5( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -474,7 +380,7 @@ ([selector, { field, value, offset }]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode7(node, "accountNode"); | ||
| assertIsNode(node, "accountNode"); | ||
| const accountData = resolveNestedTypeNode(node.data); | ||
| const fieldIndex = accountData.fields.findIndex((f) => f.name === field); | ||
| if (fieldIndex < 0) { | ||
| throw new CodamaError6(CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| account: node, | ||
@@ -490,3 +396,3 @@ missingField: field, | ||
| node.data, | ||
| () => structTypeNode2([ | ||
| () => structTypeNode([ | ||
| ...accountData.fields.slice(0, fieldIndex), | ||
@@ -508,26 +414,13 @@ structFieldTypeNode({ | ||
| } | ||
| // src/setFixedAccountSizesVisitor.ts | ||
| import { accountNode as accountNode2, assertIsNode as assertIsNode8 } from "@codama/nodes"; | ||
| import { | ||
| getByteSizeVisitor, | ||
| getLastNodeFromPath as getLastNodeFromPath2, | ||
| isNodePath, | ||
| LinkableDictionary as LinkableDictionary3, | ||
| pipe as pipe4, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor2, | ||
| topDownTransformerVisitor, | ||
| visit as visit3 | ||
| } from "@codama/visitors-core"; | ||
| function setFixedAccountSizesVisitor() { | ||
| const linkables = new LinkableDictionary3(); | ||
| const linkables = new LinkableDictionary(); | ||
| const visitor = topDownTransformerVisitor( | ||
| [ | ||
| { | ||
| select: (path) => isNodePath(path, "accountNode") && getLastNodeFromPath2(path).size === void 0, | ||
| select: (path) => isNodePath(path, "accountNode") && getLastNodeFromPath(path).size === void 0, | ||
| transform: (node, stack) => { | ||
| assertIsNode8(node, "accountNode"); | ||
| const size = visit3(node.data, getByteSizeVisitor(linkables, { stack })); | ||
| assertIsNode(node, "accountNode"); | ||
| const size = visit(node.data, getByteSizeVisitor(linkables, { stack })); | ||
| if (size === null) return node; | ||
| return accountNode2({ ...node, size }); | ||
| return accountNode({ ...node, size }); | ||
| } | ||
@@ -538,24 +431,4 @@ } | ||
| ); | ||
| return pipe4(visitor, (v) => recordLinkablesOnFirstVisitVisitor2(v, linkables)); | ||
| return pipe(visitor, (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/setInstructionAccountDefaultValuesVisitor.ts | ||
| import { | ||
| camelCase as camelCase5, | ||
| identityValueNode, | ||
| instructionNode as instructionNode3, | ||
| payerValueNode, | ||
| programIdValueNode, | ||
| publicKeyValueNode | ||
| } from "@codama/nodes"; | ||
| import { | ||
| extendVisitor as extendVisitor3, | ||
| LinkableDictionary as LinkableDictionary4, | ||
| NodeStack as NodeStack2, | ||
| nonNullableIdentityVisitor, | ||
| pipe as pipe5, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor3, | ||
| recordNodeStackVisitor as recordNodeStackVisitor2, | ||
| visit as visit4 | ||
| } from "@codama/visitors-core"; | ||
| var getCommonInstructionAccountDefaultRules = () => [ | ||
@@ -664,4 +537,4 @@ { | ||
| function setInstructionAccountDefaultValuesVisitor(rules) { | ||
| const linkables = new LinkableDictionary4(); | ||
| const stack = new NodeStack2(); | ||
| const linkables = new LinkableDictionary(); | ||
| const stack = new NodeStack(); | ||
| const sortedRules = rules.sort((a, b) => { | ||
@@ -675,11 +548,11 @@ const ia = "instruction" in a; | ||
| return sortedRules.find((rule) => { | ||
| if ("instruction" in rule && rule.instruction && camelCase5(rule.instruction) !== instruction.name) { | ||
| if ("instruction" in rule && rule.instruction && camelCase(rule.instruction) !== instruction.name) { | ||
| return false; | ||
| } | ||
| return typeof rule.account === "string" ? camelCase5(rule.account) === account.name : rule.account.test(account.name); | ||
| return typeof rule.account === "string" ? camelCase(rule.account) === account.name : rule.account.test(account.name); | ||
| }); | ||
| } | ||
| return pipe5( | ||
| return pipe( | ||
| nonNullableIdentityVisitor({ keys: ["rootNode", "programNode", "instructionNode"] }), | ||
| (v) => extendVisitor3(v, { | ||
| (v) => extendVisitor(v, { | ||
| visitInstruction(node) { | ||
@@ -696,3 +569,3 @@ const instructionPath = stack.getPath("instructionNode"); | ||
| ...account, | ||
| defaultValue: visit4( | ||
| defaultValue: visit( | ||
| rule.defaultValue, | ||
@@ -706,3 +579,3 @@ fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, true) | ||
| }); | ||
| return instructionNode3({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -713,18 +586,8 @@ accounts: instructionAccounts | ||
| }), | ||
| (v) => recordNodeStackVisitor2(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor3(v, linkables) | ||
| (v) => recordNodeStackVisitor(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/setInstructionDiscriminatorsVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode9, | ||
| fieldDiscriminatorNode as fieldDiscriminatorNode2, | ||
| instructionArgumentNode as instructionArgumentNode3, | ||
| instructionNode as instructionNode4, | ||
| numberTypeNode as numberTypeNode2 | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor6 } from "@codama/visitors-core"; | ||
| function setInstructionDiscriminatorsVisitor(map) { | ||
| return bottomUpTransformerVisitor6( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -734,4 +597,4 @@ ([selector, discriminator]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode9(node, "instructionNode"); | ||
| const discriminatorArgument = instructionArgumentNode3({ | ||
| assertIsNode(node, "instructionNode"); | ||
| const discriminatorArgument = instructionArgumentNode({ | ||
| defaultValue: discriminator.value, | ||
@@ -741,9 +604,9 @@ defaultValueStrategy: discriminator.strategy ?? "omitted", | ||
| name: discriminator.name ?? "discriminator", | ||
| type: discriminator.type ?? numberTypeNode2("u8") | ||
| type: discriminator.type ?? numberTypeNode("u8") | ||
| }); | ||
| return instructionNode4({ | ||
| return instructionNode({ | ||
| ...node, | ||
| arguments: [discriminatorArgument, ...node.arguments], | ||
| discriminators: [ | ||
| fieldDiscriminatorNode2(discriminator.name ?? "discriminator"), | ||
| fieldDiscriminatorNode(discriminator.name ?? "discriminator"), | ||
| ...node.discriminators ?? [] | ||
@@ -757,9 +620,4 @@ ] | ||
| } | ||
| // src/setNumberWrappersVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, CodamaError as CodamaError7 } from "@codama/errors"; | ||
| import { amountTypeNode, assertIsNestedTypeNode, dateTimeTypeNode, solAmountTypeNode } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor7 } from "@codama/visitors-core"; | ||
| function setNumberWrappersVisitor(map) { | ||
| return bottomUpTransformerVisitor7( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -778,3 +636,3 @@ ([selectorStack, wrapper]) => ({ | ||
| default: | ||
| throw new CodamaError7(CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| } | ||
@@ -786,18 +644,7 @@ } | ||
| } | ||
| // src/setStructDefaultValuesVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode10, | ||
| camelCase as camelCase6, | ||
| instructionArgumentNode as instructionArgumentNode4, | ||
| instructionNode as instructionNode5, | ||
| structFieldTypeNode as structFieldTypeNode2, | ||
| structTypeNode as structTypeNode3 | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor8 } from "@codama/visitors-core"; | ||
| function setStructDefaultValuesVisitor(map) { | ||
| return bottomUpTransformerVisitor8( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([stack, defaultValues]) => { | ||
| const camelCasedDefaultValues = Object.fromEntries( | ||
| Object.entries(defaultValues).map(([key, value]) => [camelCase6(key), value]) | ||
| Object.entries(defaultValues).map(([key, value]) => [camelCase(key), value]) | ||
| ); | ||
@@ -808,3 +655,3 @@ return [ | ||
| transform: (node) => { | ||
| assertIsNode10(node, "structTypeNode"); | ||
| assertIsNode(node, "structTypeNode"); | ||
| const fields = node.fields.map((field) => { | ||
@@ -814,3 +661,3 @@ const defaultValue = camelCasedDefaultValues[field.name]; | ||
| if (defaultValue === null) { | ||
| return structFieldTypeNode2({ | ||
| return structFieldTypeNode({ | ||
| ...field, | ||
@@ -821,3 +668,3 @@ defaultValue: void 0, | ||
| } | ||
| return structFieldTypeNode2({ | ||
| return structFieldTypeNode({ | ||
| ...field, | ||
@@ -828,3 +675,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }); | ||
| return structTypeNode3(fields); | ||
| return structTypeNode(fields); | ||
| } | ||
@@ -835,3 +682,3 @@ }, | ||
| transform: (node) => { | ||
| assertIsNode10(node, "instructionNode"); | ||
| assertIsNode(node, "instructionNode"); | ||
| const transformArguments = (arg) => { | ||
@@ -841,3 +688,3 @@ const defaultValue = camelCasedDefaultValues[arg.name]; | ||
| if (defaultValue === null) { | ||
| return instructionArgumentNode4({ | ||
| return instructionArgumentNode({ | ||
| ...arg, | ||
@@ -848,3 +695,3 @@ defaultValue: void 0, | ||
| } | ||
| return instructionArgumentNode4({ | ||
| return instructionArgumentNode({ | ||
| ...arg, | ||
@@ -855,3 +702,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }; | ||
| return instructionNode5({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -867,10 +714,6 @@ arguments: node.arguments.map(transformArguments), | ||
| } | ||
| // src/transformDefinedTypesIntoAccountsVisitor.ts | ||
| import { accountNode as accountNode3, assertIsNode as assertIsNode11, programNode as programNode2 } from "@codama/nodes"; | ||
| import { extendVisitor as extendVisitor4, nonNullableIdentityVisitor as nonNullableIdentityVisitor2, pipe as pipe6 } from "@codama/visitors-core"; | ||
| function transformDefinedTypesIntoAccountsVisitor(definedTypes) { | ||
| return pipe6( | ||
| nonNullableIdentityVisitor2({ keys: ["rootNode", "programNode"] }), | ||
| (v) => extendVisitor4(v, { | ||
| return pipe( | ||
| nonNullableIdentityVisitor({ keys: ["rootNode", "programNode"] }), | ||
| (v) => extendVisitor(v, { | ||
| visitProgram(program) { | ||
@@ -880,4 +723,4 @@ const typesToExtract = program.definedTypes.filter((node) => definedTypes.includes(node.name)); | ||
| const newAccounts = typesToExtract.map((node) => { | ||
| assertIsNode11(node.type, "structTypeNode"); | ||
| return accountNode3({ | ||
| assertIsNode(node.type, "structTypeNode"); | ||
| return accountNode({ | ||
| ...node, | ||
@@ -889,3 +732,3 @@ data: node.type, | ||
| }); | ||
| return programNode2({ | ||
| return programNode({ | ||
| ...program, | ||
@@ -899,25 +742,14 @@ accounts: [...program.accounts, ...newAccounts], | ||
| } | ||
| // src/transformU8ArraysToBytesVisitor.ts | ||
| import { | ||
| arrayTypeNode, | ||
| assertIsNode as assertIsNode12, | ||
| bytesTypeNode, | ||
| fixedSizeTypeNode, | ||
| isNode as isNode5, | ||
| TYPE_NODES | ||
| } from "@codama/nodes"; | ||
| import { extendVisitor as extendVisitor5, nonNullableIdentityVisitor as nonNullableIdentityVisitor3, pipe as pipe7, visit as visit5 } from "@codama/visitors-core"; | ||
| function transformU8ArraysToBytesVisitor(sizes = "*") { | ||
| const hasRequiredSize = (count) => { | ||
| if (!isNode5(count, "fixedCountNode")) return false; | ||
| if (!isNode(count, "fixedCountNode")) return false; | ||
| return sizes === "*" || sizes.includes(count.value); | ||
| }; | ||
| return pipe7( | ||
| nonNullableIdentityVisitor3(), | ||
| (v) => extendVisitor5(v, { | ||
| return pipe( | ||
| nonNullableIdentityVisitor(), | ||
| (v) => extendVisitor(v, { | ||
| visitArrayType(node, { self }) { | ||
| const child = visit5(node.item, self); | ||
| assertIsNode12(child, TYPE_NODES); | ||
| if (isNode5(child, "numberTypeNode") && child.format === "u8" && isNode5(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| const child = visit(node.item, self); | ||
| assertIsNode(child, TYPE_NODES); | ||
| if (isNode(child, "numberTypeNode") && child.format === "u8" && isNode(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| return fixedSizeTypeNode(bytesTypeNode(), node.count.value); | ||
@@ -930,24 +762,9 @@ } | ||
| } | ||
| // src/unwrapDefinedTypesVisitor.ts | ||
| import { assertIsNodeFilter, camelCase as camelCase7, programNode as programNode3 } from "@codama/nodes"; | ||
| import { | ||
| extendVisitor as extendVisitor6, | ||
| findProgramNodeFromPath as findProgramNodeFromPath2, | ||
| getLastNodeFromPath as getLastNodeFromPath3, | ||
| LinkableDictionary as LinkableDictionary5, | ||
| NodeStack as NodeStack3, | ||
| nonNullableIdentityVisitor as nonNullableIdentityVisitor4, | ||
| pipe as pipe8, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor4, | ||
| recordNodeStackVisitor as recordNodeStackVisitor3, | ||
| visit as visit6 | ||
| } from "@codama/visitors-core"; | ||
| function unwrapDefinedTypesVisitor(typesToInline = "*") { | ||
| const linkables = new LinkableDictionary5(); | ||
| const stack = new NodeStack3(); | ||
| const linkables = new LinkableDictionary(); | ||
| const stack = new NodeStack(); | ||
| const typesToInlineCamelCased = (typesToInline === "*" ? [] : typesToInline).map((fullPath) => { | ||
| if (!fullPath.includes(".")) return camelCase7(fullPath); | ||
| if (!fullPath.includes(".")) return camelCase(fullPath); | ||
| const [programName, typeName] = fullPath.split("."); | ||
| return `${camelCase7(programName)}.${camelCase7(typeName)}`; | ||
| return `${camelCase(programName)}.${camelCase(typeName)}`; | ||
| }); | ||
@@ -960,7 +777,7 @@ const shouldInline = (typeName, programName) => { | ||
| }; | ||
| return pipe8( | ||
| nonNullableIdentityVisitor4(), | ||
| (v) => extendVisitor6(v, { | ||
| return pipe( | ||
| nonNullableIdentityVisitor(), | ||
| (v) => extendVisitor(v, { | ||
| visitDefinedTypeLink(linkType, { self }) { | ||
| const programName = linkType.program?.name ?? findProgramNodeFromPath2(stack.getPath())?.name; | ||
| const programName = linkType.program?.name ?? findProgramNodeFromPath(stack.getPath())?.name; | ||
| if (!shouldInline(linkType.name, programName)) { | ||
@@ -970,5 +787,5 @@ return linkType; | ||
| const definedTypePath = linkables.getPathOrThrow(stack.getPath("definedTypeLinkNode")); | ||
| const definedType = getLastNodeFromPath3(definedTypePath); | ||
| const definedType = getLastNodeFromPath(definedTypePath); | ||
| stack.pushPath(definedTypePath); | ||
| const result = visit6(definedType.type, self); | ||
| const result = visit(definedType.type, self); | ||
| stack.popPath(); | ||
@@ -978,23 +795,19 @@ return result; | ||
| visitProgram(program, { self }) { | ||
| return programNode3({ | ||
| return programNode({ | ||
| ...program, | ||
| accounts: program.accounts.map((account) => visit6(account, self)).filter(assertIsNodeFilter("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => visit6(type, self)).filter(assertIsNodeFilter("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => visit6(instruction, self)).filter(assertIsNodeFilter("instructionNode")) | ||
| accounts: program.accounts.map((account) => visit(account, self)).filter(assertIsNodeFilter("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => visit(type, self)).filter(assertIsNodeFilter("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => visit(instruction, self)).filter(assertIsNodeFilter("instructionNode")) | ||
| }); | ||
| } | ||
| }), | ||
| (v) => recordNodeStackVisitor3(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor4(v, linkables) | ||
| (v) => recordNodeStackVisitor(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/unwrapInstructionArgsDefinedTypesVisitor.ts | ||
| import { assertIsNode as assertIsNode13, definedTypeLinkNode, isNode as isNode6 } from "@codama/nodes"; | ||
| import { getRecordLinkablesVisitor, LinkableDictionary as LinkableDictionary6, rootNodeVisitor as rootNodeVisitor2, visit as visit7 } from "@codama/visitors-core"; | ||
| function unwrapInstructionArgsDefinedTypesVisitor() { | ||
| return rootNodeVisitor2((root) => { | ||
| const histogram = visit7(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new LinkableDictionary6(); | ||
| visit7(root, getRecordLinkablesVisitor(linkables)); | ||
| return rootNodeVisitor((root) => { | ||
| const histogram = visit(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new LinkableDictionary(); | ||
| visit(root, getRecordLinkablesVisitor(linkables)); | ||
| const definedTypesToInline = Object.keys(histogram).filter((key) => (histogram[key].total ?? 0) === 1 && (histogram[key].directlyAsInstructionArgs ?? 0) === 1).filter((key) => { | ||
@@ -1004,8 +817,8 @@ const names = key.split("."); | ||
| const found = linkables.get([link]); | ||
| return found && !isNode6(found.type, "enumTypeNode"); | ||
| return found && !isNode(found.type, "enumTypeNode"); | ||
| }); | ||
| if (definedTypesToInline.length > 0) { | ||
| const inlineVisitor = unwrapDefinedTypesVisitor(definedTypesToInline); | ||
| const newRoot = visit7(root, inlineVisitor); | ||
| assertIsNode13(newRoot, "rootNode"); | ||
| const newRoot = visit(root, inlineVisitor); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -1016,23 +829,6 @@ } | ||
| } | ||
| // src/unwrapTupleEnumWithSingleStructVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode14, | ||
| enumStructVariantTypeNode, | ||
| getAllDefinedTypes, | ||
| isNode as isNode7, | ||
| REGISTERED_NODE_KINDS, | ||
| resolveNestedTypeNode as resolveNestedTypeNode2, | ||
| transformNestedTypeNode as transformNestedTypeNode2 | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor9, | ||
| getNodeSelectorFunction, | ||
| rootNodeVisitor as rootNodeVisitor3, | ||
| visit as visit8 | ||
| } from "@codama/visitors-core"; | ||
| function unwrapTupleEnumWithSingleStructVisitor(enumsOrVariantsToUnwrap = "*") { | ||
| const selectorFunctions = enumsOrVariantsToUnwrap === "*" ? [() => true] : enumsOrVariantsToUnwrap.map((selector) => getNodeSelectorFunction(selector)); | ||
| const shouldUnwrap = (stack) => selectorFunctions.some((selector) => selector(stack.getPath(REGISTERED_NODE_KINDS))); | ||
| return rootNodeVisitor3((root) => { | ||
| return rootNodeVisitor((root) => { | ||
| const typesToPotentiallyUnwrap = []; | ||
@@ -1042,22 +838,22 @@ const definedTypes = new Map( | ||
| ); | ||
| let newRoot = visit8( | ||
| let newRoot = visit( | ||
| root, | ||
| bottomUpTransformerVisitor9([ | ||
| bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[enumTupleVariantTypeNode]", | ||
| transform: (node, stack) => { | ||
| assertIsNode14(node, "enumTupleVariantTypeNode"); | ||
| assertIsNode(node, "enumTupleVariantTypeNode"); | ||
| if (!shouldUnwrap(stack)) return node; | ||
| const tupleNode = resolveNestedTypeNode2(node.tuple); | ||
| const tupleNode = resolveNestedTypeNode(node.tuple); | ||
| if (tupleNode.items.length !== 1) return node; | ||
| let item = tupleNode.items[0]; | ||
| if (isNode7(item, "definedTypeLinkNode")) { | ||
| if (isNode(item, "definedTypeLinkNode")) { | ||
| const definedType = definedTypes.get(item.name); | ||
| if (!definedType) return node; | ||
| if (!isNode7(definedType.type, "structTypeNode")) return node; | ||
| if (!isNode(definedType.type, "structTypeNode")) return node; | ||
| typesToPotentiallyUnwrap.push(item.name); | ||
| item = definedType.type; | ||
| } | ||
| if (!isNode7(item, "structTypeNode")) return node; | ||
| const nestedStruct = transformNestedTypeNode2(node.tuple, () => item); | ||
| if (!isNode(item, "structTypeNode")) return node; | ||
| const nestedStruct = transformNestedTypeNode(node.tuple, () => item); | ||
| return enumStructVariantTypeNode(node.name, nestedStruct); | ||
@@ -1068,22 +864,14 @@ } | ||
| ); | ||
| assertIsNode14(newRoot, "rootNode"); | ||
| const histogram = visit8(newRoot, getDefinedTypeHistogramVisitor()); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| const histogram = visit(newRoot, getDefinedTypeHistogramVisitor()); | ||
| const typesToUnwrap = typesToPotentiallyUnwrap.filter( | ||
| (type) => !histogram[type] || histogram[type].total === 0 | ||
| ); | ||
| newRoot = visit8(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| assertIsNode14(newRoot, "rootNode"); | ||
| newRoot = visit(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
| }); | ||
| } | ||
| // src/unwrapTypeDefinedLinksVisitor.ts | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor10, | ||
| LinkableDictionary as LinkableDictionary7, | ||
| pipe as pipe9, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor5 | ||
| } from "@codama/visitors-core"; | ||
| function unwrapTypeDefinedLinksVisitor(definedLinksType) { | ||
| const linkables = new LinkableDictionary7(); | ||
| const linkables = new LinkableDictionary(); | ||
| const transformers = definedLinksType.map((selector) => ({ | ||
@@ -1096,34 +884,7 @@ select: ["[definedTypeLinkNode]", selector], | ||
| })); | ||
| return pipe9(bottomUpTransformerVisitor10(transformers), (v) => recordLinkablesOnFirstVisitVisitor5(v, linkables)); | ||
| return pipe(bottomUpTransformerVisitor(transformers), (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/updateAccountsVisitor.ts | ||
| import { | ||
| accountLinkNode, | ||
| accountNode as accountNode4, | ||
| assertIsNode as assertIsNode15, | ||
| camelCase as camelCase8, | ||
| pdaLinkNode, | ||
| pdaNode as pdaNode2, | ||
| programNode as programNode4, | ||
| transformNestedTypeNode as transformNestedTypeNode3 | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor11, | ||
| findProgramNodeFromPath as findProgramNodeFromPath3 | ||
| } from "@codama/visitors-core"; | ||
| // src/renameHelpers.ts | ||
| import { | ||
| enumEmptyVariantTypeNode, | ||
| enumStructVariantTypeNode as enumStructVariantTypeNode2, | ||
| enumTupleVariantTypeNode, | ||
| enumTypeNode, | ||
| isNode as isNode8, | ||
| structFieldTypeNode as structFieldTypeNode3, | ||
| structTypeNode as structTypeNode4 | ||
| } from "@codama/nodes"; | ||
| function renameStructNode(node, map) { | ||
| return structTypeNode4( | ||
| node.fields.map((field) => map[field.name] ? structFieldTypeNode3({ ...field, name: map[field.name] }) : field) | ||
| return structTypeNode( | ||
| node.fields.map((field) => map[field.name] ? structFieldTypeNode({ ...field, name: map[field.name] }) : field) | ||
| ); | ||
@@ -1138,6 +899,6 @@ } | ||
| function renameEnumVariant(variant, newName) { | ||
| if (isNode8(variant, "enumStructVariantTypeNode")) { | ||
| return enumStructVariantTypeNode2(newName, variant.struct); | ||
| if (isNode(variant, "enumStructVariantTypeNode")) { | ||
| return enumStructVariantTypeNode(newName, variant.struct); | ||
| } | ||
| if (isNode8(variant, "enumTupleVariantTypeNode")) { | ||
| if (isNode(variant, "enumTupleVariantTypeNode")) { | ||
| return enumTupleVariantTypeNode(newName, variant.tuple); | ||
@@ -1150,5 +911,5 @@ } | ||
| function updateAccountsVisitor(map) { | ||
| return bottomUpTransformerVisitor11( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase8(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase(updates.name) : void 0; | ||
| const pdasToUpsert = []; | ||
@@ -1159,5 +920,5 @@ const transformers = [ | ||
| transform: (node, stack) => { | ||
| assertIsNode15(node, "accountNode"); | ||
| assertIsNode(node, "accountNode"); | ||
| if ("delete" in updates) return null; | ||
| const programNode6 = findProgramNodeFromPath3(stack.getPath()); | ||
| const programNode6 = findProgramNodeFromPath(stack.getPath()); | ||
| const { seeds, pda, ...assignableUpdates } = updates; | ||
@@ -1168,3 +929,3 @@ let newPda = node.pda; | ||
| pdasToUpsert.push({ | ||
| pda: pdaNode2({ name: pda.name, seeds }), | ||
| pda: pdaNode({ name: pda.name, seeds }), | ||
| program: programNode6.name | ||
@@ -1176,3 +937,3 @@ }); | ||
| pdasToUpsert.push({ | ||
| pda: pdaNode2({ name: node.pda.name, seeds }), | ||
| pda: pdaNode({ name: node.pda.name, seeds }), | ||
| program: programNode6.name | ||
@@ -1183,10 +944,10 @@ }); | ||
| pdasToUpsert.push({ | ||
| pda: pdaNode2({ name: newName ?? node.name, seeds }), | ||
| pda: pdaNode({ name: newName ?? node.name, seeds }), | ||
| program: programNode6.name | ||
| }); | ||
| } | ||
| return accountNode4({ | ||
| return accountNode({ | ||
| ...node, | ||
| ...assignableUpdates, | ||
| data: transformNestedTypeNode3( | ||
| data: transformNestedTypeNode( | ||
| node.data, | ||
@@ -1202,3 +963,3 @@ (struct) => renameStructNode(struct, updates.data ?? {}) | ||
| transform: (node) => { | ||
| assertIsNode15(node, "programNode"); | ||
| assertIsNode(node, "programNode"); | ||
| const pdasToUpsertForProgram = pdasToUpsert.filter((p) => p.program === node.name).map((p) => p.pda); | ||
@@ -1212,3 +973,3 @@ if (pdasToUpsertForProgram.length === 0) return node; | ||
| const newPdas = [...node.pdas.map((p) => pdasToUpdate.get(p.name) ?? p), ...pdasToCreate]; | ||
| return programNode4({ ...node, pdas: newPdas }); | ||
| return programNode({ ...node, pdas: newPdas }); | ||
| } | ||
@@ -1222,3 +983,3 @@ } | ||
| transform: (node) => { | ||
| assertIsNode15(node, "accountLinkNode"); | ||
| assertIsNode(node, "accountLinkNode"); | ||
| return accountLinkNode(newName); | ||
@@ -1230,4 +991,4 @@ } | ||
| transform: (node) => { | ||
| assertIsNode15(node, "pdaNode"); | ||
| return pdaNode2({ name: newName, seeds: node.seeds }); | ||
| assertIsNode(node, "pdaNode"); | ||
| return pdaNode({ name: newName, seeds: node.seeds }); | ||
| } | ||
@@ -1238,3 +999,3 @@ }, | ||
| transform: (node) => { | ||
| assertIsNode15(node, "pdaLinkNode"); | ||
| assertIsNode(node, "pdaLinkNode"); | ||
| return pdaLinkNode(newName); | ||
@@ -1249,16 +1010,6 @@ } | ||
| } | ||
| // src/updateDefinedTypesVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode16, | ||
| camelCase as camelCase9, | ||
| definedTypeLinkNode as definedTypeLinkNode2, | ||
| definedTypeNode, | ||
| isNode as isNode9 | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor12 } from "@codama/visitors-core"; | ||
| function updateDefinedTypesVisitor(map) { | ||
| return bottomUpTransformerVisitor12( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase9(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1268,3 +1019,3 @@ { | ||
| transform: (node) => { | ||
| assertIsNode16(node, "definedTypeNode"); | ||
| assertIsNode(node, "definedTypeNode"); | ||
| if ("delete" in updates) { | ||
@@ -1275,5 +1026,5 @@ return null; | ||
| let newType = node.type; | ||
| if (isNode9(node.type, "structTypeNode")) { | ||
| if (isNode(node.type, "structTypeNode")) { | ||
| newType = renameStructNode(node.type, dataUpdates ?? {}); | ||
| } else if (isNode9(node.type, "enumTypeNode")) { | ||
| } else if (isNode(node.type, "enumTypeNode")) { | ||
| newType = renameEnumNode(node.type, dataUpdates ?? {}); | ||
@@ -1294,4 +1045,4 @@ } | ||
| transform: (node) => { | ||
| assertIsNode16(node, "definedTypeLinkNode"); | ||
| return definedTypeLinkNode2(newName); | ||
| assertIsNode(node, "definedTypeLinkNode"); | ||
| return definedTypeLinkNode(newName); | ||
| } | ||
@@ -1304,8 +1055,4 @@ }); | ||
| } | ||
| // src/updateErrorsVisitor.ts | ||
| import { assertIsNode as assertIsNode17, errorNode } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor13 } from "@codama/visitors-core"; | ||
| function updateErrorsVisitor(map) { | ||
| return bottomUpTransformerVisitor13( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -1315,3 +1062,3 @@ ([name, updates]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode17(node, "errorNode"); | ||
| assertIsNode(node, "errorNode"); | ||
| if ("delete" in updates) return null; | ||
@@ -1324,23 +1071,5 @@ return errorNode({ ...node, ...updates }); | ||
| } | ||
| // src/updateInstructionsVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode18, | ||
| instructionAccountNode, | ||
| instructionArgumentNode as instructionArgumentNode5, | ||
| instructionNode as instructionNode6, | ||
| TYPE_NODES as TYPE_NODES2 | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor14, | ||
| LinkableDictionary as LinkableDictionary8, | ||
| NodeStack as NodeStack5, | ||
| pipe as pipe10, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor6, | ||
| recordNodeStackVisitor as recordNodeStackVisitor4, | ||
| visit as visit9 | ||
| } from "@codama/visitors-core"; | ||
| function updateInstructionsVisitor(map) { | ||
| const linkables = new LinkableDictionary8(); | ||
| const stack = new NodeStack5(); | ||
| const linkables = new LinkableDictionary(); | ||
| const stack = new NodeStack(); | ||
| const transformers = Object.entries(map).map( | ||
@@ -1350,3 +1079,3 @@ ([selector, updates]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode18(node, "instructionNode"); | ||
| assertIsNode(node, "instructionNode"); | ||
| if ("delete" in updates) { | ||
@@ -1361,3 +1090,3 @@ return null; | ||
| ); | ||
| return instructionNode6({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -1372,6 +1101,6 @@ ...metadataUpdates, | ||
| ); | ||
| return pipe10( | ||
| bottomUpTransformerVisitor14(transformers), | ||
| (v) => recordNodeStackVisitor4(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor6(v, linkables) | ||
| return pipe( | ||
| bottomUpTransformerVisitor(transformers), | ||
| (v) => recordNodeStackVisitor(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
@@ -1391,3 +1120,3 @@ } | ||
| ...acountWithoutDefault, | ||
| defaultValue: visit9(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| defaultValue: visit(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| }); | ||
@@ -1401,3 +1130,3 @@ } | ||
| usedArguments.add(node.name); | ||
| return instructionArgumentNode5({ | ||
| return instructionArgumentNode({ | ||
| ...node, | ||
@@ -1416,3 +1145,3 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| usedArguments.add(node.name); | ||
| return instructionArgumentNode5({ | ||
| return instructionArgumentNode({ | ||
| ...node, | ||
@@ -1430,4 +1159,4 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| const { type } = argUpdate; | ||
| assertIsNode18(type, TYPE_NODES2); | ||
| return instructionArgumentNode5({ | ||
| assertIsNode(type, TYPE_NODES); | ||
| return instructionArgumentNode({ | ||
| defaultValue: argUpdate.defaultValue ?? void 0, | ||
@@ -1443,10 +1172,6 @@ defaultValueStrategy: argUpdate.defaultValueStrategy ?? void 0, | ||
| } | ||
| // src/updateProgramsVisitor.ts | ||
| import { assertIsNode as assertIsNode19, camelCase as camelCase10, programLinkNode, programNode as programNode5 } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor15 } from "@codama/visitors-core"; | ||
| function updateProgramsVisitor(map) { | ||
| return bottomUpTransformerVisitor15( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([name, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase10(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1456,5 +1181,5 @@ { | ||
| transform: (node) => { | ||
| assertIsNode19(node, "programNode"); | ||
| assertIsNode(node, "programNode"); | ||
| if ("delete" in updates) return null; | ||
| return programNode5({ ...node, ...updates }); | ||
| return programNode({ ...node, ...updates }); | ||
| } | ||
@@ -1467,3 +1192,3 @@ } | ||
| transform: (node) => { | ||
| assertIsNode19(node, "programLinkNode"); | ||
| assertIsNode(node, "programLinkNode"); | ||
| return programLinkNode(newName); | ||
@@ -1477,31 +1202,5 @@ } | ||
| } | ||
| export { | ||
| addPdasVisitor, | ||
| createSubInstructionsFromEnumArgsVisitor, | ||
| deduplicateIdenticalDefinedTypesVisitor, | ||
| fillDefaultPdaSeedValuesVisitor, | ||
| flattenInstructionArguments, | ||
| flattenInstructionDataArgumentsVisitor, | ||
| flattenStruct, | ||
| flattenStructVisitor, | ||
| getCommonInstructionAccountDefaultRules, | ||
| getDefinedTypeHistogramVisitor, | ||
| setAccountDiscriminatorFromFieldVisitor, | ||
| setFixedAccountSizesVisitor, | ||
| setInstructionAccountDefaultValuesVisitor, | ||
| setInstructionDiscriminatorsVisitor, | ||
| setNumberWrappersVisitor, | ||
| setStructDefaultValuesVisitor, | ||
| transformDefinedTypesIntoAccountsVisitor, | ||
| transformU8ArraysToBytesVisitor, | ||
| unwrapDefinedTypesVisitor, | ||
| unwrapInstructionArgsDefinedTypesVisitor, | ||
| unwrapTupleEnumWithSingleStructVisitor, | ||
| unwrapTypeDefinedLinksVisitor, | ||
| updateAccountsVisitor, | ||
| updateDefinedTypesVisitor, | ||
| updateErrorsVisitor, | ||
| updateInstructionsVisitor, | ||
| updateProgramsVisitor | ||
| }; | ||
| export { addPdasVisitor, createSubInstructionsFromEnumArgsVisitor, deduplicateIdenticalDefinedTypesVisitor, fillDefaultPdaSeedValuesVisitor, flattenInstructionArguments, flattenInstructionDataArgumentsVisitor, flattenStruct, flattenStructVisitor, getCommonInstructionAccountDefaultRules, getDefinedTypeHistogramVisitor, setAccountDiscriminatorFromFieldVisitor, setFixedAccountSizesVisitor, setInstructionAccountDefaultValuesVisitor, setInstructionDiscriminatorsVisitor, setNumberWrappersVisitor, setStructDefaultValuesVisitor, transformDefinedTypesIntoAccountsVisitor, transformU8ArraysToBytesVisitor, unwrapDefinedTypesVisitor, unwrapInstructionArgsDefinedTypesVisitor, unwrapTupleEnumWithSingleStructVisitor, unwrapTypeDefinedLinksVisitor, updateAccountsVisitor, updateDefinedTypesVisitor, updateErrorsVisitor, updateInstructionsVisitor, updateProgramsVisitor }; | ||
| //# sourceMappingURL=index.node.mjs.map | ||
| //# sourceMappingURL=index.node.mjs.map |
+187
-488
@@ -0,8 +1,7 @@ | ||
| import { bottomUpTransformerVisitor, LinkableDictionary, pipe, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor, getUniqueHashStringVisitor, visit, deleteNodesVisitor, getLastNodeFromPath, identityVisitor, extendVisitor, NodeStack, mergeVisitor, interceptVisitor, findProgramNodeFromPath, recordNodeStackVisitor, topDownTransformerVisitor, isNodePath, getByteSizeVisitor, nonNullableIdentityVisitor, getRecordLinkablesVisitor, getNodeSelectorFunction } from '@codama/visitors-core'; | ||
| export * from '@codama/visitors-core'; | ||
| import { CodamaError, CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER } from '@codama/errors'; | ||
| import { payerValueNode, identityValueNode, programIdValueNode, publicKeyValueNode, camelCase, assertIsNode, programNode, pdaNode, instructionNode, isNode, instructionArgumentNode, numberTypeNode, numberValueNode, getAllPrograms, INSTRUCTION_INPUT_VALUE_NODES, pdaValueNode, pdaSeedValueNode, accountValueNode, getAllInstructionArguments, argumentValueNode, isNodeFilter, structTypeNode, resolveNestedTypeNode, accountNode, fieldDiscriminatorNode, transformNestedTypeNode, structFieldTypeNode, assertIsNestedTypeNode, amountTypeNode, solAmountTypeNode, dateTimeTypeNode, TYPE_NODES, fixedSizeTypeNode, bytesTypeNode, arrayTypeNode, assertIsNodeFilter, definedTypeLinkNode, getAllDefinedTypes, enumStructVariantTypeNode, accountLinkNode, pdaLinkNode, errorNode, instructionAccountNode, programLinkNode, REGISTERED_NODE_KINDS, definedTypeNode, enumTypeNode, enumTupleVariantTypeNode, enumEmptyVariantTypeNode } from '@codama/nodes'; | ||
| // src/index.ts | ||
| export * from "@codama/visitors-core"; | ||
| // src/addPdasVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__CANNOT_ADD_DUPLICATED_PDA_NAMES, CodamaError } from "@codama/errors"; | ||
| import { assertIsNode, camelCase, pdaNode, programNode } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor } from "@codama/visitors-core"; | ||
| function addPdasVisitor(pdas) { | ||
@@ -35,37 +34,8 @@ return bottomUpTransformerVisitor( | ||
| } | ||
| // src/createSubInstructionsFromEnumArgsVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, CodamaError as CodamaError3 } from "@codama/errors"; | ||
| import { | ||
| assertIsNode as assertIsNode3, | ||
| camelCase as camelCase3, | ||
| instructionArgumentNode as instructionArgumentNode2, | ||
| instructionNode as instructionNode2, | ||
| isNode as isNode2, | ||
| numberTypeNode, | ||
| numberValueNode | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor3, | ||
| LinkableDictionary, | ||
| pipe, | ||
| recordLinkablesOnFirstVisitVisitor | ||
| } from "@codama/visitors-core"; | ||
| // src/flattenInstructionDataArgumentsVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, CodamaError as CodamaError2 } from "@codama/errors"; | ||
| import { | ||
| assertIsNode as assertIsNode2, | ||
| camelCase as camelCase2, | ||
| instructionArgumentNode, | ||
| instructionNode, | ||
| isNode | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor2 } from "@codama/visitors-core"; | ||
| function flattenInstructionDataArgumentsVisitor() { | ||
| return bottomUpTransformerVisitor2([ | ||
| return bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[instructionNode]", | ||
| transform: (instruction) => { | ||
| assertIsNode2(instruction, "instructionNode"); | ||
| assertIsNode(instruction, "instructionNode"); | ||
| return instructionNode({ | ||
@@ -80,4 +50,4 @@ ...instruction, | ||
| var flattenInstructionArguments = (nodes, options = "*") => { | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase2); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes(camelCase2(node.name)); | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase); | ||
| const shouldInline = (node) => options === "*" || camelCaseOptions.includes(camelCase(node.name)); | ||
| const inlinedArguments = nodes.flatMap((node) => { | ||
@@ -94,3 +64,3 @@ if (isNode(node.type, "structTypeNode") && shouldInline(node)) { | ||
| if (hasConflictingNames) { | ||
| throw new CodamaError2(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
@@ -105,3 +75,3 @@ }); | ||
| const linkables = new LinkableDictionary(); | ||
| const visitor = bottomUpTransformerVisitor3( | ||
| const visitor = bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -111,9 +81,9 @@ ([selector, argNameInput]) => ({ | ||
| transform: (node, stack) => { | ||
| assertIsNode3(node, "instructionNode"); | ||
| assertIsNode(node, "instructionNode"); | ||
| const argFields = node.arguments; | ||
| const argName = camelCase3(argNameInput); | ||
| const argName = camelCase(argNameInput); | ||
| const argFieldIndex = argFields.findIndex((field) => field.name === argName); | ||
| const argField = argFieldIndex >= 0 ? argFields[argFieldIndex] : null; | ||
| if (!argField) { | ||
| throw new CodamaError3(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -125,10 +95,10 @@ instruction: node, | ||
| let argType; | ||
| if (isNode2(argField.type, "enumTypeNode")) { | ||
| if (isNode(argField.type, "enumTypeNode")) { | ||
| argType = argField.type; | ||
| } else if (isNode2(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| } else if (isNode(argField.type, "definedTypeLinkNode") && linkables.has([...stack.getPath(), argField.type])) { | ||
| const linkedType = linkables.get([...stack.getPath(), argField.type])?.type; | ||
| assertIsNode3(linkedType, "enumTypeNode"); | ||
| assertIsNode(linkedType, "enumTypeNode"); | ||
| argType = linkedType; | ||
| } else { | ||
| throw new CodamaError3(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INSTRUCTION_ENUM_ARGUMENT_NOT_FOUND, { | ||
| argumentName: argName, | ||
@@ -140,6 +110,6 @@ instruction: node, | ||
| const subInstructions = argType.variants.map((variant, index) => { | ||
| const subName = camelCase3(`${node.name} ${variant.name}`); | ||
| const subName = camelCase(`${node.name} ${variant.name}`); | ||
| const subFields = argFields.slice(0, argFieldIndex); | ||
| subFields.push( | ||
| instructionArgumentNode2({ | ||
| instructionArgumentNode({ | ||
| defaultValue: numberValueNode(index), | ||
@@ -151,5 +121,5 @@ defaultValueStrategy: "omitted", | ||
| ); | ||
| if (isNode2(variant, "enumStructVariantTypeNode")) { | ||
| if (isNode(variant, "enumStructVariantTypeNode")) { | ||
| subFields.push( | ||
| instructionArgumentNode2({ | ||
| instructionArgumentNode({ | ||
| ...argField, | ||
@@ -159,5 +129,5 @@ type: variant.struct | ||
| ); | ||
| } else if (isNode2(variant, "enumTupleVariantTypeNode")) { | ||
| } else if (isNode(variant, "enumTupleVariantTypeNode")) { | ||
| subFields.push( | ||
| instructionArgumentNode2({ | ||
| instructionArgumentNode({ | ||
| ...argField, | ||
@@ -169,3 +139,3 @@ type: variant.tuple | ||
| subFields.push(...argFields.slice(argFieldIndex + 1)); | ||
| return instructionNode2({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -176,3 +146,3 @@ arguments: flattenInstructionArguments(subFields), | ||
| }); | ||
| return instructionNode2({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -187,11 +157,2 @@ subInstructions: [...node.subInstructions ?? [], ...subInstructions] | ||
| } | ||
| // src/deduplicateIdenticalDefinedTypesVisitor.ts | ||
| import { assertIsNode as assertIsNode4, getAllPrograms } from "@codama/nodes"; | ||
| import { | ||
| deleteNodesVisitor, | ||
| getUniqueHashStringVisitor, | ||
| rootNodeVisitor, | ||
| visit | ||
| } from "@codama/visitors-core"; | ||
| function deduplicateIdenticalDefinedTypesVisitor() { | ||
@@ -228,3 +189,3 @@ return rootNodeVisitor((root) => { | ||
| const newRoot = visit(root, deleteNodesVisitor(deleteSelectors)); | ||
| assertIsNode4(newRoot, "rootNode"); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -235,25 +196,5 @@ } | ||
| } | ||
| // src/fillDefaultPdaSeedValuesVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, CodamaError as CodamaError4 } from "@codama/errors"; | ||
| import { | ||
| accountValueNode, | ||
| argumentValueNode, | ||
| assertIsNode as assertIsNode5, | ||
| getAllInstructionArguments, | ||
| INSTRUCTION_INPUT_VALUE_NODES, | ||
| isNode as isNode3, | ||
| isNodeFilter, | ||
| pdaSeedValueNode, | ||
| pdaValueNode | ||
| } from "@codama/nodes"; | ||
| import { | ||
| extendVisitor, | ||
| getLastNodeFromPath, | ||
| identityVisitor, | ||
| pipe as pipe2 | ||
| } from "@codama/visitors-core"; | ||
| function fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, strictMode = false) { | ||
| const instruction = getLastNodeFromPath(instructionPath); | ||
| return pipe2( | ||
| return pipe( | ||
| identityVisitor({ keys: INSTRUCTION_INPUT_VALUE_NODES }), | ||
@@ -263,8 +204,8 @@ (v) => extendVisitor(v, { | ||
| const visitedNode = next(node); | ||
| assertIsNode5(visitedNode, "pdaValueNode"); | ||
| const foundPda = isNode3(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| assertIsNode(visitedNode, "pdaValueNode"); | ||
| const foundPda = isNode(visitedNode.pda, "pdaNode") ? visitedNode.pda : linkables.get([...instructionPath, visitedNode.pda]); | ||
| if (!foundPda) return visitedNode; | ||
| const seeds = addDefaultSeedValuesFromPdaWhenMissing(instruction, foundPda, visitedNode.seeds); | ||
| if (strictMode && !allSeedsAreValid(instruction, foundPda, seeds)) { | ||
| throw new CodamaError4(CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INVALID_PDA_SEED_VALUES, { | ||
| instruction, | ||
@@ -290,5 +231,5 @@ instructionName: instruction.name, | ||
| return pda.seeds.flatMap((seed) => { | ||
| if (!isNode3(seed, "variablePdaSeedNode")) return []; | ||
| if (!isNode(seed, "variablePdaSeedNode")) return []; | ||
| const hasMatchingAccount = instruction.accounts.some((a) => a.name === seed.name); | ||
| if (isNode3(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| if (isNode(seed.type, "publicKeyTypeNode") && hasMatchingAccount) { | ||
| return [pdaSeedValueNode(seed.name, accountValueNode(seed.name))]; | ||
@@ -308,6 +249,6 @@ } | ||
| const validSeeds = seeds.every((seed) => { | ||
| if (isNode3(seed.value, "accountValueNode")) { | ||
| if (isNode(seed.value, "accountValueNode")) { | ||
| return allAccountsName.includes(seed.value.name); | ||
| } | ||
| if (isNode3(seed.value, "argumentValueNode")) { | ||
| if (isNode(seed.value, "argumentValueNode")) { | ||
| return allArgumentsName.includes(seed.value.name); | ||
@@ -319,14 +260,4 @@ } | ||
| } | ||
| // src/flattenStructVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES as CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES2, CodamaError as CodamaError5 } from "@codama/errors"; | ||
| import { | ||
| assertIsNode as assertIsNode6, | ||
| camelCase as camelCase4, | ||
| isNode as isNode4, | ||
| structTypeNode | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor4 } from "@codama/visitors-core"; | ||
| function flattenStructVisitor(map) { | ||
| return bottomUpTransformerVisitor4( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -341,7 +272,7 @@ ([stack, options]) => ({ | ||
| var flattenStruct = (node, options = "*") => { | ||
| assertIsNode6(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase4); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes(camelCase4(field.name)); | ||
| assertIsNode(node, "structTypeNode"); | ||
| const camelCaseOptions = options === "*" ? options : options.map(camelCase); | ||
| const shouldInline = (field) => options === "*" || camelCaseOptions.includes(camelCase(field.name)); | ||
| const inlinedFields = node.fields.flatMap((field) => { | ||
| if (isNode4(field.type, "structTypeNode") && shouldInline(field)) { | ||
| if (isNode(field.type, "structTypeNode") && shouldInline(field)) { | ||
| return field.type.fields; | ||
@@ -356,3 +287,3 @@ } | ||
| if (hasConflictingNames) { | ||
| throw new CodamaError5(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES2, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__CANNOT_FLATTEN_STRUCT_WITH_CONFLICTING_ATTRIBUTES, { | ||
| conflictingAttributes: uniqueDuplicates | ||
@@ -363,14 +294,2 @@ }); | ||
| }; | ||
| // src/getDefinedTypeHistogramVisitor.ts | ||
| import { | ||
| extendVisitor as extendVisitor2, | ||
| findProgramNodeFromPath, | ||
| interceptVisitor, | ||
| mergeVisitor, | ||
| NodeStack, | ||
| pipe as pipe3, | ||
| recordNodeStackVisitor, | ||
| visit as visit2 | ||
| } from "@codama/visitors-core"; | ||
| function mergeHistograms(histograms) { | ||
@@ -398,3 +317,3 @@ const result = {}; | ||
| let stackLevel = 0; | ||
| return pipe3( | ||
| return pipe( | ||
| mergeVisitor( | ||
@@ -410,7 +329,7 @@ () => ({}), | ||
| }), | ||
| (v) => extendVisitor2(v, { | ||
| (v) => extendVisitor(v, { | ||
| visitAccount(node, { self }) { | ||
| mode = "account"; | ||
| stackLevel = 0; | ||
| const histogram = visit2(node.data, self); | ||
| const histogram = visit(node.data, self); | ||
| mode = null; | ||
@@ -422,3 +341,3 @@ return histogram; | ||
| stackLevel = 0; | ||
| const histogram = visit2(node.type, self); | ||
| const histogram = visit(node.type, self); | ||
| mode = null; | ||
@@ -443,6 +362,6 @@ return histogram; | ||
| stackLevel = 0; | ||
| const dataHistograms = node.arguments.map((arg) => visit2(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => visit2(arg, self)); | ||
| const dataHistograms = node.arguments.map((arg) => visit(arg, self)); | ||
| const extraHistograms = (node.extraArguments ?? []).map((arg) => visit(arg, self)); | ||
| mode = null; | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => visit2(ix, self)); | ||
| const subHistograms = (node.subInstructions ?? []).map((ix) => visit(ix, self)); | ||
| return mergeHistograms([...dataHistograms, ...extraHistograms, ...subHistograms]); | ||
@@ -454,17 +373,4 @@ } | ||
| } | ||
| // src/setAccountDiscriminatorFromFieldVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, CodamaError as CodamaError6 } from "@codama/errors"; | ||
| import { | ||
| accountNode, | ||
| assertIsNode as assertIsNode7, | ||
| fieldDiscriminatorNode, | ||
| resolveNestedTypeNode, | ||
| structFieldTypeNode, | ||
| structTypeNode as structTypeNode2, | ||
| transformNestedTypeNode | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor5 } from "@codama/visitors-core"; | ||
| function setAccountDiscriminatorFromFieldVisitor(map) { | ||
| return bottomUpTransformerVisitor5( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -474,7 +380,7 @@ ([selector, { field, value, offset }]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode7(node, "accountNode"); | ||
| assertIsNode(node, "accountNode"); | ||
| const accountData = resolveNestedTypeNode(node.data); | ||
| const fieldIndex = accountData.fields.findIndex((f) => f.name === field); | ||
| if (fieldIndex < 0) { | ||
| throw new CodamaError6(CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__ACCOUNT_FIELD_NOT_FOUND, { | ||
| account: node, | ||
@@ -490,3 +396,3 @@ missingField: field, | ||
| node.data, | ||
| () => structTypeNode2([ | ||
| () => structTypeNode([ | ||
| ...accountData.fields.slice(0, fieldIndex), | ||
@@ -508,26 +414,13 @@ structFieldTypeNode({ | ||
| } | ||
| // src/setFixedAccountSizesVisitor.ts | ||
| import { accountNode as accountNode2, assertIsNode as assertIsNode8 } from "@codama/nodes"; | ||
| import { | ||
| getByteSizeVisitor, | ||
| getLastNodeFromPath as getLastNodeFromPath2, | ||
| isNodePath, | ||
| LinkableDictionary as LinkableDictionary3, | ||
| pipe as pipe4, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor2, | ||
| topDownTransformerVisitor, | ||
| visit as visit3 | ||
| } from "@codama/visitors-core"; | ||
| function setFixedAccountSizesVisitor() { | ||
| const linkables = new LinkableDictionary3(); | ||
| const linkables = new LinkableDictionary(); | ||
| const visitor = topDownTransformerVisitor( | ||
| [ | ||
| { | ||
| select: (path) => isNodePath(path, "accountNode") && getLastNodeFromPath2(path).size === void 0, | ||
| select: (path) => isNodePath(path, "accountNode") && getLastNodeFromPath(path).size === void 0, | ||
| transform: (node, stack) => { | ||
| assertIsNode8(node, "accountNode"); | ||
| const size = visit3(node.data, getByteSizeVisitor(linkables, { stack })); | ||
| assertIsNode(node, "accountNode"); | ||
| const size = visit(node.data, getByteSizeVisitor(linkables, { stack })); | ||
| if (size === null) return node; | ||
| return accountNode2({ ...node, size }); | ||
| return accountNode({ ...node, size }); | ||
| } | ||
@@ -538,24 +431,4 @@ } | ||
| ); | ||
| return pipe4(visitor, (v) => recordLinkablesOnFirstVisitVisitor2(v, linkables)); | ||
| return pipe(visitor, (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/setInstructionAccountDefaultValuesVisitor.ts | ||
| import { | ||
| camelCase as camelCase5, | ||
| identityValueNode, | ||
| instructionNode as instructionNode3, | ||
| payerValueNode, | ||
| programIdValueNode, | ||
| publicKeyValueNode | ||
| } from "@codama/nodes"; | ||
| import { | ||
| extendVisitor as extendVisitor3, | ||
| LinkableDictionary as LinkableDictionary4, | ||
| NodeStack as NodeStack2, | ||
| nonNullableIdentityVisitor, | ||
| pipe as pipe5, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor3, | ||
| recordNodeStackVisitor as recordNodeStackVisitor2, | ||
| visit as visit4 | ||
| } from "@codama/visitors-core"; | ||
| var getCommonInstructionAccountDefaultRules = () => [ | ||
@@ -664,4 +537,4 @@ { | ||
| function setInstructionAccountDefaultValuesVisitor(rules) { | ||
| const linkables = new LinkableDictionary4(); | ||
| const stack = new NodeStack2(); | ||
| const linkables = new LinkableDictionary(); | ||
| const stack = new NodeStack(); | ||
| const sortedRules = rules.sort((a, b) => { | ||
@@ -675,11 +548,11 @@ const ia = "instruction" in a; | ||
| return sortedRules.find((rule) => { | ||
| if ("instruction" in rule && rule.instruction && camelCase5(rule.instruction) !== instruction.name) { | ||
| if ("instruction" in rule && rule.instruction && camelCase(rule.instruction) !== instruction.name) { | ||
| return false; | ||
| } | ||
| return typeof rule.account === "string" ? camelCase5(rule.account) === account.name : rule.account.test(account.name); | ||
| return typeof rule.account === "string" ? camelCase(rule.account) === account.name : rule.account.test(account.name); | ||
| }); | ||
| } | ||
| return pipe5( | ||
| return pipe( | ||
| nonNullableIdentityVisitor({ keys: ["rootNode", "programNode", "instructionNode"] }), | ||
| (v) => extendVisitor3(v, { | ||
| (v) => extendVisitor(v, { | ||
| visitInstruction(node) { | ||
@@ -696,3 +569,3 @@ const instructionPath = stack.getPath("instructionNode"); | ||
| ...account, | ||
| defaultValue: visit4( | ||
| defaultValue: visit( | ||
| rule.defaultValue, | ||
@@ -706,3 +579,3 @@ fillDefaultPdaSeedValuesVisitor(instructionPath, linkables, true) | ||
| }); | ||
| return instructionNode3({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -713,18 +586,8 @@ accounts: instructionAccounts | ||
| }), | ||
| (v) => recordNodeStackVisitor2(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor3(v, linkables) | ||
| (v) => recordNodeStackVisitor(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/setInstructionDiscriminatorsVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode9, | ||
| fieldDiscriminatorNode as fieldDiscriminatorNode2, | ||
| instructionArgumentNode as instructionArgumentNode3, | ||
| instructionNode as instructionNode4, | ||
| numberTypeNode as numberTypeNode2 | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor6 } from "@codama/visitors-core"; | ||
| function setInstructionDiscriminatorsVisitor(map) { | ||
| return bottomUpTransformerVisitor6( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -734,4 +597,4 @@ ([selector, discriminator]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode9(node, "instructionNode"); | ||
| const discriminatorArgument = instructionArgumentNode3({ | ||
| assertIsNode(node, "instructionNode"); | ||
| const discriminatorArgument = instructionArgumentNode({ | ||
| defaultValue: discriminator.value, | ||
@@ -741,9 +604,9 @@ defaultValueStrategy: discriminator.strategy ?? "omitted", | ||
| name: discriminator.name ?? "discriminator", | ||
| type: discriminator.type ?? numberTypeNode2("u8") | ||
| type: discriminator.type ?? numberTypeNode("u8") | ||
| }); | ||
| return instructionNode4({ | ||
| return instructionNode({ | ||
| ...node, | ||
| arguments: [discriminatorArgument, ...node.arguments], | ||
| discriminators: [ | ||
| fieldDiscriminatorNode2(discriminator.name ?? "discriminator"), | ||
| fieldDiscriminatorNode(discriminator.name ?? "discriminator"), | ||
| ...node.discriminators ?? [] | ||
@@ -757,9 +620,4 @@ ] | ||
| } | ||
| // src/setNumberWrappersVisitor.ts | ||
| import { CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, CodamaError as CodamaError7 } from "@codama/errors"; | ||
| import { amountTypeNode, assertIsNestedTypeNode, dateTimeTypeNode, solAmountTypeNode } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor7 } from "@codama/visitors-core"; | ||
| function setNumberWrappersVisitor(map) { | ||
| return bottomUpTransformerVisitor7( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -778,3 +636,3 @@ ([selectorStack, wrapper]) => ({ | ||
| default: | ||
| throw new CodamaError7(CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| throw new CodamaError(CODAMA_ERROR__VISITORS__INVALID_NUMBER_WRAPPER, { wrapper }); | ||
| } | ||
@@ -786,18 +644,7 @@ } | ||
| } | ||
| // src/setStructDefaultValuesVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode10, | ||
| camelCase as camelCase6, | ||
| instructionArgumentNode as instructionArgumentNode4, | ||
| instructionNode as instructionNode5, | ||
| structFieldTypeNode as structFieldTypeNode2, | ||
| structTypeNode as structTypeNode3 | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor8 } from "@codama/visitors-core"; | ||
| function setStructDefaultValuesVisitor(map) { | ||
| return bottomUpTransformerVisitor8( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([stack, defaultValues]) => { | ||
| const camelCasedDefaultValues = Object.fromEntries( | ||
| Object.entries(defaultValues).map(([key, value]) => [camelCase6(key), value]) | ||
| Object.entries(defaultValues).map(([key, value]) => [camelCase(key), value]) | ||
| ); | ||
@@ -808,3 +655,3 @@ return [ | ||
| transform: (node) => { | ||
| assertIsNode10(node, "structTypeNode"); | ||
| assertIsNode(node, "structTypeNode"); | ||
| const fields = node.fields.map((field) => { | ||
@@ -814,3 +661,3 @@ const defaultValue = camelCasedDefaultValues[field.name]; | ||
| if (defaultValue === null) { | ||
| return structFieldTypeNode2({ | ||
| return structFieldTypeNode({ | ||
| ...field, | ||
@@ -821,3 +668,3 @@ defaultValue: void 0, | ||
| } | ||
| return structFieldTypeNode2({ | ||
| return structFieldTypeNode({ | ||
| ...field, | ||
@@ -828,3 +675,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }); | ||
| return structTypeNode3(fields); | ||
| return structTypeNode(fields); | ||
| } | ||
@@ -835,3 +682,3 @@ }, | ||
| transform: (node) => { | ||
| assertIsNode10(node, "instructionNode"); | ||
| assertIsNode(node, "instructionNode"); | ||
| const transformArguments = (arg) => { | ||
@@ -841,3 +688,3 @@ const defaultValue = camelCasedDefaultValues[arg.name]; | ||
| if (defaultValue === null) { | ||
| return instructionArgumentNode4({ | ||
| return instructionArgumentNode({ | ||
| ...arg, | ||
@@ -848,3 +695,3 @@ defaultValue: void 0, | ||
| } | ||
| return instructionArgumentNode4({ | ||
| return instructionArgumentNode({ | ||
| ...arg, | ||
@@ -855,3 +702,3 @@ defaultValue: "kind" in defaultValue ? defaultValue : defaultValue.value, | ||
| }; | ||
| return instructionNode5({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -867,10 +714,6 @@ arguments: node.arguments.map(transformArguments), | ||
| } | ||
| // src/transformDefinedTypesIntoAccountsVisitor.ts | ||
| import { accountNode as accountNode3, assertIsNode as assertIsNode11, programNode as programNode2 } from "@codama/nodes"; | ||
| import { extendVisitor as extendVisitor4, nonNullableIdentityVisitor as nonNullableIdentityVisitor2, pipe as pipe6 } from "@codama/visitors-core"; | ||
| function transformDefinedTypesIntoAccountsVisitor(definedTypes) { | ||
| return pipe6( | ||
| nonNullableIdentityVisitor2({ keys: ["rootNode", "programNode"] }), | ||
| (v) => extendVisitor4(v, { | ||
| return pipe( | ||
| nonNullableIdentityVisitor({ keys: ["rootNode", "programNode"] }), | ||
| (v) => extendVisitor(v, { | ||
| visitProgram(program) { | ||
@@ -880,4 +723,4 @@ const typesToExtract = program.definedTypes.filter((node) => definedTypes.includes(node.name)); | ||
| const newAccounts = typesToExtract.map((node) => { | ||
| assertIsNode11(node.type, "structTypeNode"); | ||
| return accountNode3({ | ||
| assertIsNode(node.type, "structTypeNode"); | ||
| return accountNode({ | ||
| ...node, | ||
@@ -889,3 +732,3 @@ data: node.type, | ||
| }); | ||
| return programNode2({ | ||
| return programNode({ | ||
| ...program, | ||
@@ -899,25 +742,14 @@ accounts: [...program.accounts, ...newAccounts], | ||
| } | ||
| // src/transformU8ArraysToBytesVisitor.ts | ||
| import { | ||
| arrayTypeNode, | ||
| assertIsNode as assertIsNode12, | ||
| bytesTypeNode, | ||
| fixedSizeTypeNode, | ||
| isNode as isNode5, | ||
| TYPE_NODES | ||
| } from "@codama/nodes"; | ||
| import { extendVisitor as extendVisitor5, nonNullableIdentityVisitor as nonNullableIdentityVisitor3, pipe as pipe7, visit as visit5 } from "@codama/visitors-core"; | ||
| function transformU8ArraysToBytesVisitor(sizes = "*") { | ||
| const hasRequiredSize = (count) => { | ||
| if (!isNode5(count, "fixedCountNode")) return false; | ||
| if (!isNode(count, "fixedCountNode")) return false; | ||
| return sizes === "*" || sizes.includes(count.value); | ||
| }; | ||
| return pipe7( | ||
| nonNullableIdentityVisitor3(), | ||
| (v) => extendVisitor5(v, { | ||
| return pipe( | ||
| nonNullableIdentityVisitor(), | ||
| (v) => extendVisitor(v, { | ||
| visitArrayType(node, { self }) { | ||
| const child = visit5(node.item, self); | ||
| assertIsNode12(child, TYPE_NODES); | ||
| if (isNode5(child, "numberTypeNode") && child.format === "u8" && isNode5(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| const child = visit(node.item, self); | ||
| assertIsNode(child, TYPE_NODES); | ||
| if (isNode(child, "numberTypeNode") && child.format === "u8" && isNode(node.count, "fixedCountNode") && hasRequiredSize(node.count)) { | ||
| return fixedSizeTypeNode(bytesTypeNode(), node.count.value); | ||
@@ -930,24 +762,9 @@ } | ||
| } | ||
| // src/unwrapDefinedTypesVisitor.ts | ||
| import { assertIsNodeFilter, camelCase as camelCase7, programNode as programNode3 } from "@codama/nodes"; | ||
| import { | ||
| extendVisitor as extendVisitor6, | ||
| findProgramNodeFromPath as findProgramNodeFromPath2, | ||
| getLastNodeFromPath as getLastNodeFromPath3, | ||
| LinkableDictionary as LinkableDictionary5, | ||
| NodeStack as NodeStack3, | ||
| nonNullableIdentityVisitor as nonNullableIdentityVisitor4, | ||
| pipe as pipe8, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor4, | ||
| recordNodeStackVisitor as recordNodeStackVisitor3, | ||
| visit as visit6 | ||
| } from "@codama/visitors-core"; | ||
| function unwrapDefinedTypesVisitor(typesToInline = "*") { | ||
| const linkables = new LinkableDictionary5(); | ||
| const stack = new NodeStack3(); | ||
| const linkables = new LinkableDictionary(); | ||
| const stack = new NodeStack(); | ||
| const typesToInlineCamelCased = (typesToInline === "*" ? [] : typesToInline).map((fullPath) => { | ||
| if (!fullPath.includes(".")) return camelCase7(fullPath); | ||
| if (!fullPath.includes(".")) return camelCase(fullPath); | ||
| const [programName, typeName] = fullPath.split("."); | ||
| return `${camelCase7(programName)}.${camelCase7(typeName)}`; | ||
| return `${camelCase(programName)}.${camelCase(typeName)}`; | ||
| }); | ||
@@ -960,7 +777,7 @@ const shouldInline = (typeName, programName) => { | ||
| }; | ||
| return pipe8( | ||
| nonNullableIdentityVisitor4(), | ||
| (v) => extendVisitor6(v, { | ||
| return pipe( | ||
| nonNullableIdentityVisitor(), | ||
| (v) => extendVisitor(v, { | ||
| visitDefinedTypeLink(linkType, { self }) { | ||
| const programName = linkType.program?.name ?? findProgramNodeFromPath2(stack.getPath())?.name; | ||
| const programName = linkType.program?.name ?? findProgramNodeFromPath(stack.getPath())?.name; | ||
| if (!shouldInline(linkType.name, programName)) { | ||
@@ -970,5 +787,5 @@ return linkType; | ||
| const definedTypePath = linkables.getPathOrThrow(stack.getPath("definedTypeLinkNode")); | ||
| const definedType = getLastNodeFromPath3(definedTypePath); | ||
| const definedType = getLastNodeFromPath(definedTypePath); | ||
| stack.pushPath(definedTypePath); | ||
| const result = visit6(definedType.type, self); | ||
| const result = visit(definedType.type, self); | ||
| stack.popPath(); | ||
@@ -978,23 +795,19 @@ return result; | ||
| visitProgram(program, { self }) { | ||
| return programNode3({ | ||
| return programNode({ | ||
| ...program, | ||
| accounts: program.accounts.map((account) => visit6(account, self)).filter(assertIsNodeFilter("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => visit6(type, self)).filter(assertIsNodeFilter("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => visit6(instruction, self)).filter(assertIsNodeFilter("instructionNode")) | ||
| accounts: program.accounts.map((account) => visit(account, self)).filter(assertIsNodeFilter("accountNode")), | ||
| definedTypes: program.definedTypes.filter((definedType) => !shouldInline(definedType.name, program.name)).map((type) => visit(type, self)).filter(assertIsNodeFilter("definedTypeNode")), | ||
| instructions: program.instructions.map((instruction) => visit(instruction, self)).filter(assertIsNodeFilter("instructionNode")) | ||
| }); | ||
| } | ||
| }), | ||
| (v) => recordNodeStackVisitor3(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor4(v, linkables) | ||
| (v) => recordNodeStackVisitor(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
| } | ||
| // src/unwrapInstructionArgsDefinedTypesVisitor.ts | ||
| import { assertIsNode as assertIsNode13, definedTypeLinkNode, isNode as isNode6 } from "@codama/nodes"; | ||
| import { getRecordLinkablesVisitor, LinkableDictionary as LinkableDictionary6, rootNodeVisitor as rootNodeVisitor2, visit as visit7 } from "@codama/visitors-core"; | ||
| function unwrapInstructionArgsDefinedTypesVisitor() { | ||
| return rootNodeVisitor2((root) => { | ||
| const histogram = visit7(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new LinkableDictionary6(); | ||
| visit7(root, getRecordLinkablesVisitor(linkables)); | ||
| return rootNodeVisitor((root) => { | ||
| const histogram = visit(root, getDefinedTypeHistogramVisitor()); | ||
| const linkables = new LinkableDictionary(); | ||
| visit(root, getRecordLinkablesVisitor(linkables)); | ||
| const definedTypesToInline = Object.keys(histogram).filter((key) => (histogram[key].total ?? 0) === 1 && (histogram[key].directlyAsInstructionArgs ?? 0) === 1).filter((key) => { | ||
@@ -1004,8 +817,8 @@ const names = key.split("."); | ||
| const found = linkables.get([link]); | ||
| return found && !isNode6(found.type, "enumTypeNode"); | ||
| return found && !isNode(found.type, "enumTypeNode"); | ||
| }); | ||
| if (definedTypesToInline.length > 0) { | ||
| const inlineVisitor = unwrapDefinedTypesVisitor(definedTypesToInline); | ||
| const newRoot = visit7(root, inlineVisitor); | ||
| assertIsNode13(newRoot, "rootNode"); | ||
| const newRoot = visit(root, inlineVisitor); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
@@ -1016,23 +829,6 @@ } | ||
| } | ||
| // src/unwrapTupleEnumWithSingleStructVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode14, | ||
| enumStructVariantTypeNode, | ||
| getAllDefinedTypes, | ||
| isNode as isNode7, | ||
| REGISTERED_NODE_KINDS, | ||
| resolveNestedTypeNode as resolveNestedTypeNode2, | ||
| transformNestedTypeNode as transformNestedTypeNode2 | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor9, | ||
| getNodeSelectorFunction, | ||
| rootNodeVisitor as rootNodeVisitor3, | ||
| visit as visit8 | ||
| } from "@codama/visitors-core"; | ||
| function unwrapTupleEnumWithSingleStructVisitor(enumsOrVariantsToUnwrap = "*") { | ||
| const selectorFunctions = enumsOrVariantsToUnwrap === "*" ? [() => true] : enumsOrVariantsToUnwrap.map((selector) => getNodeSelectorFunction(selector)); | ||
| const shouldUnwrap = (stack) => selectorFunctions.some((selector) => selector(stack.getPath(REGISTERED_NODE_KINDS))); | ||
| return rootNodeVisitor3((root) => { | ||
| return rootNodeVisitor((root) => { | ||
| const typesToPotentiallyUnwrap = []; | ||
@@ -1042,22 +838,22 @@ const definedTypes = new Map( | ||
| ); | ||
| let newRoot = visit8( | ||
| let newRoot = visit( | ||
| root, | ||
| bottomUpTransformerVisitor9([ | ||
| bottomUpTransformerVisitor([ | ||
| { | ||
| select: "[enumTupleVariantTypeNode]", | ||
| transform: (node, stack) => { | ||
| assertIsNode14(node, "enumTupleVariantTypeNode"); | ||
| assertIsNode(node, "enumTupleVariantTypeNode"); | ||
| if (!shouldUnwrap(stack)) return node; | ||
| const tupleNode = resolveNestedTypeNode2(node.tuple); | ||
| const tupleNode = resolveNestedTypeNode(node.tuple); | ||
| if (tupleNode.items.length !== 1) return node; | ||
| let item = tupleNode.items[0]; | ||
| if (isNode7(item, "definedTypeLinkNode")) { | ||
| if (isNode(item, "definedTypeLinkNode")) { | ||
| const definedType = definedTypes.get(item.name); | ||
| if (!definedType) return node; | ||
| if (!isNode7(definedType.type, "structTypeNode")) return node; | ||
| if (!isNode(definedType.type, "structTypeNode")) return node; | ||
| typesToPotentiallyUnwrap.push(item.name); | ||
| item = definedType.type; | ||
| } | ||
| if (!isNode7(item, "structTypeNode")) return node; | ||
| const nestedStruct = transformNestedTypeNode2(node.tuple, () => item); | ||
| if (!isNode(item, "structTypeNode")) return node; | ||
| const nestedStruct = transformNestedTypeNode(node.tuple, () => item); | ||
| return enumStructVariantTypeNode(node.name, nestedStruct); | ||
@@ -1068,22 +864,14 @@ } | ||
| ); | ||
| assertIsNode14(newRoot, "rootNode"); | ||
| const histogram = visit8(newRoot, getDefinedTypeHistogramVisitor()); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| const histogram = visit(newRoot, getDefinedTypeHistogramVisitor()); | ||
| const typesToUnwrap = typesToPotentiallyUnwrap.filter( | ||
| (type) => !histogram[type] || histogram[type].total === 0 | ||
| ); | ||
| newRoot = visit8(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| assertIsNode14(newRoot, "rootNode"); | ||
| newRoot = visit(newRoot, unwrapDefinedTypesVisitor(typesToUnwrap)); | ||
| assertIsNode(newRoot, "rootNode"); | ||
| return newRoot; | ||
| }); | ||
| } | ||
| // src/unwrapTypeDefinedLinksVisitor.ts | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor10, | ||
| LinkableDictionary as LinkableDictionary7, | ||
| pipe as pipe9, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor5 | ||
| } from "@codama/visitors-core"; | ||
| function unwrapTypeDefinedLinksVisitor(definedLinksType) { | ||
| const linkables = new LinkableDictionary7(); | ||
| const linkables = new LinkableDictionary(); | ||
| const transformers = definedLinksType.map((selector) => ({ | ||
@@ -1096,34 +884,7 @@ select: ["[definedTypeLinkNode]", selector], | ||
| })); | ||
| return pipe9(bottomUpTransformerVisitor10(transformers), (v) => recordLinkablesOnFirstVisitVisitor5(v, linkables)); | ||
| return pipe(bottomUpTransformerVisitor(transformers), (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)); | ||
| } | ||
| // src/updateAccountsVisitor.ts | ||
| import { | ||
| accountLinkNode, | ||
| accountNode as accountNode4, | ||
| assertIsNode as assertIsNode15, | ||
| camelCase as camelCase8, | ||
| pdaLinkNode, | ||
| pdaNode as pdaNode2, | ||
| programNode as programNode4, | ||
| transformNestedTypeNode as transformNestedTypeNode3 | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor11, | ||
| findProgramNodeFromPath as findProgramNodeFromPath3 | ||
| } from "@codama/visitors-core"; | ||
| // src/renameHelpers.ts | ||
| import { | ||
| enumEmptyVariantTypeNode, | ||
| enumStructVariantTypeNode as enumStructVariantTypeNode2, | ||
| enumTupleVariantTypeNode, | ||
| enumTypeNode, | ||
| isNode as isNode8, | ||
| structFieldTypeNode as structFieldTypeNode3, | ||
| structTypeNode as structTypeNode4 | ||
| } from "@codama/nodes"; | ||
| function renameStructNode(node, map) { | ||
| return structTypeNode4( | ||
| node.fields.map((field) => map[field.name] ? structFieldTypeNode3({ ...field, name: map[field.name] }) : field) | ||
| return structTypeNode( | ||
| node.fields.map((field) => map[field.name] ? structFieldTypeNode({ ...field, name: map[field.name] }) : field) | ||
| ); | ||
@@ -1138,6 +899,6 @@ } | ||
| function renameEnumVariant(variant, newName) { | ||
| if (isNode8(variant, "enumStructVariantTypeNode")) { | ||
| return enumStructVariantTypeNode2(newName, variant.struct); | ||
| if (isNode(variant, "enumStructVariantTypeNode")) { | ||
| return enumStructVariantTypeNode(newName, variant.struct); | ||
| } | ||
| if (isNode8(variant, "enumTupleVariantTypeNode")) { | ||
| if (isNode(variant, "enumTupleVariantTypeNode")) { | ||
| return enumTupleVariantTypeNode(newName, variant.tuple); | ||
@@ -1150,5 +911,5 @@ } | ||
| function updateAccountsVisitor(map) { | ||
| return bottomUpTransformerVisitor11( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase8(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase(updates.name) : void 0; | ||
| const pdasToUpsert = []; | ||
@@ -1159,5 +920,5 @@ const transformers = [ | ||
| transform: (node, stack) => { | ||
| assertIsNode15(node, "accountNode"); | ||
| assertIsNode(node, "accountNode"); | ||
| if ("delete" in updates) return null; | ||
| const programNode6 = findProgramNodeFromPath3(stack.getPath()); | ||
| const programNode6 = findProgramNodeFromPath(stack.getPath()); | ||
| const { seeds, pda, ...assignableUpdates } = updates; | ||
@@ -1168,3 +929,3 @@ let newPda = node.pda; | ||
| pdasToUpsert.push({ | ||
| pda: pdaNode2({ name: pda.name, seeds }), | ||
| pda: pdaNode({ name: pda.name, seeds }), | ||
| program: programNode6.name | ||
@@ -1176,3 +937,3 @@ }); | ||
| pdasToUpsert.push({ | ||
| pda: pdaNode2({ name: node.pda.name, seeds }), | ||
| pda: pdaNode({ name: node.pda.name, seeds }), | ||
| program: programNode6.name | ||
@@ -1183,10 +944,10 @@ }); | ||
| pdasToUpsert.push({ | ||
| pda: pdaNode2({ name: newName ?? node.name, seeds }), | ||
| pda: pdaNode({ name: newName ?? node.name, seeds }), | ||
| program: programNode6.name | ||
| }); | ||
| } | ||
| return accountNode4({ | ||
| return accountNode({ | ||
| ...node, | ||
| ...assignableUpdates, | ||
| data: transformNestedTypeNode3( | ||
| data: transformNestedTypeNode( | ||
| node.data, | ||
@@ -1202,3 +963,3 @@ (struct) => renameStructNode(struct, updates.data ?? {}) | ||
| transform: (node) => { | ||
| assertIsNode15(node, "programNode"); | ||
| assertIsNode(node, "programNode"); | ||
| const pdasToUpsertForProgram = pdasToUpsert.filter((p) => p.program === node.name).map((p) => p.pda); | ||
@@ -1212,3 +973,3 @@ if (pdasToUpsertForProgram.length === 0) return node; | ||
| const newPdas = [...node.pdas.map((p) => pdasToUpdate.get(p.name) ?? p), ...pdasToCreate]; | ||
| return programNode4({ ...node, pdas: newPdas }); | ||
| return programNode({ ...node, pdas: newPdas }); | ||
| } | ||
@@ -1222,3 +983,3 @@ } | ||
| transform: (node) => { | ||
| assertIsNode15(node, "accountLinkNode"); | ||
| assertIsNode(node, "accountLinkNode"); | ||
| return accountLinkNode(newName); | ||
@@ -1230,4 +991,4 @@ } | ||
| transform: (node) => { | ||
| assertIsNode15(node, "pdaNode"); | ||
| return pdaNode2({ name: newName, seeds: node.seeds }); | ||
| assertIsNode(node, "pdaNode"); | ||
| return pdaNode({ name: newName, seeds: node.seeds }); | ||
| } | ||
@@ -1238,3 +999,3 @@ }, | ||
| transform: (node) => { | ||
| assertIsNode15(node, "pdaLinkNode"); | ||
| assertIsNode(node, "pdaLinkNode"); | ||
| return pdaLinkNode(newName); | ||
@@ -1249,16 +1010,6 @@ } | ||
| } | ||
| // src/updateDefinedTypesVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode16, | ||
| camelCase as camelCase9, | ||
| definedTypeLinkNode as definedTypeLinkNode2, | ||
| definedTypeNode, | ||
| isNode as isNode9 | ||
| } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor12 } from "@codama/visitors-core"; | ||
| function updateDefinedTypesVisitor(map) { | ||
| return bottomUpTransformerVisitor12( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([selector, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase9(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1268,3 +1019,3 @@ { | ||
| transform: (node) => { | ||
| assertIsNode16(node, "definedTypeNode"); | ||
| assertIsNode(node, "definedTypeNode"); | ||
| if ("delete" in updates) { | ||
@@ -1275,5 +1026,5 @@ return null; | ||
| let newType = node.type; | ||
| if (isNode9(node.type, "structTypeNode")) { | ||
| if (isNode(node.type, "structTypeNode")) { | ||
| newType = renameStructNode(node.type, dataUpdates ?? {}); | ||
| } else if (isNode9(node.type, "enumTypeNode")) { | ||
| } else if (isNode(node.type, "enumTypeNode")) { | ||
| newType = renameEnumNode(node.type, dataUpdates ?? {}); | ||
@@ -1294,4 +1045,4 @@ } | ||
| transform: (node) => { | ||
| assertIsNode16(node, "definedTypeLinkNode"); | ||
| return definedTypeLinkNode2(newName); | ||
| assertIsNode(node, "definedTypeLinkNode"); | ||
| return definedTypeLinkNode(newName); | ||
| } | ||
@@ -1304,8 +1055,4 @@ }); | ||
| } | ||
| // src/updateErrorsVisitor.ts | ||
| import { assertIsNode as assertIsNode17, errorNode } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor13 } from "@codama/visitors-core"; | ||
| function updateErrorsVisitor(map) { | ||
| return bottomUpTransformerVisitor13( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).map( | ||
@@ -1315,3 +1062,3 @@ ([name, updates]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode17(node, "errorNode"); | ||
| assertIsNode(node, "errorNode"); | ||
| if ("delete" in updates) return null; | ||
@@ -1324,23 +1071,5 @@ return errorNode({ ...node, ...updates }); | ||
| } | ||
| // src/updateInstructionsVisitor.ts | ||
| import { | ||
| assertIsNode as assertIsNode18, | ||
| instructionAccountNode, | ||
| instructionArgumentNode as instructionArgumentNode5, | ||
| instructionNode as instructionNode6, | ||
| TYPE_NODES as TYPE_NODES2 | ||
| } from "@codama/nodes"; | ||
| import { | ||
| bottomUpTransformerVisitor as bottomUpTransformerVisitor14, | ||
| LinkableDictionary as LinkableDictionary8, | ||
| NodeStack as NodeStack5, | ||
| pipe as pipe10, | ||
| recordLinkablesOnFirstVisitVisitor as recordLinkablesOnFirstVisitVisitor6, | ||
| recordNodeStackVisitor as recordNodeStackVisitor4, | ||
| visit as visit9 | ||
| } from "@codama/visitors-core"; | ||
| function updateInstructionsVisitor(map) { | ||
| const linkables = new LinkableDictionary8(); | ||
| const stack = new NodeStack5(); | ||
| const linkables = new LinkableDictionary(); | ||
| const stack = new NodeStack(); | ||
| const transformers = Object.entries(map).map( | ||
@@ -1350,3 +1079,3 @@ ([selector, updates]) => ({ | ||
| transform: (node) => { | ||
| assertIsNode18(node, "instructionNode"); | ||
| assertIsNode(node, "instructionNode"); | ||
| if ("delete" in updates) { | ||
@@ -1361,3 +1090,3 @@ return null; | ||
| ); | ||
| return instructionNode6({ | ||
| return instructionNode({ | ||
| ...node, | ||
@@ -1372,6 +1101,6 @@ ...metadataUpdates, | ||
| ); | ||
| return pipe10( | ||
| bottomUpTransformerVisitor14(transformers), | ||
| (v) => recordNodeStackVisitor4(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor6(v, linkables) | ||
| return pipe( | ||
| bottomUpTransformerVisitor(transformers), | ||
| (v) => recordNodeStackVisitor(v, stack), | ||
| (v) => recordLinkablesOnFirstVisitVisitor(v, linkables) | ||
| ); | ||
@@ -1391,3 +1120,3 @@ } | ||
| ...acountWithoutDefault, | ||
| defaultValue: visit9(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| defaultValue: visit(defaultValue, fillDefaultPdaSeedValuesVisitor(instructionPath, linkables)) | ||
| }); | ||
@@ -1401,3 +1130,3 @@ } | ||
| usedArguments.add(node.name); | ||
| return instructionArgumentNode5({ | ||
| return instructionArgumentNode({ | ||
| ...node, | ||
@@ -1416,3 +1145,3 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| usedArguments.add(node.name); | ||
| return instructionArgumentNode5({ | ||
| return instructionArgumentNode({ | ||
| ...node, | ||
@@ -1430,4 +1159,4 @@ defaultValue: argUpdate.defaultValue ?? node.defaultValue, | ||
| const { type } = argUpdate; | ||
| assertIsNode18(type, TYPE_NODES2); | ||
| return instructionArgumentNode5({ | ||
| assertIsNode(type, TYPE_NODES); | ||
| return instructionArgumentNode({ | ||
| defaultValue: argUpdate.defaultValue ?? void 0, | ||
@@ -1443,10 +1172,6 @@ defaultValueStrategy: argUpdate.defaultValueStrategy ?? void 0, | ||
| } | ||
| // src/updateProgramsVisitor.ts | ||
| import { assertIsNode as assertIsNode19, camelCase as camelCase10, programLinkNode, programNode as programNode5 } from "@codama/nodes"; | ||
| import { bottomUpTransformerVisitor as bottomUpTransformerVisitor15 } from "@codama/visitors-core"; | ||
| function updateProgramsVisitor(map) { | ||
| return bottomUpTransformerVisitor15( | ||
| return bottomUpTransformerVisitor( | ||
| Object.entries(map).flatMap(([name, updates]) => { | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase10(updates.name) : void 0; | ||
| const newName = typeof updates === "object" && "name" in updates && updates.name ? camelCase(updates.name) : void 0; | ||
| const transformers = [ | ||
@@ -1456,5 +1181,5 @@ { | ||
| transform: (node) => { | ||
| assertIsNode19(node, "programNode"); | ||
| assertIsNode(node, "programNode"); | ||
| if ("delete" in updates) return null; | ||
| return programNode5({ ...node, ...updates }); | ||
| return programNode({ ...node, ...updates }); | ||
| } | ||
@@ -1467,3 +1192,3 @@ } | ||
| transform: (node) => { | ||
| assertIsNode19(node, "programLinkNode"); | ||
| assertIsNode(node, "programLinkNode"); | ||
| return programLinkNode(newName); | ||
@@ -1477,31 +1202,5 @@ } | ||
| } | ||
| export { | ||
| addPdasVisitor, | ||
| createSubInstructionsFromEnumArgsVisitor, | ||
| deduplicateIdenticalDefinedTypesVisitor, | ||
| fillDefaultPdaSeedValuesVisitor, | ||
| flattenInstructionArguments, | ||
| flattenInstructionDataArgumentsVisitor, | ||
| flattenStruct, | ||
| flattenStructVisitor, | ||
| getCommonInstructionAccountDefaultRules, | ||
| getDefinedTypeHistogramVisitor, | ||
| setAccountDiscriminatorFromFieldVisitor, | ||
| setFixedAccountSizesVisitor, | ||
| setInstructionAccountDefaultValuesVisitor, | ||
| setInstructionDiscriminatorsVisitor, | ||
| setNumberWrappersVisitor, | ||
| setStructDefaultValuesVisitor, | ||
| transformDefinedTypesIntoAccountsVisitor, | ||
| transformU8ArraysToBytesVisitor, | ||
| unwrapDefinedTypesVisitor, | ||
| unwrapInstructionArgsDefinedTypesVisitor, | ||
| unwrapTupleEnumWithSingleStructVisitor, | ||
| unwrapTypeDefinedLinksVisitor, | ||
| updateAccountsVisitor, | ||
| updateDefinedTypesVisitor, | ||
| updateErrorsVisitor, | ||
| updateInstructionsVisitor, | ||
| updateProgramsVisitor | ||
| }; | ||
| export { addPdasVisitor, createSubInstructionsFromEnumArgsVisitor, deduplicateIdenticalDefinedTypesVisitor, fillDefaultPdaSeedValuesVisitor, flattenInstructionArguments, flattenInstructionDataArgumentsVisitor, flattenStruct, flattenStructVisitor, getCommonInstructionAccountDefaultRules, getDefinedTypeHistogramVisitor, setAccountDiscriminatorFromFieldVisitor, setFixedAccountSizesVisitor, setInstructionAccountDefaultValuesVisitor, setInstructionDiscriminatorsVisitor, setNumberWrappersVisitor, setStructDefaultValuesVisitor, transformDefinedTypesIntoAccountsVisitor, transformU8ArraysToBytesVisitor, unwrapDefinedTypesVisitor, unwrapInstructionArgsDefinedTypesVisitor, unwrapTupleEnumWithSingleStructVisitor, unwrapTypeDefinedLinksVisitor, updateAccountsVisitor, updateDefinedTypesVisitor, updateErrorsVisitor, updateInstructionsVisitor, updateProgramsVisitor }; | ||
| //# sourceMappingURL=index.react-native.mjs.map | ||
| //# sourceMappingURL=index.react-native.mjs.map |
+4
-4
| { | ||
| "name": "@codama/visitors", | ||
| "version": "1.4.3", | ||
| "version": "1.4.4", | ||
| "description": "All visitors for the Codama framework", | ||
@@ -38,5 +38,5 @@ "exports": { | ||
| "dependencies": { | ||
| "@codama/errors": "1.4.3", | ||
| "@codama/visitors-core": "1.4.3", | ||
| "@codama/nodes": "1.4.3" | ||
| "@codama/nodes": "1.4.4", | ||
| "@codama/errors": "1.4.4", | ||
| "@codama/visitors-core": "1.4.4" | ||
| }, | ||
@@ -43,0 +43,0 @@ "license": "MIT", |
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
No alert changes
Worsened metrics
- Total package byte prevSize
944359
-0.23%- Lines of code
6224
-14.14%Dependency changes
+ Added
@codama/errors@1.4.4(transitive)+ Added
@codama/node-types@1.4.4(transitive)+ Added
@codama/nodes@1.4.4(transitive)+ Added
@codama/visitors-core@1.4.4(transitive)- Removed
@codama/errors@1.4.3(transitive)- Removed
@codama/node-types@1.4.3(transitive)- Removed
@codama/nodes@1.4.3(transitive)- Removed
@codama/visitors-core@1.4.3(transitive)Updated
@codama/errors@1.4.4Updated
@codama/nodes@1.4.4Updated
@codama/visitors-core@1.4.4