xmlui 0.11.4 → 0.11.6

package/dist/scripts/src/language-server/services/format.js

@@ -1,569 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleDocumentFormatting = handleDocumentFormatting;
-exports.format = format;
-const xmlui_parser_1 = require("../../parsers/xmlui-parser");
-function handleDocumentFormatting({ node, getText, options, offsetToPosition, }) {
-    const formatted = format(node, getText, options);
-    // If content is already formatted correctly, return empty array
-    const unformattedContent = getText(node, false);
-    if (formatted === unformattedContent) {
-        return [];
-    }
-    const entireDocumentRange = {
-        start: { line: 0, character: 0 },
-        end: offsetToPosition(unformattedContent.length),
-    };
-    return [
-        {
-            range: entireDocumentRange,
-            newText: formatted,
-        },
-    ];
-}
-class XmluiFormatter {
-    constructor(node, getText, options) {
-        this.maxConsecutiveNewlines = 2;
-        this.maxLineLength = 80;
-        this.newlineToken = "\n";
-        this.getText = getText;
-        this.startingNode = node;
-        this.indentationLvl = 0;
-        this.tabSize = options.tabSize;
-        this.indentationToken = options.insertSpaces ? " ".repeat(options.tabSize) : "\t";
-        if (options.insertFinalNewline && !options.trimFinalNewlines) {
-            this.trimRespectingOptions = (formatted) => {
-                return formatted.trim() + this.newlineToken;
-            };
-        }
-        else {
-            this.trimRespectingOptions = (formatted) => {
-                return formatted.trim();
-            };
-        }
-    }
-    format() {
-        let formattedStr;
-        if (this.startingNode.kind !== xmlui_parser_1.SyntaxKind.ContentListNode) {
-            formattedStr = this.getText(this.startingNode);
-        }
-        formattedStr = this.printContentListNode(this.startingNode);
-        formattedStr = this.trimRespectingOptions(formattedStr);
-        return formattedStr;
-    }
-    printContentListNode(node) {
-        var _a;
-        let acc = "";
-        for (let i = 0; i < node.children.length; i++) {
-            const c = node.children[i];
-            const prevChild = i > 0 ? node.children[i - 1] : null;
-            switch (c.kind) {
-                case xmlui_parser_1.SyntaxKind.CData:
-                case xmlui_parser_1.SyntaxKind.Script:
-                case xmlui_parser_1.SyntaxKind.ElementNode: {
-                    acc += this.printTagLikeTriviaInContent(prevChild, c);
-                    acc += this.printTagLike(c);
-                    break;
-                }
-                case xmlui_parser_1.SyntaxKind.StringLiteral:
-                case xmlui_parser_1.SyntaxKind.TextNode: {
-                    const formattedContent = this.printContentString(c);
-                    if (formattedContent !== "") {
-                        acc += this.newlineToken;
-                        acc += this.indent(this.indentationLvl);
-                        acc += formattedContent;
-                    }
-                    else {
-                        acc.trimEnd();
-                    }
-                    break;
-                }
-                case xmlui_parser_1.SyntaxKind.ErrorNode:
-                    acc += this.getText(c, false);
-                    break;
-                case xmlui_parser_1.SyntaxKind.EndOfFileToken: {
-                    const collapsedTrivias = this.collapseBlankLines((_a = c.triviaBefore) !== null && _a !== void 0 ? _a : []);
-                    acc += this.addWsToCollapsedTriviaInContentList(collapsedTrivias, prevChild);
-                    break;
-                }
-            }
-        }
-        return acc;
-    }
-    printTagLikeTriviaInContent(prevSibling, node) {
-        if (!prevSibling) {
-            return this.printTriviaBeforeFirstTaglikeInContent(node);
-        }
-        else if (prevSibling.isTagLike()) {
-            return this.printTriviaBetweenSiblingTaglikes(node, prevSibling);
-        }
-        else if (prevSibling.kind === xmlui_parser_1.SyntaxKind.TextNode ||
-            prevSibling.kind === xmlui_parser_1.SyntaxKind.StringLiteral) {
-            return this.printTriviaBetweenTextAndTaglike(prevSibling, node);
-        }
-        else {
-            // prevSibling is an error node, treat is as any taglike
-            return this.printTriviaBetweenSiblingTaglikes(node, prevSibling);
-        }
-    }
-    printTriviaBetweenTextAndTaglike(textNode, node) {
-        var _a;
-        let acc = "";
-        const trivias = (_a = node.getTriviaNodes()) !== null && _a !== void 0 ? _a : [];
-        const collapsedTrivias = this.collapseBlankLines(trivias);
-        acc += this.addWsToCollapsedTriviaInContentList(collapsedTrivias, textNode);
-        return acc;
-    }
-    printTriviaBeforeFirstTaglikeInContent(node) {
-        const triviaBetweenTaglikes = node.getTriviaNodes();
-        if (!triviaBetweenTaglikes) {
-            if (node.start === 0)
-                return "";
-            return this.newlineToken + this.indent(this.indentationLvl);
-        }
-        const collapsedTrivias = this.collapseBlankLines(triviaBetweenTaglikes);
-        let acc = this.addWsToCollapsedTriviaInContentList(collapsedTrivias, null);
-        return acc;
-    }
-    printTriviaBetweenSiblingTaglikes(node, prevNode) {
-        const triviaBetweenTaglikes = node.getTriviaNodes();
-        if (!triviaBetweenTaglikes) {
-            return this.newlineToken + this.indent(this.indentationLvl);
-        }
-        const collapsedTrivias = this.collapseBlankLines(triviaBetweenTaglikes);
-        let acc = this.addWsToCollapsedTriviaInContentList(collapsedTrivias, prevNode);
-        return acc;
-    }
-    /* Filters out trivias so that only comments and newline remain.
-    Respects the maximum permitted consecitive blank lines and throws out any extra consecutive newlines. */
-    collapseBlankLines(trivias) {
-        let consecutiveNewlines = 0;
-        const accTrivias = [];
-        for (let t of trivias) {
-            if (t.kind === xmlui_parser_1.SyntaxKind.NewLineTrivia) {
-                consecutiveNewlines++;
-                if (consecutiveNewlines <= this.maxConsecutiveNewlines) {
-                    accTrivias.push(t);
-                }
-            }
-            else if (t.kind === xmlui_parser_1.SyntaxKind.CommentTrivia) {
-                consecutiveNewlines = 0;
-                accTrivias.push(t);
-            }
-        }
-        return accTrivias;
-    }
-    addWsToCollapsedTriviaInContentList(trivias, prevContentNode) {
-        var _a;
-        let newlinesAfterText = null;
-        let newlinesFromText = null;
-        let prevContentIsText = false;
-        let newlinesBeforeFirstComment = " ";
-        if (prevContentNode) {
-            prevContentIsText =
-                prevContentNode.kind === xmlui_parser_1.SyntaxKind.StringLiteral ||
-                    prevContentNode.kind === xmlui_parser_1.SyntaxKind.TextNode;
-            if (prevContentIsText) {
-                const trailingNewlinesInText = newlinesInTrailingWhitespace(this.getText(prevContentNode));
-                newlinesAfterText = Math.min(trailingNewlinesInText, this.maxConsecutiveNewlines);
-                if (newlinesAfterText > 0) {
-                    newlinesFromText = this.newlineToken.repeat(newlinesAfterText);
-                    newlinesBeforeFirstComment = newlinesFromText + this.indent(this.indentationLvl);
-                }
-            }
-        }
-        let acc = "";
-        let lastKeptTriviaIsComment = false;
-        for (let i = 0; i < trivias.length; i++) {
-            const t = trivias[i];
-            switch (t.kind) {
-                case xmlui_parser_1.SyntaxKind.CommentTrivia: {
-                    if (i === 0) {
-                        acc += newlinesBeforeFirstComment;
-                        acc += this.getText(t);
-                    }
-                    else {
-                        acc += this.indent(this.indentationLvl) + this.getText(t);
-                    }
-                    if (((_a = trivias[i + 1]) === null || _a === void 0 ? void 0 : _a.kind) === xmlui_parser_1.SyntaxKind.CommentTrivia) {
-                        acc += this.newlineToken;
-                    }
-                    lastKeptTriviaIsComment = true;
-                    break;
-                }
-                case xmlui_parser_1.SyntaxKind.NewLineTrivia: {
-                    acc += this.newlineToken;
-                    lastKeptTriviaIsComment = false;
-                    break;
-                }
-            }
-        }
-        if (lastKeptTriviaIsComment) {
-            acc += this.newlineToken;
-        }
-        else if (trivias.length === 0) {
-            acc += newlinesFromText !== null && newlinesFromText !== void 0 ? newlinesFromText : this.newlineToken;
-        }
-        acc += this.indent(this.indentationLvl);
-        return acc;
-    }
-    addWsToCollapsedCloseNodeStartTrivia(trivias, lastContentNode) {
-        var _a, _b;
-        let newlinesAfterText = null;
-        let lastContentIsText = false;
-        if (lastContentNode) {
-            if (lastContentNode.kind === xmlui_parser_1.SyntaxKind.StringLiteral ||
-                lastContentNode.kind === xmlui_parser_1.SyntaxKind.TextNode) {
-                lastContentIsText = true;
-                const trailingNewlinesInText = newlinesInTrailingWhitespace(this.getText(lastContentNode));
-                newlinesAfterText = Math.min(trailingNewlinesInText, this.maxConsecutiveNewlines);
-            }
-        }
-        const contentEndsInNewlines = lastContentIsText && newlinesAfterText > 0;
-        let acc = "";
-        if (contentEndsInNewlines) {
-            acc += this.newlineToken.repeat(newlinesAfterText);
-        }
-        for (let i = 0; i < trivias.length; ++i) {
-            const t = trivias[i];
-            switch (t.kind) {
-                case xmlui_parser_1.SyntaxKind.CommentTrivia: {
-                    if (i === 0 && ((lastContentIsText && newlinesAfterText === 0) || !lastContentIsText)) {
-                        acc += " ";
-                        acc += this.getText(t);
-                    }
-                    else {
-                        acc += this.indent(this.indentationLvl + 1) + this.getText(t);
-                    }
-                    if (((_a = trivias[i + 1]) === null || _a === void 0 ? void 0 : _a.kind) === xmlui_parser_1.SyntaxKind.CommentTrivia) {
-                        acc += this.newlineToken;
-                    }
-                    break;
-                }
-                case xmlui_parser_1.SyntaxKind.NewLineTrivia: {
-                    acc += this.newlineToken;
-                    break;
-                }
-            }
-        }
-        if (!lastContentNode && trivias.length === 0) {
-            // leave the closing tag on the same line
-            // when there's nothing inside it
-        }
-        else if (contentEndsInNewlines || ((_b = trivias.at(-1)) === null || _b === void 0 ? void 0 : _b.kind) === xmlui_parser_1.SyntaxKind.NewLineTrivia) {
-            acc += this.indent(this.indentationLvl);
-        }
-        else {
-            acc += this.newlineToken;
-            acc += this.indent(this.indentationLvl);
-        }
-        return acc;
-    }
-    printTagLike(node) {
-        switch (node.kind) {
-            case xmlui_parser_1.SyntaxKind.Script:
-            case xmlui_parser_1.SyntaxKind.CData:
-                return this.getText(node);
-            default:
-                return this.printElementNode(node);
-        }
-    }
-    printElementNode(node) {
-        let acc = "";
-        const contentListIdx = node.children.findIndex((c) => c.kind === xmlui_parser_1.SyntaxKind.ContentListNode);
-        const hasContentList = contentListIdx !== -1;
-        const closeNodeStartIdx = node.children.findIndex((c) => c.kind === xmlui_parser_1.SyntaxKind.CloseNodeStart);
-        const hasCloseNodeStart = closeNodeStartIdx !== -1;
-        let nodesOfOpenTagNodeEndIdx;
-        if (hasContentList) {
-            nodesOfOpenTagNodeEndIdx = contentListIdx;
-        }
-        else if (hasCloseNodeStart) {
-            nodesOfOpenTagNodeEndIdx = closeNodeStartIdx;
-        }
-        else {
-            nodesOfOpenTagNodeEndIdx = node.children.length;
-        }
-        const nodesOfOpenTagNode = node.children.slice(0, nodesOfOpenTagNodeEndIdx);
-        acc += this.printOpenTag(nodesOfOpenTagNode);
-        let lastContentNode = null;
-        if (hasContentList) {
-            const contentListNode = node.children[contentListIdx];
-            lastContentNode = contentListNode.children.at(-1);
-            ++this.indentationLvl;
-            acc += this.printContentListNode(contentListNode);
-            --this.indentationLvl;
-        }
-        let nodesOfCloseTagNodeStartIdx;
-        if (hasCloseNodeStart) {
-            nodesOfCloseTagNodeStartIdx = closeNodeStartIdx;
-        }
-        else if (hasContentList) {
-            nodesOfCloseTagNodeStartIdx = contentListIdx + 1;
-        }
-        else {
-            nodesOfCloseTagNodeStartIdx = nodesOfOpenTagNodeEndIdx + 1;
-        }
-        const closeTagNodes = node.children.slice(nodesOfCloseTagNodeStartIdx);
-        acc += this.printClosingTag(closeTagNodes, lastContentNode);
-        return acc;
-    }
-    printOpenTag(tagChildren) {
-        let acc = "";
-        for (let i = 0; i < tagChildren.length; ++i) {
-            const c = tagChildren[i];
-            switch (c.kind) {
-                case xmlui_parser_1.SyntaxKind.OpenNodeStart:
-                    acc += "<";
-                    break;
-                case xmlui_parser_1.SyntaxKind.CloseNodeStart:
-                    acc += "</";
-                    break;
-                case xmlui_parser_1.SyntaxKind.TagNameNode:
-                    acc += this.printTagName(c);
-                    break;
-                case xmlui_parser_1.SyntaxKind.NodeClose:
-                case xmlui_parser_1.SyntaxKind.NodeEnd:
-                case xmlui_parser_1.SyntaxKind.AttributeListNode:
-                    acc += this.printTagAfterName(tagChildren.slice(i), acc);
-                    return acc;
-                case xmlui_parser_1.SyntaxKind.ErrorNode:
-                    acc += this.getText(c, false);
-            }
-        }
-        return acc;
-    }
-    printClosingTag(tagChildren, lastContentNode) {
-        var _a;
-        let acc = "";
-        for (let i = 0; i < tagChildren.length; ++i) {
-            const c = tagChildren[i];
-            switch (c.kind) {
-                case xmlui_parser_1.SyntaxKind.CloseNodeStart:
-                    const collapsedTrivias = this.collapseBlankLines((_a = c.triviaBefore) !== null && _a !== void 0 ? _a : []);
-                    acc += this.addWsToCollapsedCloseNodeStartTrivia(collapsedTrivias, lastContentNode);
-                    acc += "</";
-                    break;
-                case xmlui_parser_1.SyntaxKind.TagNameNode:
-                    acc += this.printTagName(c);
-                    break;
-                case xmlui_parser_1.SyntaxKind.NodeEnd:
-                    acc += this.printTagAfterName(tagChildren.slice(i), acc);
-                    return acc;
-                case xmlui_parser_1.SyntaxKind.ErrorNode:
-                    acc += this.getText(c, false);
-            }
-        }
-        return acc;
-    }
-    printTagAfterName(nodes, tagAcc) {
-        let acc = "";
-        let closingIsNodeClose = false;
-        let attrSegmentsFormatted = [];
-        let closingSegmentsFormatted = [];
-        let attrsAlreadyMultiline = false;
-        for (let i = 0; i < nodes.length; ++i) {
-            const c = nodes[i];
-            switch (c.kind) {
-                case xmlui_parser_1.SyntaxKind.AttributeListNode:
-                    attrSegmentsFormatted = this.printAttrList(c);
-                    attrsAlreadyMultiline = c.children.some((attr) => {
-                        var _a;
-                        return (_a = attr
-                            .getTriviaNodes()) === null || _a === void 0 ? void 0 : _a.some((attrTrivia) => attrTrivia.kind === xmlui_parser_1.SyntaxKind.NewLineTrivia);
-                    });
-                    break;
-                case xmlui_parser_1.SyntaxKind.NodeClose: {
-                    closingIsNodeClose = true;
-                    const comments = this.getCommentsSpaceJoined(c);
-                    if (comments) {
-                        closingSegmentsFormatted = [comments, "/>"];
-                    }
-                    else {
-                        closingSegmentsFormatted = ["/>"];
-                    }
-                    break;
-                }
-                case xmlui_parser_1.SyntaxKind.NodeEnd: {
-                    closingIsNodeClose = false;
-                    const comments = this.getCommentsSpaceJoined(c);
-                    if (comments) {
-                        closingSegmentsFormatted = [comments, ">"];
-                    }
-                    else {
-                        closingSegmentsFormatted = [">"];
-                    }
-                    break;
-                }
-                case xmlui_parser_1.SyntaxKind.ErrorNode:
-                    acc += this.getText(c, true);
-                    break;
-            }
-        }
-        const lineLenBeforeAttrs = this.indentationLvl * this.tabSize + tagAcc.length;
-        const errorNodesLen = acc.length;
-        const restOfTag = attrSegmentsFormatted.concat(closingSegmentsFormatted);
-        const restOfTagNonWsLen = restOfTag.reduce((sum, attr) => attr.length + sum, 0);
-        const spacesBetweenRestOfTagNodes = attrSegmentsFormatted.length - 1;
-        const sameLineTagLen = errorNodesLen + lineLenBeforeAttrs + restOfTagNonWsLen + spacesBetweenRestOfTagNodes;
-        const breakAttrsToMultipleLines = attrsAlreadyMultiline || sameLineTagLen > this.maxLineLength;
-        const attrsAndTrailingComments = attrSegmentsFormatted.concat(closingSegmentsFormatted.slice(0, -1));
-        const hasClosing = closingSegmentsFormatted.length > 0;
-        const closingFormatted = closingSegmentsFormatted.at(-1);
-        if (breakAttrsToMultipleLines) {
-            const wsBeforeAttr = this.newlineToken + this.indent(this.indentationLvl + 1);
-            const attrsFormatted = attrsAndTrailingComments.join(wsBeforeAttr);
-            if (attrsAndTrailingComments.length > 0) {
-                acc += wsBeforeAttr + attrsFormatted;
-            }
-            if (hasClosing) {
-                if (closingIsNodeClose) {
-                    acc += " ";
-                }
-                acc += closingFormatted;
-            }
-        }
-        else {
-            const wsBeforeAttr = " ";
-            const attrsFormatted = attrsAndTrailingComments.join(wsBeforeAttr);
-            if (attrsAndTrailingComments.length > 0) {
-                acc += wsBeforeAttr + attrsFormatted;
-            }
-            if (hasClosing) {
-                if (closingIsNodeClose) {
-                    acc += " ";
-                }
-                acc += closingFormatted;
-            }
-        }
-        return acc;
-    }
-    printAttrList(node) {
-        const attrsFormatted = [];
-        for (const c of node.children) {
-            const comments = this.getCommentsSpaceJoined(c);
-            if (comments) {
-                attrsFormatted.push(comments);
-            }
-            attrsFormatted.push(this.printAttrNode(c));
-        }
-        return attrsFormatted;
-    }
-    /**
-     *
-     * @param node a potential ErrorNode
-     * @returns the formatted string if the node was an ErrorNode
-     * otherwise `null`.
-     */
-    printIfErrNode(node) {
-        if (node.kind === xmlui_parser_1.SyntaxKind.ErrorNode) {
-            return this.getText(node, true);
-        }
-        else {
-            return null;
-        }
-    }
-    /**
-     * trivia before the first child element is not handled, as that is
-     * the job of the parent function, that joins attrNodes together
-     *
-     * @param node attrNode
-     * @returns
-     */
-    printAttrNode(node) {
-        const formattedErrNode = this.printIfErrNode(node);
-        if (formattedErrNode !== null) {
-            return formattedErrNode;
-        }
-        let acc = this.printAttrKeyNode(node.children[0]);
-        const otherChildren = node.children.slice(1);
-        acc += this.printNodesSpaceJoinedCommentsBefore(otherChildren);
-        return acc;
-    }
-    printAttrKeyNode(node) {
-        let acc = this.getText(node.children[0]);
-        const otherChildren = node.children.slice(1);
-        acc += this.printNodesSpaceJoinedCommentsBefore(otherChildren);
-        return acc;
-    }
-    printNodesSpaceJoinedCommentsBefore(nodes) {
-        let acc = "";
-        for (let node of nodes) {
-            if (node.kind === xmlui_parser_1.SyntaxKind.ErrorNode) {
-                acc += this.getText(node, false);
-                continue;
-            }
-            const comment = this.getCommentsSpaceJoined(node);
-            if (comment) {
-                acc += " " + comment + " ";
-            }
-            acc += this.getText(node);
-        }
-        return acc;
-    }
-    printTagName(node) {
-        const commentBefName = this.getCommentsSpaceJoined(node.children[0]);
-        const firstTokenPrint = this.getText(node.children[0]);
-        let acc = commentBefName ? ` ${commentBefName} ${firstTokenPrint}` : firstTokenPrint;
-        acc += this.printNodesSpaceJoinedCommentsBefore(node.children.slice(1));
-        return acc;
-    }
-    printContentString(node) {
-        return this.getText(node, false).trim();
-    }
-    indent(lvl) {
-        return this.indentationToken.repeat(lvl);
-    }
-    getComments(node) {
-        var _a;
-        const triviaNodes = (_a = node.getTriviaNodes()) !== null && _a !== void 0 ? _a : [];
-        return triviaNodes
-            .filter(({ kind }) => kind === xmlui_parser_1.SyntaxKind.CommentTrivia)
-            .map((comment) => this.getText(comment));
-    }
-    /**
-     *
-     * @returns null if the node doesn't have comment trivia,
-     * otherwise the comments, joined with a space char.
-     */
-    getCommentsSpaceJoined(node) {
-        const comments = this.getComments(node);
-        if (comments.length === 0) {
-            return null;
-        }
-        return comments.join(" ");
-    }
-    /**
-     * Check if comments have newlines before them
-     */
-    hasNewlineTriviaBeforeComment(node) {
-        const triviaNodes = node.getTriviaNodes();
-        if (!triviaNodes) {
-            return false;
-        }
-        for (let c of triviaNodes) {
-            if (c.kind === xmlui_parser_1.SyntaxKind.NewLineTrivia) {
-                return true;
-            }
-            else if (c.kind === xmlui_parser_1.SyntaxKind.CommentTrivia) {
-                return false;
-            }
-        }
-        return false;
-    }
-}
-function format(node, getText, options) {
-    const formatter = new XmluiFormatter(node, getText, options);
-    return formatter.format();
-}
-function newlinesInTrailingWhitespace(text) {
-    const trimmedPrevText = text.trimEnd();
-    const trailingWhitespace = text.substring(trimmedPrevText.length);
-    let newlineCount = 0;
-    for (const c of trailingWhitespace) {
-        if (c === "\n") {
-            newlineCount++;
-        }
-    }
-    return newlineCount;
-}