xmlui 0.10.13 → 0.10.14

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

@@ -0,0 +1,270 @@
+"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.handleCompletionResolve = handleCompletionResolve;
+exports.handleCompletion = handleCompletion;
+const vscode_languageserver_1 = require("vscode-languageserver");
+const utils_1 = require("../../parsers/xmlui-parser/utils");
+const syntax_kind_1 = require("../../parsers/xmlui-parser/syntax-kind");
+const docGen = __importStar(require("./common/docs-generation"));
+const syntax_node_utilities_1 = require("./common/syntax-node-utilities");
+const metadata_utils_1 = require("./common/metadata-utils");
+function handleCompletionResolve({ item, metaByComp: metaByComp, }) {
+    var _a;
+    const metadataAccessInfo = (_a = item === null || item === void 0 ? void 0 : item.data) === null || _a === void 0 ? void 0 : _a.metadataAccessInfo;
+    if (metadataAccessInfo) {
+        const { componentName, attribute } = metadataAccessInfo;
+        const componentMeta = metaByComp.getComponent(componentName);
+        if (!componentMeta) {
+            return null;
+        }
+        if (attribute) {
+            const attributeMetadata = componentMeta.getAttrForKind(attribute);
+            item.documentation = markupContent(docGen.generateAttrDescription(attribute.name, attributeMetadata));
+        }
+        else {
+            item.documentation = markupContent(docGen.generateCompNameDescription(componentName, componentMeta.getMetadata()));
+        }
+    }
+    return item;
+}
+function handleCompletion({ parseResult: { node }, getText, metaByComp }, position) {
+    const findRes = (0, utils_1.findTokenAtPos)(node, position);
+    if (!findRes) {
+        return null;
+    }
+    const { chainAtPos, chainBeforePos } = findRes;
+    if (findRes.chainBeforePos === undefined) {
+        return handleCompletionInsideToken(chainAtPos, position, metaByComp, getText);
+    }
+    const nodeBefore = chainBeforePos.at(-1);
+    switch (nodeBefore.kind) {
+        case syntax_kind_1.SyntaxKind.OpenNodeStart:
+            const defaultCompNames = allComponentNames(metaByComp);
+            const closestElementNodeSuspect = chainBeforePos.at(-2);
+            if (closestElementNodeSuspect && closestElementNodeSuspect.kind === syntax_kind_1.SyntaxKind.ElementNode) {
+                const matchingNode = (0, syntax_node_utilities_1.getFirstNodeFromAncestorChain)(chainBeforePos.slice(0, -3), syntax_kind_1.SyntaxKind.ElementNode);
+                if (!matchingNode)
+                    return defaultCompNames;
+                const compName = getNameFromElement(matchingNode, getText);
+                if (!compName)
+                    return defaultCompNames;
+                const compNameSuggestion = componentCompletionItem("/" + compName, 0);
+                return [compNameSuggestion, ...defaultCompNames.map((c) => (Object.assign(Object.assign({}, c), { sortText: "1" })))];
+            }
+            return defaultCompNames;
+        case syntax_kind_1.SyntaxKind.CloseNodeStart: {
+            //TODO: this can be substituted for an function that finds the first ElementNode up the tree
+            const closestElementNodeSuspect = chainBeforePos.at(-2);
+            if (closestElementNodeSuspect && closestElementNodeSuspect.kind === syntax_kind_1.SyntaxKind.ElementNode) {
+                const compName = getNameFromElement(closestElementNodeSuspect, getText);
+                if (!compName)
+                    return allComponentNames(metaByComp);
+                return [componentCompletionItem(compName)];
+            }
+            else {
+                return allComponentNames(metaByComp);
+            }
+        }
+        case syntax_kind_1.SyntaxKind.Identifier:
+            const pathToElementNode = (0, syntax_node_utilities_1.visitAncestorsInChain)(chainBeforePos, (n) => n.kind === syntax_kind_1.SyntaxKind.ElementNode);
+            const parentOfnodeBefore = chainBeforePos.at(-2);
+            const completeCompName = (parentOfnodeBefore === null || parentOfnodeBefore === void 0 ? void 0 : parentOfnodeBefore.kind) === syntax_kind_1.SyntaxKind.TagNameNode && position === nodeBefore.end;
+            if (completeCompName) {
+                if (pathToElementNode && (0, syntax_node_utilities_1.insideClosingTag)(pathToElementNode)) {
+                    const compName = getNameFromElement(pathToElementNode.at(-1), getText);
+                    if (!compName)
+                        return allComponentNames(metaByComp);
+                    return [componentCompletionItem(compName)];
+                }
+                return allComponentNames(metaByComp);
+            }
+    }
+    const completeForProp = chainBeforePos.some((n) => n.kind === syntax_kind_1.SyntaxKind.AttributeKeyNode ||
+        n.kind === syntax_kind_1.SyntaxKind.TagNameNode ||
+        n.kind === syntax_kind_1.SyntaxKind.AttributeNode);
+    if (completeForProp) {
+        const tagNameNode = (0, syntax_node_utilities_1.findTagNameNodeInStack)(chainBeforePos);
+        if (!tagNameNode) {
+            return null;
+        }
+        const compName = (0, syntax_node_utilities_1.compNameForTagNameNode)(tagNameNode, getText);
+        if (!compName) {
+            return null;
+        }
+        return completionForNewAttr(compName, metaByComp);
+    }
+    return null;
+}
+function allComponentNames(md) {
+    return md.componentNames().map(componentCompletionItem);
+}
+/**
+ * Retrieves the name from an ElementNode
+ * @param elementNode has to point to a ElementNode
+ * @returns
+ */
+function getNameFromElement(elementNode, getText) {
+    const nameNode = elementNode.children.find((c) => c.kind === syntax_kind_1.SyntaxKind.TagNameNode);
+    if (nameNode === undefined) {
+        return null;
+    }
+    // --- Handle namespaces
+    const colonIdx = nameNode.children.findIndex((c) => c.kind === syntax_kind_1.SyntaxKind.Colon);
+    let nameSpace = undefined;
+    let nameIdentSearchSpace = nameNode.children;
+    let name = undefined;
+    if (colonIdx !== -1) {
+        nameIdentSearchSpace = nameNode.children.slice(colonIdx + 1);
+        const nameSpaceIdx = nameNode.children.findIndex((c) => c.kind === syntax_kind_1.SyntaxKind.Identifier);
+        if (nameSpaceIdx < colonIdx) {
+            nameSpace = getText(nameNode.children[nameSpaceIdx]);
+        }
+    }
+    const nameIdent = nameIdentSearchSpace.find((c) => c.kind === syntax_kind_1.SyntaxKind.Identifier);
+    if (nameIdent === undefined) {
+        return null;
+    }
+    name = getText(nameIdent);
+    const value = nameSpace !== undefined ? nameSpace + ":" + name : name;
+    return value;
+}
+function handleCompletionInsideToken(chainAtPos, position, metaByComp, getText) {
+    const parent = chainAtPos.at(-2);
+    if (!parent) {
+        return null;
+    }
+    switch (parent.kind) {
+        case syntax_kind_1.SyntaxKind.TagNameNode: {
+            const tagNameNodeParent = chainAtPos.at(-3);
+            const tagNameNodeIdx = tagNameNodeParent.children.findIndex((c) => c === parent);
+            if (tagNameNodeIdx <= 0) {
+                return null;
+            }
+            const previousNode = tagNameNodeParent.children[tagNameNodeIdx - 1];
+            if (previousNode.kind === syntax_kind_1.SyntaxKind.CloseNodeStart &&
+                tagNameNodeParent.kind === syntax_kind_1.SyntaxKind.ElementNode) {
+                const compName = getNameFromElement(tagNameNodeParent, getText);
+                if (!compName)
+                    return allComponentNames(metaByComp);
+                return [componentCompletionItem(compName)];
+            }
+            return allComponentNames(metaByComp);
+        }
+        case syntax_kind_1.SyntaxKind.AttributeKeyNode: {
+            const tagNameNode = (0, syntax_node_utilities_1.findTagNameNodeInStack)(chainAtPos);
+            const compName = (0, syntax_node_utilities_1.compNameForTagNameNode)(tagNameNode, getText);
+            return completionForNewAttr(compName, metaByComp);
+        }
+    }
+    return null;
+}
+function completionForNewAttr(compName, metaByComp) {
+    const metadata = metaByComp.getComponent(compName);
+    if (!metadata) {
+        return null;
+    }
+    const completionItemFromAttr = attributeCompletionItem.bind({}, compName);
+    return metadata.getAllAttributes().map(completionItemFromAttr);
+}
+function attrKindToCompletionItemKind(attrKind) {
+    switch (attrKind) {
+        case "api":
+            return vscode_languageserver_1.CompletionItemKind.Function;
+        case "event":
+            return vscode_languageserver_1.CompletionItemKind.Event;
+        case "layout":
+            return vscode_languageserver_1.CompletionItemKind.Unit;
+        case "prop":
+        case "implicit":
+            return vscode_languageserver_1.CompletionItemKind.Property;
+        default:
+            const _exhaustiveCheck = attrKind;
+            return _exhaustiveCheck;
+    }
+}
+function attributeCompletionItem(componentName, attribute) {
+    const label = attribute.kind === "event" ? (0, metadata_utils_1.addOnPrefix)(attribute.name) : attribute.name;
+    return {
+        label,
+        kind: attrKindToCompletionItemKind(attribute.kind),
+        sortText: attributeDisplayOrder(attribute.kind) + label,
+        data: {
+            metadataAccessInfo: {
+                componentName,
+                attribute,
+            },
+        },
+    };
+}
+function componentCompletionItem(componentName, sortingOrder) {
+    const sortText = sortingOrder !== undefined &&
+        sortingOrder !== 0 &&
+        sortingOrder !== null &&
+        !isNaN(sortingOrder)
+        ? sortingOrder.toString()
+        : "";
+    return {
+        label: componentName,
+        kind: vscode_languageserver_1.CompletionItemKind.Constructor,
+        sortText,
+        data: {
+            metadataAccessInfo: {
+                componentName,
+            },
+        },
+    };
+}
+function markupContent(content) {
+    return {
+        kind: vscode_languageserver_1.MarkupKind.Markdown,
+        value: content,
+    };
+}
+function attributeDisplayOrder(kind) {
+    switch (kind) {
+        case "api":
+        case "prop":
+        case "implicit":
+        case "event":
+            return "0";
+        case "layout":
+            return "1";
+        default: {
+            const _exhaustiveCheck = kind;
+            return _exhaustiveCheck;
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiagnostics = getDiagnostics;
+exports.errorToLspDiag = errorToLspDiag;
+const lsp_utils_1 = require("./common/lsp-utils");
+function getDiagnostics(ctx) {
+    const { errors } = ctx.parseResult;
+    return errors.map((e) => {
+        return errorToLspDiag(e, ctx.offsetToPos);
+    });
+}
+function errorToLspDiag(e, offsetToPos) {
+    return {
+        severity: e.category,
+        range: (0, lsp_utils_1.offsetToPosRange)(offsetToPos, e),
+        message: e.message,
+        code: e.code,
+    };
+}