@lensmap/language-server 0.2.1 → 0.3.0

package/dist/preview/index.html

@@ -5,9 +5,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="theme-color" content="#10171f" />
     <title>Lensmap · Spatial lens lab</title>
-    <script type="module" crossorigin src="/assets/playground-BCY9v6Ap.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/styles-Bnie2-Dn.js">
-    <link rel="stylesheet" crossorigin href="/assets/styles-9bHR-mQh.css">
+    <script type="module" crossorigin src="/assets/playground-B1_UXc9t.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/styles-BEj3ZVHM.js">
+    <link rel="stylesheet" crossorigin href="/assets/styles-BANxTO8w.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/preview/preview.html

@@ -6,9 +6,9 @@
     <meta name="theme-color" content="#10171f" />
     <meta name="referrer" content="no-referrer" />
     <title>Lensmap · Editor preview</title>
-    <script type="module" crossorigin src="/assets/preview-BRCvwAxB.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/styles-Bnie2-Dn.js">
-    <link rel="stylesheet" crossorigin href="/assets/styles-9bHR-mQh.css">
+    <script type="module" crossorigin src="/assets/preview-Bugh_5CI.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/styles-BEj3ZVHM.js">
+    <link rel="stylesheet" crossorigin href="/assets/styles-BANxTO8w.css">
     <link rel="stylesheet" crossorigin href="/assets/preview-DDOSTiJj.css">
   </head>
   <body>

package/dist/server.js

@@ -2,8 +2,10 @@ import { randomBytes, timingSafeEqual } from "node:crypto";
 import { readFile, realpath, stat } from "node:fs/promises";
 import { createServer, } from "node:http";
 import { extname, resolve, sep } from "node:path";
-import { ConnectionTypeSchema, connectionWording, DocumentSession, positionToOffset, } from "@lensmap/document";
+import { ConnectionTypeSchema, connectionWording, DocumentSession, offsetToPosition, parseVocabulary, positionToOffset, vocabularyLocations, } from "@lensmap/document";
 import { CodeActionKind, CompletionItemKind, createConnection, StreamMessageReader, StreamMessageWriter, TextDocumentSyncKind, } from "vscode-languageserver/node";
+import { ProjectVocabularies } from "./vocabulary-project.js";
+import { analyzeVocabularyForTooling, declaresType, typeNameAt, typeValueRangeAt, } from "./vocabulary-tooling.js";
 class HttpError extends Error {
     status;
     constructor(status, message) {
@@ -92,6 +94,24 @@ export async function startServer(options) {
     let closePromise;
     let origin = "";
     let previewURL = "";
+    let workspaceUris = [];
+    const projects = new ProjectVocabularies((root, input) => {
+        if (closed)
+            return;
+        for (const [uri, entry] of entries) {
+            if (projects.rootFor(uri) !== root)
+                continue;
+            entry.vocabularyRequest = (entry.vocabularyRequest ?? 0) + 1;
+            entry.loading = false;
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            entry.timer = undefined;
+            entry.session.setVocabulary(input);
+            publish(entry);
+        }
+        for (const uri of projects.resources(root))
+            void publishVocabulary(uri);
+    });
     const envelope = () => ({
         type: "session",
         documents: [...entries.values()].map(({ session }) => session.snapshot()),
@@ -120,6 +140,48 @@ export async function startServer(options) {
             throw new HttpError(409, "Current source has not produced valid bindings.");
         return entry;
     };
+    const reportedExternal = new Set();
+    const externalDiagnostics = (uri) => {
+        const result = [...entries.values()].flatMap(({ session }) => session.snapshot().diagnostics.filter((item) => item.uri === uri));
+        const buffer = projects.buffer(uri);
+        if (!result.length && buffer) {
+            const parsed = uri.endsWith(".lenstypes")
+                ? parseVocabulary(buffer.source, uri)
+                : projects.cachedInput(uri);
+            if (parsed?.error && (!parsed.uri || parsed.uri === uri)) {
+                const at = offsetToPosition(buffer.source, parsed.offset ?? 0);
+                result.push({
+                    message: parsed.error,
+                    uri,
+                    range: { start: at, end: at },
+                });
+            }
+        }
+        return [
+            ...new Map(result.map((item) => [JSON.stringify(item), item])).values(),
+        ];
+    };
+    const publishExternal = () => {
+        const current = new Set([
+            ...projects.resources(),
+            ...[...entries.values()].flatMap(({ session }) => session
+                .snapshot()
+                .diagnostics.flatMap((item) => item.uri && item.uri !== session.uri ? [item.uri] : [])),
+        ]);
+        for (const uri of new Set([...reportedExternal, ...current])) {
+            void connection.sendDiagnostics({
+                uri,
+                diagnostics: externalDiagnostics(uri).map((item) => ({
+                    ...item,
+                    severity: 1,
+                    source: "lensmap",
+                })),
+            });
+        }
+        reportedExternal.clear();
+        for (const uri of current)
+            reportedExternal.add(uri);
+    };
     const publish = (entry) => {
         const snapshot = entry.session.snapshot();
         emit({ type: "snapshot", snapshot });
@@ -127,12 +189,15 @@ export async function startServer(options) {
             void connection.sendDiagnostics({
                 uri: snapshot.uri,
                 version: snapshot.revision,
-                diagnostics: snapshot.diagnostics.map((item) => ({
+                diagnostics: snapshot.diagnostics
+                    .filter((item) => !item.uri || item.uri === snapshot.uri)
+                    .map((item) => ({
                     ...item,
                     severity: 1,
                     source: "lensmap",
                 })),
             });
+        publishExternal();
         for (const observer of observers)
             observer();
     };
@@ -140,9 +205,57 @@ export async function startServer(options) {
         if (entry.timer)
             clearTimeout(entry.timer);
         entry.timer = undefined;
+        if (entry.loading)
+            return;
         entry.session.analyze();
         publish(entry);
     };
+    const loadVocabulary = async (entry) => {
+        const uri = entry.session.uri;
+        const request = (entry.vocabularyRequest ?? 0) + 1;
+        entry.vocabularyRequest = request;
+        entry.loading = true;
+        const input = await projects.forUri(uri);
+        if (closed ||
+            entries.get(uri) !== entry ||
+            entry.vocabularyRequest !== request)
+            return;
+        entry.loading = false;
+        if (entry.timer)
+            clearTimeout(entry.timer);
+        entry.timer = undefined;
+        entry.session.setVocabulary(input);
+        publish(entry);
+    };
+    const vocabularyContext = async (uri) => {
+        const input = await projects.forUri(uri);
+        const buffer = projects.buffer(uri);
+        const related = [...entries].filter(([mapUri]) => projects.rootFor(mapUri) === projects.rootFor(uri));
+        const contextualMap = input.uri === uri
+            ? (related.find(([mapUri]) => mapUri === activeUri) ?? related[0])?.[1]
+            : undefined;
+        return {
+            ...analyzeVocabularyForTooling(uri, input, entries.get(uri)?.session.source ?? contextualMap?.session.source, buffer && uri.endsWith(".lenstypes") ? buffer.source : undefined),
+            contextualUri: contextualMap?.session.uri,
+        };
+    };
+    const publishVocabulary = async (uri) => {
+        const buffer = projects.buffer(uri);
+        if (!buffer || closed)
+            return;
+        await projects.forUri(uri);
+        if (closed || projects.buffer(uri) !== buffer)
+            return;
+        void connection.sendDiagnostics({
+            uri,
+            version: buffer.version,
+            diagnostics: externalDiagnostics(uri).map((item) => ({
+                ...item,
+                severity: 1,
+                source: "lensmap",
+            })),
+        });
+    };
     const waitForReadback = (entry, base, expected) => new Promise((done) => {
         const matches = () => !closed &&
             entries.get(entry.session.snapshot().uri) === entry &&
@@ -444,6 +557,7 @@ export async function startServer(options) {
         if (closePromise)
             return closePromise;
         closed = true;
+        projects.dispose();
         for (const entry of entries.values())
             if (entry.timer)
                 clearTimeout(entry.timer);
@@ -463,6 +577,10 @@ export async function startServer(options) {
         connection.dispose();
     };
     connection.onInitialize((params) => {
+        workspaceUris =
+            params.workspaceFolders?.map((folder) => folder.uri) ??
+                (params.rootUri ? [params.rootUri] : []);
+        projects.setRoots(workspaceUris);
         canApply = params.capabilities.workspace?.applyEdit === true;
         canShowDocument =
             params.capabilities.window?.showDocument?.support === true;
@@ -472,6 +590,10 @@ export async function startServer(options) {
                 textDocumentSync: TextDocumentSyncKind.Incremental,
                 documentHighlightProvider: true,
                 definitionProvider: true,
+                hoverProvider: true,
+                workspace: {
+                    workspaceFolders: { supported: true, changeNotifications: true },
+                },
                 completionProvider: { triggerCharacters: [":", " "] },
                 codeActionProvider: true,
                 executeCommandProvider: {
@@ -485,7 +607,14 @@ export async function startServer(options) {
             serverInfo: { name: "Lensmap", version: "0.0.0" },
         };
     });
-    connection.onDidOpenTextDocument(({ textDocument: document }) => {
+    connection.onDidOpenTextDocument(async ({ textDocument: document }) => {
+        if (shutdown || closed)
+            return;
+        if (projects.isResource(document.uri)) {
+            await projects.open(document.uri, document.text, document.version);
+            await publishVocabulary(document.uri);
+            return;
+        }
         if (shutdown ||
             closed ||
             (!document.uri.endsWith(".lensmap") && document.languageId !== "lensmap"))
@@ -494,16 +623,38 @@ export async function startServer(options) {
         if (previous?.timer)
             clearTimeout(previous.timer);
         const entry = {
-            session: new DocumentSession(document.uri, document.text, document.version),
+            session: new DocumentSession(document.uri, document.text, document.version, { error: "Project vocabulary is loading." }),
         };
+        entry.session.receive(document.text, document.version);
         entries.set(document.uri, entry);
         activeUri = document.uri;
         emit(envelope());
         publish(entry);
+        await loadVocabulary(entry);
     });
-    connection.onDidChangeTextDocument(({ textDocument: document, contentChanges }) => {
+    connection.onDidChangeTextDocument(async ({ textDocument: document, contentChanges }) => {
         if (shutdown || closed)
             return;
+        const vocabulary = projects.buffer(document.uri);
+        if (vocabulary) {
+            if (document.version <= vocabulary.version)
+                return;
+            let source = vocabulary.source;
+            for (const change of contentChanges) {
+                if ("range" in change) {
+                    const start = positionToOffset(source, change.range.start);
+                    const end = positionToOffset(source, change.range.end);
+                    if (end < start)
+                        return;
+                    source = source.slice(0, start) + change.text + source.slice(end);
+                }
+                else
+                    source = change.text;
+            }
+            await projects.open(document.uri, source, document.version);
+            await publishVocabulary(document.uri);
+            return;
+        }
         const entry = entries.get(document.uri);
         if (!entry || document.version <= entry.session.revision)
             return;
@@ -547,11 +698,17 @@ export async function startServer(options) {
             });
         }
     });
-    connection.onDidCloseTextDocument(({ textDocument }) => {
+    connection.onDidCloseTextDocument(async ({ textDocument }) => {
+        if (projects.buffer(textDocument.uri)) {
+            await projects.close(textDocument.uri);
+            publishExternal();
+            return;
+        }
         const entry = entries.get(textDocument.uri);
         if (entry?.timer)
             clearTimeout(entry.timer);
         entries.delete(textDocument.uri);
+        publishExternal();
         if (activeUri === textDocument.uri)
             activeUri = entries.keys().next().value ?? null;
         emit(envelope());
@@ -566,24 +723,78 @@ export async function startServer(options) {
         focus(textDocument.uri, at, false);
         return entry.session.highlights(at).map((range) => ({ range, kind: 1 }));
     });
-    connection.onDefinition(({ textDocument, position: at }) => {
+    connection.onDefinition(async ({ textDocument, position: at }) => {
         const session = entries.get(textDocument.uri)?.session;
+        const source = session?.source ?? projects.buffer(textDocument.uri)?.source;
+        const name = source === undefined ? undefined : typeNameAt(source, at);
+        if (name && source !== undefined) {
+            const { input, contextualUri } = await vocabularyContext(textDocument.uri);
+            const sources = [
+                { uri: textDocument.uri, source },
+                ...(contextualUri
+                    ? [
+                        {
+                            uri: contextualUri,
+                            source: entries.get(contextualUri)?.session.source,
+                        },
+                    ]
+                    : []),
+                { uri: input.uri, source: input.source },
+            ];
+            for (const candidate of sources) {
+                if (!candidate.uri || candidate.source === undefined)
+                    continue;
+                const locations = vocabularyLocations(candidate.source, candidate.uri);
+                if (!Object.hasOwn(locations, name))
+                    continue;
+                const span = locations[name].name;
+                return {
+                    uri: candidate.uri,
+                    range: {
+                        start: offsetToPosition(candidate.source, span.start),
+                        end: offsetToPosition(candidate.source, span.end),
+                    },
+                };
+            }
+            return null;
+        }
         const key = session?.locate(at);
         const range = key ? session?.definition(key) : undefined;
         return range ? { uri: textDocument.uri, range } : null;
     });
-    connection.onCompletion(({ textDocument, position: at }) => {
+    connection.onCompletion(async ({ textDocument, position: at }) => {
         const session = entries.get(textDocument.uri)?.session;
-        if (!session)
+        const source = session?.source ?? projects.buffer(textDocument.uri)?.source;
+        if (source === undefined)
             return [];
-        const line = session.source.split(/\r?\n/)[at.line]?.slice(0, at.character) ?? "";
-        if (/^\s*(?:-\s*)?type:\s*[^#]*$/.test(line))
-            return ConnectionTypeSchema.options.map((type) => ({
+        const line = source.split(/\r?\n/)[at.line]?.slice(0, at.character) ?? "";
+        const prefix = /^\s*(?:-\s*)?(?:type|extends)\s*:\s*/.exec(line);
+        const scalarRange = prefix ? typeValueRangeAt(source, at) : undefined;
+        if (prefix &&
+            (scalarRange || !line.slice(prefix[0].length).includes("#"))) {
+            const { snapshot, input } = await vocabularyContext(textDocument.uri);
+            const vocabulary = snapshot.vocabulary ?? session?.snapshot().vocabulary;
+            const names = new Set([
+                ...ConnectionTypeSchema.options,
+                ...Object.keys(vocabulary ?? {}),
+                ...Object.keys(input.declarations ?? {}),
+            ]);
+            return [...names].map((type) => ({
                 label: type,
                 kind: CompletionItemKind.EnumMember,
-                detail: connectionWording(type, "outgoing"),
+                detail: connectionWording(type, "outgoing", vocabulary && Object.hasOwn(vocabulary, type)
+                    ? vocabulary[type]
+                    : undefined),
+                textEdit: {
+                    range: scalarRange ?? {
+                        start: { line: at.line, character: prefix[0].length },
+                        end: at,
+                    },
+                    newText: JSON.stringify(type),
+                },
             }));
-        if (!session.snapshot().valid || session.snapshot().pending)
+        }
+        if (!session?.snapshot().valid || session.snapshot().pending)
             return [];
         if (!/^\s*(?:-\s*)?node_id:\s*[^#]*$/.test(line))
             return [];
@@ -597,6 +808,46 @@ export async function startServer(options) {
                 },
             ]) ?? []);
     });
+    connection.onHover(async ({ textDocument, position: at }) => {
+        const source = entries.get(textDocument.uri)?.session.source ??
+            projects.buffer(textDocument.uri)?.source;
+        if (source === undefined)
+            return null;
+        const name = typeNameAt(source, at);
+        if (!name)
+            return null;
+        const { snapshot, input, contextualUri } = await vocabularyContext(textDocument.uri);
+        const registry = snapshot.vocabulary ?? {};
+        const definition = Object.hasOwn(registry, name)
+            ? registry[name]
+            : undefined;
+        if (!definition)
+            return null;
+        const origin = declaresType(source, name)
+            ? textDocument.uri
+            : contextualUri &&
+                declaresType(entries.get(contextualUri)?.session.source ?? "", name)
+                ? contextualUri
+                : Object.hasOwn(input.declarations ?? {}, name)
+                    ? input.uri
+                    : "built-in";
+        return {
+            contents: {
+                kind: "plaintext",
+                value: `${name} (${definition.coreKind})\n${definition.text} / ${definition.reverseText}\nDefined in ${origin ?? "project vocabulary"}`,
+            },
+        };
+    });
+    connection.onNotification("workspace/didChangeWorkspaceFolders", (params) => {
+        const deleted = new Set(params.event.removed.map((folder) => folder.uri));
+        workspaceUris = [
+            ...workspaceUris.filter((uri) => !deleted.has(uri)),
+            ...params.event.added.map((folder) => folder.uri),
+        ];
+        projects.setRoots(workspaceUris);
+        for (const entry of entries.values())
+            void loadVocabulary(entry);
+    });
     connection.onCodeAction(({ textDocument, range }) => entries.has(textDocument.uri)
         ? [
             {

package/dist/vocabulary-project.d.ts

@@ -0,0 +1,30 @@
+import type { VocabularyInput } from "@lensmap/document";
+export interface VocabularyBuffer {
+    source: string;
+    version: number;
+}
+/** Only known workspace config and vocabulary files, never HTTP-supplied paths. */
+export declare class ProjectVocabularies {
+    private readonly changed;
+    private roots;
+    private readonly projects;
+    private readonly buffers;
+    private readonly requests;
+    private readonly pending;
+    private serial;
+    private disposed;
+    constructor(changed: (root: string, input: VocabularyInput) => void);
+    setRoots(uris: readonly string[]): void;
+    rootFor(uri: string): string | undefined;
+    private refresh;
+    private load;
+    forUri(uri: string): Promise<VocabularyInput>;
+    isResource(uri: string): boolean;
+    buffer(uri: string): VocabularyBuffer | undefined;
+    cachedInput(uri: string): VocabularyInput | undefined;
+    open(uri: string, source: string, version: number): Promise<boolean>;
+    close(uri: string): Promise<boolean>;
+    resources(root?: string): string[];
+    private clearWatches;
+    dispose(): void;
+}

package/dist/vocabulary-project.js

@@ -0,0 +1,146 @@
+import { unwatchFile, watchFile } from "node:fs";
+import { resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readProjectVocabulary } from "@lensmap/document/project";
+const filePath = (uri) => {
+    try {
+        return resolve(fileURLToPath(uri));
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Only known workspace config and vocabulary files, never HTTP-supplied paths. */
+export class ProjectVocabularies {
+    changed;
+    roots = [];
+    projects = new Map();
+    buffers = new Map();
+    requests = new Map();
+    pending = new Map();
+    serial = 0;
+    disposed = false;
+    constructor(changed) {
+        this.changed = changed;
+    }
+    setRoots(uris) {
+        this.clearWatches();
+        this.roots = [...new Set(uris.flatMap((uri) => filePath(uri) ?? []))].sort((a, b) => b.length - a.length);
+    }
+    rootFor(uri) {
+        const path = filePath(uri);
+        return path
+            ? this.roots.find((root) => path.startsWith(root.endsWith(sep) ? root : `${root}${sep}`))
+            : undefined;
+    }
+    refresh(root, notify) {
+        const request = ++this.serial;
+        this.requests.set(root, request);
+        const work = this.load(root, request, notify).finally(() => {
+            if (this.pending.get(root) === work)
+                this.pending.delete(root);
+        });
+        this.pending.set(root, work);
+        return work;
+    }
+    async load(root, request, notify) {
+        if (this.disposed)
+            return;
+        const overlays = new Map([...this.buffers].flatMap(([uri, buffer]) => {
+            const path = filePath(uri);
+            return path ? [[path, buffer.source]] : [];
+        }));
+        const result = await readProjectVocabulary(root, overlays);
+        if (this.disposed ||
+            this.requests.get(root) !== request ||
+            !this.roots.includes(root))
+            return;
+        const signature = JSON.stringify(result.input);
+        let project = this.projects.get(root);
+        const changed = project?.signature !== signature;
+        if (!project) {
+            project = { input: result.input, signature, watches: new Map() };
+            this.projects.set(root, project);
+        }
+        project.input = result.input;
+        project.signature = signature;
+        const files = new Set(result.files);
+        for (const [path, listener] of project.watches) {
+            if (files.has(path))
+                continue;
+            unwatchFile(path, listener);
+            project.watches.delete(path);
+        }
+        for (const path of files) {
+            if (project.watches.has(path))
+                continue;
+            const listener = () => {
+                void this.refresh(root, true);
+            };
+            project.watches.set(path, listener);
+            watchFile(path, { persistent: false, interval: 100 }, listener);
+        }
+        if (notify && changed)
+            this.changed(root, project.input);
+    }
+    async forUri(uri) {
+        const root = this.rootFor(uri);
+        if (!root)
+            return {};
+        if (!this.projects.has(root) && !this.pending.has(root))
+            void this.refresh(root, false);
+        for (;;) {
+            const work = this.pending.get(root);
+            if (!work)
+                break;
+            await work;
+        }
+        return this.projects.get(root)?.input ?? {};
+    }
+    isResource(uri) {
+        const path = filePath(uri), root = this.rootFor(uri);
+        return Boolean(path &&
+            (path.endsWith(".lenstypes") ||
+                (root && path === resolve(root, "lensmap.config.json"))));
+    }
+    buffer(uri) {
+        return this.buffers.get(uri);
+    }
+    cachedInput(uri) {
+        const root = this.rootFor(uri);
+        return root ? this.projects.get(root)?.input : undefined;
+    }
+    async open(uri, source, version) {
+        if (!this.isResource(uri))
+            return false;
+        this.buffers.set(uri, { source, version });
+        const root = this.rootFor(uri);
+        if (root)
+            await this.refresh(root, true);
+        return true;
+    }
+    async close(uri) {
+        if (!this.buffers.delete(uri))
+            return false;
+        const root = this.rootFor(uri);
+        if (root)
+            await this.refresh(root, true);
+        return true;
+    }
+    resources(root) {
+        return [...this.buffers.keys()].filter((uri) => !root || this.rootFor(uri) === root);
+    }
+    clearWatches() {
+        for (const project of this.projects.values())
+            for (const [path, listener] of project.watches)
+                unwatchFile(path, listener);
+        this.projects.clear();
+        this.requests.clear();
+        this.pending.clear();
+    }
+    dispose() {
+        this.disposed = true;
+        this.clearWatches();
+        this.buffers.clear();
+    }
+}

package/dist/vocabulary-tooling.d.ts

@@ -0,0 +1,11 @@
+import { type SourcePosition, type SourceRange, type VocabularyInput } from "@lensmap/document";
+/** Reuse engine resolution for editor tooling, without publishing a second graph. */
+export declare function analyzeVocabularyForTooling(uri: string, supplied: VocabularyInput, mapSource?: string, vocabularySource?: string): {
+    snapshot: import("@lensmap/document").DocumentSnapshot;
+    input: VocabularyInput;
+};
+/** Native YAML scalar decoding preserves quoted/Unicode names exactly. */
+export declare function typeNameAt(source: string, at: SourcePosition): string | undefined;
+/** Replace the native scalar, including existing quotes but excluding comments. */
+export declare function typeValueRangeAt(source: string, at: SourcePosition): SourceRange | undefined;
+export declare function declaresType(source: string, name: string): boolean;