round-core 0.0.6 → 0.0.7

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

@@ -0,0 +1,396 @@
+const {
+    createConnection,
+    TextDocuments,
+    ProposedFeatures,
+    TextDocumentSyncKind,
+    Diagnostic,
+    DiagnosticSeverity,
+    Position,
+    Range,
+    FileChangeType,
+    DidChangeWatchedFilesNotification
+} = require('vscode-languageserver/node');
+
+const { TextDocument } = require('vscode-languageserver-textdocument');
+const { transformLSP } = require('./round-transformer-lsp');
+const ts = require('typescript');
+const path = require('path');
+const fs = require('fs');
+const { glob } = require('glob');
+const { URI } = require('vscode-uri');
+
+function normalizePath(p) {
+    if (!p) return p;
+    return path.normalize(p).replace(/\\/g, '/');
+}
+
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+
+// Virtual document storage
+const virtualDocs = new Map(); // roundUri -> { roundDoc, tsxText, map, version }
+const tsFiles = new Map();     // tsxFsPath -> { text, version }
+let workspaceRoot = null;
+let roundRootCached = null;
+function getRoundRoot() {
+    if (roundRootCached) return roundRootCached;
+    const localNodeModules = path.join(workspaceRoot || '', 'node_modules', 'round-core');
+    const sourceDir = path.resolve(__dirname, "../../src");
+    roundRootCached = normalizePath(fs.existsSync(localNodeModules) ? localNodeModules : sourceDir);
+    return roundRootCached;
+}
+
+const host = {
+    getScriptFileNames: () => {
+        const names = Array.from(tsFiles.keys());
+        const root = getRoundRoot();
+
+        // Try to find the best d.ts
+        const dtsPaths = [
+            path.join(root, "src/index.d.ts"),
+            path.join(root, "index.d.ts"),
+            path.join(root, "dist/index.d.ts")
+        ];
+
+        const dtsPath = dtsPaths.find(p => fs.existsSync(p));
+        const entryPath = dtsPath || normalizePath(path.join(root, "index.js"));
+
+        if (fs.existsSync(entryPath) && !names.includes(entryPath)) names.push(entryPath);
+        return names;
+    },
+    getScriptVersion: fileName => {
+        const normalized = normalizePath(fileName);
+        if (tsFiles.has(normalized)) return tsFiles.get(normalized).version.toString();
+        if (fs.existsSync(normalized)) {
+            try {
+                return fs.statSync(normalized).mtimeMs.toString();
+            } catch (e) {
+                return '0';
+            }
+        }
+        return '0';
+    },
+    getScriptSnapshot: fileName => {
+        const text = host.readFile(fileName);
+        return text ? ts.ScriptSnapshot.fromString(text) : undefined;
+    },
+    getCurrentDirectory: () => workspaceRoot || process.cwd(),
+    getCompilationSettings: () => {
+        const settings = {
+            jsx: ts.JsxEmit.React,
+            jsxFactory: 'React.createElement',
+            jsxFragmentFactory: 'React.Fragment',
+            allowJs: true,
+            target: ts.ScriptTarget.ESNext,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            skipLibCheck: true,
+            lib: ['lib.esnext.d.ts', 'lib.dom.d.ts'],
+            baseUrl: workspaceRoot || '.',
+            paths: {}
+        };
+
+        const root = getRoundRoot();
+        const dtsPaths = [
+            path.join(root, "src/index.d.ts"),
+            path.join(root, "index.d.ts"),
+            path.join(root, "dist/index.d.ts")
+        ];
+        const dtsPath = dtsPaths.find(p => fs.existsSync(p));
+        const entryPath = dtsPath || normalizePath(path.join(root, "index.js"));
+
+        settings.paths["round-core"] = [entryPath];
+        settings.paths["round-core/*"] = [path.join(root, "*")];
+
+        return settings;
+    },
+    getDefaultLibFileName: options => normalizePath(ts.getDefaultLibFilePath(options)),
+    fileExists: fileName => {
+        const normalized = normalizePath(fileName);
+        return tsFiles.has(normalized) || ts.sys.fileExists(normalized);
+    },
+    readFile: fileName => {
+        const normalized = normalizePath(fileName);
+        if (tsFiles.has(normalized)) return tsFiles.get(normalized).text;
+        if (ts.sys.fileExists(normalized)) {
+            try {
+                return ts.sys.readFile(normalized);
+            } catch (e) {
+                return undefined;
+            }
+        }
+        return undefined;
+    },
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories,
+};
+
+const ls = ts.createLanguageService(host, ts.createDocumentRegistry());
+
+connection.onInitialize((params) => {
+    workspaceRoot = params.rootPath || (params.workspaceFolders?.[0]?.uri ? URI.parse(params.workspaceFolders[0].uri).fsPath : null);
+
+    return {
+        capabilities: {
+            textDocumentSync: TextDocumentSyncKind.Full,
+            hoverProvider: true,
+            definitionProvider: true
+        }
+    };
+});
+
+connection.onInitialized(async () => {
+    if (workspaceRoot) {
+        connection.console.log(`Scanning workspace: ${workspaceRoot}`);
+        const files = await glob('**/*.round', { cwd: workspaceRoot, ignore: 'node_modules/**', absolute: true });
+        const discovered = [];
+        for (const file of files) {
+            const uri = URI.file(file).toString();
+            const content = fs.readFileSync(file, 'utf8');
+            processFile(uri, content, 0, false);
+            discovered.push(uri);
+        }
+        // Phase 2: Send diagnostics now that all files are in context
+        for (const uri of discovered) {
+            const tsxFsPath = normalizePath(URI.parse(uri + '.tsx').fsPath);
+            sendDiagnostics(uri, tsxFsPath);
+        }
+        connection.console.log(`Initialized with ${files.length} .round files`);
+    }
+
+    connection.client.register(DidChangeWatchedFilesNotification.type, {
+        watchers: [{ globPattern: '**/*.round' }]
+    });
+});
+
+function processFile(uri, text, version, send = true) {
+    try {
+        const { code, edits } = transformLSP(text, uri);
+        const tsxFsPath = normalizePath(URI.parse(uri + '.tsx').fsPath);
+
+        tsFiles.set(tsxFsPath, { text: code, version });
+        virtualDocs.set(uri, {
+            roundDoc: TextDocument.create(uri, 'round', version, text),
+            tsxText: code,
+            edits, // Store precise edits
+            version
+        });
+
+        if (send) sendDiagnostics(uri, tsxFsPath);
+    } catch (e) {
+        // connection.console.error(`Transform failed for ${uri}: ${e.message}`);
+    }
+}
+
+documents.onDidChangeContent(change => {
+    processFile(change.document.uri, change.document.getText(), change.document.version);
+});
+
+connection.onDidChangeWatchedFiles(params => {
+    for (const change of params.changes) {
+        if (change.type === FileChangeType.Deleted) {
+            const tsxFsPath = normalizePath(URI.parse(change.uri + '.tsx').fsPath);
+            tsFiles.delete(tsxFsPath);
+            virtualDocs.delete(change.uri);
+        } else if (change.type === FileChangeType.Created || change.type === FileChangeType.Changed) {
+            const doc = documents.get(change.uri);
+            if (!doc) {
+                const fsPath = normalizePath(URI.parse(change.uri).fsPath);
+                if (fs.existsSync(fsPath)) {
+                    processFile(change.uri, fs.readFileSync(fsPath, 'utf8'), Date.now());
+                }
+            }
+        }
+    }
+});
+
+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;
+    }
+}
+`;
+
+function sendDiagnostics(roundUri, tsxFsPath) {
+    try {
+        const vdoc = virtualDocs.get(roundUri);
+        if (!vdoc) return;
+
+        const allDiagnostics = [
+            ...ls.getSyntacticDiagnostics(tsxFsPath),
+            ...ls.getSemanticDiagnostics(tsxFsPath),
+            ...ls.getSuggestionDiagnostics(tsxFsPath)
+        ];
+
+        const mapped = allDiagnostics.map(diag => {
+            const range = mapTsxRangeToRound(diag.start, diag.length, vdoc);
+            if (!range) return null;
+            return {
+                severity: mapSeverity(diag.category),
+                range,
+                message: ts.flattenDiagnosticMessageText(diag.messageText, '\n'),
+                source: 'round-ts'
+            };
+        }).filter(Boolean);
+
+        connection.sendDiagnostics({ uri: roundUri, diagnostics: mapped });
+    } catch (e) {
+        connection.console.error(`Diagnostics failed for ${tsxFsPath}: ${e.message}`);
+    }
+}
+
+function toGeneratedOffset(originalOffset, edits) {
+    let current = originalOffset;
+    for (const edit of edits) {
+        if (edit.offset <= originalOffset) {
+            // If the edit is entirely before our offset, or starts at it
+            if (originalOffset >= edit.offset + edit.length) {
+                current += (edit.newLength - edit.length);
+            } else {
+                // Offset is inside the range being replaced
+                // map it to the start of the replacement
+                current += (edit.offset - originalOffset);
+                break;
+            }
+        }
+    }
+    return current;
+}
+
+function toOriginalOffset(generatedOffset, edits) {
+    let current = generatedOffset;
+    let original = generatedOffset;
+
+    // Need to work backwards through the edits to find the original location
+    // Since edits are sorted by original offset, we can simulate the transformation
+    let accum = 0;
+    for (const edit of edits) {
+        const genStart = edit.offset + accum;
+        const genEnd = genStart + edit.newLength;
+
+        if (generatedOffset < genStart) {
+            // Offset is before this edit
+            return generatedOffset - accum;
+        }
+
+        if (generatedOffset >= genStart && generatedOffset < genEnd) {
+            // Offset is inside the replacement
+            return edit.offset;
+        }
+
+        accum += (edit.newLength - edit.length);
+    }
+
+    return generatedOffset - accum;
+}
+
+function mapTsxRangeToRound(start, length, vdoc) {
+    const edits = vdoc.edits || [];
+    const originalStart = toOriginalOffset(start, edits);
+    const originalEnd = toOriginalOffset(start + length, edits);
+
+    return {
+        start: vdoc.roundDoc.positionAt(originalStart),
+        end: vdoc.roundDoc.positionAt(originalEnd)
+    };
+}
+
+function mapSeverity(category) {
+    switch (category) {
+        case ts.DiagnosticCategory.Error: return DiagnosticSeverity.Error;
+        case ts.DiagnosticCategory.Warning: return DiagnosticSeverity.Warning;
+        case ts.DiagnosticCategory.Message: return DiagnosticSeverity.Information;
+        case ts.DiagnosticCategory.Suggestion: return DiagnosticSeverity.Hint;
+        default: return DiagnosticSeverity.Error;
+    }
+}
+
+connection.onHover((params) => {
+    try {
+        const vdoc = virtualDocs.get(params.textDocument.uri);
+        if (!vdoc) return null;
+
+        const tsxFsPath = normalizePath(URI.parse(params.textDocument.uri + '.tsx').fsPath);
+        const originalOffset = vdoc.roundDoc.offsetAt(params.position);
+        const offset = toGeneratedOffset(originalOffset, vdoc.edits || []);
+
+        const info = ls.getQuickInfoAtPosition(tsxFsPath, offset);
+        if (!info) return null;
+
+        const text = ts.displayPartsToString(info.displayParts);
+        const docs = ts.displayPartsToString(info.documentation);
+        const tags = info.tags ? info.tags.map(t => `*@${t.name}* ${t.text ? ts.displayPartsToString(t.text) : ''}`).join('\n\n') : '';
+
+        return {
+            contents: {
+                kind: 'markdown',
+                value: `\`\`\`typescript\n${text}\n\`\`\`\n${docs}${tags ? '\n\n' + tags : ''}`
+            }
+        };
+    } catch (e) {
+        return null;
+    }
+});
+
+connection.onDefinition((params) => {
+    try {
+        const vdoc = virtualDocs.get(params.textDocument.uri);
+        if (!vdoc) return null;
+
+        const tsxFsPath = normalizePath(URI.parse(params.textDocument.uri + '.tsx').fsPath);
+        const originalOffset = vdoc.roundDoc.offsetAt(params.position);
+        const offset = toGeneratedOffset(originalOffset, vdoc.edits || []);
+
+        const defs = ls.getDefinitionAtPosition(tsxFsPath, offset);
+        if (!defs || defs.length === 0) return null;
+
+        return defs.map(def => {
+            let fsPath = normalizePath(def.fileName);
+            let start = def.textSpan.start;
+            let length = def.textSpan.length;
+
+            const isVirtual = fsPath.endsWith('.round.tsx');
+            const uri = isVirtual ? URI.file(fsPath.slice(0, -4)).toString() : URI.file(fsPath).toString();
+
+            if (isVirtual) {
+                const targetVdoc = virtualDocs.get(uri);
+                if (targetVdoc && targetVdoc.edits) {
+                    start = toOriginalOffset(start, targetVdoc.edits);
+                }
+            }
+
+            const targetVdoc = virtualDocs.get(uri);
+            if (targetVdoc) {
+                return {
+                    uri,
+                    range: {
+                        start: targetVdoc.roundDoc.positionAt(start),
+                        end: targetVdoc.roundDoc.positionAt(start + length)
+                    }
+                };
+            }
+
+            return {
+                uri,
+                range: {
+                    start: { line: 0, character: 0 },
+                    end: { line: 0, character: 0 }
+                }
+            };
+        }).filter(Boolean);
+    } catch (e) {
+        return null;
+    }
+});
+
+documents.listen(connection);
+connection.listen();

package/extension/snippets/javascript.code-snippets

@@ -0,0 +1,266 @@
+{
+	"Constructor": {
+		"prefix": "ctor",
+		"body": [
+			"/**",
+			" *",
+			" */",
+			"constructor() {",
+			"\tsuper();",
+			"\t$0",
+			"}"
+		],
+		"description": "Constructor"
+	},
+	"Class Definition": {
+		"prefix": "class",
+		"isFileTemplate": true,
+		"body": [
+			"class ${1:name} {",
+			"\tconstructor(${2:parameters}) {",
+			"\t\t$0",
+			"\t}",
+			"}"
+		],
+		"description": "Class Definition"
+	},
+	"Method Definition": {
+		"prefix": "method",
+		"body": [
+			"/**",
+			" * ",
+			" */",
+			"${1:name}() {",
+			"\t$0",
+			"}"
+		],
+		"description": "Method Definition"
+	},
+	"Import Statement": {
+		"prefix": "import",
+		"body": [
+			"import { $0 } from \"${1:module}\";"
+		],
+		"description": "Import external module"
+	},
+	"Log to the console": {
+		"prefix": "log",
+		"body": [
+			"console.log($1);",
+			"$0"
+		],
+		"description": "Log to the console"
+	},
+	"Log warning to console": {
+		"prefix": "warn",
+		"body": [
+			"console.warn($1);",
+			"$0"
+		],
+		"description": "Log warning to the console"
+	},
+	"Log error to console": {
+		"prefix": "error",
+		"body": [
+			"console.error($1);",
+			"$0"
+		],
+		"description": "Log error to the console"
+	},
+	"Throw Exception": {
+		"prefix": "throw",
+		"body": [
+			"throw new Error(\"$1\");",
+			"$0"
+		],
+		"description": "Throw Exception"
+	},
+	"For Loop": {
+		"prefix": "for",
+		"body": [
+			"for (let ${1:index} = 0; ${1:index} < ${2:array}.length; ${1:index}++) {",
+			"\tconst ${3:element} = ${2:array}[${1:index}];",
+			"\t$TM_SELECTED_TEXT$0",
+			"}"
+		],
+		"description": "For Loop"
+	},
+	"For-Each Loop using =>": {
+		"prefix": "foreach =>",
+		"body": [
+			"${1:array}.forEach(${2:element} => {",
+			"\t$TM_SELECTED_TEXT$0",
+			"});"
+		],
+		"description": "For-Each Loop using =>"
+	},
+	"For-In Loop": {
+		"prefix": "forin",
+		"body": [
+			"for (const ${1:key} in ${2:object}) {",
+			"\tif (!Object.hasOwn(${2:object}, ${1:key})) continue;",
+			"\t",
+			"\tconst ${3:element} = ${2:object}[${1:key}];",
+			"\t",
+			"\t$TM_SELECTED_TEXT$0",
+			"}"
+		],
+		"description": "For-In Loop"
+	},
+	"For-Of Loop": {
+		"prefix": "forof",
+		"body": [
+			"for (const ${1:element} of ${2:object}) {",
+			"\t$TM_SELECTED_TEXT$0",
+			"}"
+		],
+		"description": "For-Of Loop"
+	},
+	"For-Await-Of Loop": {
+		"prefix": "forawaitof",
+		"body": [
+			"for await (const ${1:element} of ${2:object}) {",
+			"\t$TM_SELECTED_TEXT$0",
+			"}"
+		],
+		"description": "For-Await-Of Loop"
+	},
+	"Function Statement": {
+		"prefix": "function",
+		"body": [
+			"function ${1:name}(${2:params}) {",
+			"\t$TM_SELECTED_TEXT$0",
+			"}"
+		],
+		"description": "Function Statement"
+	},
+	"If Statement": {
+		"prefix": "if",
+		"body": [
+			"if (${1:condition}) {",
+			"\t$TM_SELECTED_TEXT$0",
+			"}"
+		],
+		"description": "If Statement"
+	},
+	"If-Else Statement": {
+		"prefix": "ifelse",
+		"body": [
+			"if (${1:condition}) {",
+			"\t$TM_SELECTED_TEXT$0",
+			"} else {",
+			"\t",
+			"}"
+		],
+		"description": "If-Else Statement"
+	},
+	"New Statement": {
+		"prefix": "new",
+		"body": [
+			"const ${1:name} = new ${2:type}(${3:arguments});$0"
+		],
+		"description": "New Statement"
+	},
+	"Switch Statement": {
+		"prefix": "switch",
+		"body": [
+			"switch (${1:key}) {",
+			"\tcase ${2:value}:",
+			"\t\t$0",
+			"\t\tbreak;",
+			"",
+			"\tdefault:",
+			"\t\tbreak;",
+			"}"
+		],
+		"description": "Switch Statement"
+	},
+	"While Statement": {
+		"prefix": "while",
+		"body": [
+			"while (${1:condition}) {",
+			"\t$TM_SELECTED_TEXT$0",
+			"}"
+		],
+		"description": "While Statement"
+	},
+	"Do-While Statement": {
+		"prefix": "dowhile",
+		"body": [
+			"do {",
+			"\t$TM_SELECTED_TEXT$0",
+			"} while (${1:condition});"
+		],
+		"description": "Do-While Statement"
+	},
+	"Try-Catch Statement": {
+		"prefix": "trycatch",
+		"body": [
+			"try {",
+			"\t$TM_SELECTED_TEXT$0",
+			"} catch (${1:error}) {",
+			"\t",
+			"}"
+		],
+		"description": "Try-Catch Statement"
+	},
+	"Set Timeout Function": {
+		"prefix": "settimeout",
+		"body": [
+			"setTimeout(() => {",
+			"\t$TM_SELECTED_TEXT$0",
+			"}, ${1:timeout});"
+		],
+		"description": "Set Timeout Function"
+	},
+	"Set Interval Function": {
+		"prefix": "setinterval",
+		"body": [
+			"setInterval(() => {",
+			"\t$TM_SELECTED_TEXT$0",
+			"}, ${1:interval});"
+		],
+		"description": "Set Interval Function"
+	},
+	"Region Start": {
+		"prefix": "#region",
+		"body": [
+			"//#region $0"
+		],
+		"description": "Folding Region Start"
+	},
+	"Region End": {
+		"prefix": "#endregion",
+		"body": [
+			"//#endregion"
+		],
+		"description": "Folding Region End"
+	},
+	"new Promise": {
+		"prefix": "newpromise",
+		"body": [
+			"new Promise((resolve, reject) => {",
+			"\t$TM_SELECTED_TEXT$0",
+			"})"
+		],
+		"description": "Create a new Promise"
+	},
+	"Async Function Statement": {
+		"prefix": "async function",
+		"body": [
+			"async function ${1:name}(${2:params}) {",
+			"\t$TM_SELECTED_TEXT$0",
+			"}"
+		],
+		"description": "Async Function Statement"
+	},
+	"Async Function Expression": {
+		"prefix": "async arrow function",
+		"body": [
+			"async (${1:params}) => {",
+			"\t$TM_SELECTED_TEXT$0",
+			"}"
+		],
+		"description": "Async Function Expression"
+	}
+}