xmlui 0.9.11 → 0.9.13

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

@@ -200,7 +200,7 @@ function parseXmlUiMarkup(text) {
             }
         }
         if (eat(syntax_kind_1.SyntaxKind.Equal)) {
-            if (!eat(syntax_kind_1.SyntaxKind.StringLiteral) && !eat(syntax_kind_1.SyntaxKind.Identifier)) {
+            if (!eat(syntax_kind_1.SyntaxKind.StringLiteral)) {
                 const attrFollowWithoutIdent = [syntax_kind_1.SyntaxKind.NodeEnd, syntax_kind_1.SyntaxKind.NodeClose];
                 errRecover(diagnostics_1.Diag_Attr_Value_Expected, attrFollowWithoutIdent);
             }

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

@@ -618,7 +618,6 @@ function nodeToComponentDef(node, originalGetText, fileId) {
         const shouldCollapseWhitespace = tagName !== "event" && tagName !== "method";
         const attrs = getAttributes(node);
         desugarKeyOnlyAttrs(attrs);
-        desugarQuotelessAttrs(attrs, getText);
         parseEscapeCharactersInAttrValues(attrs);
         parseEscapeCharactersInContent(childNodes);
         mergeConsecutiveTexts(childNodes, shouldCollapseWhitespace);
@@ -1030,15 +1029,6 @@ function desugarKeyOnlyAttrs(attrs) {
         }
     }
 }
-function desugarQuotelessAttrs(attrs, getText) {
-    var _a, _b, _c;
-    for (let attr of attrs) {
-        const attrValue = (_a = attr.children) === null || _a === void 0 ? void 0 : _a[2];
-        if (((_c = (_b = attr.children) === null || _b === void 0 ? void 0 : _b[2]) === null || _c === void 0 ? void 0 : _c.kind) === syntax_kind_1.SyntaxKind.Identifier) {
-            attrValue.text = '"' + getText(attrValue) + '"';
-        }
-    }
-}
 function addToNamespaces(namespaceStack, comp, nsKey, value) {
     var _a;
     let nsCommaSeparated = value.split(":");

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

@@ -42,13 +42,11 @@ function findTokenAtPos(node, position) {
     if (node.start > position || position > node.end) {
         return undefined;
     }
-    // if (position === node.end) {
-    //   return {
-    //     chainBeforePos: findLastToken(node),
-    //     sharedParents: 0,
-    //   };
-    // }
-    const res = { chainAtPos: chain };
+    const res = {
+        chainAtPos: chain,
+        chainBeforePos: undefined,
+        sharedParents: undefined
+    };
     while (node.children !== undefined && node.children.length > 0) {
         //todo: make it a binary search before finding a fork
         const nodeAtPosIdx = node.children.findIndex((n) => n.start <= position &&
@@ -57,9 +55,8 @@ function findTokenAtPos(node, position) {
         const nodeBeforePos = node.children[nodeAtPosIdx - 1];
         if (nodeBeforePos !== undefined && position <= nodeAtPos.pos) {
             sharedParents = chain.length;
-            chainBeforePos = findLastToken(nodeBeforePos);
             return {
-                chainBeforePos,
+                chainBeforePos: chain.concat(findLastToken(nodeBeforePos)),
                 sharedParents,
                 chainAtPos: chain.concat(findFirstToken(nodeAtPos)),
             };

package/dist/{server-common-DxRVCeIE.mjs → server-common-DW5h7Q34.mjs}

@@ -1,6 +1,6 @@
 import { MarkupKind as MarkupKind$1, CompletionItemKind as CompletionItemKind$1, TextDocuments as TextDocuments$1, TextDocumentSyncKind, DidChangeConfigurationNotification } from "vscode-languageserver";
 import { TextDocument as TextDocument$1 } from "vscode-languageserver-textdocument";
-import { S as SyntaxKind, x as findTokenAtPos, o as createXmlUiParser } from "./parser-mzWvH7dz.mjs";
+import { S as SyntaxKind, x as findTokenAtPos, c as createXmlUiParser } from "./parser-CBXS8ft2.mjs";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getAugmentedNamespace(n) {
   if (n.__esModule) return n;
@@ -18757,6 +18757,40 @@ function compNameForTagNameNode(tagNameNode, getText) {
   const nameNode = tagNameNode.children.findLast((c) => c.kind === SyntaxKind.Identifier);
   return getText(nameNode);
 }
+function insideClosingTag(pathToElementNode) {
+  if (pathToElementNode === null) {
+    return false;
+  }
+  const elementNode = pathToElementNode.at(-1);
+  const nodeBeforeElementNode = pathToElementNode.at(-2);
+  const inputWasOnlyAnElementNode = !nodeBeforeElementNode;
+  if (inputWasOnlyAnElementNode) {
+    return false;
+  }
+  const idxClosingStartToken = elementNode.children.findIndex((n) => n.kind === SyntaxKind.CloseNodeStart);
+  if (idxClosingStartToken === -1) {
+    return false;
+  }
+  const idxElementNodeChild = elementNode.children.findIndex((n) => n === nodeBeforeElementNode);
+  if (idxClosingStartToken <= idxElementNodeChild) {
+    return true;
+  }
+  return false;
+}
+function pathToNodeInAscendands(chain, predicate) {
+  let currentIdx = -1;
+  let current = chain.at(currentIdx);
+  let path = [current];
+  while (current) {
+    if (predicate(current)) {
+      return path;
+    }
+    currentIdx--;
+    current = chain.at(currentIdx);
+    path.push(current);
+  }
+  return null;
+}
 function handleCompletionResolve({
   item,
   metaByComp: metaByComp2
@@ -18764,7 +18798,6 @@ function handleCompletionResolve({
   var _a2;
   const metadataAccessInfo = (_a2 = item == null ? void 0 : item.data) == null ? void 0 : _a2.metadataAccessInfo;
   if (metadataAccessInfo) {
-    metaByComp2.Alert.props;
     const { componentName } = metadataAccessInfo;
     const componentMeta = metaByComp2[componentName];
     if ("prop" in metadataAccessInfo) {
@@ -18793,7 +18826,19 @@ function handleCompletion({ parseResult: { node }, getText, metaByComp: metaByCo
     case SyntaxKind.OpenNodeStart:
       return allComponentNames(metaByComp2);
     case SyntaxKind.CloseNodeStart:
-      return matchingTagName(findRes, metaByComp2, getText);
+      const closestElementNodeSuspect = chainBeforePos.at(-2) ?? chainAtPos.at(sharedParents - 1);
+      if (closestElementNodeSuspect && closestElementNodeSuspect.kind === SyntaxKind.ElementNode) {
+        return matchingTagName(closestElementNodeSuspect, metaByComp2, getText);
+      } else {
+        return allComponentNames(metaByComp2);
+      }
+    case SyntaxKind.Identifier:
+      const pathToElementNode = pathToNodeInAscendands(chainBeforePos, (n) => n.kind === SyntaxKind.ElementNode);
+      if (pathToElementNode && insideClosingTag(pathToElementNode)) {
+        const elementNode = pathToElementNode.at(-1);
+        return matchingTagName(elementNode, metaByComp2, getText);
+      }
+      return allComponentNames(metaByComp2);
   }
   const completeForProp = chainBeforePos.some(
     (n) => n.kind === SyntaxKind.AttributeKeyNode || n.kind === SyntaxKind.TagNameNode || n.kind === SyntaxKind.AttributeNode
@@ -18801,47 +18846,36 @@ function handleCompletion({ parseResult: { node }, getText, metaByComp: metaByCo
   if (completeForProp) {
     const tagNameNode = findTagNameNodeInStack(chainAtPos);
     const compName = compNameForTagNameNode(tagNameNode, getText);
-    return completionForNewProps(compName, metaByComp2);
+    return completionForNewProp(compName, metaByComp2);
   }
   return null;
 }
 function allComponentNames(md) {
-  return Object.keys(md).map(componentCompletionItem);
+  return Object.keys(md).map((compName) => CompletionItemBuilder.withComponent(compName).componentResolveData().build());
 }
-function matchingTagName({ chainAtPos, chainBeforePos, sharedParents }, metaByComp2, getText) {
-  let parentBefore;
-  if (chainBeforePos.length > 1) {
-    parentBefore = chainBeforePos[chainBeforePos.length - 2];
-  } else if (sharedParents > 0) {
-    parentBefore = chainAtPos[sharedParents - 1];
-  } else {
+function matchingTagName(elementNode, metaByComp2, getText) {
+  const nameNode = elementNode.children.find((c) => c.kind === SyntaxKind.TagNameNode);
+  if (nameNode === void 0) {
     return allComponentNames(metaByComp2);
   }
-  if (parentBefore.kind === SyntaxKind.ElementNode) {
-    const nameNode = parentBefore.children.find((c) => c.kind === SyntaxKind.TagNameNode);
-    if (nameNode === void 0) {
-      return allComponentNames(metaByComp2);
-    }
-    const colonIdx = nameNode.children.findIndex((c) => c.kind === SyntaxKind.Colon);
-    let nameSpace = void 0;
-    let nameIdentSearchSpace = nameNode.children;
-    let name = void 0;
-    if (colonIdx !== -1) {
-      nameIdentSearchSpace = nameNode.children.slice(colonIdx + 1);
-      const nameSpaceIdx = nameNode.children.findIndex((c) => c.kind === SyntaxKind.Identifier);
-      if (nameSpaceIdx < colonIdx) {
-        nameSpace = getText(nameNode.children[nameSpaceIdx]);
-      }
-    }
-    const nameIdent = nameIdentSearchSpace.find((c) => c.kind === SyntaxKind.Identifier);
-    if (nameIdent === void 0) {
-      return allComponentNames(metaByComp2);
+  const colonIdx = nameNode.children.findIndex((c) => c.kind === SyntaxKind.Colon);
+  let nameSpace = void 0;
+  let nameIdentSearchSpace = nameNode.children;
+  let name = void 0;
+  if (colonIdx !== -1) {
+    nameIdentSearchSpace = nameNode.children.slice(colonIdx + 1);
+    const nameSpaceIdx = nameNode.children.findIndex((c) => c.kind === SyntaxKind.Identifier);
+    if (nameSpaceIdx < colonIdx) {
+      nameSpace = getText(nameNode.children[nameSpaceIdx]);
     }
-    name = getText(nameIdent);
-    const value = nameSpace !== void 0 ? nameSpace + ":" + name : name;
-    return [componentCompletionItem(value)];
   }
-  return null;
+  const nameIdent = nameIdentSearchSpace.find((c) => c.kind === SyntaxKind.Identifier);
+  if (nameIdent === void 0) {
+    return allComponentNames(metaByComp2);
+  }
+  name = getText(nameIdent);
+  const value = nameSpace !== void 0 ? nameSpace + ":" + name : name;
+  return [CompletionItemBuilder.withComponent(value).build()];
 }
 function handleCompletionInsideToken(chainAtPos, position, metaByComp2, getText) {
   const parent = chainAtPos.at(-2);
@@ -18850,48 +18884,33 @@ function handleCompletionInsideToken(chainAtPos, position, metaByComp2, getText)
   }
   switch (parent.kind) {
     case 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 === SyntaxKind.CloseNodeStart && tagNameNodeParent.kind === SyntaxKind.ElementNode) {
+        return matchingTagName(tagNameNodeParent, metaByComp2, getText);
+      }
       return allComponentNames(metaByComp2);
     }
     case SyntaxKind.AttributeKeyNode: {
       const tagNameNode = findTagNameNodeInStack(chainAtPos);
       const compName = compNameForTagNameNode(tagNameNode, getText);
-      return completionForNewProps(compName, metaByComp2);
+      return completionForNewProp(compName, metaByComp2);
     }
   }
   return null;
 }
-function completionForNewProps(compName, metaByComp2) {
+function completionForNewProp(compName, metaByComp2) {
   const metadata = metaByComp2[compName];
   if (!metadata || !metadata.props) {
     return null;
   }
-  return Object.keys(metadata.props).map((propName) => propCompletionItem(compName, propName));
-}
-function componentCompletionItem(name) {
-  return {
-    label: name,
-    kind: CompletionItemKind$1.Constructor,
-    labelDetails: {
-      description: "Core component"
-    },
-    data: {
-      metadataAccessInfo: {
-        componentName: name
-      }
-    }
-  };
-}
-function propCompletionItem(componentName, name) {
-  return {
-    label: name,
-    kind: CompletionItemKind$1.Property,
-    data: {
-      metadataAccessInfo: {
-        prop: name,
-        componentName
-      }
-    }
-  };
+  return Object.keys(metadata.props).map(
+    (propName) => CompletionItemBuilder.withProp(propName).propResolveData(compName).build()
+  );
 }
 function markupContent(content) {
   return {
@@ -18899,6 +18918,45 @@ function markupContent(content) {
     value: content
   };
 }
+class CompletionItemBuilder {
+  static withComponent(name) {
+    const item = {
+      label: name,
+      kind: CompletionItemKind$1.Constructor
+    };
+    return new CompletionItemBuilder(item);
+  }
+  static withProp(propName) {
+    const item = {
+      label: propName,
+      kind: CompletionItemKind$1.Property
+    };
+    return new CompletionItemBuilder(item);
+  }
+  constructor(item) {
+    this.item = item;
+  }
+  componentResolveData() {
+    const data = {
+      metadataAccessInfo: { componentName: this.item.label }
+    };
+    this.item.data = data;
+    return this;
+  }
+  propResolveData(componentName) {
+    const data = {
+      metadataAccessInfo: {
+        componentName,
+        prop: this.item.label
+      }
+    };
+    this.item.data = data;
+    return this;
+  }
+  build() {
+    return this.item;
+  }
+}
 function handleHover({ parseResult: { node }, getText, metaByComp: metaByComp2 }, position) {
   const findRes = findTokenAtPos(node, position);
   console.log("findres: ", findRes);