ecmarkup/lib/Algorithm.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const Builder_1 = require("./Builder");
const utils_1 = require("./utils");
const utils_2 = require("./lint/utils");
const emd = require("ecmarkdown");
function findLabeledSteps(root) {
    const steps = [];
    emd.visit(root, {
        enter(node) {
            if (node.name === 'ordered-list-item' && node.id != null) {
                steps.push(node);
            }
        },
    });
    return steps;
}
/*@internal*/
class Algorithm extends Builder_1.default {
    static enter(context) {
        return __awaiter(this, void 0, void 0, function* () {
            context.inAlg = true;
            const { spec, node, clauseStack } = context;
            const innerHTML = node.innerHTML; // TODO use original slice, forward this from linter
            let emdTree;
            if ('ecmarkdownTree' in node) {
                emdTree = node.ecmarkdownTree;
            }
            else {
                try {
                    emdTree = emd.parseAlgorithm(innerHTML);
                }
                catch (e) {
                    utils_1.warnEmdFailure(spec.warn, node, e);
                }
            }
            if (emdTree == null) {
                node.innerHTML = utils_1.wrapEmdFailure(innerHTML);
                return;
            }
            if (spec.opts.lintSpec && spec.locate(node) != null && !node.hasAttribute('example')) {
                const clause = clauseStack[clauseStack.length - 1];
                const namespace = clause ? clause.namespace : spec.namespace;
                const nonterminals = utils_2.collectNonterminalsFromEmd(emdTree).map(({ name, loc }) => ({
                    name,
                    loc,
                    node,
                    namespace,
                }));
                spec._ntStringRefs = spec._ntStringRefs.concat(nonterminals);
            }
            const rawHtml = emd.emit(emdTree);
            // replace spaces after !/? with   to prevent bad line breaking
            const html = rawHtml.replace(/((?:\s+|>)[!?])\s+(\w+\s*\()/g, '$1 $2');
            node.innerHTML = html;
            const labeledStepEntries = [];
            const replaces = node.getAttribute('replaces-step');
            if (replaces) {
                context.spec.replacementAlgorithms.push({
                    element: node,
                    target: replaces,
                });
                context.spec.replacementAlgorithmToContainedLabeledStepEntries.set(node, labeledStepEntries);
            }
            if (replaces && node.firstElementChild.children.length > 1) {
                const labeledSteps = findLabeledSteps(emdTree);
                for (const step of labeledSteps) {
                    const itemSource = innerHTML.slice(step.location.start.offset, step.location.end.offset);
                    const offset = itemSource.match(/^\s*\d+\. \[id="/)[0].length;
                    spec.warn({
                        type: 'contents',
                        ruleId: 'labeled-step-in-replacement',
                        message: 'labeling a step in a replacement algorithm which has multiple top-level steps is unsupported because the resulting step number would be ambiguous',
                        node,
                        nodeRelativeLine: step.location.start.line,
                        nodeRelativeColumn: step.location.start.column + offset,
                    });
                }
            }
            for (const step of node.querySelectorAll('li[id]')) {
                const entry = {
                    type: 'step',
                    id: step.id,
                    stepNumbers: getStepNumbers(step),
                };
                context.spec.biblio.add(entry);
                if (replaces) {
                    // The biblio entries for labeled steps in replacement algorithms will be modified in-place by a subsequent pass
                    labeledStepEntries.push(entry);
                    context.spec.labeledStepsToBeRectified.add(step.id);
                }
            }
        });
    }
    static exit(context) {
        context.inAlg = false;
    }
}
exports.default = Algorithm;
Algorithm.elements = ['EMU-ALG'];
function getStepNumbers(item) {
    var _a;
    const { indexOf } = Array.prototype;
    const counts = [];
    while (((_a = item.parentElement) === null || _a === void 0 ? void 0 : _a.tagName) === 'OL') {
        counts.unshift(1 + indexOf.call(item.parentElement.children, item));
        item = item.parentElement.parentElement;
    }
    return counts;
}