xmlui 0.9.2 → 0.9.3

package/dist/scripts/src/syntax/monaco/grammar.monacoLanguage.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmluiGrammar = void 0;
+exports.XmluiGrammar = {
+    id: "xmlui",
+    config: {
+        comments: {
+            blockComment: ["<!--", "-->"],
+        },
+        brackets: [["<", ">"]],
+        autoClosingPairs: [
+            { open: "<", close: ">" },
+            { open: "'", close: "'" },
+            { open: '"', close: '"' },
+            { open: "`", close: "`" },
+        ],
+        surroundingPairs: [
+            { open: "<", close: ">" },
+            { open: "'", close: "'" },
+            { open: '"', close: '"' },
+            { open: "`", close: "`" },
+        ],
+    },
+    language: {
+        defaultToken: "",
+        tokenPostfix: ".xmlui",
+        ignoreCase: false,
+        identifier: /[a-zA-Z$_][-\w.$]*/,
+        tokenizer: {
+            root: [
+                { include: "@commentStart" },
+                { include: "@helperTag" },
+                { include: "@componentTagStart" },
+                { include: "@escapeCharacter" },
+                { include: "@textWithBindingExpr" },
+                { include: "@entity" },
+                { include: "@cdataStart" },
+            ],
+            helperTag: [
+                { include: "@scriptTagStart" },
+                { include: "@eventTagStart" },
+                { include: "@apiTagStart" },
+                { include: "@methodTagStart" },
+                { include: "@propOrVarTagStart" },
+            ],
+            eventTagStart: [
+                [
+                    /(<)((?:[a-zA-Z_][\w\.\-]*?:)?)(event)/,
+                    ["delimiter.angle", "namespace", { token: "tag-event", next: "@eventTag" }],
+                ],
+            ],
+            eventTag: [
+                { include: "@commentStart" },
+                { include: "@valueAttributeScriptInsideStart" },
+                { include: "@attributeStart" },
+                [/\/>/, "delimiter.angle", "@pop"],
+                [
+                    /(<\/)(event)(\s*>)/,
+                    ["delimiter.angle", "tag-event", { token: "delimiter.angle", next: "@pop" }],
+                ],
+                [/>/, { token: "delimiter.angle", next: "@eventTagContent" }],
+            ],
+            eventTagContent: [
+                { include: "commentStart" },
+                { include: "componentTagStart" },
+                [
+                    /[^<]/,
+                    { token: "@rematch", next: "@eventTagScriptContent", nextEmbedded: "xmluiscript" },
+                ],
+                [/<\/event\s*>/, { token: "@rematch", next: "@pop" }],
+            ],
+            eventTagScriptContent: [
+                [/<\/event\s*>/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+                [/[^<]/, ""],
+            ],
+            methodTagStart: [
+                [
+                    /(<)((?:[a-zA-Z_][\w\.\-]*?:)?)(method)/,
+                    ["delimiter.angle", "namespace", { token: "tag-helper", next: "@methodTag" }],
+                ],
+            ],
+            methodTag: [
+                { include: "@commentStart" },
+                { include: "@valueAttributeScriptInsideStart" },
+                { include: "@attributeStart" },
+                [/\/>/, "delimiter.angle", "@pop"],
+                [
+                    />/,
+                    {
+                        token: "delimiter.angle",
+                        next: "@methodTagScriptContent",
+                        nextEmbedded: "xmluiscript",
+                    },
+                ],
+                [
+                    /(<\/)(method)(\s*>)/,
+                    ["delimiter.angle", "tag-helper", { token: "delimiter.angle", next: "@pop" }],
+                ],
+            ],
+            methodTagScriptContent: [
+                [/<\/method\s*>/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+                [/[^</]/, ""],
+            ],
+            apiTagStart: [
+                [
+                    /(<)((?:[a-zA-Z_][\w\.\-]*?:)?)(api)/,
+                    ["delimiter.angle", "namespace", { token: "tag-helper", next: "@apiTag" }],
+                ],
+            ],
+            apiTag: [
+                { include: "@commentStart" },
+                { include: "@valueAttributeScriptInsideStart" },
+                { include: "@attributeStart" },
+                [/\/>/, "delimiter.angle", "@pop"],
+                [
+                    />/,
+                    { token: "delimiter.angle", next: "@apiTagScriptContent", nextEmbedded: "xmluiscript" },
+                ],
+                [
+                    /(<\/)(api)(\s*>)/,
+                    ["delimiter.angle", "tag-helper", { token: "delimiter.angle", next: "@pop" }],
+                ],
+            ],
+            apiTagScriptContent: [
+                [/<\/api\s*>/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+                [/[^</]/, ""],
+            ],
+            valueAttributeScriptInsideStart: [
+                [
+                    /(^|\s+)(value)(\s*=)(['\"`])/,
+                    [
+                        "",
+                        "attribute",
+                        "operators",
+                        {
+                            cases: {
+                                "'": { token: "string", next: "@singleQuotedScript", nextEmbedded: "xmluiscript" },
+                                '"': { token: "string", next: "@doubleQuotedScript", nextEmbedded: "xmluiscript" },
+                                "`": {
+                                    token: "string",
+                                    next: "@backtickQuotedScript",
+                                    nextEmbedded: "xmluiscript",
+                                },
+                            },
+                        },
+                    ],
+                ],
+            ],
+            scriptTagStart: [
+                [
+                    /(<)(script\s*)(>)/,
+                    [
+                        "delimiter.angle",
+                        "tag-script",
+                        { token: "delimiter.angle", nextEmbedded: "xmluiscript", next: "@scriptTag" },
+                    ],
+                ],
+                [/(<\/)(script\s*)(>)/, ["delimiter.angle", "tag-script", "delimiter.angle"]],
+            ],
+            scriptTag: [
+                [/<\/script>/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+                [/[^<]+/, ""],
+            ],
+            propOrVarTagStart: [
+                [
+                    /(<\/?)((?:[a-zA-Z_][\w\.\-]*?:)?)((?:property)|(?:prop)|(?:var))/,
+                    ["delimiter.angle", "namespace", { token: "tag-helper", next: "@propOrVarTag" }],
+                ],
+            ],
+            propOrVarTag: [
+                [/\/?>/, { token: "delimiter.angle", next: "@pop" }],
+                { include: "@commentStart" },
+                { include: "@attributeStart" },
+            ],
+            componentTagStart: [
+                [
+                    /(\s*<\/?)((?:[a-zA-Z_][\w\.\-]*?:)?)([A-Z][\w\.\-]*)/,
+                    ["delimiter.angle", "namespace", { token: "tag-component", next: "@componentTag" }],
+                ],
+            ],
+            componentTag: [
+                [/\/?>/, { token: "delimiter.angle", next: "@pop" }],
+                { include: "@commentStart" },
+                { include: "@eventHandler" },
+                { include: "@attributeStart" },
+            ],
+            eventHandler: [
+                [
+                    /(^|\s+)(on[A-Z][-\w.]*)(\s*=)(['\"`])/,
+                    [
+                        "",
+                        "attribute",
+                        "operators",
+                        {
+                            cases: {
+                                "'": { token: "string", next: "@singleQuotedScript", nextEmbedded: "xmluiscript" },
+                                '"': { token: "string", next: "@doubleQuotedScript", nextEmbedded: "xmluiscript" },
+                                "`": {
+                                    token: "string",
+                                    next: "@backtickQuotedScript",
+                                    nextEmbedded: "xmluiscript",
+                                },
+                            },
+                        },
+                    ],
+                ],
+            ],
+            doubleQuotedScript: [
+                [/"/, { token: "string", next: "@pop", nextEmbedded: "@pop" }],
+                [/[^"]/, ""],
+            ],
+            singleQuotedScript: [
+                [/'/, { token: "string", next: "@pop", nextEmbedded: "@pop" }],
+                [/[^']/, ""],
+            ],
+            backtickQuotedScript: [
+                [/`/, { token: "string", next: "@pop", nextEmbedded: "@pop" }],
+                [/[^`]/, ""],
+            ],
+            attributeStart: [
+                [
+                    /(^|\s+)(@identifier(?::@identifier)?)(\s*=\s*)(['\"`])/,
+                    [
+                        "",
+                        "attribute",
+                        "operators",
+                        {
+                            cases: {
+                                "'": { token: "string", next: "@singleQuotedString" },
+                                '"': { token: "string", next: "@doubleQuotedString" },
+                                "`": { token: "string", next: "@backtickQuotedString" },
+                            },
+                        },
+                    ],
+                ],
+                [
+                    /(^|\s+)(@identifier(?::@identifier)?)(\s*=\s*)(@identifier)/,
+                    ["", "attribute", "operators", "string"],
+                ],
+                [/(^|\s+)(@identifier(?::@identifier)?)/, ["", "attribute"]],
+            ],
+            singleQuotedString: [
+                [/'/, "string", "@pop"],
+                { include: "@textWithBindingExpr" },
+                [/[^']/, "string"],
+            ],
+            doubleQuotedString: [
+                [/"/, "string", "@pop"],
+                { include: "@textWithBindingExpr" },
+                [/[^"]/, "string"],
+            ],
+            backtickQuotedString: [
+                [/`/, "string", "@pop"],
+                { include: "@textWithBindingExpr" },
+                [/[^`]/, "string"],
+            ],
+            textWithBindingExpr: [
+                { include: "@escapeCharacter" },
+                { include: "@entity" },
+                [/{/, { token: "delimiter.curly", next: "@bindingExpr", nextEmbedded: "xmluiscript" }],
+            ],
+            bindingExpr: [
+                [/}/, { token: "delimiter.curly", next: "@pop", nextEmbedded: "@pop" }],
+                [/[^}]+/, ""],
+            ],
+            cdataStart: [
+                [
+                    /(<!\[)(CDATA)(\[)/,
+                    ["delimiter.angle", "tag-cdata", { token: "delimiter.angle", next: "@cdata" }],
+                ],
+            ],
+            cdata: [
+                [/]]>/, "delimiter.angle", "@pop"],
+                [/./, "string"],
+            ],
+            commentStart: [[/<!--/, "comment", "@comment"]],
+            comment: [
+                [/[^<\-]+/, "comment.content"],
+                [/-->/, { token: "comment", next: "@pop" }],
+                [/[<\-]/, "comment.content"],
+            ],
+            escapeCharacter: [[/\\S/, "string.escape"]],
+            entity: [[/&(amp|lt|gt|quot|apos|nbsp);/, "string.escape"]],
+        },
+    },
+};

package/dist/scripts/src/syntax/monaco/xmlui-dark.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const darkTheme = {
+    base: "vs-dark",
+    inherit: true,
+    rules: [
+        { token: "comment", foreground: "#4E4E4E" },
+        { token: "comment.content", foreground: "#4E4E4E" },
+        { token: "tag-component", foreground: "#F07100" },
+        { token: "tag-event", foreground: "#3572F6" },
+        { token: "tag-helper", foreground: "#3572F6" },
+        { token: "attribute", foreground: "#C79B00" },
+        { token: "operators", foreground: "#7235C7" },
+        { token: "delimiter.angle", foreground: "#66748E" },
+        { token: "delimiter.curly", foreground: "#000000" },
+        { token: "string", foreground: "#497A48" },
+        { token: "tag-cdata", foreground: "#1BADFF" },
+        { token: "tag-script", foreground: "#0CA6A6" },
+        { token: "string.escape", foreground: "#1BB95A" },
+        { token: "constant", foreground: "#FF00E8" },
+    ],
+    colors: {
+        "editor.background": "#17232b",
+        "editor.foreground": "#497A48",
+    },
+};
+exports.default = darkTheme;

package/dist/scripts/src/syntax/monaco/xmlui-light.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lightTheme = {
+    base: "vs",
+    inherit: true,
+    rules: [
+        { token: "comment", foreground: "#4E4E4E" },
+        { token: "comment.content", foreground: "#4E4E4E" },
+        { token: "tag-component", foreground: "#F07100" },
+        { token: "tag-event", foreground: "#3572F6" },
+        { token: "tag-helper", foreground: "#3572F6" },
+        { token: "attribute", foreground: "#C79B00" },
+        { token: "operators", foreground: "#7235C7" },
+        { token: "delimiter.angle", foreground: "#66748E" },
+        { token: "delimiter.curly", foreground: "#000000" },
+        { token: "string", foreground: "#497A48" },
+        { token: "tag-cdata", foreground: "#1BADFF" },
+        { token: "tag-script", foreground: "#0CA6A6" },
+        { token: "string.escape", foreground: "#1BB95A" },
+        { token: "constant", foreground: "#FF00E8" },
+    ],
+    colors: {
+        "editor.foreground": "#497A48",
+    },
+};
+exports.default = lightTheme;

package/dist/scripts/src/syntax/monaco/xmluiscript.monacoLanguage.js

@@ -0,0 +1,310 @@
+"use strict";
+/* Based on https://github.com/microsoft/monaco-editor/blob/main/src/basic-languages/javascript/javascript.ts */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmluiScripGrammar = void 0;
+exports.XmluiScripGrammar = {
+    id: "xmluiscript",
+    config: {
+        wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+        comments: {
+            lineComment: "//",
+            blockComment: ["/*", "*/"],
+        },
+        brackets: [
+            ["{", "}"],
+            ["[", "]"],
+            ["(", ")"],
+        ],
+        onEnterRules: [
+            {
+                // e.g. /** | */
+                beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+                afterText: /^\s*\*\/$/,
+                action: {
+                    // numeric repr of indentAction: languages.IndentAction.IndentOutdent, but without the "monaco-core" package
+                    indentAction: 2,
+                    appendText: " * ",
+                },
+            },
+            {
+                // e.g. /** ...|
+                beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+                action: {
+                    // numeric repr of indentAction: languages.IndentAction.None, but without the "monaco-core" package
+                    indentAction: 0,
+                    appendText: " * ",
+                },
+            },
+            {
+                // e.g.  * ...|
+                beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
+                action: {
+                    // numeric repr of indentAction: languages.IndentAction.None, but without the "monaco-core" package
+                    indentAction: 0,
+                    appendText: "* ",
+                },
+            },
+            {
+                // e.g.  */|
+                beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
+                action: {
+                    // numeric repr of indentAction: languages.IndentAction.None, but without the "monaco-core" package
+                    indentAction: 0,
+                    removeText: 1,
+                },
+            },
+        ],
+        autoClosingPairs: [
+            { open: "{", close: "}" },
+            { open: "[", close: "]" },
+            { open: "(", close: ")" },
+            { open: '"', close: '"', notIn: ["string"] },
+            { open: "'", close: "'", notIn: ["string", "comment"] },
+            { open: "`", close: "`", notIn: ["string", "comment"] },
+            { open: "/**", close: " */", notIn: ["string"] },
+        ],
+        folding: {
+            markers: {
+                start: new RegExp("^\\s*//\\s*#?region\\b"),
+                end: new RegExp("^\\s*//\\s*#?endregion\\b"),
+            },
+        },
+    },
+    language: {
+        // Set defaultToken to invalid to see what you do not tokenize yet
+        defaultToken: "invalid",
+        tokenPostfix: ".xs",
+        typeKeywords: [],
+        keywords: [
+            "break",
+            "case",
+            "catch",
+            "class",
+            "continue",
+            "const",
+            "constructor",
+            "debugger",
+            "default",
+            "delete",
+            "do",
+            "else",
+            "export",
+            "extends",
+            "false",
+            "finally",
+            "for",
+            "from",
+            "function",
+            "get",
+            "if",
+            "import",
+            "in",
+            "instanceof",
+            "let",
+            "new",
+            "null",
+            "return",
+            "set",
+            "static",
+            "super",
+            "switch",
+            "symbol",
+            "this",
+            "throw",
+            "true",
+            "try",
+            "typeof",
+            "undefined",
+            "var",
+            "void",
+            "while",
+            "with",
+            "yield",
+            "async",
+            "await",
+            "of",
+        ],
+        operators: [
+            "<=",
+            ">=",
+            "==",
+            "!=",
+            "===",
+            "!==",
+            "=>",
+            "+",
+            "-",
+            "**",
+            "*",
+            "/",
+            "%",
+            "++",
+            "--",
+            "<<",
+            "</",
+            ">>",
+            ">>>",
+            "&",
+            "|",
+            "^",
+            "!",
+            "~",
+            "&&",
+            "||",
+            "??",
+            "?",
+            ":",
+            "=",
+            "+=",
+            "-=",
+            "*=",
+            "**=",
+            "/=",
+            "%=",
+            "<<=",
+            ">>=",
+            ">>>=",
+            "&=",
+            "|=",
+            "^=",
+            "@",
+        ],
+        // we include these common regular expressions
+        symbols: /[=><!~?:&|+\-*\/\^%]+/,
+        escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+        digits: /\d+(_+\d+)*/,
+        octaldigits: /[0-7]+(_+[0-7]+)*/,
+        binarydigits: /[0-1]+(_+[0-1]+)*/,
+        hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+        regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+        regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+        // The main tokenizer for our languages
+        tokenizer: {
+            root: [[/[{}]/, "delimiter.bracket"], { include: "common" }],
+            common: [
+                // identifiers and keywords
+                [
+                    /#?[a-z_$][\w$]*/,
+                    {
+                        cases: {
+                            "@keywords": "keyword",
+                            "@default": "identifier",
+                        },
+                    },
+                ],
+                [/[A-Z][\w\$]*/, "type.identifier"], // to show class names nicely
+                // [/[A-Z][\w\$]*/, 'identifier'],
+                // whitespace
+                { include: "@whitespace" },
+                // regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
+                [
+                    /\/(?=([^\\\/]|\\.)+\/([dgimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+                    { token: "regexp", bracket: "@open", next: "@regexp" },
+                ],
+                // delimiters and operators
+                [/[()\[\]]/, "@brackets"],
+                [/[<>](?!@symbols)/, "@brackets"],
+                [/!(?=([^=]|$))/, "delimiter"],
+                [
+                    /@symbols/,
+                    {
+                        cases: {
+                            "@operators": "delimiter",
+                            "@default": "",
+                        },
+                    },
+                ],
+                // numbers
+                [/(@digits)[eE]([\-+]?(@digits))?/, "number.float"],
+                [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, "number.float"],
+                [/0[xX](@hexdigits)n?/, "number.hex"],
+                [/0[oO]?(@octaldigits)n?/, "number.octal"],
+                [/0[bB](@binarydigits)n?/, "number.binary"],
+                [/(@digits)n?/, "number"],
+                // delimiter: after number because of .\d floats
+                [/[;,.]/, "delimiter"],
+                // strings
+                [/"([^"\\]|\\.)*$/, "string.invalid"], // non-teminated string
+                [/'([^'\\]|\\.)*$/, "string.invalid"], // non-teminated string
+                [/"/, "string", "@string_double"],
+                [/'/, "string", "@string_single"],
+                [/`/, "string", "@string_backtick"],
+            ],
+            whitespace: [
+                [/[ \t\r\n]+/, ""],
+                [/\/\*\*(?!\/)/, "comment.doc", "@jsdoc"],
+                [/\/\*/, "comment", "@comment"],
+                [/\/\/.*$/, "comment"],
+            ],
+            comment: [
+                [/[^\/*]+/, "comment"],
+                [/\*\//, "comment", "@pop"],
+                [/[\/*]/, "comment"],
+            ],
+            jsdoc: [
+                [/[^\/*]+/, "comment.doc"],
+                [/\*\//, "comment.doc", "@pop"],
+                [/[\/*]/, "comment.doc"],
+            ],
+            // We match regular expression quite precisely
+            regexp: [
+                [
+                    /(\{)(\d+(?:,\d*)?)(\})/,
+                    ["regexp.escape.control", "regexp.escape.control", "regexp.escape.control"],
+                ],
+                [
+                    /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+                    ["regexp.escape.control", { token: "regexp.escape.control", next: "@regexrange" }],
+                ],
+                [/(\()(\?:|\?=|\?!)/, ["regexp.escape.control", "regexp.escape.control"]],
+                [/[()]/, "regexp.escape.control"],
+                [/@regexpctl/, "regexp.escape.control"],
+                [/[^\\\/]/, "regexp"],
+                [/@regexpesc/, "regexp.escape"],
+                [/\\\./, "regexp.invalid"],
+                [
+                    /(\/)([dgimsuy]*)/,
+                    [{ token: "regexp", bracket: "@close", next: "@pop" }, "keyword.other"],
+                ],
+            ],
+            regexrange: [
+                [/-/, "regexp.escape.control"],
+                [/\^/, "regexp.invalid"],
+                [/@regexpesc/, "regexp.escape"],
+                [/[^\]]/, "regexp"],
+                [
+                    /\]/,
+                    {
+                        token: "regexp.escape.control",
+                        next: "@pop",
+                        bracket: "@close",
+                    },
+                ],
+            ],
+            string_double: [
+                [/[^\\"]+/, "string"],
+                [/@escapes/, "string.escape"],
+                [/\\./, "string.escape.invalid"],
+                [/"/, "string", "@pop"],
+            ],
+            string_single: [
+                [/[^\\']+/, "string"],
+                [/@escapes/, "string.escape"],
+                [/\\./, "string.escape.invalid"],
+                [/'/, "string", "@pop"],
+            ],
+            string_backtick: [
+                [/\$\{/, { token: "delimiter.bracket", next: "@bracketCounting" }],
+                [/[^\\`$]+/, "string"],
+                [/@escapes/, "string.escape"],
+                [/\\./, "string.escape.invalid"],
+                [/`/, "string", "@pop"],
+            ],
+            bracketCounting: [
+                [/\{/, "delimiter.bracket", "@bracketCounting"],
+                [/\}/, "delimiter.bracket", "@pop"],
+                { include: "common" },
+            ],
+        },
+    },
+};