import * as vscode from "vscode"; import { LanguageClient } from "vscode-languageclient/node"; export const externalScheme = "prometeu-source"; export type ExternalContent = { descriptor: { uri: string; revision: string; origin: string; name: string; languageId: string; readOnly: true; origins?: { startOffset: number; endOffset: number; definitionPath: string; jsonPointer: string; assetUuid: string }[] }; text: string; }; /** Immutable virtual documents. No filesystem provider and no content-change events. */ export class ExternalSources implements vscode.TextDocumentContentProvider, vscode.Disposable { private client?: LanguageClient; private consumerId?: string; private readonly documents = new Map(); private readonly available = new Set(); private readonly closed = new Set(); private readonly status = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 10); refreshStatus(): void { const document = vscode.window.activeTextEditor?.document; if (document?.uri.scheme === externalScheme && !this.canQuery(document)) { this.status.text = "Prometeu: external source unavailable"; this.status.tooltip = "Reconnect to Studio or navigate again to obtain the current source revision."; this.status.show(); } else this.status.hide(); } get initializationOptions(): object { return this.consumerId ? { prometeuExternalConsumerId: this.consumerId } : {}; } canQuery(document: vscode.TextDocument): boolean { const uri = document.uri; if (uri.scheme !== externalScheme) return true; const content = this.documents.get(uri.toString()); return !!this.client && this.available.has(uri.toString()) && !!content && document.getText().replace(/\r\n?/g, "\n") === content.text.replace(/\r\n?/g, "\n"); } async connected(client: LanguageClient): Promise { const experimental = client.initializeResult?.capabilities.experimental; if (!experimental?.prometeuExternalSources) return; this.client = client; this.consumerId = experimental.prometeuExternalConsumerId; for (const uri of this.closed) await this.release(uri); this.closed.clear(); for (const [uri, old] of this.documents) { try { const current = await this.request("revalidateExternalSource", uri); if (current.descriptor.revision === old.descriptor.revision && current.text === old.text) this.available.add(uri); } catch { /* Keep displayed text; fresh navigation is required. */ } } this.refreshStatus(); } disconnected(): void { this.client = undefined; this.available.clear(); this.refreshStatus(); } resetSession(): void { this.disconnected(); this.consumerId = undefined; this.closed.clear(); } private request(operation: string, uri: string): Promise { if (!this.client || !this.consumerId) return Promise.reject(new Error("External source unavailable: reconnect to Studio.")); return this.client.sendRequest(`prometeu/${operation}`, { consumerId: this.consumerId, uri }); } async provideTextDocumentContent(uri: vscode.Uri, token: vscode.CancellationToken): Promise { const key = uri.toString(); const old = this.documents.get(key); if (old) return old.text; const content = await this.request("readExternalSource", key); if (token.isCancellationRequested) { await this.release(key); throw new Error("External source read cancelled."); } if (!content.descriptor.readOnly || content.descriptor.uri !== key) throw new Error("Invalid external source descriptor."); this.documents.set(key, content); this.available.add(key); this.refreshStatus(); return content.text; } originLenses(document: vscode.TextDocument): vscode.CodeLens[] { if (!this.canQuery(document)) return []; const content = this.documents.get(document.uri.toString()); return (content?.descriptor.origins ?? []).map(origin => { const offset = Buffer.from(document.getText(), "utf8").subarray(0, origin.startOffset).toString("utf8").length; const position = document.positionAt(offset); return new vscode.CodeLens(new vscode.Range(position, position), { title: "Open animation definition in Studio", command: "prometeu.openAnimationOrigin", arguments: [document.uri, origin.startOffset] }); }); } async openAnimationOrigin(uri: vscode.Uri, byteOffset: number): Promise { const document = vscode.workspace.textDocuments.find(doc => doc.uri.toString() === uri.toString()); if (!document || !this.canQuery(document) || !this.client || !this.consumerId) throw new Error("Animation source unavailable: navigate again to obtain the current revision."); await this.client.sendRequest("prometeu/openAnimationOrigin", { consumerId: this.consumerId, uri: uri.toString(), offset: byteOffset }); } async opened(document: vscode.TextDocument): Promise { if (document.uri.scheme !== externalScheme) return; const content = this.documents.get(document.uri.toString()); if (content && content.descriptor.languageId !== document.languageId) await vscode.languages.setTextDocumentLanguage(document, content.descriptor.languageId); } async closeDocument(document: vscode.TextDocument): Promise { const uri = document.uri.toString(); if (!this.documents.has(uri)) return; // Changing language also fires close/open; retain while VS Code still owns the document. await new Promise(resolve => setTimeout(resolve, 0)); if (vscode.workspace.textDocuments.some(open => open.uri.toString() === uri && !open.isClosed)) return; this.documents.delete(uri); this.available.delete(uri); if (this.client) await this.release(uri); else this.closed.add(uri); } private async release(uri: string): Promise { if (this.client && this.consumerId) await this.client.sendRequest("prometeu/releaseExternalSource", { consumerId: this.consumerId, uri }); } async shutdown(): Promise { if (this.client && this.consumerId) await this.client.sendRequest("prometeu/releaseExternalSource", { consumerId: this.consumerId, uri: null }); this.resetSession(); this.documents.clear(); } dispose(): void { this.disconnected(); this.documents.clear(); this.status.dispose(); } }