ecmarkup/lib/Eqn.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 emd = require("ecmarkdown");
const utils = require("./utils");
/*@internal*/
class Eqn extends Builder_1.default {
    // @ts-ignore
    constructor() {
        throw new Error('not actually constructible');
    }
    static enter(context) {
        return __awaiter(this, void 0, void 0, function* () {
            const { spec, node, clauseStack } = context;
            const aoid = node.getAttribute('aoid');
            if (aoid) {
                const existing = spec.biblio.keysForNamespace(spec.namespace);
                if (existing.has(aoid)) {
                    spec.warn({
                        type: 'attr-value',
                        attr: 'aoid',
                        node,
                        ruleId: 'duplicate-definition',
                        message: `duplicate definition ${JSON.stringify(aoid)}`,
                    });
                }
                const id = node.getAttribute('id');
                if (id) {
                    spec.biblio.add({
                        type: 'op',
                        aoid,
                        id,
                    });
                }
                else {
                    const clause = clauseStack[clauseStack.length - 1];
                    const clauseId = clause ? clause.id : ''; // TODO: no eqns outside of clauses, eh?
                    spec.biblio.add({
                        type: 'op',
                        aoid,
                        refId: clauseId,
                    });
                }
            }
            let contents;
            try {
                contents = emd.fragment(node.innerHTML);
            }
            catch (e) {
                utils.warnEmdFailure(spec.warn, node, e);
                node.innerHTML = utils.wrapEmdFailure(node.innerHTML);
                return;
            }
            if (utils.shouldInline(node)) {
                const classString = node.getAttribute('class');
                let classes;
                if (classString) {
                    classes = classString.split(' ');
                }
                else {
                    classes = [];
                }
                if (classes.indexOf('inline') === -1) {
                    node.setAttribute('class', classes.concat(['inline']).join(' '));
                }
            }
            else {
                contents =
                    '<div>' +
                        contents
                            .split(/\r?\n/g)
                            .filter(s => s.trim().length > 0)
                            .join('</div><div>') +
                        '</div>';
            }
            node.innerHTML = contents;
        });
    }
}
exports.default = Eqn;
Eqn.elements = ['EMU-EQN'];