wasm-idle 0.7.2 → 1.0.0

package/dist/lsp/cpp/server.js

@@ -1,68 +0,0 @@
-import { resolveCppLanguageServerRuntimeAssetConfig } from '../runtime';
-import ClangdWorker from '../../clangd/worker?worker';
-import { WorkerAssetBridge } from '../../playground/assetBridge';
-import { BrowserMessageReader, BrowserMessageWriter } from '../../utils/vscodeJsonrpcBrowser';
-const currentUrl = () => globalThis.location?.href || '';
-async function createServer(assetConfig) {
-    let resolveReady = () => { };
-    let rejectReady = (_error) => { };
-    const ready = new Promise((resolve, reject) => {
-        resolveReady = resolve;
-        rejectReady = reject;
-    });
-    const worker = new ClangdWorker();
-    const assetBridge = new WorkerAssetBridge(worker, 'clangd', assetConfig);
-    const cleanup = () => {
-        worker.removeEventListener('message', readyListener);
-        worker.removeEventListener('error', errorListener);
-    };
-    const readyListener = (event) => {
-        if (assetBridge.handleMessage(event))
-            return;
-        switch (event.data?.type) {
-            case 'ready': {
-                cleanup();
-                resolveReady();
-                break;
-            }
-            case 'error': {
-                cleanup();
-                rejectReady(new Error(event.data?.message || 'clangd failed to initialize'));
-                break;
-            }
-        }
-    };
-    const errorListener = (event) => {
-        cleanup();
-        rejectReady(event.error || new Error(event.message || 'clangd worker failed'));
-    };
-    worker.addEventListener('message', readyListener);
-    worker.addEventListener('error', errorListener);
-    worker.postMessage({
-        type: 'init',
-        baseUrl: assetConfig.baseUrl,
-        assets: {
-            baseUrl: assetConfig.baseUrl,
-            useAssetBridge: assetConfig.useAssetBridge
-        }
-    });
-    await ready;
-    return worker;
-}
-export async function getCppLanguageServer(options) {
-    const assetConfig = resolveCppLanguageServerRuntimeAssetConfig(options, currentUrl());
-    const worker = await createServer(assetConfig);
-    const reader = new BrowserMessageReader(worker);
-    const writer = new BrowserMessageWriter(worker);
-    return {
-        transport: { reader, writer },
-        syncFile: (path) => {
-            worker.postMessage({ type: 'sync-file', name: path });
-        },
-        dispose: () => {
-            worker.terminate();
-            reader.dispose();
-            writer.dispose();
-        }
-    };
-}

package/dist/lsp/index.d.ts

@@ -1,5 +0,0 @@
-export { getEditorLanguageServer } from './registry';
-export { resolveCppLanguageServerBaseUrl, resolveCppLanguageServerRuntimeAssetConfig, resolvePythonLanguageServerBaseUrl } from './runtime';
-export { getCppLanguageServer } from './cpp/server';
-export { getPythonLanguageServer } from './python/server';
-export type { EditorLanguageServerHandle, EditorLanguageServerRuntimeOptions } from './types';

package/dist/lsp/index.js

@@ -1,4 +0,0 @@
-export { getEditorLanguageServer } from './registry';
-export { resolveCppLanguageServerBaseUrl, resolveCppLanguageServerRuntimeAssetConfig, resolvePythonLanguageServerBaseUrl } from './runtime';
-export { getCppLanguageServer } from './cpp/server';
-export { getPythonLanguageServer } from './python/server';

package/dist/lsp/python/main.worker.js

@@ -1,92 +0,0 @@
-/// <reference lib="WebWorker" />
-import { loadPyodide } from 'pyodide';
-import packageInitSource from './package/arcturus_python_lsp/__init__.py?raw';
-import packageServerSource from './package/arcturus_python_lsp/server.py?raw';
-let pyodide = null;
-let bridge = null;
-let initPromise = null;
-let configuredPyodideBaseUrl = '/pyodide/';
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function normalizeBaseUrl(baseUrl) {
-    return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
-}
-function emitTransportMessage(payload) {
-    try {
-        self.postMessage(JSON.parse(payload));
-    }
-    catch (error) {
-        console.error('Failed to emit Python LSP payload', error, payload);
-    }
-}
-function installPythonServerPackage(currentPyodide) {
-    currentPyodide.FS.mkdirTree('/arcturus_lsp/arcturus_python_lsp');
-    currentPyodide.FS.writeFile('/arcturus_lsp/arcturus_python_lsp/__init__.py', packageInitSource);
-    currentPyodide.FS.writeFile('/arcturus_lsp/arcturus_python_lsp/server.py', packageServerSource);
-}
-async function bootstrapPythonBridge(pyodideBaseUrl) {
-    if (bridge)
-        return;
-    if (initPromise)
-        return initPromise;
-    initPromise = (async () => {
-        self.postMessage({ type: 'progress', stage: 'load-pyodide' });
-        pyodide = await loadPyodide({ indexURL: normalizeBaseUrl(pyodideBaseUrl) });
-        pyodide.registerJsModule('arcturus_lsp_bridge', {
-            emit: emitTransportMessage
-        });
-        await pyodide.loadPackage('jedi');
-        installPythonServerPackage(pyodide);
-        await pyodide.runPythonAsync(`
-import sys
-
-if "/arcturus_lsp" not in sys.path:
-    sys.path.insert(0, "/arcturus_lsp")
-
-from arcturus_python_lsp import create_bridge
-
-_arcturus_python_lsp_bridge = create_bridge()
-`);
-        const bridgeProxy = pyodide.globals.get('_arcturus_python_lsp_bridge');
-        bridge = (payload) => {
-            bridgeProxy(payload);
-        };
-        self.postMessage({ type: 'ready' });
-    })().catch((error) => {
-        const message = toErrorMessage(error);
-        console.error('Python LSP bootstrap failed', error);
-        self.postMessage({ type: 'error', error: message });
-        initPromise = null;
-        bridge = null;
-        throw error;
-    });
-    return initPromise;
-}
-self.addEventListener('message', (event) => {
-    const payload = event.data;
-    if (!payload || typeof payload !== 'object')
-        return;
-    if (payload.type === 'init') {
-        configuredPyodideBaseUrl =
-            typeof payload.pyodideBaseUrl === 'string' ? payload.pyodideBaseUrl : '/pyodide/';
-        void bootstrapPythonBridge(configuredPyodideBaseUrl).catch((error) => {
-            console.error('Failed to initialize Python LSP worker', error);
-        });
-        return;
-    }
-    if ('type' in payload)
-        return;
-    const serialized = JSON.stringify(payload);
-    if (bridge) {
-        bridge(serialized);
-        return;
-    }
-    void bootstrapPythonBridge(configuredPyodideBaseUrl)
-        .then(() => {
-        bridge?.(serialized);
-    })
-        .catch((error) => {
-        console.error('Failed to forward LSP message to Python bridge', error);
-    });
-});

package/dist/lsp/python/package/arcturus_python_lsp/__init__.py

@@ -1,3 +0,0 @@
-from .server import create_bridge
-
-__all__ = ["create_bridge"]

package/dist/lsp/python/package/arcturus_python_lsp/server.py

@@ -1,462 +0,0 @@
-from __future__ import annotations
-
-import ast
-import json
-from pathlib import Path
-from urllib.parse import unquote, urlparse
-
-from jedi import Project, Script
-
-from arcturus_lsp_bridge import emit
-
-SERVER_NAME = "arcturus-python-lsp"
-SERVER_VERSION = "0.2.0"
-WORKSPACE_ROOT = "/workspace"
-
-TEXT_DOCUMENT_SYNC_FULL = 1
-DIAGNOSTIC_SEVERITY_ERROR = 1
-
-COMPLETION_ITEM_KIND = {
-    "text": 1,
-    "method": 2,
-    "function": 3,
-    "constructor": 4,
-    "field": 5,
-    "variable": 6,
-    "class": 7,
-    "interface": 8,
-    "module": 9,
-    "property": 10,
-    "unit": 11,
-    "value": 12,
-    "enum": 13,
-    "keyword": 14,
-    "snippet": 15,
-    "color": 16,
-    "file": 17,
-    "reference": 18,
-    "folder": 19,
-    "enumMember": 20,
-    "constant": 21,
-    "struct": 22,
-    "event": 23,
-    "operator": 24,
-    "typeParameter": 25,
-}
-
-SYMBOL_KIND = {
-    "file": 1,
-    "module": 2,
-    "namespace": 3,
-    "package": 4,
-    "class": 5,
-    "method": 6,
-    "property": 7,
-    "field": 8,
-    "constructor": 9,
-    "enum": 10,
-    "interface": 11,
-    "function": 12,
-    "variable": 13,
-    "constant": 14,
-}
-
-COMPLETION_KIND_MAP = {
-    "module": COMPLETION_ITEM_KIND["module"],
-    "class": COMPLETION_ITEM_KIND["class"],
-    "instance": COMPLETION_ITEM_KIND["variable"],
-    "function": COMPLETION_ITEM_KIND["function"],
-    "param": COMPLETION_ITEM_KIND["variable"],
-    "path": COMPLETION_ITEM_KIND["file"],
-    "keyword": COMPLETION_ITEM_KIND["keyword"],
-    "statement": COMPLETION_ITEM_KIND["keyword"],
-    "property": COMPLETION_ITEM_KIND["property"],
-}
-
-SYMBOL_KIND_MAP = {
-    "module": SYMBOL_KIND["module"],
-    "class": SYMBOL_KIND["class"],
-    "function": SYMBOL_KIND["function"],
-    "statement": SYMBOL_KIND["variable"],
-    "instance": SYMBOL_KIND["variable"],
-    "param": SYMBOL_KIND["variable"],
-}
-
-
-def _uri_to_path(uri: str) -> str:
-    if uri.startswith("file://"):
-        return unquote(urlparse(uri).path)
-
-    parsed = urlparse(uri)
-    if parsed.scheme and parsed.path:
-        return unquote(parsed.path)
-
-    return uri
-
-
-def _path_to_uri(path: Path) -> str:
-    return path.as_posix()
-
-
-class Document:
-    def __init__(
-        self,
-        uri: str,
-        source: str,
-        version: int | None = None,
-        language_id: str | None = None,
-    ) -> None:
-        self.uri = uri
-        self.source = source
-        self.version = version
-        self.language_id = language_id
-        self.path = _uri_to_path(uri)
-
-    @property
-    def lines(self) -> list[str]:
-        lines = self.source.splitlines(True)
-        return lines or [""]
-
-    def offset_at(self, position: dict) -> int:
-        line = max(int(position.get("line", 0)), 0)
-        character = max(int(position.get("character", 0)), 0)
-        lines = self.lines
-        if line >= len(lines):
-            return len(self.source)
-
-        offset = sum(len(lines[idx]) for idx in range(line))
-        return offset + min(character, len(lines[line]))
-
-    def apply_change(self, change: dict) -> None:
-        if "range" not in change or change["range"] is None:
-            self.source = change.get("text", "")
-            return
-
-        change_range = change["range"]
-        start = self.offset_at(change_range["start"])
-        end = self.offset_at(change_range["end"])
-        self.source = self.source[:start] + change.get("text", "") + self.source[end:]
-
-
-class ArcturusPythonLsp:
-    def __init__(self) -> None:
-        self.workspace_root = WORKSPACE_ROOT
-        Path(self.workspace_root).mkdir(parents=True, exist_ok=True)
-        self.project = Project(
-            path=self.workspace_root,
-            smart_sys_path=True,
-            load_unsafe_extensions=False,
-        )
-        self.documents: dict[str, Document] = {}
-        self.shutdown_requested = False
-
-    def handle(self, payload: str) -> None:
-        message = json.loads(payload)
-        if message.get("jsonrpc") != "2.0":
-            return
-
-        method = message.get("method")
-        if not method:
-            return
-
-        if "id" in message:
-            self._handle_request(message["id"], method, message.get("params") or {})
-        else:
-            self._handle_notification(method, message.get("params") or {})
-
-    def _emit(self, body: dict) -> None:
-        emit(json.dumps(body))
-
-    def _respond(self, msg_id, result=None, error: dict | None = None) -> None:
-        response = {"jsonrpc": "2.0", "id": msg_id}
-        if error is not None:
-            response["error"] = error
-        else:
-            response["result"] = result
-        self._emit(response)
-
-    def _notify(self, method: str, params: dict) -> None:
-        self._emit({"jsonrpc": "2.0", "method": method, "params": params})
-
-    def _refresh_project(self, root_uri: str | None) -> None:
-        if root_uri:
-            self.workspace_root = _uri_to_path(root_uri)
-
-        Path(self.workspace_root).mkdir(parents=True, exist_ok=True)
-        self.project = Project(
-            path=self.workspace_root,
-            smart_sys_path=True,
-            load_unsafe_extensions=False,
-        )
-
-    def _document(self, uri: str) -> Document:
-        return self.documents[uri]
-
-    def _mirror_document(self, uri: str) -> None:
-        document = self._document(uri)
-        path = Path(document.path)
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(document.source, encoding="utf-8")
-
-    def _script(self, uri: str) -> Script:
-        document = self._document(uri)
-        return Script(code=document.source, path=document.path, project=self.project)
-
-    def _range_for_name(self, name) -> dict | None:
-        if name.line is None or name.column is None:
-            return None
-
-        return {
-            "start": {"line": name.line - 1, "character": name.column},
-            "end": {"line": name.line - 1, "character": name.column + len(name.name)},
-        }
-
-    def _location_for_name(self, name, fallback_uri: str) -> dict | None:
-        range_value = self._range_for_name(name)
-        if range_value is None:
-            return None
-
-        module_path = getattr(name, "module_path", None)
-        uri = fallback_uri
-        if module_path is not None:
-            uri = _path_to_uri(Path(module_path))
-
-        return {"uri": uri, "range": range_value}
-
-    def _completion_kind(self, name_type: str) -> int:
-        return COMPLETION_KIND_MAP.get(name_type, COMPLETION_ITEM_KIND["text"])
-
-    def _symbol_kind(self, name_type: str) -> int:
-        return SYMBOL_KIND_MAP.get(name_type, SYMBOL_KIND["variable"])
-
-    def _publish_diagnostics(self, uri: str) -> None:
-        document = self._document(uri)
-        diagnostics: list[dict] = []
-
-        try:
-            ast.parse(document.source, filename=document.path)
-        except SyntaxError as error:
-            line = max((error.lineno or 1) - 1, 0)
-            column = max((error.offset or 1) - 1, 0)
-            diagnostics.append(
-                {
-                    "range": {
-                        "start": {"line": line, "character": column},
-                        "end": {"line": line, "character": column + 1},
-                    },
-                    "severity": DIAGNOSTIC_SEVERITY_ERROR,
-                    "source": SERVER_NAME,
-                    "message": error.msg or "Syntax error",
-                }
-            )
-
-        self._notify(
-            "textDocument/publishDiagnostics",
-            {"uri": uri, "diagnostics": diagnostics},
-        )
-
-    def _hover_text(self, definitions) -> str | None:
-        chunks: list[str] = []
-        for definition in definitions:
-            description = getattr(definition, "description", "") or definition.name
-            doc = definition.docstring(raw=False).strip()
-            block = description if not doc else f"{description}\n\n{doc}"
-            if block and block not in chunks:
-                chunks.append(block)
-
-        if not chunks:
-            return None
-
-        return "\n\n---\n\n".join(chunks)
-
-    def _initialize(self, params: dict) -> dict:
-        root_uri = params.get("rootUri")
-        if not root_uri and params.get("workspaceFolders"):
-            root_uri = params["workspaceFolders"][0].get("uri")
-        self._refresh_project(root_uri)
-        return {
-            "capabilities": {
-                "textDocumentSync": TEXT_DOCUMENT_SYNC_FULL,
-                "completionProvider": {
-                    "triggerCharacters": [".", "(", "[", '"', "'"],
-                    "resolveProvider": False,
-                },
-                "hoverProvider": True,
-                "definitionProvider": True,
-                "documentSymbolProvider": True,
-                "signatureHelpProvider": {"triggerCharacters": ["(", ","]},
-            },
-            "serverInfo": {"name": SERVER_NAME, "version": SERVER_VERSION},
-        }
-
-    def _shutdown(self):
-        self.shutdown_requested = True
-        return None
-
-    def _completion(self, params: dict) -> dict:
-        position = params["position"]
-        completions = self._script(params["textDocument"]["uri"]).complete(
-            line=position["line"] + 1,
-            column=position["character"],
-        )
-        items = []
-        for completion in completions:
-            item = {
-                "label": completion.name_with_symbols or completion.name,
-                "kind": self._completion_kind(completion.type),
-                "detail": completion.type,
-                "insertText": completion.complete or completion.name,
-            }
-            doc = completion.docstring(raw=False).strip()
-            if doc:
-                item["documentation"] = doc
-            items.append(item)
-        return {"isIncomplete": False, "items": items}
-
-    def _signature_help(self, params: dict) -> dict | None:
-        position = params["position"]
-        signatures = self._script(params["textDocument"]["uri"]).get_signatures(
-            line=position["line"] + 1,
-            column=position["character"],
-        )
-        if not signatures:
-            return None
-
-        items = []
-        for signature in signatures:
-            items.append(
-                {
-                    "label": signature.to_string(),
-                    "documentation": signature.docstring(raw=False).strip() or None,
-                    "parameters": [
-                        {"label": parameter.to_string()} for parameter in signature.params
-                    ],
-                }
-            )
-
-        return {"signatures": items, "activeSignature": 0, "activeParameter": 0}
-
-    def _hover(self, params: dict) -> dict | None:
-        position = params["position"]
-        definitions = self._script(params["textDocument"]["uri"]).infer(
-            line=position["line"] + 1,
-            column=position["character"],
-        )
-        hover_text = self._hover_text(definitions)
-        if not hover_text:
-            return None
-        return {"contents": {"kind": "markdown", "value": hover_text}}
-
-    def _definition(self, params: dict) -> list[dict] | None:
-        position = params["position"]
-        definitions = self._script(params["textDocument"]["uri"]).goto(
-            line=position["line"] + 1,
-            column=position["character"],
-            follow_imports=True,
-            follow_builtin_imports=True,
-        )
-        locations = [
-            location
-            for location in (
-                self._location_for_name(definition, params["textDocument"]["uri"])
-                for definition in definitions
-            )
-            if location is not None
-        ]
-        return locations or None
-
-    def _document_symbols(self, params: dict) -> list[dict]:
-        names = self._script(params["textDocument"]["uri"]).get_names(
-            all_scopes=True,
-            definitions=True,
-            references=False,
-        )
-        symbols = []
-        for name in names:
-            location = self._location_for_name(name, params["textDocument"]["uri"])
-            if location is None:
-                continue
-            symbols.append(
-                {
-                    "name": name.name,
-                    "kind": self._symbol_kind(name.type),
-                    "location": location,
-                    "containerName": getattr(name, "full_name", None) or name.name,
-                }
-            )
-        return symbols
-
-    def _handle_request(self, msg_id, method: str, params: dict) -> None:
-        try:
-            handlers = {
-                "initialize": self._initialize,
-                "shutdown": self._shutdown,
-                "textDocument/completion": self._completion,
-                "textDocument/signatureHelp": self._signature_help,
-                "textDocument/hover": self._hover,
-                "textDocument/definition": self._definition,
-                "textDocument/documentSymbol": self._document_symbols,
-            }
-            handler = handlers.get(method)
-            if handler is None:
-                self._respond(
-                    msg_id,
-                    error={"code": -32601, "message": f"Method not found: {method}"},
-                )
-                return
-            self._respond(msg_id, result=handler(params))
-        except Exception as error:
-            self._respond(
-                msg_id,
-                error={"code": -32603, "message": str(error) or "Internal server error"},
-            )
-
-    def _handle_notification(self, method: str, params: dict) -> None:
-        try:
-            if method == "initialized":
-                return
-            if method == "exit":
-                self.shutdown_requested = True
-                return
-            if method == "textDocument/didOpen":
-                text_document = params["textDocument"]
-                self.documents[text_document["uri"]] = Document(
-                    uri=text_document["uri"],
-                    source=text_document.get("text", ""),
-                    version=text_document.get("version"),
-                    language_id=text_document.get("languageId"),
-                )
-                self._mirror_document(text_document["uri"])
-                self._publish_diagnostics(text_document["uri"])
-                return
-            if method == "textDocument/didChange":
-                text_document = params["textDocument"]
-                document = self._document(text_document["uri"])
-                for change in params.get("contentChanges", []):
-                    document.apply_change(change)
-                document.version = text_document.get("version")
-                self._mirror_document(text_document["uri"])
-                self._publish_diagnostics(text_document["uri"])
-                return
-            if method == "textDocument/didSave":
-                text_document = params["textDocument"]
-                document = self._document(text_document["uri"])
-                if "text" in params and params["text"] is not None:
-                    document.source = params["text"]
-                self._mirror_document(text_document["uri"])
-                self._publish_diagnostics(text_document["uri"])
-                return
-            if method == "textDocument/didClose":
-                text_document = params["textDocument"]
-                self.documents.pop(text_document["uri"], None)
-                self._notify(
-                    "textDocument/publishDiagnostics",
-                    {"uri": text_document["uri"], "diagnostics": []},
-                )
-        except Exception:
-            return
-
-
-def create_bridge():
-    server = ArcturusPythonLsp()
-    return server.handle

package/dist/lsp/python/server.d.ts

@@ -1,2 +0,0 @@
-import type { EditorLanguageServerHandle, EditorLanguageServerRuntimeOptions } from '../types';
-export declare function getPythonLanguageServer(options?: string | EditorLanguageServerRuntimeOptions): Promise<EditorLanguageServerHandle>;