xmlui 0.11.3 → 0.11.4

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

@@ -3,7 +3,6 @@ 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
@@ -24,21 +23,22 @@ function handleDocumentFormatting({ node, getText, options, offsetToPosition, })
 }
 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.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;
+            this.trimRespectingOptions = (formatted) => {
+                return formatted.trim() + this.newlineToken;
             };
         }
         else {
-            this.handleTrailingWhitespace = (formatted) => {
-                return formatted.trimEnd();
+            this.trimRespectingOptions = (formatted) => {
+                return formatted.trim();
             };
         }
     }
@@ -48,15 +48,12 @@ class XmluiFormatter {
             formattedStr = this.getText(this.startingNode);
         }
         formattedStr = this.printContentListNode(this.startingNode);
-        formattedStr = this.handleTrailingWhitespace(formattedStr);
+        formattedStr = this.trimRespectingOptions(formattedStr);
         return formattedStr;
     }
     printContentListNode(node) {
-        let acc = this.printEveryTrivia(node);
-        if (!node.children) {
-            acc += this.getText(node);
-            return acc;
-        }
+        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;
@@ -64,39 +61,17 @@ class XmluiFormatter {
                 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.printTagLikeTriviaInContent(prevChild, c);
                     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.newlineToken;
                         acc += this.indent(this.indentationLvl);
                         acc += formattedContent;
-                        acc += this.newlineToken;
                     }
                     else {
                         acc.trimEnd();
@@ -106,17 +81,182 @@ class XmluiFormatter {
                 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;
+                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) {
@@ -134,37 +274,38 @@ class XmluiFormatter {
         const hasContentList = contentListIdx !== -1;
         const closeNodeStartIdx = node.children.findIndex((c) => c.kind === xmlui_parser_1.SyntaxKind.CloseNodeStart);
         const hasCloseNodeStart = closeNodeStartIdx !== -1;
-        let openTagNodeCount;
+        let nodesOfOpenTagNodeEndIdx;
         if (hasContentList) {
-            openTagNodeCount = contentListIdx;
+            nodesOfOpenTagNodeEndIdx = contentListIdx;
         }
         else if (hasCloseNodeStart) {
-            openTagNodeCount = closeNodeStartIdx;
+            nodesOfOpenTagNodeEndIdx = closeNodeStartIdx;
         }
         else {
-            openTagNodeCount = node.children.length;
+            nodesOfOpenTagNodeEndIdx = node.children.length;
         }
-        const openTagNodes = node.children.slice(0, openTagNodeCount);
-        acc += this.printOpenTag(openTagNodes);
+        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.newlineToken;
             acc += this.printContentListNode(contentListNode);
             --this.indentationLvl;
         }
-        let closeTagNodesStartIdx;
+        let nodesOfCloseTagNodeStartIdx;
         if (hasCloseNodeStart) {
-            closeTagNodesStartIdx = closeNodeStartIdx;
+            nodesOfCloseTagNodeStartIdx = closeNodeStartIdx;
         }
         else if (hasContentList) {
-            closeTagNodesStartIdx = contentListIdx + 1;
+            nodesOfCloseTagNodeStartIdx = contentListIdx + 1;
         }
         else {
-            closeTagNodesStartIdx = openTagNodeCount + 1;
+            nodesOfCloseTagNodeStartIdx = nodesOfOpenTagNodeEndIdx + 1;
         }
-        const closeTagNodes = node.children.slice(closeTagNodesStartIdx);
-        acc += this.printClosingTag(closeTagNodes, hasContentList);
+        const closeTagNodes = node.children.slice(nodesOfCloseTagNodeStartIdx);
+        acc += this.printClosingTag(closeTagNodes, lastContentNode);
         return acc;
     }
     printOpenTag(tagChildren) {
@@ -192,21 +333,16 @@ class XmluiFormatter {
         }
         return acc;
     }
-    printClosingTag(tagChildren, hasContentList) {
+    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 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) + "</";
+                    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);
@@ -224,20 +360,20 @@ class XmluiFormatter {
         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;
+                    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: {
-                    closingOffsetInAcc = acc.length;
                     closingIsNodeClose = true;
                     const comments = this.getCommentsSpaceJoined(c);
                     if (comments) {
@@ -249,7 +385,6 @@ class XmluiFormatter {
                     break;
                 }
                 case xmlui_parser_1.SyntaxKind.NodeEnd: {
-                    closingOffsetInAcc = acc.length;
                     closingIsNodeClose = false;
                     const comments = this.getCommentsSpaceJoined(c);
                     if (comments) {
@@ -376,15 +511,12 @@ class XmluiFormatter {
     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);
+        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));
@@ -405,7 +537,10 @@ class XmluiFormatter {
      * Check if comments have newlines before them
      */
     hasNewlineTriviaBeforeComment(node) {
-        const triviaNodes = (0, syntax_node_utilities_1.getTriviaNodes)(node);
+        const triviaNodes = node.getTriviaNodes();
+        if (!triviaNodes) {
+            return false;
+        }
         for (let c of triviaNodes) {
             if (c.kind === xmlui_parser_1.SyntaxKind.NewLineTrivia) {
                 return true;
@@ -419,12 +554,16 @@ class XmluiFormatter {
 }
 function format(node, getText, options) {
     const formatter = new XmluiFormatter(node, getText, options);
-    const formattedString = formatter.format();
-    return formattedString;
+    return formatter.format();
 }
-function hasNewlineInTrailingWhitespace(text) {
-    const lastNewlineIdx = text.lastIndexOf("\n");
+function newlinesInTrailingWhitespace(text) {
     const trimmedPrevText = text.trimEnd();
-    const textEndedInNewline = lastNewlineIdx >= trimmedPrevText.length;
-    return textEndedInNewline;
+    const trailingWhitespace = text.substring(trimmedPrevText.length);
+    let newlineCount = 0;
+    for (const c of trailingWhitespace) {
+        if (c === "\n") {
+            newlineCount++;
+        }
+    }
+    return newlineCount;
 }

package/dist/scripts/src/parsers/xmlui-parser/parser.js

@@ -83,6 +83,9 @@ function parseXmlUiMarkup(text) {
                 case syntax_kind_1.SyntaxKind.OpenNodeStart:
                     parseOpeningTag();
                     break;
+                case syntax_kind_1.SyntaxKind.TextNode:
+                    bumpAny();
+                    break;
                 case syntax_kind_1.SyntaxKind.CloseNodeStart: {
                     const errNode = errNodeUntil(RECOVER_FILE);
                     errorAt(diagnostics_1.DIAGS.unexpectedCloseTag, errNode.pos, errNode.end);
@@ -493,11 +496,9 @@ function parseXmlUiMarkup(text) {
         else {
             pos = token.start;
         }
-        let start = pos;
         let triviaBefore = undefined;
         if (leadingComments.length > 0) {
             triviaBefore = leadingComments;
-            start = leadingComments[0].pos;
         }
         let kind = syntax_kind_1.SyntaxKind.TextNode;
         let end = -1;

package/dist/scripts/src/parsers/xmlui-parser/syntax-node.js

@@ -27,6 +27,11 @@ class Node {
     isAttributeNode() {
         return this.kind === syntax_kind_1.SyntaxKind.AttributeNode;
     }
+    isTagLike() {
+        return (this.kind === syntax_kind_1.SyntaxKind.ElementNode ||
+            this.kind === syntax_kind_1.SyntaxKind.CData ||
+            this.kind == syntax_kind_1.SyntaxKind.Script);
+    }
     isAttributeKeyNode() {
         return this.kind === syntax_kind_1.SyntaxKind.AttributeKeyNode;
     }
@@ -42,6 +47,17 @@ class Node {
     findTokenAtPos(position) {
         return (0, utils_1.findTokenAtPos)(this, position);
     }
+    getTriviaNodes() {
+        if (this.pos === this.start) {
+            return null;
+        }
+        else if (this.triviaBefore) {
+            return this.triviaBefore;
+        }
+        else {
+            return this.children[0].getTriviaNodes();
+        }
+    }
 }
 exports.Node = Node;
 class ElementNode extends Node {

package/dist/standalone/xmlui-standalone.es.d.ts

@@ -1429,7 +1429,7 @@ declare type SpinnerProps = {
     className?: string;
 };
 
-declare const Splitter: ({ initialPrimarySize, minPrimarySize, maxPrimarySize, orientation, children, style, className, swapped, floating, splitterTemplate, resize, ...rest }: SplitterProps) => JSX_2.Element;
+declare const Splitter: ({ initialPrimarySize, minPrimarySize, maxPrimarySize, orientation, children, style, className, swapped, floating, splitterTemplate, resize, visibleChildCount, ...rest }: SplitterProps) => JSX_2.Element;
 
 declare type SplitterProps = {
     children: default_2.ReactNode[] | default_2.ReactNode;
@@ -1443,6 +1443,7 @@ declare type SplitterProps = {
     initialPrimarySize?: string;
     minPrimarySize?: string;
     maxPrimarySize?: string;
+    visibleChildCount?: number;
 };
 
 declare type SPREAD_EXPRESSION = typeof T_SPREAD_EXPRESSION;
@@ -1574,7 +1575,7 @@ declare const standaloneExports: {
         autoFocus?: boolean;
         contextualLabel?: string;
     } & Pick<default_2.HTMLAttributes<HTMLButtonElement>, "className" | "aria-disabled" | "aria-label" | "aria-controls" | "aria-expanded" | "role" | "onFocus" | "onBlur" | "onClick" | "tabIndex" | "onMouseEnter" | "onMouseLeave"> & default_2.RefAttributes<HTMLButtonElement>>;
-    Splitter: ({ initialPrimarySize, minPrimarySize, maxPrimarySize, orientation, children, style, className, swapped, floating, splitterTemplate, resize, ...rest }: {
+    Splitter: ({ initialPrimarySize, minPrimarySize, maxPrimarySize, orientation, children, style, className, swapped, floating, splitterTemplate, resize, visibleChildCount, ...rest }: {
         children: default_2.ReactNode[] | default_2.ReactNode;
         style?: default_2.CSSProperties;
         className?: string;
@@ -1586,6 +1587,7 @@ declare const standaloneExports: {
         initialPrimarySize?: string;
         minPrimarySize?: string;
         maxPrimarySize?: string;
+        visibleChildCount?: number;
     }) => default_3.JSX.Element;
     getColor: typeof xmluiExports.getColor;
     TabItem: default_2.ForwardRefExoticComponent<Tab_2 & default_2.RefAttributes<HTMLDivElement>>;