Function visitNode

question-servers/freeform.js:384–461

(node)

        const questionElements = new Set([..._.keys(coreElementsCache), ..._.keys(context.course_elements)]);

        const visitNode = async (node) => {
            if (node.tagName && questionElements.has(node.tagName)) {
                const elementName = node.tagName;
                const elementFile = module.exports.getElementController(elementName, context);
                if (phase === 'render' && !_.includes(renderedElementNames, elementName)) {
                    renderedElementNames.push(elementName);
                }
                // We need to wrap it in another node, since only child nodes
                // are serialized
                const serializedNode = parse5.serialize({
                    childNodes: [node],
                });
                let ret_val, consoleLog;
                try {
                    [ret_val, consoleLog] = await module.exports.elementFunction(pc, phase, elementName, serializedNode, data, context);
                } catch (e) {
                    const courseIssue = new Error(`${elementFile}: Error calling ${phase}(): ${e.toString()}`);
                    courseIssue.data = e.data;
                    courseIssue.fatal = true;
                    // We'll catch this and add it to the course issues list
                    throw courseIssue;
                }
                if (_.isString(consoleLog) && consoleLog.length > 0) {
                    const courseIssue = new Error(`${elementFile}: output logged on console during ${phase}()`);
                    courseIssue.data = { outputBoth: consoleLog };
                    courseIssue.fatal = false;
                    courseIssues.push(courseIssue);
                }
                if (phase == 'render') {
                    if (!_.isString(ret_val)) {
                        const courseIssue = new Error(`${elementFile}: Error calling ${phase}(): return value is not a string`);
                        courseIssue.data = { ret_val };
                        courseIssue.fatal = true;
                        throw courseIssue;
                    }
                    node = parse5.parseFragment(ret_val);
                } else if (phase == 'file') {
                    // Convert ret_val from base64 back to buffer (this always works,
                    // whether or not ret_val is valid base64)
                    const buf = Buffer.from(ret_val, 'base64');
                    // If the buffer has non-zero length...
                    if (buf.length > 0) {
                        if (fileData.length > 0) {
                            // If fileData already has non-zero length, throw an error
                            const courseIssue = new Error(`${elementFile}: Error calling ${phase}(): attempting to overwrite non-empty fileData`);
                            courseIssue.fatal = true;
                            throw courseIssue;
                        } else {
                            // If not, replace fileData with buffer
                            fileData = buf;
                        }
                    }
                } else {
                    // the following line is safe because we can't be in multiple copies of this function simultaneously
                    data = ret_val; // eslint-disable-line require-atomic-updates
                    const checkErr = module.exports.checkData(data, origData, phase);
                    if (checkErr) {
                        const courseIssue = new Error(`${elementFile}: Invalid state after ${phase}(): ${checkErr}`);