@nasa-jpl/aerie-sequence-languages 0.0.1

package/dist/esm/converters/satf-sasf-utils.js

@@ -0,0 +1,927 @@
+import { getBalancedDuration, getDurationTimeComponents, parseDurationString, validateTime, TimeTypes, } from '@nasa-jpl/aerie-time-utils';
+import { removeEscapedQuotes, removeQuote, unquoteUnescape } from '../utils/string';
+import { SatfLanguage } from '../languages/satf/grammar/satf-sasf.js';
+import { SATF_SASF_NODES } from '../languages/satf/constants/satf-sasf-constants.js';
+import { SeqnParser } from '../languages/seq-n/seq-n';
+import { SEQN_NODES } from '../languages/seq-n/seqn-grammar-constants';
+/**
+ * Asynchronously converts a parsed SeqN tree via lezer into a structured SATF representation.
+ *
+ * Parse different sections (metadata, variables, steps) of the SeqN tree and
+ * assemble them into a `ParsedSatf` object containing the corresponding SATF sections.
+ *
+ * @async
+ * @param {string} sequence - The original SeqN source text corresponding to the `seqnTree`.
+ * @param {string[]} [globalVariables] - Optional. A list of predefined global variable names to be used
+ * @param {CommandDictionary} [commandDictionary] - Optional. A dictionary containing command definitions.
+ * @returns {Promise<ParsedSatf>} A Promise that resolves to an object containing the generated
+ * SATF `header`, `parameters , `variables`, and `steps` block strings (or undefined if a section is empty/not generated).
+ */
+export async function seqnToSATF(seqn, globalVariables, commandDictionary) {
+    const seqnTree = SeqnParser.parse(seqn);
+    const header = parseHeaderfromSeqn(seqnTree, seqn);
+    const parameters = satfVariablesFromSeqn(seqnTree, seqn);
+    const variables = satfVariablesFromSeqn(seqnTree, seqn, 'Variables');
+    const steps = satfStepsFromSeqn(seqnTree, seqn, [...(globalVariables ? globalVariables : []), ...getSatfVariableNames(seqnTree, seqn)], commandDictionary);
+    return {
+        header,
+        ...(parameters ? { parameters } : {}),
+        ...(variables ? { variables } : {}),
+        ...(steps ? { steps } : {}),
+    };
+}
+/**
+ * Asynchronously converts a parsed SeqN tree via lezer into a structured SASF representation.
+ *
+ * Parse the metadata section and generate SASF request blocks from the SeqN tree.
+ * It then combines these into a `ParsedSasf` object.
+ *
+ * @async
+ * @param {string} sequence - The original SeqN source text corresponding to the `seqnTree`.
+ * @param {string[]} [globalVariables] - Optional. A list of predefined global variable names to be used
+ *
+ * @param {CommandDictionary} [commandDictionary] - Optional. A dictionary containing command definitions,
+ * @returns {Promise<ParsedSasf>} A Promise that resolves to an object containing the generated
+ * SASF `metadata` string and the concatenated `requests` string (or undefined if a section is empty/not generated).
+ */
+export async function seqnToSASF(seqn, globalVariables, commandDictionary) {
+    const seqnTree = SeqnParser.parse(seqn);
+    const header = parseHeaderfromSeqn(seqnTree, seqn);
+    // TODO: I don't think sasf have varaibles or parameters:
+    // const parameters = satfVariablesFromSeqn(seqnTree, seqn);
+    // const variables = satfVariablesFromSeqn(seqnTree, seqn, 'Variables');
+    const requests = sasfRequestFromSeqN(seqnTree, seqn, globalVariables, commandDictionary);
+    return {
+        header,
+        requests,
+    };
+}
+function parseHeaderfromSeqn(seqnTree, sequence) {
+    const metadata = {};
+    const metadataEntries = seqnTree.topNode.getChild(SEQN_NODES.METADATA)?.getChildren(SEQN_NODES.METADATA_ENTRY) ?? [];
+    for (const entry of metadataEntries) {
+        const keyNode = entry.getChild(SEQN_NODES.KEY);
+        const valueNode = entry.getChild(SEQN_NODES.VALUE);
+        if (keyNode === null || valueNode === null) {
+            continue;
+        }
+        const key = unquoteUnescape(sequence.slice(keyNode.from, keyNode.to));
+        const value = sequence.slice(valueNode.from, valueNode.to);
+        metadata[key] = value;
+    }
+    let commentMetadata = seqnTree.topNode.getChildren(SEQN_NODES.LINE_COMMENT);
+    if (commentMetadata.length === 0) {
+        commentMetadata = seqnTree.topNode.getChild(SEQN_NODES.COMMANDS)?.getChildren(SEQN_NODES.LINE_COMMENT) ?? [];
+    }
+    for (const comment of commentMetadata) {
+        const text = sequence.slice(comment.from, comment.to);
+        const [key, value] = text.split('=').map(unquoteUnescape);
+        if (key && value) {
+            metadata[key.slice(1).trim()] = value;
+        }
+    }
+    return metadata;
+}
+function satfStepsFromSeqn(seqnTree, sequence, variables, commandDictionary) {
+    let stepNode = seqnTree.topNode.getChild(SATF_SASF_NODES.COMMANDS)?.firstChild;
+    let steps = [];
+    while (stepNode) {
+        steps.push(stepNode);
+        stepNode = stepNode.nextSibling;
+    }
+    steps = steps.filter((step) => step.name !== SATF_SASF_NODES.LINE_COMMENT);
+    if (steps === null || steps.length === 0) {
+        return undefined;
+    }
+    return `STEPS,\n${steps
+        .map((step, index) => {
+        return parseSeqNStep(step, sequence, commandDictionary, variables, 1 + index++);
+    })
+        .filter((step) => step)
+        .join('\n')}\nend`;
+}
+function parseSeqNStep(child, text, commandDictionary, variables, order) {
+    switch (child?.name) {
+        case SEQN_NODES.COMMAND:
+            return parseSeqNCommand(child, text, commandDictionary, variables, order);
+        case SEQN_NODES.ACTIVATE:
+            return parseSeqNActivate(child, text, commandDictionary, variables, order);
+        case 'Load':
+        case 'GroundBlock':
+        case 'GroundEvent':
+        default:
+            return undefined;
+    }
+}
+function parseSeqNCommand(commandNode, sequence, commandDictionary, variables, order) {
+    const time = parseSeqNTime(commandNode, sequence);
+    const stemNode = commandNode.getChild(SEQN_NODES.STEM);
+    const stem = stemNode ? sequence.slice(stemNode.from, stemNode.to) : 'UNKNOWN';
+    const argsNode = commandNode.getChild(SEQN_NODES.ARGS);
+    const args = argsNode ? parseSeqNArgs(argsNode, sequence, commandDictionary, variables, stem) : [];
+    const description = parseSeqNDescription(commandNode, sequence);
+    const metadata = parsSeqNMetadata(commandNode, sequence, [SEQN_NODES.NTEXT]);
+    const models = parseSeqNModel(commandNode, sequence);
+    return (`${'\t'}command(${order},` +
+        `\n${'\t'.repeat(2)}SCHEDULED_TIME,\\${time.tag}\\,${time.type},` +
+        `${metadata ? `\n${'\t'.repeat(2)}${metadata},` : ''}` +
+        `${description ? `\n${'\t'.repeat(2)}COMMENT,\\${description}\\,` : ''}` +
+        `${models ? `\n${'\t'.repeat(2)}ASSUMED_MODEL_VALUES,\\${models}\\,` : ''}` +
+        `\n${'\t'.repeat(2)}${stem}${args.length !== 0 ? `(${serializeSeqNArgs(args)})` : ''}` +
+        `\n${'\t'}),`);
+}
+function parseSeqNActivate(stepNode, sequence, commandDictionary, variables, order) {
+    const nameNode = stepNode.getChild(SEQN_NODES.SEQUENCE_NAME);
+    const sequenceName = nameNode ? unquoteUnescape(sequence.slice(nameNode.from, nameNode.to)) : 'UNKNOWN';
+    const time = parseSeqNTime(stepNode, sequence);
+    const argsNode = stepNode.getChild(SEQN_NODES.ARGS);
+    const args = argsNode ? parseSeqNArgs(argsNode, sequence, commandDictionary, variables, sequenceName) : [];
+    const engine = parseSeqNEngine(stepNode, sequence);
+    const epoch = parseSeqNEpoch(stepNode, sequence);
+    return `${'\t'}SPAWN(${order},
+  ${'\t'.repeat(2)}SCHEDULED_TIME,\\${time.tag}\\,${time.type},${engine !== undefined
+        ? `
+  ${'\t'.repeat(2)}RETURN_ENGINE_ID_TO,\\${engine}\\,`
+        : ''}${epoch !== undefined
+        ? `
+  ${'\t'.repeat(2)}EPOCH,${epoch},`
+        : ''}
+  ${'\t'.repeat(2)}RT_on_board_block(${sequenceName},${serializeSeqNArgs(args)})
+  ${'\t'}),`;
+}
+function parseSeqNEngine(stepNode, text) {
+    const engineNode = stepNode.getChild(SATF_SASF_NODES.ENGINE)?.getChild(SATF_SASF_NODES.NUMBER);
+    return engineNode ? parseInt(text.slice(engineNode.from, engineNode.to), 10) : undefined;
+}
+function parseSeqNEpoch(stepNode, text) {
+    const epochNode = stepNode.getChild(SATF_SASF_NODES.EPOCH)?.getChild(SATF_SASF_NODES.STRING);
+    return epochNode ? unquoteUnescape(text.slice(epochNode.from, epochNode.to)) : undefined;
+}
+function parseSeqNTime(commandNode, sequence) {
+    const tag = '00:00:01';
+    const timeTagNode = commandNode.getChild('TimeTag');
+    if (timeTagNode === null) {
+        return { tag: '00:00:00', type: 'UNKNOWN' };
+    }
+    const time = timeTagNode.firstChild;
+    if (time === null) {
+        return { tag, type: 'UNKNOWN' };
+    }
+    const timeValue = sequence.slice(time.from + 1, time.to).trim();
+    if (time.name === 'TimeComplete') {
+        return { tag, type: 'WAIT_PREVIOUS_END' };
+    }
+    else if (time.name === 'TimeGroundEpoch') {
+        const parentNode = time.parent;
+        if (parentNode) {
+            // ex: G+3:00 "GroundEpochName"
+            const parentNodeText = sequence.slice(parentNode.from, parentNode.to);
+            const splitParentNodeText = parentNodeText.slice(1, parentNodeText.length).split(' ');
+            if (splitParentNodeText.length > 0) {
+                const epochTag = splitParentNodeText[0];
+                const epochName = unquoteUnescape(splitParentNodeText[1]);
+                return { tag: `${epochName}${epochTag}`, type: 'GROUND_EPOCH' };
+            }
+        }
+    }
+    else {
+        if (validateTime(timeValue, TimeTypes.ISO_ORDINAL_TIME)) {
+            return { tag: timeValue, type: 'ABSOLUTE' };
+        }
+        else if (validateTime(timeValue, TimeTypes.DOY_TIME)) {
+            const { isNegative, days, hours, minutes, seconds, milliseconds } = getDurationTimeComponents(parseDurationString(timeValue, 'seconds'));
+            const signed = timeValue.charAt(0) === '-' || timeValue.charAt(0) === '+';
+            return {
+                tag: `${isNegative}${days}${hours}:${minutes}:${seconds}${milliseconds}`,
+                type: signed ? 'EPOCH' : 'FROM_PREVIOUS_START',
+            };
+        }
+        else if (validateTime(timeValue, TimeTypes.SECOND_TIME)) {
+            const signed = timeValue.charAt(0) === '-' || timeValue.charAt(0) === '+';
+            let balancedTime = getBalancedDuration(timeValue);
+            if (parseDurationString(balancedTime, 'seconds').milliseconds === 0) {
+                balancedTime = balancedTime.slice(0, -4);
+            }
+            return { tag: balancedTime, type: signed ? 'EPOCH' : 'FROM_PREVIOUS_START' };
+        }
+    }
+    return { tag, type: 'UNKNOWN' };
+}
+function parseSeqNDescription(node, text) {
+    const descriptionNode = node.getChild(SEQN_NODES.LINE_COMMENT);
+    if (!descriptionNode) {
+        return undefined;
+    }
+    // +1 offset to drop '#' prefix
+    const description = text.slice(descriptionNode.from + 1, descriptionNode.to).trim();
+    return removeEscapedQuotes(description);
+}
+function parseSeqNArgs(argsNode, sequence, commandDictionary, variables, stem) {
+    const args = [];
+    let argNode = argsNode.firstChild;
+    const dictArguments = commandDictionary?.fswCommandMap[stem]?.arguments ?? [];
+    let i = 0;
+    while (argNode) {
+        const dictionaryArg = dictArguments[i] ?? null;
+        const arg = parseSeqNArg(argNode, sequence, dictionaryArg, variables);
+        if (arg !== undefined) {
+            args.push(arg);
+        }
+        argNode = argNode?.nextSibling;
+        i++;
+    }
+    return args;
+}
+function parseSeqNArg(argNode, sequence, dictionaryArg, variables) {
+    const nodeValue = sequence.slice(argNode.from, argNode.to);
+    if (variables.includes(nodeValue)) {
+        return {
+            name: undefined,
+            type: 'string',
+            value: `"${nodeValue}"`,
+        };
+    }
+    switch (argNode.name) {
+        case SEQN_NODES.BOOLEAN: {
+            return {
+                name: dictionaryArg ? dictionaryArg.name : undefined,
+                type: 'boolean',
+                value: nodeValue === 'true' ? 'TRUE' : 'FALSE',
+            };
+        }
+        case SEQN_NODES.ENUM: {
+            return {
+                name: dictionaryArg ? dictionaryArg.name : undefined,
+                type: 'enum',
+                value: nodeValue,
+            };
+        }
+        case SEQN_NODES.NUMBER: {
+            const decimalCount = nodeValue.slice(nodeValue.indexOf('.') + 1).length;
+            return {
+                name: dictionaryArg ? dictionaryArg.name : undefined,
+                type: 'number',
+                value: parseFloat(nodeValue).toFixed(decimalCount),
+            };
+        }
+        case SEQN_NODES.STRING: {
+            return {
+                name: dictionaryArg ? dictionaryArg.name : undefined,
+                type: 'string',
+                value: nodeValue,
+            };
+        }
+        default: {
+            break;
+        }
+    }
+}
+function serializeSeqNArgs(args) {
+    return args
+        .map(arg => {
+        return `${arg.value}`;
+    })
+        .join(', ');
+}
+function getSatfVariableNames(seqnTree, text) {
+    let types = [SEQN_NODES.PARAMETER_DECLARATION, SEQN_NODES.LOCAL_DECLARATION];
+    let names = [];
+    for (let i = 0; i < types.length; i++) {
+        let variableContainer = seqnTree.topNode.getChild(types[i]);
+        if (!variableContainer) {
+            continue;
+        }
+        const variables = variableContainer.getChildren(SEQN_NODES.VARIABLE);
+        if (!variables || variables.length === 0) {
+            continue;
+        }
+        variables.forEach((variableNode) => {
+            const nameNode = variableNode.getChild(SEQN_NODES.ENUM);
+            if (nameNode) {
+                names.push(text.slice(nameNode.from, nameNode.to));
+            }
+        });
+    }
+    return names;
+}
+function satfVariablesFromSeqn(seqnTree, text, type = 'Parameters') {
+    let nType = 'ParameterDeclaration';
+    if (type === 'Variables') {
+        nType = 'LocalDeclaration';
+    }
+    const variableContainer = seqnTree.topNode.getChild(nType);
+    if (!variableContainer) {
+        return undefined;
+    }
+    const variables = variableContainer.getChildren(SEQN_NODES.VARIABLE);
+    if (!variables || variables.length === 0) {
+        return undefined;
+    }
+    const serializedVariables = variables
+        .map((variableNode) => {
+        const nameNode = variableNode.getChild(SEQN_NODES.ENUM);
+        const typeNode = variableNode.getChild(SEQN_NODES.TYPE);
+        const enumNode = variableNode.getChild(SEQN_NODES.ENUM_NAME);
+        const rangeNode = variableNode.getChild(SEQN_NODES.RANGE);
+        const allowableValuesNode = variableNode.getChild(SEQN_NODES.VALUES);
+        const objects = variableNode.getChildren(SEQN_NODES.OBJECT);
+        const variableText = nameNode ? text.slice(nameNode.from, nameNode.to) : 'UNKNOWN';
+        const variable = { name: variableText, type: 'INT' };
+        if (typeNode) {
+            variable.type = text.slice(typeNode.from, typeNode.to);
+            if (enumNode) {
+                variable.enum_name = text.slice(enumNode.from, enumNode.to);
+            }
+            if (rangeNode) {
+                const allowableRanges = parseAllowableRanges(text, rangeNode);
+                if (allowableRanges && allowableRanges.length > 0) {
+                    variable.allowable_ranges = allowableRanges;
+                }
+            }
+            if (allowableValuesNode) {
+                const allowableValues = parseAllowableValues(text, allowableValuesNode);
+                if (allowableValues && allowableValues.length > 0) {
+                    variable.allowable_values = allowableValues;
+                }
+            }
+            // old style for parameters and variables
+        }
+        else {
+            for (const object of objects) {
+                const properties = object.getChildren(SEQN_NODES.PROPERTY);
+                properties.forEach(property => {
+                    const propertyName = property.getChild(SEQN_NODES.PROPERTY_NAME);
+                    const propertyValue = propertyName?.nextSibling;
+                    if (!propertyName || !propertyValue) {
+                        return;
+                    }
+                    const propertyNameString = text.slice(propertyName?.from, propertyName?.to).replaceAll('"', '');
+                    const propertyValueString = text.slice(propertyValue?.from, propertyValue?.to).replaceAll('"', '');
+                    switch (propertyNameString.toLowerCase()) {
+                        case 'allowable_ranges': {
+                            if (!propertyValue) {
+                                break;
+                            }
+                            const allowableRanges = parseAllowableRanges(text, propertyValue);
+                            if (allowableRanges && allowableRanges.length > 0) {
+                                variable.allowable_ranges = allowableRanges;
+                            }
+                            break;
+                        }
+                        case 'allowable_values':
+                            {
+                                if (!propertyValue) {
+                                    break;
+                                }
+                                const allowableValues = parseAllowableValues(text, propertyValue);
+                                if (allowableValues && allowableValues.length > 0) {
+                                    variable.allowable_values = allowableValues;
+                                }
+                            }
+                            break;
+                        case 'enum_name':
+                            variable.enum_name = propertyValueString;
+                            break;
+                        case 'sc_name':
+                            variable.sc_name = propertyValueString;
+                            break;
+                        case 'type':
+                            variable.type = propertyValueString;
+                            break;
+                    }
+                });
+            }
+        }
+        //convert seqn type to satf type
+        switch (variable.type) {
+            case SEQN_NODES.VAR_UINT:
+                variable.type = SATF_SASF_NODES.PARAM_UNSIGNED_DECIMAL;
+                break;
+            case SEQN_NODES.VAR_INT:
+                variable.type = SATF_SASF_NODES.PARAM_SIGNED_DECIMAL;
+                break;
+            case SEQN_NODES.VAR_STRING:
+                variable.type = SATF_SASF_NODES.PARAM_QUOTED_STRING;
+                break;
+            case SEQN_NODES.VAR_FLOAT:
+                break;
+            case SEQN_NODES.VAR_ENUM:
+                variable.type = SATF_SASF_NODES.PARAM_STRING;
+                break;
+        }
+        return (`\t${variable.name}` +
+            `(\n\t\tTYPE,${variable.type}${variable.enum_name ? `\n\t\t\ENUM_NAME,${variable.enum_name}` : ''}` +
+            `${variable.allowable_ranges
+                ? variable.allowable_ranges
+                    .map(range => {
+                    return `\n\t\tRANGES,\\${range.min}...${range.max}\\`;
+                })
+                    .join(',')
+                : ''}` +
+            `${variable.allowable_values ? `\n\t\t\RANGES,\\${variable.allowable_values}\\` : ''}` +
+            `${variable.sc_name ? `\n\t\tSC_NAME,${variable.sc_name}` : ''}` +
+            `\n\t)`);
+    })
+        .join(',\n');
+    return `${type.toUpperCase()},\n ${serializedVariables},\nend,\n`;
+}
+function parseAllowableRanges(text, rangeNode) {
+    if (!rangeNode) {
+        return [];
+    }
+    return text
+        .slice(rangeNode.from, rangeNode.to)
+        .split(',')
+        .map(range => {
+        const rangeMatch = /^(?<min>[-+]?\d+(\.\d*)?)?(\.\.\.)(?<max>[-+]?\d+(\.\d*)?)?$/.exec(range.replaceAll('"', '').trim());
+        if (rangeMatch && rangeMatch.groups) {
+            const { min, max } = rangeMatch.groups;
+            const maxNum = !isNaN(Number(max)) ? Number(max) : Infinity;
+            const minNum = !isNaN(Number(min)) ? Number(min) : -Infinity;
+            return { max: maxNum, min: minNum };
+        }
+        return undefined;
+    })
+        .filter(range => range !== undefined);
+}
+function parseAllowableValues(text, allowableValuesNode) {
+    const allowableValues = text
+        .slice(allowableValuesNode.from + 1, allowableValuesNode.to - 1)
+        .split(',')
+        .map(value => value.trim());
+    return allowableValues.length > 0 ? allowableValues : undefined;
+}
+function sasfRequestFromSeqN(seqnTree, sequence, variables = [], commandDictionary) {
+    const requests = seqnTree.topNode.getChild(SEQN_NODES.COMMANDS)?.getChildren(SEQN_NODES.REQUEST);
+    if (requests == null || requests.length === 0) {
+        return undefined;
+    }
+    return requests
+        .map((requestNode) => {
+        const nameNode = requestNode.getChild(SEQN_NODES.REQUEST_NAME);
+        const name = nameNode ? unquoteUnescape(sequence.slice(nameNode.from, nameNode.to)) : 'UNKNOWN';
+        const parsedTime = parseSeqNTime(requestNode, sequence);
+        const requester = parsSeqNMetadata(requestNode, sequence, ['REQUESTOR']);
+        const processor = parsSeqNMetadata(requestNode, sequence, ['PROCESSOR']);
+        const key = parsSeqNMetadata(requestNode, sequence, ['KEY']);
+        const request = `request(${name},` +
+            `\n\tSTART_TIME, ${parsedTime.tag},` +
+            `${requester ? `\n\t${requester.replaceAll('\\', '\"')}` : ''},` +
+            `${processor ? `\n\t${processor.replaceAll('\\', '\"')}` : ''},` +
+            `${key ? `\n\t${key.replaceAll('\\', '\"')}` : ''})`;
+        `\n\n`;
+        let order = 1;
+        let child = requestNode?.getChild(SEQN_NODES.STEPS)?.firstChild;
+        const steps = [];
+        while (child) {
+            steps.push(`\t${parseSeqNStep(child, sequence, commandDictionary, variables, order++)?.replaceAll('\n', '\n\t')}`);
+            child = child?.nextSibling;
+        }
+        return `${request}\n${steps.join('\n')}\nend;\n`;
+    })
+        .join(',\n');
+}
+/**
+ * Parses a SATF formatted string asynchronously to extract header information and sequence data.
+ * It utilizes the SatfLanguage parser to generate SeqN parts.
+ *
+ * @async
+ * @function satfToSeqn
+ * @param {string} satf - The SATF or SASF formatted string content to parse.
+ * @param {string[]} [globalVariables] - Optional. A list of predefined global variable names to be used
+ * during the parsing of steps
+ * @returns {Promise<ParsedSequence>} A Promise that resolves to an object containing the parsed header
+ * and an array of sequence objects.
+ * If the input string does not contain a top-level SATF structure recognized by the parser,
+ * it resolves with a default empty ParsedSequence object (e.g., { header: "", sequences: [] }).
+ */
+export async function satfToSeqn(satf, globalVariables) {
+    const base = SatfLanguage.parser.parse(satf).topNode;
+    const satfNode = base.getChild(SATF_SASF_NODES.SATF);
+    if (!satfNode) {
+        return { metadata: '', sequences: [] };
+    }
+    const metadata = parseHeader(satfNode.getChild(SATF_SASF_NODES.HEADER), satf);
+    const sequences = parseBody(satfNode.getChild(SATF_SASF_NODES.BODY), globalVariables, satf);
+    return { metadata, sequences };
+}
+export async function sasfToSeqn(sasf, globalVariables) {
+    const base = SatfLanguage.parser.parse(sasf).topNode;
+    const sasfNode = base.getChild(SATF_SASF_NODES.SASF);
+    if (!sasfNode) {
+        return { metadata: '', sequences: [] };
+    }
+    const metadata = parseHeader(sasfNode.getChild(SATF_SASF_NODES.HEADER), sasf);
+    const sequences = parseBody(sasfNode.getChild(SATF_SASF_NODES.BODY), globalVariables, sasf);
+    return { metadata, sequences };
+}
+function parseHeader(headerNode, text) {
+    const header = '';
+    if (!headerNode) {
+        return header;
+    }
+    const sfduHeader = headerNode
+        .getChild(SATF_SASF_NODES.SFDU_HEADER)
+        ?.getChild(SATF_SASF_NODES.HEADER_PAIRS)
+        ?.getChildren(SATF_SASF_NODES.HEADER_PAIR) ?? [];
+    return sfduHeader
+        .map((pairNode) => {
+        const keyNode = pairNode.getChild(SATF_SASF_NODES.KEY);
+        const valueNode = pairNode.getChild(SATF_SASF_NODES.VALUE);
+        if (!keyNode || !valueNode) {
+            console.error(`Error processing header entry: ${text.slice(pairNode.from, pairNode.to)}`);
+            return '';
+        }
+        const key = text.slice(keyNode.from, keyNode.to).trim();
+        const value = text.slice(valueNode.from, valueNode.to).trim();
+        if (key.length === 0 || value.length === 0) {
+            return '';
+        }
+        return `@METADATA "${key}" "${value}"`;
+    })
+        .join('\n');
+}
+function parseBody(bodyNode, globalVariables = [], text) {
+    if (!bodyNode) {
+        return [];
+    }
+    //satf
+    if (bodyNode.getChild(SATF_SASF_NODES.ACTIVITY_TYPE_DEFINITIONS)) {
+        const activityTypeNodes = bodyNode.getChild(SATF_SASF_NODES.ACTIVITY_TYPE_DEFINITIONS)?.getChildren(SATF_SASF_NODES.ACTIVITY_TYPE_GROUP) ??
+            [];
+        return activityTypeNodes.map((group, i) => {
+            let sequenceName = 'sequence-' + i;
+            const sequenceNameNode = group.getChild(SATF_SASF_NODES.ACTIVITY_TYPE_NAME);
+            const seqGenNode = group.getChild(SATF_SASF_NODES.SEQGEN);
+            const vcNode = group.getChild(SATF_SASF_NODES.VIRTUAL_CHANNEL);
+            const onBoardFilenameNode = group.getChild(SATF_SASF_NODES.ON_BOARD_FILENAME);
+            const onBoardFilePathNode = group.getChild(SATF_SASF_NODES.ON_BOARD_PATH);
+            if (sequenceNameNode) {
+                const name = text.slice(sequenceNameNode.from, sequenceNameNode.to);
+                sequenceName = name.split('/').pop() || 'sequence-' + i;
+            }
+            const inputParameters = parseParameters(group.getChild(SATF_SASF_NODES.PARAMETERS), 'INPUT_PARAMS', text);
+            const localVariables = parseParameters(group.getChild(SATF_SASF_NODES.VARIABLES), 'LOCALS', text);
+            let metadata = '';
+            if (vcNode) {
+                metadata += `@METADATA "VIRTUAL_CHANNEL" "${text.slice(vcNode.from, vcNode.to)}"\n`;
+            }
+            if (onBoardFilenameNode) {
+                metadata += `@METADATA "ON_BOARD_FILENAME" "${text.slice(onBoardFilenameNode.from, onBoardFilenameNode.to)}"\n`;
+            }
+            if (onBoardFilePathNode) {
+                metadata += `@METADATA "ON_BOARD_PATH" "${text.slice(onBoardFilePathNode.from, onBoardFilePathNode.to)}"\n`;
+            }
+            if (seqGenNode) {
+                metadata += `@METADATA "SEQGEN" "${text.slice(seqGenNode.from, seqGenNode.to)}"\n`;
+            }
+            metadata = metadata.trimEnd();
+            const steps = parseSteps(group.getChild(SATF_SASF_NODES.STEPS), [
+                ...parseVariableName(group.getChild(SATF_SASF_NODES.PARAMETERS), text),
+                ...parseVariableName(group.getChild(SATF_SASF_NODES.VARIABLES), text),
+                ...globalVariables,
+            ], text);
+            return {
+                name: sequenceName,
+                metadata,
+                inputParameters,
+                localVariables,
+                steps,
+            };
+        });
+    }
+    //sasf
+    if (bodyNode.getChild(SATF_SASF_NODES.REQUESTS)) {
+        const requestNodes = bodyNode.getChild(SATF_SASF_NODES.REQUESTS)?.getChildren(SATF_SASF_NODES.REQUEST) ?? [];
+        return requestNodes.map((group, i) => {
+            let requests = '';
+            const requestNameNode = group.getChild(SATF_SASF_NODES.REQUEST_NAME);
+            const requestorNode = group.getChild(SATF_SASF_NODES.REQUESTOR);
+            const processorNode = group.getChild(SATF_SASF_NODES.PROCESSOR);
+            const keyNode = group.getChild(SATF_SASF_NODES.KEY);
+            const startTimeNode = group.getChild(SATF_SASF_NODES.START_TIME);
+            const sequenceName = requestNameNode ? text.slice(requestNameNode.from, requestNameNode.to) : 'sequence-' + i;
+            requests += parseTimeTagNode(startTimeNode ? startTimeNode.getChild(SATF_SASF_NODES.TIME) : null, startTimeNode ? startTimeNode.getChild(SATF_SASF_NODES.TIME_RELATION) : null, text);
+            requests += `@REQUEST_BEGIN("${sequenceName}")\n`;
+            requests += parseSteps(group.getChild(SATF_SASF_NODES.STEPS), globalVariables, text)
+                .split('\n')
+                .map(line => ' '.repeat(2) + line)
+                .join('\n');
+            requests += `\n@REQUEST_END\n`;
+            if (requestorNode) {
+                requests += `@METADATA "REQUESTOR" "${removeQuote(text.slice(requestorNode.from, requestorNode.to))}"\n`;
+            }
+            if (processorNode) {
+                requests += `@METADATA "PROCESSOR" "${removeQuote(text.slice(processorNode.from, processorNode.to))}"\n`;
+            }
+            if (keyNode) {
+                requests += `@METADATA "KEY" "${removeQuote(text.slice(keyNode.from, keyNode.to))}"\n`;
+            }
+            return { name: sequenceName, requests };
+        });
+    }
+    return [];
+}
+function parseVariableName(parameterNode, text) {
+    if (!parameterNode) {
+        return [];
+    }
+    const entries = parameterNode.getChildren(SATF_SASF_NODES.ENTRY);
+    if (!entries || entries.length == 0) {
+        return [];
+    }
+    return entries.map(param => {
+        const nameNode = param.getChild(SATF_SASF_NODES.NAME);
+        return nameNode ? `${text.slice(nameNode.from, nameNode.to)}` : '';
+    });
+}
+/** Mapping between SATF and SeqN from Taifun
+  UNSIGNED_DECIMAL -> UINT
+  SIGNED_DECIMAL -> INT
+  HEXADECIMAL -> STRING
+  OCTAL -> STRING
+  BINARY -> STRING
+  ENGINEERING -> FLOAT
+  TIME -> STRING
+  DURATION -> STRING
+  STRING -> STRING | ENUM (if enum_name is defined)
+  QUOATED_STRING -> STRING
+  NOTE: HEXADECIMAL, OCTAL, BINARY are all uint in seqgen
+ */
+function parseParameters(parameterNode, variableType, text) {
+    if (!parameterNode) {
+        return '';
+    }
+    const entries = parameterNode.getChildren(SATF_SASF_NODES.ENTRY);
+    if (entries && entries.length > 0) {
+        let parameter = `@${variableType}_BEGIN\n`;
+        parameter += entries
+            .map(param => {
+            const nameNode = param.getChild(SATF_SASF_NODES.NAME);
+            const typeNode = param.getChild(SATF_SASF_NODES.TYPE);
+            const rangesNode = param.getChildren(SATF_SASF_NODES.RANGE);
+            const enumNameNode = param.getChild(SATF_SASF_NODES.ENUM_NAME);
+            const name = nameNode ? `${text.slice(nameNode.from, nameNode.to)}` : '';
+            const enumName = enumNameNode ? ` ${text.slice(enumNameNode.from, enumNameNode.to)}` : '';
+            let type = typeNode ? text.slice(typeNode.from, typeNode.to).trim() : '';
+            switch (type) {
+                case SATF_SASF_NODES.PARAM_UNSIGNED_DECIMAL:
+                    type = SEQN_NODES.VAR_UINT;
+                    break;
+                case SATF_SASF_NODES.PARAM_SIGNED_DECIMAL:
+                    type = SEQN_NODES.VAR_INT;
+                    break;
+                case SATF_SASF_NODES.PARAM_HEXADECIMAL:
+                case SATF_SASF_NODES.PARAM_OCTAL:
+                case SATF_SASF_NODES.PARAM_BINARY:
+                case SATF_SASF_NODES.PARAM_TIME:
+                case SATF_SASF_NODES.PARAM_DURATION:
+                case SATF_SASF_NODES.PARAM_QUOTED_STRING:
+                    type = SEQN_NODES.VAR_STRING;
+                    break;
+                case SATF_SASF_NODES.PARAM_ENGINEERING:
+                    type = SEQN_NODES.VAR_FLOAT;
+                    break;
+                case SEQN_NODES.VAR_STRING:
+                    {
+                        // Always an enum matches the jpl_sequence tool
+                        //if (enumNameNode) {
+                        type = SEQN_NODES.VAR_ENUM;
+                        //} else {
+                        //  type = VAR_STRING;
+                        //}
+                    }
+                    break;
+                default:
+                    console.log(`type: ${type} is not supported`);
+            }
+            const allowableValues = [];
+            const allowableRanges = [];
+            rangesNode.forEach((range) => {
+                text
+                    .slice(range.from, range.to)
+                    .split(',')
+                    .forEach(r => {
+                    r = r.replaceAll('"', '').trim();
+                    if (r.includes('...')) {
+                        allowableRanges.push(r);
+                    }
+                    else {
+                        allowableValues.push(r);
+                    }
+                });
+            });
+            return `${name} ${type}${enumName}${allowableRanges.length === 0 ? (allowableValues.length === 0 ? '' : ' ""') : ` "${allowableRanges.join(', ')}"`}${allowableValues.length === 0 ? '' : ` "${allowableValues.join(', ')}"`}`;
+        })
+            .join('\n');
+        parameter += `\n@${variableType}_END`;
+        return parameter;
+    }
+    return '';
+}
+function parseSteps(stepNode, variableNames, text) {
+    const step = '';
+    if (!stepNode) {
+        return step;
+    }
+    const commandNodes = stepNode.getChildren(SATF_SASF_NODES.COMMAND);
+    return commandNodes
+        .map(command => {
+        const time = parseTimeNode(command.getChild(SATF_SASF_NODES.SCHEDULED_TIME), text);
+        const stem = parseStem(command.getChild(SATF_SASF_NODES.STEM), text);
+        const comment = parseComment(command.getChild(SATF_SASF_NODES.COMMENT), text);
+        const args = parseArgsNode(command.getChild(SATF_SASF_NODES.ARGS), variableNames, text);
+        const models = parseModel(command.getChild(SATF_SASF_NODES.ASSUMED_MODEL_VALUES), text);
+        const metadata = parseSatfCommandMetadata(command, text);
+        //metadata
+        return `${time}${stem}${args.length > 0 ? ` ${args}` : ''}${comment.length > 0 ? ` ${comment}` : ''}${metadata.length > 0 ? `\n${metadata}` : ''}${models.length > 0 ? `\n${models}` : ''}`;
+    })
+        .join('\n');
+}
+function parseTimeNode(timeNode, text) {
+    if (!timeNode) {
+        return 'C ';
+    }
+    const timeValueNode = timeNode.getChild(SATF_SASF_NODES.TIME);
+    const timeTagNode = timeNode.getChild(SATF_SASF_NODES.TIME_RELATION);
+    return parseTimeTagNode(timeValueNode, timeTagNode, text);
+}
+function parseTimeTagNode(timeValueNode, timeTagNode, text) {
+    if (timeValueNode && !timeTagNode) {
+        return `A${text.slice(timeValueNode.from, timeValueNode.to)} `;
+    }
+    else if (!timeValueNode || !timeTagNode) {
+        return `R00:00:00`;
+    }
+    const time = text.slice(timeValueNode.from, timeValueNode.to);
+    const timeTag = text.slice(timeTagNode.from, timeTagNode.to);
+    switch (timeTag.trim()) {
+        case 'ABSOLUTE':
+            return `A${time} `;
+        case 'EPOCH':
+            return `E${time} `;
+        case 'FROM_PREVIOUS_START':
+            return `R${time} `;
+        case 'FROM_REQUEST_START':
+        case 'FROM_ACTIVITY_START':
+            return `B${time} `;
+        case 'WAIT_PREVIOUS_END':
+            return `C `;
+        default:
+            return 'error';
+    }
+}
+function parseComment(commentNode, text) {
+    let comment = commentNode
+        ? `${text
+            .slice(commentNode.from, commentNode.to)
+            .split('\n')
+            .map(line => line.trim())
+            .join(' ')
+            .trim()}` // flatten comment to one line SeqN doesn't support multi-line comments on a command
+        : '';
+    if (comment.length === 0) {
+        return comment;
+    }
+    return `# ${removeQuote(comment)}`;
+}
+function parseStem(stemNode, text) {
+    return stemNode ? text.slice(stemNode.from, stemNode.to) : '';
+}
+function parseArgsNode(argsNode, variableNames, text) {
+    if (!argsNode) {
+        return '';
+    }
+    let argNode = argsNode.firstChild;
+    const args = [];
+    while (argNode) {
+        args.push(`${parseArgNode(argNode, variableNames, text)}`);
+        argNode = argNode?.nextSibling;
+    }
+    return args.join(' ');
+}
+function parseArgNode(argNode, variableNames, text) {
+    if (!argNode) {
+        return '';
+    }
+    const argValue = removeQuote(text.slice(argNode.from, argNode.to));
+    if (variableNames.includes(argValue)) {
+        return argValue;
+    }
+    switch (argNode.name) {
+        case SATF_SASF_NODES.STRING:
+            return `"${argValue}"`;
+        case SATF_SASF_NODES.NUMBER:
+        case SATF_SASF_NODES.BOOLEAN:
+        case SATF_SASF_NODES.ENUM:
+        case SATF_SASF_NODES.GLOBAL:
+            return `${argValue}`;
+        case SATF_SASF_NODES.ARITHMETICAL:
+            return `(${argValue})`;
+        default: {
+            console.log(`${argNode.name}: ${argValue} is not supported`);
+            return 'Error';
+        }
+    }
+}
+function parsSeqNMetadata(node, text, filter) {
+    const metadataNode = node.getChild('Metadata');
+    if (!metadataNode) {
+        return undefined;
+    }
+    const metadataEntry = metadataNode.getChildren('MetaEntry');
+    if (!metadataEntry || metadataEntry.length === 0) {
+        return undefined;
+    }
+    const obj = [];
+    metadataEntry.forEach(entry => {
+        const keyNode = entry.getChild('Key');
+        const valueNode = entry.getChild('Value');
+        if (!keyNode || !valueNode) {
+            return; // Skip this entry if either the key or value is missing
+        }
+        const keyText = unquoteUnescape(text.slice(keyNode.from, keyNode.to));
+        if (!filter.includes(keyText)) {
+            return;
+        }
+        let value = text.slice(valueNode.from, valueNode.to);
+        try {
+            value = JSON.parse(value);
+        }
+        catch (e) {
+            console.log(`Malformed metadata ${value}`);
+        }
+        obj.push(`${keyText.toUpperCase()},\\${value}\\`);
+    });
+    return obj.join(`,\n${'\t'.repeat(2)}`);
+}
+function parseSatfCommandMetadata(commandNode, text) {
+    let metadata = '';
+    if (!commandNode) {
+        return metadata;
+    }
+    const inclusionNode = commandNode.getChild(SATF_SASF_NODES.INCLUSION_CONDITION);
+    const drawNode = commandNode.getChild(SATF_SASF_NODES.DRAW);
+    const nTextNode = commandNode.getChild(SATF_SASF_NODES.NTEXT);
+    if (inclusionNode) {
+        metadata += `@METADATA "INCLUSION_CONDITION" "${removeQuote(text.slice(inclusionNode.from, inclusionNode.to))}"\n`;
+    }
+    if (drawNode) {
+        metadata += `@METADATA "DRAW" "${removeQuote(text.slice(drawNode.from, drawNode.to))}"\n`;
+    }
+    if (nTextNode) {
+        metadata += `@METADATA "NTEXT" "${removeQuote(text.slice(nTextNode.from, nTextNode.to))}"\n`;
+    }
+    return metadata.slice(0, -1);
+}
+function parseModel(modelNode, text) {
+    if (!modelNode) {
+        return '';
+    }
+    const modelsNode = modelNode.getChildren(SATF_SASF_NODES.MODEL);
+    return modelsNode
+        .map(model => {
+        const keyNode = model.getChild(SATF_SASF_NODES.KEY);
+        const valueNode = model.getChild(SATF_SASF_NODES.VALUE);
+        if (!keyNode || !valueNode) {
+            return null;
+        }
+        return `@MODEL "${text.slice(keyNode.from, keyNode.to)}" ${text.slice(valueNode.from, valueNode.to)} "00:00:00"`;
+    })
+        .filter(model => model !== null)
+        .join('\n');
+}
+function parseSeqNModel(node, text) {
+    const modelContainer = node.getChild('Models');
+    if (!modelContainer) {
+        return undefined;
+    }
+    const modelNodes = modelContainer.getChildren('Model');
+    if (!modelNodes || modelNodes.length === 0) {
+        return undefined;
+    }
+    const models = [];
+    for (const modelNode of modelNodes) {
+        const variableNode = modelNode.getChild('Variable');
+        const valueNode = modelNode.getChild('Value');
+        const variable = variableNode ? unquoteUnescape(text.slice(variableNode.from, variableNode.to)) : 'UNKNOWN';
+        // Value can be string, number or boolean
+        let value;
+        const valueChild = valueNode?.firstChild;
+        if (valueChild) {
+            const valueText = text.slice(valueChild.from, valueChild.to);
+            if (valueChild.name === 'String') {
+                value = valueText;
+            }
+            else if (valueChild.name === 'Boolean') {
+                value = !/^FALSE$/i.test(valueText);
+            }
+            else if (valueChild.name === 'Number') {
+                value = Number(valueText);
+            }
+        }
+        models.push(`${variable}=${value}`);
+    }
+    return models.join(',');
+}
+//# sourceMappingURL=satf-sasf-utils.js.map