xmlui 0.10.13 → 0.10.15

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

@@ -0,0 +1,430 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDocumentFormatting = handleDocumentFormatting;
+exports.format = format;
+const xmlui_parser_1 = require("../../parsers/xmlui-parser");
+const syntax_node_utilities_1 = require("./common/syntax-node-utilities");
+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.newlineToken = "\n";
+        this.getText = getText;
+        this.startingNode = node;
+        this.indentationLvl = 0;
+        this.maxLineLength = 80;
+        this.tabSize = options.tabSize;
+        this.indentationToken = options.insertSpaces ? " ".repeat(options.tabSize) : "\t";
+        if (options.insertFinalNewline && !options.trimFinalNewlines) {
+            this.handleTrailingWhitespace = (formatted) => {
+                return formatted.trimEnd() + this.newlineToken;
+            };
+        }
+        else {
+            this.handleTrailingWhitespace = (formatted) => {
+                return formatted.trimEnd();
+            };
+        }
+    }
+    format() {
+        let formattedStr;
+        if (this.startingNode.kind !== xmlui_parser_1.SyntaxKind.ContentListNode) {
+            formattedStr = this.getText(this.startingNode);
+        }
+        formattedStr = this.printContentListNode(this.startingNode);
+        formattedStr = this.handleTrailingWhitespace(formattedStr);
+        return formattedStr;
+    }
+    printContentListNode(node) {
+        let acc = this.printEveryTrivia(node);
+        if (!node.children) {
+            acc += this.getText(node);
+            return 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: {
+                    const comment = this.getCommentsSpaceJoined(c);
+                    const prevIsText = (prevChild === null || prevChild === void 0 ? void 0 : prevChild.kind) === xmlui_parser_1.SyntaxKind.TextNode;
+                    if (comment) {
+                        let commentInline = true;
+                        if (this.hasNewlineTriviaBeforeComment(c)) {
+                            commentInline = false;
+                        }
+                        else if (prevIsText) {
+                            const prevText = this.getText(prevChild);
+                            commentInline = !hasNewlineInTrailingWhitespace(prevText);
+                        }
+                        if (commentInline) {
+                            if (acc.at(-1) === this.newlineToken) {
+                                acc = acc.substring(0, acc.length - this.newlineToken.length);
+                            }
+                            acc += ` ${comment}${this.newlineToken}`;
+                        }
+                        else {
+                            acc += this.indent(this.indentationLvl) + comment + this.newlineToken;
+                        }
+                    }
+                    acc += this.indent(this.indentationLvl);
+                    acc += this.printTagLike(c);
+                    acc += this.newlineToken;
+                    break;
+                }
+                case xmlui_parser_1.SyntaxKind.StringLiteral:
+                case xmlui_parser_1.SyntaxKind.TextNode: {
+                    const formattedContent = this.printContentString(c);
+                    if (formattedContent !== "") {
+                        acc += this.indent(this.indentationLvl);
+                        acc += formattedContent;
+                        acc += this.newlineToken;
+                    }
+                    else {
+                        acc.trimEnd();
+                    }
+                    break;
+                }
+                case xmlui_parser_1.SyntaxKind.ErrorNode:
+                    acc += this.getText(c, false);
+                    break;
+                case xmlui_parser_1.SyntaxKind.EndOfFileToken:
+                    const comment = this.getCommentsSpaceJoined(c);
+                    if (comment) {
+                        if (!this.hasNewlineTriviaBeforeComment(c) && acc.at(-1) === this.newlineToken) {
+                            acc = acc.substring(0, acc.length - this.newlineToken.length) + " ";
+                        }
+                        acc += this.indent(this.indentationLvl) + comment;
+                    }
+                    break;
+            }
+        }
+        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 openTagNodeCount;
+        if (hasContentList) {
+            openTagNodeCount = contentListIdx;
+        }
+        else if (hasCloseNodeStart) {
+            openTagNodeCount = closeNodeStartIdx;
+        }
+        else {
+            openTagNodeCount = node.children.length;
+        }
+        const openTagNodes = node.children.slice(0, openTagNodeCount);
+        acc += this.printOpenTag(openTagNodes);
+        if (hasContentList) {
+            const contentListNode = node.children[contentListIdx];
+            ++this.indentationLvl;
+            acc += this.newlineToken;
+            acc += this.printContentListNode(contentListNode);
+            --this.indentationLvl;
+        }
+        let closeTagNodesStartIdx;
+        if (hasCloseNodeStart) {
+            closeTagNodesStartIdx = closeNodeStartIdx;
+        }
+        else if (hasContentList) {
+            closeTagNodesStartIdx = contentListIdx + 1;
+        }
+        else {
+            closeTagNodesStartIdx = openTagNodeCount + 1;
+        }
+        const closeTagNodes = node.children.slice(closeTagNodesStartIdx);
+        acc += this.printClosingTag(closeTagNodes, hasContentList);
+        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, hasContentList) {
+        let acc = "";
+        for (let i = 0; i < tagChildren.length; ++i) {
+            const c = tagChildren[i];
+            switch (c.kind) {
+                case xmlui_parser_1.SyntaxKind.CloseNodeStart:
+                    const comment = this.getCommentsSpaceJoined(c);
+                    if (comment) {
+                        if (!hasContentList) {
+                            acc += this.newlineToken;
+                        }
+                        acc += this.indent(this.indentationLvl + 1);
+                        acc += comment + this.newlineToken;
+                    }
+                    acc += this.indent(this.indentationLvl) + "</";
+                    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 attrListOffsetInAcc;
+        let closingSegmentsFormatted = [];
+        let closingOffsetInAcc;
+        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) => (0, syntax_node_utilities_1.getTriviaNodes)(attr).some((attrTrivia) => attrTrivia.kind === xmlui_parser_1.SyntaxKind.NewLineTrivia));
+                    attrListOffsetInAcc = acc.length;
+                    break;
+                case xmlui_parser_1.SyntaxKind.NodeClose: {
+                    closingOffsetInAcc = acc.length;
+                    closingIsNodeClose = true;
+                    const comments = this.getCommentsSpaceJoined(c);
+                    if (comments) {
+                        closingSegmentsFormatted = [comments, "/>"];
+                    }
+                    else {
+                        closingSegmentsFormatted = ["/>"];
+                    }
+                    break;
+                }
+                case xmlui_parser_1.SyntaxKind.NodeEnd: {
+                    closingOffsetInAcc = acc.length;
+                    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();
+    }
+    printEveryTrivia(node) {
+        var _a;
+        return ((_a = node.triviaBefore) !== null && _a !== void 0 ? _a : []).map((trivia) => this.getText(trivia)).join("");
+    }
+    indent(lvl) {
+        return this.indentationToken.repeat(lvl);
+    }
+    getComments(node) {
+        const triviaNodes = (0, syntax_node_utilities_1.getTriviaNodes)(node);
+        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 = (0, syntax_node_utilities_1.getTriviaNodes)(node);
+        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);
+    const formattedString = formatter.format();
+    return formattedString;
+}
+function hasNewlineInTrailingWhitespace(text) {
+    const lastNewlineIdx = text.lastIndexOf("\n");
+    const trimmedPrevText = text.trimEnd();
+    const textEndedInNewline = lastNewlineIdx >= trimmedPrevText.length;
+    return textEndedInNewline;
+}

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

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHoverCore = handleHoverCore;
+exports.handleHover = handleHover;
+const utils_1 = require("../../parsers/xmlui-parser/utils");
+const syntax_kind_1 = require("../../parsers/xmlui-parser/syntax-kind");
+const syntax_node_utilities_1 = require("./common/syntax-node-utilities");
+const docGen = __importStar(require("./common/docs-generation"));
+const vscode_languageserver_1 = require("vscode-languageserver");
+const lsp_utils_1 = require("./common/lsp-utils");
+/**
+ * @returns The hover content string
+ */
+function handleHoverCore({ node, getText, metaByComp }, position) {
+    const findRes = (0, utils_1.findTokenAtPos)(node, position);
+    if (findRes === undefined) {
+        return null;
+    }
+    const { chainAtPos } = findRes;
+    const atNode = chainAtPos.at(-1);
+    const parentNode = chainAtPos.at(-2);
+    switch (atNode.kind) {
+        case syntax_kind_1.SyntaxKind.Identifier:
+            switch (parentNode === null || parentNode === void 0 ? void 0 : parentNode.kind) {
+                case syntax_kind_1.SyntaxKind.TagNameNode: {
+                    return hoverName({
+                        metaByComp: metaByComp,
+                        tagNameNode: parentNode,
+                        identNode: atNode,
+                        getText
+                    });
+                }
+                case syntax_kind_1.SyntaxKind.AttributeKeyNode: {
+                    return hoverAttr({
+                        metaByComp,
+                        attrKeyNode: parentNode,
+                        parentStack: chainAtPos.slice(0, -2),
+                        getText,
+                    });
+                }
+            }
+            break;
+    }
+    return null;
+}
+function handleHover(ctx, position) {
+    const hoverRes = handleHoverCore(ctx, position);
+    if (hoverRes === null) {
+        return null;
+    }
+    const { value, range } = hoverRes;
+    return {
+        contents: {
+            kind: vscode_languageserver_1.MarkupKind.Markdown,
+            value,
+        },
+        range: (0, lsp_utils_1.offsetToPosRange)(ctx.offsetToPosition, range)
+    };
+}
+function hoverAttr({ metaByComp, attrKeyNode, parentStack, getText, }) {
+    var _a, _b;
+    if (parentStack.at(-1).kind !== syntax_kind_1.SyntaxKind.AttributeNode) {
+        return null;
+    }
+    if (parentStack.at(-2).kind !== syntax_kind_1.SyntaxKind.AttributeListNode) {
+        return null;
+    }
+    const tag = parentStack.at(-3);
+    if ((tag === null || tag === void 0 ? void 0 : tag.kind) !== syntax_kind_1.SyntaxKind.ElementNode) {
+        return null;
+    }
+    const tagNameNode = (0, syntax_node_utilities_1.findTagNameNodeInStack)(parentStack);
+    if (!tagNameNode) {
+        return null;
+    }
+    const compName = (0, syntax_node_utilities_1.compNameForTagNameNode)(tagNameNode, getText);
+    const component = metaByComp.getComponent(compName);
+    if (!component) {
+        return null;
+    }
+    const attrKeyChildren = attrKeyNode.children;
+    const identIdx = attrKeyChildren.findIndex((c) => c.kind === syntax_kind_1.SyntaxKind.Identifier);
+    if (identIdx === -1) {
+        return null;
+    }
+    const attrIdent = attrKeyChildren[identIdx];
+    const propIsNamespaceDefinition = ((_a = attrKeyChildren[identIdx + 1]) === null || _a === void 0 ? void 0 : _a.kind) === syntax_kind_1.SyntaxKind.Colon &&
+        ((_b = attrKeyChildren[identIdx + 2]) === null || _b === void 0 ? void 0 : _b.kind) === syntax_kind_1.SyntaxKind.Identifier &&
+        getText(attrIdent) === "xmlns";
+    if (propIsNamespaceDefinition) {
+        return {
+            value: `Defines a namespace. TODO Further Documentation needed.`,
+            range: {
+                pos: attrKeyNode.pos,
+                end: attrKeyNode.end,
+            },
+        };
+    }
+    const attrName = getText(attrIdent);
+    const attrMd = component.getAttr(attrName);
+    if (!attrMd) {
+        return null;
+    }
+    const value = docGen.generateAttrDescription(attrName, attrMd);
+    return {
+        value,
+        range: {
+            pos: attrKeyNode.pos,
+            end: attrKeyNode.end,
+        },
+    };
+}
+function hoverName({ metaByComp, tagNameNode, identNode, getText, }) {
+    var _a;
+    const compName = (0, syntax_node_utilities_1.compNameForTagNameNode)(tagNameNode, getText);
+    if (!compName) {
+        return null;
+    }
+    const compMetadata = (_a = metaByComp.getComponent(compName)) === null || _a === void 0 ? void 0 : _a.getMetadata();
+    if (!compMetadata) {
+        return null;
+    }
+    const value = docGen.generateCompNameDescription(compName, compMetadata);
+    return {
+        value,
+        range: {
+            pos: identNode.pos,
+            end: identNode.end,
+        },
+    };
+}