458 lines
16 KiB
TypeScript
458 lines
16 KiB
TypeScript
#!/usr/bin/env bun
|
|
import {
|
|
completionItems,
|
|
definitionLocation,
|
|
documentDiagnostics,
|
|
documentSymbols,
|
|
formatDocument,
|
|
hover,
|
|
offsetAt,
|
|
positionAt,
|
|
semanticTokens,
|
|
semanticTokensLegend,
|
|
wordAt,
|
|
virtualTypeScriptDocument,
|
|
workspaceCompletionItems,
|
|
workspaceSymbolLocations,
|
|
clearWorkspaceIndexCache,
|
|
extractComponentRefactor,
|
|
htmlToWrn,
|
|
type TextDocument,
|
|
} from "./index.ts";
|
|
import {
|
|
htmlCompletions,
|
|
htmlFoldingRanges,
|
|
htmlHover,
|
|
htmlLinkedEditingRanges,
|
|
htmlTagComplete,
|
|
mergeCompletions,
|
|
} from "./html-service.ts";
|
|
import { clearHtmlRegionCache } from "./html-regions.ts";
|
|
|
|
type JsonRpc = { jsonrpc?: string; id?: number | string; method?: string; params?: any };
|
|
const documents = new Map<string, TextDocument>();
|
|
const diagnosticTimers = new Map<string, ReturnType<typeof setTimeout>>();
|
|
const MAX_OPEN_DOCUMENTS = 256;
|
|
const DIAGNOSTIC_DEBOUNCE_MS = 300;
|
|
let buffer = Buffer.alloc(0);
|
|
let workspaceRoot = process.cwd();
|
|
|
|
function rootFromUri(uri?: string): string {
|
|
if (!uri?.startsWith("file://")) return workspaceRoot;
|
|
return decodeURIComponent(uri.slice(7)).replace(/^\/([A-Za-z]:)/, "$1");
|
|
}
|
|
|
|
function send(value: unknown): void {
|
|
const body = Buffer.from(JSON.stringify(value));
|
|
process.stdout.write(`Content-Length: ${body.length}\r\n\r\n`);
|
|
process.stdout.write(body);
|
|
}
|
|
function result(id: JsonRpc["id"], value: unknown): void {
|
|
send({ jsonrpc: "2.0", id, result: value });
|
|
}
|
|
function internalDiagnostic(document: TextDocument, error: unknown) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
return {
|
|
range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
|
|
severity: 1,
|
|
code: "WRN-LSP-INTERNAL",
|
|
source: "wrnexus",
|
|
message: `WRNexus language analysis failed safely: ${message}`,
|
|
};
|
|
}
|
|
|
|
function safeDocumentDiagnostics(document: TextDocument, includeTypes = true) {
|
|
try {
|
|
return documentDiagnostics(document, { includeTypes });
|
|
} catch (error) {
|
|
process.stderr.write(
|
|
`[wrnexus-lsp] diagnostics failed for ${document.uri}: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`,
|
|
);
|
|
return [internalDiagnostic(document, error)];
|
|
}
|
|
}
|
|
|
|
function publish(document: TextDocument, includeTypes = true): void {
|
|
send({
|
|
jsonrpc: "2.0",
|
|
method: "textDocument/publishDiagnostics",
|
|
params: { uri: document.uri, diagnostics: safeDocumentDiagnostics(document, includeTypes) },
|
|
});
|
|
}
|
|
|
|
function clearDiagnosticTimer(uri: string): void {
|
|
const timer = diagnosticTimers.get(uri);
|
|
if (timer) clearTimeout(timer);
|
|
diagnosticTimers.delete(uri);
|
|
}
|
|
|
|
function schedulePublish(document: TextDocument): void {
|
|
clearDiagnosticTimer(document.uri);
|
|
const expectedVersion = document.version;
|
|
diagnosticTimers.set(
|
|
document.uri,
|
|
setTimeout(() => {
|
|
diagnosticTimers.delete(document.uri);
|
|
const current = documents.get(document.uri);
|
|
if (current && current.version === expectedVersion) publish(current, false);
|
|
}, DIAGNOSTIC_DEBOUNCE_MS),
|
|
);
|
|
}
|
|
|
|
function rememberDocument(document: TextDocument): void {
|
|
documents.delete(document.uri);
|
|
documents.set(document.uri, document);
|
|
while (documents.size > MAX_OPEN_DOCUMENTS) {
|
|
const oldest = documents.keys().next().value;
|
|
if (typeof oldest !== "string") break;
|
|
documents.delete(oldest);
|
|
clearDiagnosticTimer(oldest);
|
|
}
|
|
}
|
|
|
|
async function handle(message: JsonRpc): Promise<void> {
|
|
const params = message.params ?? {};
|
|
switch (message.method) {
|
|
case "initialize":
|
|
workspaceRoot = params.rootPath ?? rootFromUri(params.rootUri);
|
|
result(message.id, {
|
|
serverInfo: { name: "WRNexus Language Server", version: "0.8.3" },
|
|
capabilities: {
|
|
textDocumentSync: { openClose: true, change: 1, save: true },
|
|
documentFormattingProvider: true,
|
|
completionProvider: {
|
|
triggerCharacters: ["<", "@", ":", ".", " ", "=", '"', "/"],
|
|
},
|
|
hoverProvider: true,
|
|
foldingRangeProvider: true,
|
|
linkedEditingRangeProvider: true,
|
|
definitionProvider: true,
|
|
referencesProvider: true,
|
|
renameProvider: { prepareProvider: true },
|
|
documentSymbolProvider: true,
|
|
semanticTokensProvider: { legend: semanticTokensLegend, full: true },
|
|
codeActionProvider: {
|
|
codeActionKinds: [
|
|
"quickfix",
|
|
"refactor.extract",
|
|
"refactor.rewrite",
|
|
"source.organizeImports",
|
|
],
|
|
},
|
|
experimental: { wrnexusVirtualTypeScript: true },
|
|
},
|
|
});
|
|
break;
|
|
case "initialized":
|
|
break;
|
|
case "shutdown":
|
|
for (const timer of diagnosticTimers.values()) clearTimeout(timer);
|
|
diagnosticTimers.clear();
|
|
result(message.id, null);
|
|
break;
|
|
case "exit":
|
|
for (const timer of diagnosticTimers.values()) clearTimeout(timer);
|
|
diagnosticTimers.clear();
|
|
documents.clear();
|
|
process.exit(0);
|
|
break;
|
|
case "textDocument/didOpen": {
|
|
const item = params.textDocument;
|
|
const document = { uri: item.uri, text: item.text, version: item.version };
|
|
rememberDocument(document);
|
|
publish(document);
|
|
break;
|
|
}
|
|
case "textDocument/didChange": {
|
|
const existing = documents.get(params.textDocument.uri);
|
|
const text = params.contentChanges?.at(-1)?.text;
|
|
if (existing && typeof text === "string") {
|
|
existing.text = text;
|
|
existing.version = params.textDocument.version;
|
|
schedulePublish(existing);
|
|
}
|
|
break;
|
|
}
|
|
case "textDocument/didSave": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
if (document) {
|
|
clearDiagnosticTimer(document.uri);
|
|
clearWorkspaceIndexCache(workspaceRoot);
|
|
publish(document, true);
|
|
}
|
|
break;
|
|
}
|
|
case "textDocument/didClose":
|
|
clearDiagnosticTimer(params.textDocument.uri);
|
|
documents.delete(params.textDocument.uri);
|
|
clearHtmlRegionCache(params.textDocument.uri);
|
|
send({
|
|
jsonrpc: "2.0",
|
|
method: "textDocument/publishDiagnostics",
|
|
params: { uri: params.textDocument.uri, diagnostics: [] },
|
|
});
|
|
break;
|
|
case "wrnexus/serverStatus":
|
|
result(message.id, {
|
|
openDocuments: documents.size,
|
|
pendingDiagnostics: diagnosticTimers.size,
|
|
memory: process.memoryUsage(),
|
|
});
|
|
break;
|
|
case "textDocument/formatting": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
result(
|
|
message.id,
|
|
document
|
|
? formatDocument(document, params.options?.tabSize, params.options?.insertSpaces)
|
|
: [],
|
|
);
|
|
break;
|
|
}
|
|
case "textDocument/completion": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
const wrnexus = [...completionItems(), ...workspaceCompletionItems(workspaceRoot)];
|
|
const html = document ? htmlCompletions(document, params.position) : [];
|
|
result(message.id, html.length ? mergeCompletions(wrnexus, html) : wrnexus);
|
|
break;
|
|
}
|
|
case "textDocument/documentSymbol": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
result(message.id, document ? documentSymbols(document) : []);
|
|
break;
|
|
}
|
|
case "textDocument/semanticTokens/full": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
result(message.id, document ? semanticTokens(document) : { data: [] });
|
|
break;
|
|
}
|
|
case "textDocument/hover": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
const html = document ? htmlHover(document, params.position) : null;
|
|
result(message.id, html ?? (document ? hover(document, params.position) : null));
|
|
break;
|
|
}
|
|
case "textDocument/foldingRange": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
result(message.id, document ? htmlFoldingRanges(document) : []);
|
|
break;
|
|
}
|
|
case "textDocument/linkedEditingRange": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
const ranges = document ? htmlLinkedEditingRanges(document, params.position) : null;
|
|
result(message.id, ranges ? { ranges } : null);
|
|
break;
|
|
}
|
|
case "wrn/tagComplete": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
result(message.id, document ? htmlTagComplete(document, params.position) : null);
|
|
break;
|
|
}
|
|
case "textDocument/definition": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
result(message.id, document ? definitionLocation(document, params.position) : null);
|
|
break;
|
|
}
|
|
case "textDocument/references": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
const selected = document ? wordAt(document.text, params.position) : null;
|
|
result(message.id, selected ? workspaceSymbolLocations(workspaceRoot, selected.word) : []);
|
|
break;
|
|
}
|
|
case "textDocument/prepareRename": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
result(message.id, document ? (wordAt(document.text, params.position)?.range ?? null) : null);
|
|
break;
|
|
}
|
|
case "textDocument/rename": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
const selected = document ? wordAt(document.text, params.position) : null;
|
|
if (!selected || !/^[A-Za-z_$][\w$]*$/.test(params.newName)) {
|
|
result(message.id, null);
|
|
break;
|
|
}
|
|
const changes: Record<string, Array<{ range: any; newText: string }>> = {};
|
|
for (const location of workspaceSymbolLocations(workspaceRoot, selected.word)) {
|
|
(changes[location.uri] ??= []).push({ range: location.range, newText: params.newName });
|
|
}
|
|
result(message.id, { changes });
|
|
break;
|
|
}
|
|
case "textDocument/codeAction": {
|
|
const document = documents.get(params.textDocument.uri);
|
|
if (!document) {
|
|
result(message.id, []);
|
|
break;
|
|
}
|
|
const actions: any[] = safeDocumentDiagnostics(document)
|
|
.filter((item) => item.code === "WRNA11Y001")
|
|
.map((item) => ({
|
|
title: "Add empty alt attribute",
|
|
kind: "quickfix",
|
|
diagnostics: [item],
|
|
edit: {
|
|
changes: {
|
|
[document.uri]: [
|
|
{ range: { start: item.range.end, end: item.range.end }, newText: ' alt=""' },
|
|
],
|
|
},
|
|
},
|
|
}));
|
|
const imports = [
|
|
...document.text.matchAll(
|
|
/^import(?:\s+type)?[\s\S]*?(?:;\s*|\n(?=import|\s*(?:page|component|layout|global\s+store|page\s+store)\b))/gm,
|
|
),
|
|
].map((match) => ({
|
|
start: match.index!,
|
|
end: match.index! + match[0].length,
|
|
text: match[0].trim(),
|
|
}));
|
|
if (imports.length > 1) {
|
|
const ordered = [...imports].sort((a, b) => {
|
|
const aType = /^import\s+type\b/.test(a.text) ? 0 : 1;
|
|
const bType = /^import\s+type\b/.test(b.text) ? 0 : 1;
|
|
return aType - bType || a.text.localeCompare(b.text);
|
|
});
|
|
const replacement = ordered.map((entry) => entry.text.replace(/;$/, "")).join("\n") + "\n";
|
|
const start = imports[0]!.start;
|
|
const end = imports.at(-1)!.end;
|
|
if (document.text.slice(start, end) !== replacement) {
|
|
actions.push({
|
|
title: "Organize WRN imports",
|
|
kind: "source.organizeImports",
|
|
edit: {
|
|
changes: {
|
|
[document.uri]: [
|
|
{
|
|
range: {
|
|
start: positionAt(document.text, start),
|
|
end: positionAt(document.text, end),
|
|
},
|
|
newText: replacement,
|
|
},
|
|
],
|
|
},
|
|
},
|
|
});
|
|
}
|
|
}
|
|
for (const diagnostic of params.context?.diagnostics ?? []) {
|
|
if (diagnostic.code !== "WRN-OUTPUT-LEGACY-EMIT") continue;
|
|
const start = offsetAt(document.text, diagnostic.range.start);
|
|
const end = offsetAt(document.text, diagnostic.range.end);
|
|
const source = document.text.slice(start, end);
|
|
const match = /\$emit\(\s*["']([A-Za-z_$][\w$]*)["']\s*,?/.exec(source);
|
|
if (!match) continue;
|
|
actions.push({
|
|
title: `Convert $emit to output.${match[1]}`,
|
|
kind: "quickfix",
|
|
diagnostics: [diagnostic],
|
|
isPreferred: true,
|
|
edit: {
|
|
changes: {
|
|
[document.uri]: [
|
|
{
|
|
range: diagnostic.range,
|
|
newText: source.replace(
|
|
/\$emit\(\s*["'][A-Za-z_$][\w$]*["']\s*,?\s*/,
|
|
`output.${match[1]}(`,
|
|
),
|
|
},
|
|
],
|
|
},
|
|
},
|
|
});
|
|
}
|
|
const selected = document.text.slice(
|
|
document.text
|
|
.split(/\r?\n/)
|
|
.slice(0, params.range.start.line)
|
|
.reduce((n, line) => n + line.length + 1, 0) + params.range.start.character,
|
|
document.text
|
|
.split(/\r?\n/)
|
|
.slice(0, params.range.end.line)
|
|
.reduce((n, line) => n + line.length + 1, 0) + params.range.end.character,
|
|
);
|
|
if (selected.trim().startsWith("<")) {
|
|
try {
|
|
actions.push({
|
|
title: "Extract selection to WRN component",
|
|
kind: "refactor.extract",
|
|
edit: extractComponentRefactor(document, params.range, "ExtractedComponent"),
|
|
});
|
|
actions.push({
|
|
title: "Convert selected HTML to WRN page",
|
|
kind: "refactor.rewrite",
|
|
edit: {
|
|
changes: {
|
|
[document.uri]: [
|
|
{ range: params.range, newText: htmlToWrn(selected, "ImportedPage") },
|
|
],
|
|
},
|
|
},
|
|
});
|
|
} catch {
|
|
/* selection is not safely convertible */
|
|
}
|
|
}
|
|
result(message.id, actions);
|
|
break;
|
|
}
|
|
case "wrnexus/virtualDocument": {
|
|
const document = documents.get(params.textDocument?.uri ?? params.uri);
|
|
result(message.id, document ? virtualTypeScriptDocument(document) : null);
|
|
break;
|
|
}
|
|
default:
|
|
if (message.id !== undefined) result(message.id, null);
|
|
}
|
|
}
|
|
|
|
function consume(): void {
|
|
while (true) {
|
|
const end = buffer.indexOf("\r\n\r\n");
|
|
if (end < 0) return;
|
|
const header = buffer.subarray(0, end).toString();
|
|
const length = Number(/Content-Length:\s*(\d+)/i.exec(header)?.[1]);
|
|
if (!Number.isFinite(length)) {
|
|
buffer = Buffer.alloc(0);
|
|
return;
|
|
}
|
|
const bodyStart = end + 4;
|
|
if (buffer.length < bodyStart + length) return;
|
|
const body = buffer.subarray(bodyStart, bodyStart + length).toString();
|
|
buffer = buffer.subarray(bodyStart + length);
|
|
let message: JsonRpc;
|
|
try {
|
|
message = JSON.parse(body) as JsonRpc;
|
|
} catch (error) {
|
|
process.stderr.write(
|
|
`[wrnexus-lsp] invalid JSON-RPC payload: ${error instanceof Error ? error.message : String(error)}\n`,
|
|
);
|
|
continue;
|
|
}
|
|
void handle(message).catch((error) => {
|
|
const detail = error instanceof Error ? (error.stack ?? error.message) : String(error);
|
|
process.stderr.write(`[wrnexus-lsp] request failed: ${detail}\n`);
|
|
if (message.id !== undefined) {
|
|
send({
|
|
jsonrpc: "2.0",
|
|
id: message.id,
|
|
error: { code: -32603, message: "WRNexus language server request failed", data: detail },
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
process.stdin.on("data", (chunk) => {
|
|
try {
|
|
buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
|
|
consume();
|
|
} catch (error) {
|
|
process.stderr.write(
|
|
`[wrnexus-lsp] input processing failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`,
|
|
);
|
|
}
|
|
});
|
|
process.stdin.resume();
|