round-core 0.0.6 → 0.0.7

package/extension/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "round",
+  "displayName": "Round",
+  "description": "Language support for .round (Round framework)",
+  "version": "0.1.0",
+  "main": "./extension.js",
+  "publisher": "round-framework",
+  "license": "MIT",
+  "engines": {
+    "vscode": "^1.90.0"
+  },
+  "activationEvents": [
+    "onLanguage:round",
+    "workspaceContains:**/*.round"
+  ],
+  "categories": [
+    "Programming Languages"
+  ],
+  "contributes": {
+    "configurationDefaults": {
+      "[round]": {
+        "editor.maxTokenizationLineLength": 2500
+      }
+    },
+    "languages": [
+      {
+        "id": "round",
+        "aliases": [
+          "Round"
+        ],
+        "icon": {
+          "light": "./images/round-light.svg",
+          "dark": "./images/round-dark.svg"
+        },
+        "extensions": [
+          ".round"
+        ],
+        "configuration": "./javascript-language-configuration.json"
+      },
+      {
+        "id": "jsx-tags",
+        "aliases": [],
+        "configuration": "./tags-language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "round",
+        "scopeName": "source.round",
+        "path": "./syntaxes/Round.tmLanguage.json",
+        "embeddedLanguages": {
+          "meta.tag.js": "jsx-tags",
+          "meta.tag.without-attributes.js": "jsx-tags",
+          "meta.tag.attributes.js.jsx": "round",
+          "meta.embedded.expression.js": "round"
+        },
+        "tokenTypes": {
+          "punctuation.definition.template-expression": "other",
+          "entity.name.type.instance.jsdoc": "other",
+          "entity.name.function.tagged-template": "other",
+          "meta.import string.quoted": "other",
+          "variable.other.jsdoc": "other"
+        }
+      },
+      {
+        "scopeName": "source.js.jsx",
+        "path": "./syntaxes/JavaScriptReact.tmLanguage.json"
+      },
+      {
+        "scopeName": "source.js.regexp",
+        "path": "./syntaxes/Regular Expressions (JavaScript).tmLanguage"
+      }
+    ],
+    "semanticTokenScopes": [
+      {
+        "language": "round",
+        "scopes": {
+          "property": [
+            "variable.other.property.jsx"
+          ],
+          "property.readonly": [
+            "variable.other.constant.property.jsx"
+          ],
+          "variable": [
+            "variable.other.readwrite.jsx"
+          ],
+          "variable.readonly": [
+            "variable.other.constant.object.jsx"
+          ],
+          "function": [
+            "entity.name.function.jsx"
+          ],
+          "namespace": [
+            "entity.name.type.module.jsx"
+          ],
+          "variable.defaultLibrary": [
+            "support.variable.js"
+          ],
+          "function.defaultLibrary": [
+            "support.function.js"
+          ]
+        }
+      }
+    ],
+    "snippets": [
+      {
+        "language": "round",
+        "path": "./snippets/javascript.code-snippets"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ZtaMDev/RoundJS.git"
+  },
+  "dependencies": {
+    "vscode-languageclient": "^9.0.1"
+  }
+}

package/extension/package.nls.json

@@ -0,0 +1,4 @@
+{
+	"displayName": "Round Framework",
+	"description": "Provides snippets, syntax highlighting, bracket matching and folding in Round files."
+}

package/extension/round-lsp/package-lock.json

@@ -0,0 +1,185 @@
+{
+  "name": "round-lsp",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "round-lsp",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "glob": "^13.0.0",
+        "magic-string": "^0.30.21",
+        "typescript": "^5.9.3",
+        "vscode-languageserver": "^9.0.1",
+        "vscode-languageserver-textdocument": "^1.0.12",
+        "vscode-uri": "^3.1.0"
+      }
+    },
+    "node_modules/@isaacs/balanced-match": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@isaacs/balanced-match/-/balanced-match-4.0.1.tgz",
+      "integrity": "sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/@isaacs/brace-expansion": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@isaacs/brace-expansion/-/brace-expansion-5.0.0.tgz",
+      "integrity": "sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==",
+      "license": "MIT",
+      "dependencies": {
+        "@isaacs/balanced-match": "^4.0.1"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "license": "MIT"
+    },
+    "node_modules/glob": {
+      "version": "13.0.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.0.tgz",
+      "integrity": "sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==",
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "minimatch": "^10.1.1",
+        "minipass": "^7.1.2",
+        "path-scurry": "^2.0.0"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "11.2.4",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.4.tgz",
+      "integrity": "sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "10.1.1",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.1.1.tgz",
+      "integrity": "sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==",
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/brace-expansion": "^5.0.0"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/path-scurry": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.1.tgz",
+      "integrity": "sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==",
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^11.0.0",
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/vscode-jsonrpc": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
+      "integrity": "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/vscode-languageserver": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver/-/vscode-languageserver-9.0.1.tgz",
+      "integrity": "sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g==",
+      "license": "MIT",
+      "dependencies": {
+        "vscode-languageserver-protocol": "3.17.5"
+      },
+      "bin": {
+        "installServerIntoExtension": "bin/installServerIntoExtension"
+      }
+    },
+    "node_modules/vscode-languageserver-protocol": {
+      "version": "3.17.5",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz",
+      "integrity": "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==",
+      "license": "MIT",
+      "dependencies": {
+        "vscode-jsonrpc": "8.2.0",
+        "vscode-languageserver-types": "3.17.5"
+      }
+    },
+    "node_modules/vscode-languageserver-textdocument": {
+      "version": "1.0.12",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.12.tgz",
+      "integrity": "sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA==",
+      "license": "MIT"
+    },
+    "node_modules/vscode-languageserver-types": {
+      "version": "3.17.5",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz",
+      "integrity": "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==",
+      "license": "MIT"
+    },
+    "node_modules/vscode-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz",
+      "integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==",
+      "license": "MIT"
+    }
+  }
+}

package/extension/round-lsp/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "round-lsp",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "ZtaMDev",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "glob": "^13.0.0",
+    "magic-string": "^0.30.21",
+    "typescript": "^5.9.3",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "vscode-uri": "^3.1.0"
+  }
+}

package/extension/round-lsp/src/round-transformer-lsp.js

@@ -0,0 +1,248 @@
+const MagicString = require('magic-string');
+
+function transformLSP(code, filename = 'file.round') {
+    const s = new MagicString(code);
+
+    const edits = [];
+    const VIRTUAL_IMPORT = `// @ts-nocheck
+import { Fragment, createElement } from 'round-core';
+const React = { createElement, Fragment };
+
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            [elemName: string]: any;
+        }
+        interface ElementAttributesProperty { props: {}; }
+        type Element = any;
+    }
+}
+`;
+    s.prepend(VIRTUAL_IMPORT);
+    edits.push({ offset: 0, length: 0, newLength: VIRTUAL_IMPORT.length });
+
+    function applyOverlapOverwrite(start, end, content) {
+        s.overwrite(start, end, content);
+        edits.push({ offset: start, length: end - start, newLength: content.length });
+    }
+
+    // Helper to find balanced block starting at index
+    // ... (rest of helper functions same as before)
+    function parseBlock(str, startIndex) {
+        let open = 0;
+        let startBlockIndex = -1;
+        let endBlockIndex = -1;
+
+        let inSingle = false;
+        let inDouble = false;
+        let inTemplate = false;
+        let inCommentLine = false;
+        let inCommentMulti = false;
+
+        for (let i = startIndex; i < str.length; i++) {
+            const ch = str[i];
+            const prev = i > 0 ? str[i - 1] : '';
+            const next = i < str.length - 1 ? str[i + 1] : '';
+
+            if (inCommentLine) {
+                if (ch === '\n' || ch === '\r') inCommentLine = false;
+                continue;
+            }
+            if (inCommentMulti) {
+                if (ch === '*' && next === '/') {
+                    inCommentMulti = false;
+                    i++;
+                }
+                continue;
+            }
+            if (inTemplate) {
+                if (ch === '`' && prev !== '\\') inTemplate = false;
+                continue;
+            }
+            if (inSingle) {
+                if (ch === '\'' && prev !== '\\') inSingle = false;
+                continue;
+            }
+            if (inDouble) {
+                if (ch === '"' && prev !== '\\') inDouble = false;
+                continue;
+            }
+
+            if (ch === '/' && next === '/') {
+                inCommentLine = true;
+                i++;
+                continue;
+            }
+            if (ch === '/' && next === '*') {
+                inCommentMulti = true;
+                i++;
+                continue;
+            }
+            if (ch === '`') {
+                inTemplate = true;
+                continue;
+            }
+            if (ch === '\'') {
+                inSingle = true;
+                continue;
+            }
+            if (ch === '"') {
+                inDouble = true;
+                continue;
+            }
+
+            if (ch === '{') {
+                if (open === 0) startBlockIndex = i;
+                open++;
+            } else if (ch === '}') {
+                open--;
+                if (open === 0) {
+                    endBlockIndex = i;
+                    return { start: startBlockIndex, end: endBlockIndex };
+                }
+            }
+        }
+        return null;
+    }
+
+    function consumeWhitespace(str, i) {
+        while (i < str.length && /\s/.test(str[i])) i++;
+        return i;
+    }
+
+    function parseIfChain(str, ifIndex) {
+        const head = str.slice(ifIndex);
+        const m = head.match(/^if\s*\((.*?)\)\s*\{/);
+        if (!m) return null;
+
+        let i = ifIndex;
+        const chainEdits = [];
+        let hasElse = false;
+        let isFirst = true;
+
+        while (true) {
+            const cur = str.slice(i);
+            const mm = cur.match(/^if\s*\((.*?)\)\s*\{/);
+            if (!mm) break;
+
+            const cond = mm[1];
+            const condStartInMatch = mm[0].indexOf('(') + 1;
+            const condEndInMatch = mm[0].lastIndexOf(')');
+
+            // 1. "if (" or "else if (" -> "(" or ") : ("
+            const prefixReplacement = isFirst ? '(' : ') : (';
+            applyOverlapOverwrite(i, i + condStartInMatch, prefixReplacement);
+
+            // 2. Condition preserved as-is for mapping/hover accuracy
+            // Since we have // @ts-nocheck, we don't need complex ternary wrapping here.
+
+            // 3. ") {" -> ") ? (<Fragment>"
+            applyOverlapOverwrite(i + condEndInMatch, i + mm[0].length, ') ? (<Fragment>');
+
+            const blockStart = i + mm[0].length - 1;
+            const block = parseBlock(str, blockStart);
+            if (!block) break;
+
+            i = block.end;
+            const endOfBlock = i;
+
+            i++; // skip }
+            i = consumeWhitespace(str, i);
+
+            isFirst = false;
+
+            if (str.startsWith('else', i)) {
+                const nextI = consumeWhitespace(str, i + 4);
+                if (str.startsWith('if', nextI)) {
+                    // Handled by next loop iteration
+                    i = nextI;
+                    continue;
+                }
+
+                if (str[nextI] === '{') {
+                    const elseBlock = parseBlock(str, nextI);
+                    if (elseBlock) {
+                        applyOverlapOverwrite(endOfBlock, nextI + 1, '</Fragment>) : (<Fragment>');
+                        applyOverlapOverwrite(elseBlock.end, elseBlock.end + 1, '</Fragment>)');
+                        hasElse = true;
+                        i = elseBlock.end + 1;
+                        break;
+                    }
+                }
+            }
+
+            applyOverlapOverwrite(endOfBlock, endOfBlock + 1, '</Fragment>) : null');
+            break;
+        }
+
+        return { hasElse }; // chainEdits are applied immediately via applyOverlapOverwrite
+    }
+
+    // Process "if" expressions {if(cond){...}}
+    let currentCode = s.original;
+    let match;
+    const ifExprRegex = /\{\s*if\s*\(/g;
+    while ((match = ifExprRegex.exec(currentCode)) !== null) {
+        const start = match.index;
+        const outer = parseBlock(currentCode, start);
+        if (!outer) continue;
+
+        const innerIfStart = consumeWhitespace(currentCode, start + 1);
+        applyOverlapOverwrite(start, start + 1, '{(() => ');
+        parseIfChain(currentCode, innerIfStart);
+        applyOverlapOverwrite(outer.end, outer.end + 1, ')}');
+    }
+
+    // Process "for" expressions {for(item in list){...}}
+    const forExprRegex = /\{\s*for\s*\((.*?)\s+in\s+(.*?)\)\s*\{/g;
+    currentCode = s.original;
+    while ((match = forExprRegex.exec(currentCode)) !== null) {
+        const start = match.index;
+        const outer = parseBlock(currentCode, start);
+        if (!outer) continue;
+
+        const blockStart = start + match[0].lastIndexOf('{');
+        const block = parseBlock(currentCode, blockStart);
+        if (!block) continue;
+
+        const item = match[1];
+        const list = match[2];
+        const parenStart = start + match[0].indexOf('(');
+        const parenEnd = start + match[0].indexOf(')');
+
+        applyOverlapOverwrite(start, parenStart + 1, '{(() => ');
+        applyOverlapOverwrite(parenStart + 1, block.start + 1, `${list}.map(${item} => (<Fragment>`);
+        applyOverlapOverwrite(block.end, block.end + 1, '</Fragment>)))}');
+    }
+
+    // signal() replacements
+    const signalRegex = /\{\s*([A-Za-z_$][\w$]*)\s*\(\s*\)\s*\}/g;
+    currentCode = s.original;
+    while ((match = signalRegex.exec(currentCode)) !== null) {
+        const braceEnd = match[0].indexOf(match[1]);
+        applyOverlapOverwrite(match.index, match.index + braceEnd, '{() => ');
+    }
+
+    const signalAttrRegex = /=\{\s*([A-Za-z_$][\w$]*)\s*\(\s*\)\s*\}/g;
+    while ((match = signalAttrRegex.exec(currentCode)) !== null) {
+        const braceEnd = match[0].indexOf(match[1]);
+        applyOverlapOverwrite(match.index, match.index + braceEnd, '={() => ');
+    }
+
+    // Sort edits by original offset for easy lookup
+    edits.sort((a, b) => a.offset - b.offset);
+
+    return {
+        code: s.toString(),
+        edits,
+        map: s.generateMap({
+            source: filename,
+            file: filename + '.tsx',
+            includeContent: true,
+            hires: true
+        })
+    };
+}
+
+
+module.exports = { transformLSP };