ecmarkup/lib/utils.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 });
exports.validateEffects = exports.attrValueLocation = exports.attrLocation = exports.offsetToLineAndColumn = exports.copyFile = exports.writeFile = exports.readFile = exports.shouldInline = exports.logWarning = exports.logVerbose = exports.replaceTextNode = exports.domWalkBackward = exports.htmlToDom = exports.emdTextNode = exports.wrapEmdFailure = exports.warnEmdFailure = void 0;
const jsdom = require("jsdom");
const chalk = require("chalk");
const emd = require("ecmarkdown");
const fs = require("fs");
const path = require("path");
const utils_1 = require("./lint/utils");
function warnEmdFailure(report, node, e) {
    if (typeof e.line === 'number' && typeof e.column === 'number') {
        report({
            type: 'contents',
            ruleId: 'invalid-emd',
            message: `ecmarkdown failed to parse: ${e.message}`,
            node,
            nodeRelativeLine: e.line,
            nodeRelativeColumn: e.column,
        });
    }
    else {
        report({
            type: 'node',
            ruleId: 'invalid-emd',
            message: `ecmarkdown failed to parse: ${e.message}`,
            node,
        });
    }
}
exports.warnEmdFailure = warnEmdFailure;
function wrapEmdFailure(src) {
    return `#### ECMARKDOWN PARSE FAILED ####<pre>${src}</pre>`;
}
exports.wrapEmdFailure = wrapEmdFailure;
/*@internal*/
function emdTextNode(spec, node, namespace) {
    const loc = spec.locate(node);
    let c;
    if ((loc === null || loc === void 0 ? void 0 : loc.endTag) == null) {
        c = node.textContent.replace(/</g, '&lt;');
    }
    else {
        const start = loc.startTag.endOffset;
        const end = loc.endTag.startOffset;
        c = loc.source.slice(start, end);
    }
    let processed;
    try {
        const parts = emd.parseFragment(c);
        if (spec.opts.lintSpec && loc != null) {
            const nonterminals = utils_1.collectNonterminalsFromEmd(parts).map(({ name, loc }) => ({
                name,
                loc,
                node,
                namespace,
            }));
            spec._ntStringRefs = spec._ntStringRefs.concat(nonterminals);
        }
        processed = emd.emit(parts);
    }
    catch (e) {
        warnEmdFailure(spec.warn, node, e);
        processed = wrapEmdFailure(c);
    }
    const template = spec.doc.createElement('template');
    template.innerHTML = processed;
    replaceTextNode(node, template.content);
}
exports.emdTextNode = emdTextNode;
/*@internal*/
function htmlToDom(html) {
    return new jsdom.JSDOM(html, { includeNodeLocations: true });
}
exports.htmlToDom = htmlToDom;
/*@internal*/
function domWalkBackward(root, cb) {
    const childNodes = root.childNodes;
    const childLen = childNodes.length;
    for (let i = childLen - 1; i >= 0; i--) {
        const node = childNodes[i];
        if (node.nodeType !== 1)
            continue;
        const cont = cb(node);
        if (cont === false)
            continue;
        domWalkBackward(node, cb);
    }
}
exports.domWalkBackward = domWalkBackward;
/*@internal*/
function replaceTextNode(node, frag) {
    // Append all the nodes
    const parent = node.parentNode;
    if (!parent)
        return [];
    const newXrefNodes = Array.from(frag.querySelectorAll('EMU-XREF'));
    const first = frag.childNodes[0];
    if (first.nodeType === 3) {
        node.textContent = first.textContent;
        frag.removeChild(first);
    }
    else {
        // set it to empty because we don't want to break iteration
        // (I think it should work to delete it... investigate possible jsdom bug)
        node.textContent = '';
    }
    parent.insertBefore(frag, node.nextSibling);
    return newXrefNodes;
}
exports.replaceTextNode = replaceTextNode;
/*@internal*/
function logVerbose(str) {
    const dateString = new Date().toISOString();
    console.error(chalk.gray('[' + dateString + '] ') + str);
}
exports.logVerbose = logVerbose;
/*@internal*/
function logWarning(str) {
    const dateString = new Date().toISOString();
    console.error(chalk.gray('[' + dateString + '] ') + chalk.red(str));
}
exports.logWarning = logWarning;
/*@internal*/
function shouldInline(node) {
    let parent = node.parentNode;
    if (!parent)
        return false;
    while (parent &&
        parent.parentNode &&
        (parent.nodeName === 'EMU-GRAMMAR' ||
            parent.nodeName === 'EMU-IMPORT' ||
            parent.nodeName === 'INS' ||
            parent.nodeName === 'DEL')) {
        parent = parent.parentNode;
    }
    return (['EMU-ANNEX', 'EMU-CLAUSE', 'EMU-INTRO', 'EMU-NOTE', 'BODY'].indexOf(parent.nodeName) === -1);
}
exports.shouldInline = shouldInline;
/*@internal*/
function readFile(file) {
    return new Promise((resolve, reject) => {
        fs.readFile(file, 'utf8', (err, data) => (err ? reject(err) : resolve(data)));
    });
}
exports.readFile = readFile;
/*@internal*/
function writeFile(file, content) {
    return new Promise((resolve, reject) => {
        // we could do this async, but it's not worth worrying about
        fs.mkdirSync(path.dirname(file), { recursive: true });
        fs.writeFile(file, content, { encoding: 'utf8' }, err => (err ? reject(err) : resolve()));
    });
}
exports.writeFile = writeFile;
/*@internal*/
function copyFile(src, dest) {
    return __awaiter(this, void 0, void 0, function* () {
        const content = yield readFile(src);
        yield writeFile(dest, content);
    });
}
exports.copyFile = copyFile;
function offsetToLineAndColumn(string, offset) {
    const lines = string.split('\n');
    let line = 0;
    let seen = 0;
    while (true) {
        if (line >= lines.length) {
            throw new Error(`offset ${offset} exceeded string ${JSON.stringify(string)}`);
        }
        if (seen + lines[line].length >= offset) {
            break;
        }
        seen += lines[line].length + 1; // +1 for the '\n'
        ++line;
    }
    const column = offset - seen;
    return { line: line + 1, column: column + 1 };
}
exports.offsetToLineAndColumn = offsetToLineAndColumn;
function attrLocation(source, loc, attr) {
    const attrLoc = loc.startTag.attrs[attr];
    if (attrLoc == null) {
        return { line: loc.startTag.line, column: loc.startTag.col };
    }
    else {
        return { line: attrLoc.line, column: attrLoc.col };
    }
}
exports.attrLocation = attrLocation;
function attrValueLocation(source, loc, attr) {
    var _a, _b;
    const attrLoc = loc.startTag.attrs[attr];
    if (attrLoc == null || source == null) {
        return { line: loc.startTag.line, column: loc.startTag.col };
    }
    else {
        const tagText = source.slice(attrLoc.startOffset, attrLoc.endOffset);
        // RegExp.escape when
        const matcher = new RegExp(attr.replace(/[/\\^$*+?.()|[\]{}]/g, '\\$&') + '="?', 'i');
        return { line: attrLoc.line, column: attrLoc.col + ((_b = (_a = tagText.match(matcher)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0) };
    }
}
exports.attrValueLocation = attrValueLocation;
const KNOWN_EFFECTS = ['user-code'];
function validateEffects(spec, effectsRaw, node) {
    const effects = [];
    const unknownEffects = [];
    for (const e of effectsRaw) {
        if (KNOWN_EFFECTS.indexOf(e) !== -1) {
            effects.push(e);
        }
        else {
            unknownEffects.push(e);
        }
    }
    if (unknownEffects.length !== 0) {
        spec.warn({
            type: 'node',
            ruleId: 'unknown-effects',
            message: `unknown effects: ${unknownEffects}`,
            node,
        });
    }
    return effects;
}
exports.validateEffects = validateEffects;