xmlui 0.5.2-beta.4 → 0.6.0-beta.5

package/dist/scripts/src/parsers/scripting/Parser.js

@@ -209,7 +209,8 @@ class Parser {
                 declarationProps = {
                     objectDestruct,
                 };
-                endToken = objectDestruct.length > 0 ? objectDestruct[objectDestruct.length - 1].endToken : endToken;
+                endToken =
+                    objectDestruct.length > 0 ? objectDestruct[objectDestruct.length - 1].endToken : endToken;
             }
             else if (declStart.type === Token_1.TokenType.LSquare) {
                 // --- This is array destructure
@@ -220,7 +221,8 @@ class Parser {
                 declarationProps = {
                     arrayDestruct,
                 };
-                endToken = arrayDestruct.length > 0 ? arrayDestruct[arrayDestruct.length - 1].endToken : endToken;
+                endToken =
+                    arrayDestruct.length > 0 ? arrayDestruct[arrayDestruct.length - 1].endToken : endToken;
             }
             else if (declStart.type === Token_1.TokenType.Identifier) {
                 endToken = this._lexer.get();
@@ -282,7 +284,8 @@ class Parser {
                 declarationProps = {
                     objectDestruct,
                 };
-                endToken = objectDestruct.length > 0 ? objectDestruct[objectDestruct.length - 1].endToken : endToken;
+                endToken =
+                    objectDestruct.length > 0 ? objectDestruct[objectDestruct.length - 1].endToken : endToken;
             }
             else if (declStart.type === Token_1.TokenType.LSquare) {
                 // --- This is array destructure
@@ -293,7 +296,8 @@ class Parser {
                 declarationProps = {
                     arrayDestruct,
                 };
-                endToken = arrayDestruct.length > 0 ? arrayDestruct[arrayDestruct.length - 1].endToken : endToken;
+                endToken =
+                    arrayDestruct.length > 0 ? arrayDestruct[arrayDestruct.length - 1].endToken : endToken;
             }
             else if (declStart.type === Token_1.TokenType.Identifier) {
                 endToken = this._lexer.get();
@@ -1153,7 +1157,9 @@ class Parser {
      *   ;
      */
     parseExpr(allowSequence = true) {
-        return allowSequence ? this.parseSequenceExpression() : this.parseCondOrSpreadOrAsgnOrArrowExpr();
+        return allowSequence
+            ? this.parseSequenceExpression()
+            : this.parseCondOrSpreadOrAsgnOrArrowExpr();
     }
     /**
      * sequenceExpr
@@ -1851,6 +1857,8 @@ class Parser {
                     isGlobal: true,
                 }, idToken, idToken);
             }
+            case Token_1.TokenType.Backtick:
+                return this.parseTemplateLiteral();
             case Token_1.TokenType.False:
             case Token_1.TokenType.True:
                 this._lexer.get();
@@ -1901,6 +1909,34 @@ class Parser {
         }
         return null;
     }
+    parseTemplateLiteral() {
+        const startToken = this._lexer.get();
+        this._lexer.setStartingPhaseToTemplateLiteral();
+        const segments = [];
+        loop: while (true) {
+            let nextToken = this._lexer.peek();
+            switch (nextToken.type) {
+                case Token_1.TokenType.StringLiteral:
+                    this._lexer.get();
+                    const str = this.parseStringLiteral(nextToken, false);
+                    segments.push(str);
+                    break;
+                case Token_1.TokenType.DollarLBrace:
+                    this._lexer.get();
+                    const innerExpr = this.parseExpr();
+                    segments.push(innerExpr);
+                    this.expectToken(Token_1.TokenType.RBrace, "W004");
+                    this._lexer.setStartingPhaseToTemplateLiteral();
+                    break;
+                case Token_1.TokenType.Backtick:
+                    break loop;
+                default:
+                    this.reportError("W004");
+            }
+        }
+        const endToken = this._lexer.get();
+        return this.createExpressionNode("TempLitE", { segments }, startToken, endToken);
+    }
     /**
      * Parses an array literal
      */
@@ -1949,7 +1985,9 @@ class Parser {
                         if (!nameExpr) {
                             return null;
                         }
-                        if (nameExpr.type !== "IdE" && nameExpr.type !== "LitE" && nameExpr.type !== "SpreadE") {
+                        if (nameExpr.type !== "IdE" &&
+                            nameExpr.type !== "LitE" &&
+                            nameExpr.type !== "SpreadE") {
                             this.reportError("W007");
                             return null;
                         }
@@ -2000,7 +2038,8 @@ class Parser {
                     let valueExpr = null;
                     if (nameType === "IdE") {
                         const nameFollowerToken = this._lexer.peek();
-                        if (nameFollowerToken.type === Token_1.TokenType.Comma || nameFollowerToken.type === Token_1.TokenType.RBrace) {
+                        if (nameFollowerToken.type === Token_1.TokenType.Comma ||
+                            nameFollowerToken.type === Token_1.TokenType.RBrace) {
                             valueExpr = Object.assign({}, nameExpr);
                         }
                     }
@@ -2288,8 +2327,11 @@ class Parser {
      * Converts a string token to intrinsic string
      * @param token Literal token
      */
-    parseStringLiteral(token) {
-        const input = token.text.length < 2 ? "" : token.text.substring(1, token.text.length - 1);
+    parseStringLiteral(token, quoteSurrounded = true) {
+        let input = token.text;
+        if (quoteSurrounded) {
+            input = token.text.length < 2 ? "" : input.substring(1, input.length - 1);
+        }
         let result = "";
         let state = StrParseState.Normal;
         let collect = 0;
@@ -2346,7 +2388,7 @@ class Parser {
                             state = StrParseState.UX1;
                             break;
                         default:
-                            result += "\\" + ch;
+                            result += ch;
                             break;
                     }
                     break;
@@ -2645,3 +2687,4 @@ class Parser {
     }
 }
 exports.Parser = Parser;
+"TypeError: Cannot read properties of undefined (reading 'canBeUnary')\n    at Parser.parseUnaryOrPrefixExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:2041:38)\n    at Parser.parseExponentialExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1985:25)\n    at Parser.parseMultExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1951:25)\n    at Parser.parseAddExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1917:25)\n    at Par…nExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1835:25)\n    at Parser.parseEquExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1793:25)\n    at Parser.parseBitwiseAndExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1760:25)\n    at Parser.parseBitwiseXorExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1727:25)\n    at Parser.parseBitwiseOrExpr (/home/ez/code/work/xmlui/xmlui/src/parsers/scripting/Parser.ts:1694:25)";

package/dist/scripts/src/parsers/scripting/TokenTrait.js

@@ -6,6 +6,8 @@ const Token_1 = require("../../abstractions/scripting/Token");
 exports.tokenTraits = {
     [Token_1.TokenType.Eof]: {},
     [Token_1.TokenType.Ws]: {},
+    [Token_1.TokenType.DollarLBrace]: {},
+    [Token_1.TokenType.Backtick]: { expressionStart: true },
     [Token_1.TokenType.BlockComment]: {},
     [Token_1.TokenType.EolComment]: {},
     [Token_1.TokenType.Unknown]: {},

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

@@ -169,15 +169,16 @@ function parseXmlUiMarkup(text) {
         startNode();
         const attrNames = [];
         while (!atAnyOf([syntax_kind_1.SyntaxKind.EndOfFileToken, syntax_kind_1.SyntaxKind.NodeEnd, syntax_kind_1.SyntaxKind.NodeClose])) {
-            if (at(syntax_kind_1.SyntaxKind.Identifier)) {
-                parseAttr(attrNames);
-            }
-            else {
-                const atTagLike = errRecover(diagnostics_1.Diag_Attr_Identifier_Expected, firstSetTagLike);
-                if (atTagLike) {
-                    parseTagLike();
-                }
-            }
+            parseAttr(attrNames);
+            // todo: was this usefuel?
+            // if (at(SyntaxKind.Identifier)) {
+            //   parseAttr(attrNames);
+            // } else {
+            //   const atTagLike = errRecover(Diag_Attr_Identifier_Expected, firstSetTagLike);
+            //   if (atTagLike) {
+            //     parseTagLike();
+            //   }
+            // }
         }
         if (node.children.length === 0) {
             abandonNode();
@@ -187,38 +188,63 @@ function parseXmlUiMarkup(text) {
         }
     }
     function parseAttr(attrNames) {
-        //todo: make this recovery set actualy true (like implement handling cdata ,...)
-        const attrListFollow = [
-            // FOLLOW(AttrList) when a Tag is correct
-            syntax_kind_1.SyntaxKind.NodeClose,
-            syntax_kind_1.SyntaxKind.NodeEnd,
-            // FOLLOW(AttrList) when a Tag contains incorrect, but still parsed tokens for resilience
-            syntax_kind_1.SyntaxKind.CData,
-            // todo
-            // SyntaxKind.ScriptLiteral,
-            syntax_kind_1.SyntaxKind.OpenNodeStart,
-        ];
-        const attrFollow = attrListFollow.concat(syntax_kind_1.SyntaxKind.Identifier);
-        const attrIdent = peek();
-        const attrName = getText(attrIdent);
-        if (attrNames.includes(attrName)) {
-            errorAt(MakeErr.duplAttr(attrName), attrIdent.pos, attrIdent.end);
-        }
-        else if (attrName[0] >= "A" && attrName[0] <= "Z") {
-            errorAt(MakeErr.uppercaseAttr(attrName), attrIdent.pos, attrIdent.end);
+        startNode();
+        if (at(syntax_kind_1.SyntaxKind.Identifier)) {
+            parseAttrName(attrNames);
         }
         else {
-            attrNames.push(attrName);
+            const attrNameFollow = [syntax_kind_1.SyntaxKind.Equal];
+            const eqFollows = errRecover(diagnostics_1.Diag_Attr_Identifier_Expected, attrNameFollow);
+            if (!eqFollows) {
+                return;
+            }
         }
-        startNode();
-        bump(syntax_kind_1.SyntaxKind.Identifier);
         if (eat(syntax_kind_1.SyntaxKind.Equal)) {
             if (!eat(syntax_kind_1.SyntaxKind.StringLiteral) && !eat(syntax_kind_1.SyntaxKind.Identifier)) {
-                errRecover(diagnostics_1.Diag_Attr_Value_Expected, attrFollow);
+                const attrFollowWithoutIdent = [syntax_kind_1.SyntaxKind.NodeEnd, syntax_kind_1.SyntaxKind.NodeClose];
+                errRecover(diagnostics_1.Diag_Attr_Value_Expected, attrFollowWithoutIdent);
             }
         }
         completeNode(syntax_kind_1.SyntaxKind.AttributeNode);
     }
+    function parseAttrName(attrNames) {
+        const nameIdent = peek();
+        let nsIdent = undefined;
+        startNode();
+        bump(syntax_kind_1.SyntaxKind.Identifier);
+        if (eat(syntax_kind_1.SyntaxKind.Colon)) {
+            if (at(syntax_kind_1.SyntaxKind.Identifier)) {
+                nsIdent = bump(syntax_kind_1.SyntaxKind.Identifier);
+            }
+            else {
+                errRecover(diagnostics_1.Diag_Attr_Identifier_Expected, [
+                    syntax_kind_1.SyntaxKind.NodeClose,
+                    syntax_kind_1.SyntaxKind.NodeEnd,
+                    syntax_kind_1.SyntaxKind.Equal,
+                ]);
+            }
+        }
+        checkAttrName(attrNames, { nsIdent, nameIdent });
+        completeNode(syntax_kind_1.SyntaxKind.AttributeKeyNode);
+    }
+    /** emits errors when the attribute name is incorrect. Otherwise adds the attribute name to the list of valid names*/
+    function checkAttrName(attrNames, { nameIdent, nsIdent }) {
+        const attrName = getText(nameIdent);
+        const attrNs = nsIdent === undefined ? undefined : getText(nsIdent);
+        const attrKeyMatches = ({ ns, name }) => name === attrName && ns === attrNs;
+        const isDuplicate = attrNames.findIndex(attrKeyMatches) !== -1;
+        const nameStartsWithUppercase = "A" <= attrName[0] && attrName[0] <= "Z";
+        const faultyName = isDuplicate || nameStartsWithUppercase;
+        if (isDuplicate) {
+            errorAt(MakeErr.duplAttr(attrName), nameIdent.pos, nameIdent.end);
+        }
+        if (nameStartsWithUppercase) {
+            errorAt(MakeErr.uppercaseAttr(attrName), nameIdent.pos, nameIdent.end);
+        }
+        if (!faultyName) {
+            attrNames.push({ name: attrName });
+        }
+    }
     function at(kindToCheck) {
         return peek().kind === kindToCheck;
     }
@@ -233,8 +259,9 @@ function parseXmlUiMarkup(text) {
         return kinds.includes(peek().kind);
     }
     /**
-     * @param recoveryTokens the [FollowSet](https://www.geeksforgeeks.org/follow-set-in-syntax-analysis/) of the parsed InnerNode
-     * @returns true if the current token is in the recovery set, otherwise false
+     * report an error and skip the next token if it isn't in the recoveryTokens. EoF isn't skipped.
+     * @param recoveryTokens the [FollowSet](https://www.geeksforgeeks.org/follow-set-in-syntax-analysis/) of the parsed InnerNode. These tokens (or the EoF token) won't be skipped
+     * @returns true if the current token is in the recovery set or EoF
      * */
     function errRecover(errCodeAndMsg, recoveryTokens) {
         if (atAnyOf(recoveryTokens) || at(syntax_kind_1.SyntaxKind.EndOfFileToken)) {
@@ -364,6 +391,7 @@ function parseXmlUiMarkup(text) {
         if (token.kind !== kind) {
             throw new Error(`expected ${(0, syntax_kind_1.getSyntaxKindStrRepr)(kind)}, bumped a ${(0, syntax_kind_1.getSyntaxKindStrRepr)(token.kind)}`);
         }
+        return token;
     }
     function bumpAny() {
         if (peekedToken) {
@@ -454,6 +482,7 @@ function parseXmlUiMarkup(text) {
             }
         }
     }
+    /** Bumps over the next token and marks it as an error node while adding an error to the error list*/
     function errorAndBump(errCodeAndMsg) {
         errRecover(errCodeAndMsg, []);
     }

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

@@ -4,6 +4,7 @@ exports.SyntaxKind = void 0;
 exports.isTrivia = isTrivia;
 exports.isInnerNode = isInnerNode;
 exports.getSyntaxKindStrRepr = getSyntaxKindStrRepr;
+/** tokens and nodes combined. Order is significant since the functions below use the numeric values of this enum to check for a range of possible values*/
 var SyntaxKind;
 (function (SyntaxKind) {
     SyntaxKind[SyntaxKind["Unknown"] = 0] = "Unknown";
@@ -34,14 +35,15 @@ var SyntaxKind;
     // Syntax node types
     SyntaxKind[SyntaxKind["ElementNode"] = 21] = "ElementNode";
     SyntaxKind[SyntaxKind["AttributeNode"] = 22] = "AttributeNode";
-    SyntaxKind[SyntaxKind["ContentListNode"] = 23] = "ContentListNode";
-    SyntaxKind[SyntaxKind["AttributeListNode"] = 24] = "AttributeListNode";
-    SyntaxKind[SyntaxKind["TagNameNode"] = 25] = "TagNameNode";
+    SyntaxKind[SyntaxKind["AttributeKeyNode"] = 23] = "AttributeKeyNode";
+    SyntaxKind[SyntaxKind["ContentListNode"] = 24] = "ContentListNode";
+    SyntaxKind[SyntaxKind["AttributeListNode"] = 25] = "AttributeListNode";
+    SyntaxKind[SyntaxKind["TagNameNode"] = 26] = "TagNameNode";
     // should be the last syntax node type
-    SyntaxKind[SyntaxKind["ErrorNode"] = 26] = "ErrorNode";
+    SyntaxKind[SyntaxKind["ErrorNode"] = 27] = "ErrorNode";
 })(SyntaxKind || (exports.SyntaxKind = SyntaxKind = {}));
 function isTrivia(token) {
-    return (token >= SyntaxKind.CommentTrivia && token <= SyntaxKind.WhitespaceTrivia);
+    return token >= SyntaxKind.CommentTrivia && token <= SyntaxKind.WhitespaceTrivia;
 }
 function isInnerNode(token) {
     return token >= SyntaxKind.ElementNode && token <= SyntaxKind.ErrorNode;
@@ -49,58 +51,64 @@ function isInnerNode(token) {
 function getSyntaxKindStrRepr(kind) {
     switch (kind) {
         case SyntaxKind.Unknown:
-            return 'Unknown';
+            return "Unknown";
         case SyntaxKind.EndOfFileToken:
-            return 'EndOfFileToken';
+            return "EndOfFileToken";
         case SyntaxKind.CommentTrivia:
-            return 'CommentTrivia';
+            return "CommentTrivia";
         case SyntaxKind.NewLineTrivia:
-            return 'NewLineTrivia';
+            return "NewLineTrivia";
         case SyntaxKind.WhitespaceTrivia:
-            return 'WhitespaceTrivia';
+            return "WhitespaceTrivia";
         case SyntaxKind.Identifier:
-            return 'Identifier';
+            return "Identifier";
         case SyntaxKind.OpenNodeStart:
-            return 'OpenNodeStart';
+            return "OpenNodeStart";
         case SyntaxKind.CloseNodeStart:
-            return 'CloseNodeStart';
+            return "CloseNodeStart";
         case SyntaxKind.NodeEnd:
-            return 'NodeEnd';
+            return "NodeEnd";
         case SyntaxKind.NodeClose:
-            return 'NodeClose';
+            return "NodeClose";
         case SyntaxKind.Colon:
-            return 'Colon';
+            return "Colon";
         case SyntaxKind.Equal:
-            return 'Equal';
+            return "Equal";
         case SyntaxKind.StringLiteral:
-            return 'StringLiteral';
+            return "StringLiteral";
         case SyntaxKind.CData:
-            return 'CData';
+            return "CData";
         case SyntaxKind.Script:
-            return 'Script';
+            return "Script";
         case SyntaxKind.AmpersandEntity:
-            return 'AmpersandEntity';
+            return "AmpersandEntity";
         case SyntaxKind.LessThanEntity:
-            return 'LessThanEntity';
+            return "LessThanEntity";
         case SyntaxKind.GreaterThanEntity:
-            return 'GreaterThanEntity';
+            return "GreaterThanEntity";
         case SyntaxKind.SingleQuoteEntity:
-            return 'SingleQuoteEntity';
+            return "SingleQuoteEntity";
         case SyntaxKind.DoubleQuoteEntity:
-            return 'DoubleQuoteEntity';
+            return "DoubleQuoteEntity";
         case SyntaxKind.ElementNode:
-            return 'ElementNode';
+            return "ElementNode";
         case SyntaxKind.AttributeNode:
-            return 'AttributeNode';
+            return "AttributeNode";
         case SyntaxKind.TextNode:
-            return 'TextNode';
+            return "TextNode";
         case SyntaxKind.ContentListNode:
-            return 'ContentListNode';
+            return "ContentListNode";
         case SyntaxKind.AttributeListNode:
-            return 'AttributeListNode';
+            return "AttributeListNode";
         case SyntaxKind.TagNameNode:
-            return 'TagNameNode';
+            return "TagNameNode";
         case SyntaxKind.ErrorNode:
-            return 'ErrorNode';
+            return "ErrorNode";
+        case SyntaxKind.AttributeKeyNode:
+            return "AttributeKeyNode";
     }
+    return assertUnreachable(kind);
+}
+function assertUnreachable(x) {
+    throw new Error("Didn't expect to get here");
 }

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

@@ -558,13 +558,18 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
         return getText(name);
     }
     function segmentAttr(attr) {
-        let key = getText(attr.children[0]);
-        const segments = key.split(".");
+        let key = attr.children[0];
+        const hasNamespace = key.children.length === 3;
+        let namespace;
+        if (hasNamespace) {
+            namespace = getText(key.children[0]);
+        }
+        let name = getText(key.children[key.children.length - 1]);
+        const segments = name.split(".");
         if (segments.length > 2) {
             reportError("T007", attr, key);
         }
         let startSegment;
-        let name = key;
         if (segments.length === 2) {
             startSegment = segments[0];
             name = segments[1];
@@ -831,7 +836,10 @@ function createTextNodeCDataElement(textValue) {
                     {
                         kind: syntax_kind_1.SyntaxKind.AttributeNode,
                         children: [
-                            { kind: syntax_kind_1.SyntaxKind.Identifier, text: "value" },
+                            {
+                                kind: syntax_kind_1.SyntaxKind.AttributeKeyNode,
+                                children: [{ kind: syntax_kind_1.SyntaxKind.Identifier, text: "value" }],
+                            },
                             { kind: syntax_kind_1.SyntaxKind.Equal },
                             { kind: syntax_kind_1.SyntaxKind.Identifier, text: `"${textValue}"` },
                         ],
@@ -857,7 +865,10 @@ function createTextNodeElement(textValue) {
                     {
                         kind: syntax_kind_1.SyntaxKind.AttributeNode,
                         children: [
-                            { kind: syntax_kind_1.SyntaxKind.Identifier, text: "value" },
+                            {
+                                kind: syntax_kind_1.SyntaxKind.AttributeKeyNode,
+                                children: [{ kind: syntax_kind_1.SyntaxKind.Identifier, text: "value" }],
+                            },
                             { kind: syntax_kind_1.SyntaxKind.Equal },
                             { kind: syntax_kind_1.SyntaxKind.Identifier, text: `"${textValue}"` },
                         ],