@hydranium/client-browser 1.0.0-next.303 → 1.0.0-next.305

package/lib/monaco/monaco-lsp-client.d.ts

@@ -0,0 +1,495 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+/**
+ * The client half of the LSP head for a Monaco editor, over the connection the
+ * page already holds for the head.
+ *
+ * Hand-written rather than `monaco-languageclient`, which drags in the
+ * `@codingame/monaco-vscode-*` shim stack: at `platform: 'browser'` a bundler
+ * refuses a `node:*` builtin rather than shimming it, and that refusal is what
+ * keeps a page bundle a neutrality gate over the head composition it carries.
+ *
+ * A Theia or VS Code integration hands `vscode-languageclient` a document
+ * store, a marker service and a provider registry. Here Monaco is all three,
+ * and the three translations between it and LSP are the whole of the work:
+ *
+ * - **Identity.** A Monaco model URI must be string-identical to the LSP URI, or
+ *   `publishDiagnostics` addresses a document Monaco does not have and the
+ *   markers land nowhere, silently.
+ * - **Coordinates.** LSP lines and characters are 0-based; Monaco lines and
+ *   columns are 1-based. Every range crossing this file is converted.
+ * - **Versions.** Monaco's `versionId` is monotonic per model, which is exactly
+ *   what the server's text store wants for its stale-write gate, so it is used
+ *   directly rather than counted here in parallel.
+ */
+import { type BaseVersion, type TextState } from '@hydranium/protocol';
+import * as monaco from 'monaco-editor-core';
+import { type MessageConnection } from 'vscode-jsonrpc/browser';
+import { type AnnotatedTextEdit, type ApplyWorkspaceEditResult, type ClientCapabilities, type PublishDiagnosticsParams, type ServerCapabilities, SnippetTextEdit, type TextEdit, type WorkspaceEdit } from 'vscode-languageserver-protocol';
+export interface MonacoLspClientOptions {
+    /**
+     * The languages the server speaks, as Monaco registers them. A document is
+     * routed to the first entry whose `extensions` its URI ends with, and that
+     * id is the `languageId` on `didOpen`, which the server routes the document
+     * to a grammar by. No entry means the open throws rather than guessing: a
+     * document parsed by the wrong grammar reports a page of syntax errors that
+     * read as the file being broken.
+     */
+    readonly languages: readonly monaco.languages.ILanguageExtensionPoint[];
+    /** The owner of the markers this client sets, which a host reads them back by; {@link DEFAULT_MARKER_OWNER} by default. */
+    readonly markerOwner?: string;
+}
+/** The marker owner a client sets diagnostics under when its options name none. */
+export declare const DEFAULT_MARKER_OWNER = "lsp";
+/**
+ * The client capabilities for a host whose editor is a {@link MonacoLspClient},
+ * to pass as `initializeLanguageClient`'s `capabilities`: the two workspace
+ * answers of the default, plus every form the client renders, so a server that
+ * gates a form on its capability sends it. Multi-line semantic tokens stay
+ * undeclared, since Monaco cannot render one, and Langium then splits them
+ * per line. Frozen: a host that declares more spreads it.
+ */
+export declare const MONACO_CLIENT_CAPABILITIES: ClientCapabilities;
+/** One document's worth of an inbound workspace edit, ready to push into Monaco. */
+export interface ResolvedDocumentEdit {
+    readonly model: monaco.editor.ITextModel;
+    readonly operations: readonly monaco.editor.IIdentifiedSingleEditOperation[];
+}
+/**
+ * Whether one document's worth of an inbound workspace edit can be applied, and
+ * if not, what to tell the server.
+ *
+ * A REASON rather than a bare `false`, because the reason travels: it becomes
+ * `ApplyWorkspaceEditResult.failureReason`, which is the only thing the server
+ * learns about a refusal beyond the fact of it.
+ */
+export type EditResolution = {
+    readonly applicable: true;
+    readonly edit: ResolvedDocumentEdit;
+} | {
+    readonly applicable: false;
+    readonly reason: string;
+};
+/** One open document's content and the buffer version that content was read at. */
+export interface EditorDocument {
+    /**
+     * Monaco's form of the URI, as the server knows the document: a host
+     * compares it with `Uri.parse(uri).toString()` of its own, since a space or
+     * a drive-letter colon is encoded here and not in the string it opened with.
+     */
+    readonly uri: string;
+    readonly text: string;
+    readonly version: number;
+    /** The model the text was read from: a reopened URI is a new model, and a record of the old one marks nothing. */
+    readonly model: monaco.editor.ITextModel;
+}
+/**
+ * Registers the server's languages with Monaco and keeps its models in step
+ * with the LSP head on the other end of `connection`.
+ *
+ * Construction registers the languages, the providers and the inbound
+ * `workspace/applyEdit` handler; {@link openDocument} opens one document and
+ * {@link closeDocument} closes it; {@link dispose} closes every document and
+ * releases every registration. Diagnostics are NOT subscribed here — see
+ * {@link applyDiagnostics}.
+ */
+export declare class MonacoLspClient {
+    protected readonly options: MonacoLspClientOptions;
+    /**
+     * The models this client opened, by URI in Monaco's form. Every inbound
+     * edit, diagnostic and dirty read goes through this map rather than
+     * Monaco's global lookup: a page may hold a second client, and a model
+     * that client holds is not this one's to write, mark or save, however
+     * its URI reads.
+     */
+    protected readonly models: Map<string, monaco.editor.ITextModel>;
+    /** Per URI, the buffer version last known to be persisted. */
+    protected readonly savedVersions: Map<string, number>;
+    /** Everything construction and {@link registerEditorOpener} registered, released in reverse by {@link dispose}. */
+    protected readonly registrations: monaco.IDisposable[];
+    protected readonly markerOwner: string;
+    /**
+     * The host's connection, sending by method name: the LSP message types come
+     * from `vscode-languageserver-protocol`'s copy of `vscode-jsonrpc`, which
+     * need not be the connection's.
+     */
+    protected readonly connection: MessageConnection;
+    constructor(connection: MessageConnection, capabilities: ServerCapabilities, options: MonacoLspClientOptions);
+    /**
+     * The language id for `uri`, by the extensions the options name.
+     *
+     * Throws rather than falling back to a default id. An unknown extension means
+     * the host named a document the server has no grammar for, and the failure of
+     * the guessing version is that the document opens, parses as the wrong
+     * language and reports a page of syntax errors that look like the file being
+     * broken.
+     */
+    protected languageIdFor(uri: string): string;
+    /**
+     * Apply one `publishDiagnostics` notification to the model it addresses.
+     *
+     * **Called by the host's single notification handler rather than subscribing
+     * here, and that is forced rather than stylistic.**
+     * `MessageConnection.onNotification` stores handlers in a map keyed by method,
+     * so a second registration for `textDocument/publishDiagnostics` REPLACES the
+     * first and returns a disposable as though it had worked. A host with a
+     * handler for its own diagnostics view would have it taken over by a client
+     * that registered its own, and its view would freeze at whatever it had
+     * reached — with nothing on the console to say so.
+     *
+     * A URI with no model of this client's is not an error: a workspace has more
+     * documents than the host opens, so most publishes address a file Monaco
+     * has never heard of, and a model another client holds is that client's.
+     */
+    applyDiagnostics(params: PublishDiagnosticsParams): void;
+    /**
+     * Answer `workspace/applyEdit` — the server→text direction, and the half of
+     * the sync a client that only sends `didOpen` silently loses.
+     *
+     * A server-side write (a diagram drag, a form edit, an integrity repair) goes
+     * through the framework's `ModelService`, which rewrites the in-memory text
+     * document and then mirrors the settled text to whichever client holds it
+     * open, as a MINIMAL `workspace/applyEdit` computed against a shadow of that
+     * client's buffer. So the request goes out on every such write the moment the
+     * host opens a document — and a client with no handler makes
+     * `vscode-jsonrpc` answer `MethodNotFound`, which the framework logs through
+     * its tracer and therefore onto `window/logMessage`. A host that has no
+     * handler for that either loses the whole inbound direction with nothing on
+     * the console, in the editor or in the server's own report to say so.
+     *
+     * **Registered here rather than by the host, unlike `publishDiagnostics`.**
+     * `onRequest` keys handlers by method exactly as `onNotification` does, so a
+     * second registration would silently replace this one — but nothing else
+     * answers `workspace/applyEdit`, so there is no fan-out to arbitrate, and the
+     * handler needs the model store, which is this class's business.
+     *
+     * **The framework does not gate this on a client capability.**
+     * `HydraniumTextDocuments.applyEditToLanguageClient` checks that an LSP
+     * connection is bound and that the client has the document open, never a
+     * capability, and `vscode-languageserver`'s own
+     * `RemoteWorkspaceImpl.applyEdit` forwards unconditionally — so declaring
+     * `workspace.applyEdit` in `initialize` does not turn the request on and
+     * omitting it does not turn it off.
+     *
+     * **The echo does not LOOP, and is deliberately not suppressed here.**
+     * Applying the edit makes Monaco fire `onDidChangeContent`, which
+     * {@link openDocument} turns into a `didChange`. The server answers that
+     * echo with no push of its own, so nothing ping-pongs.
+     * The server correlates that `didChange` against the push still in flight
+     * and reconstructs it against the buffer this client held BEFORE the push —
+     * which is the only text its incremental ranges address — so an echo mints
+     * no version and drives no rebuild.
+     *
+     * Suppressing it would break what that correlation runs on: `didChange` is
+     * what keeps the server's per-URI shadow and its per-client version aligned
+     * with this buffer, so withholding it makes the next outbound diff wrong and
+     * makes every versioned push arrive stale. A conforming client echoes.
+     *
+     * **This client echoes the ranges it was handed, and a server must not assume
+     * that.** A host is free to minimise a coarse edit against its own buffer
+     * before applying it — Theia routes every workspace edit through
+     * `computeMoreMinimalEdits` — so the echo of a single full-document replace
+     * can arrive as a set of small ranges keyed to text the server never sent.
+     */
+    protected registerApplyEdit(): void;
+    /**
+     * Apply `edit` to the models it addresses, or refuse all of it.
+     *
+     * **Every target is resolved before any is written.** An LSP workspace edit
+     * is a unit — `failureHandling` exists precisely because a partially applied
+     * one leaves the workspace in a state no participant described — and here the
+     * server's text shadow is what would carry the damage: it tracks one text per
+     * URI, so a half-applied multi-document edit desynchronises the untouched
+     * half's baseline and every later minimal diff for it addresses the wrong
+     * lines.
+     *
+     * The framework's own egress never exercises that: it sends a write that
+     * touches two documents as two requests of one `TextDocumentEdit` each,
+     * because `applyEditToLanguageClient` is per-URI and coalesced per-URI.
+     * The loop is therefore for an adopter's server that batches, and the
+     * all-or-nothing shape is what keeps this client honest for one.
+     */
+    protected applyWorkspaceEdit(edit: WorkspaceEdit): ApplyWorkspaceEditResult;
+    /**
+     * Resolve one document's worth of an inbound edit against the model it names.
+     *
+     * Refuses, rather than dropping quietly, in three cases:
+     *
+     * - **No model for the URI.** `applied: true` for an edit that went nowhere
+     *   would leave the server's shadow believing this client holds text it does
+     *   not, and every later minimal diff for that URI would be computed against
+     *   the wrong baseline. The framework pushes only to documents the language
+     *   client has opened, and stages or keeps in the store a write to any
+     *   other, so this branch should stay unreached — it exists so that if it is
+     *   ever reached the failure is loud rather than a slow desynchronisation.
+     * - **A stale version.** The framework addresses a position-dependent
+     *   (line-keyed) push at its last known version of this buffer, precisely so
+     *   the client can refuse a push its buffer has outrun: applying a stale
+     *   range does not fail, it splices the file at the wrong lines. Refusing is
+     *   not a dead branch — `ModelService` re-pushes a full-range replace on
+     *   `applied: false`, which is position-independent and therefore correct
+     *   against whatever the buffer now holds. That retry arrives with
+     *   `version: null` and passes this gate by construction.
+     * - **A snippet edit.** Monaco applies snippets through a controller rather
+     *   than through the model, so a `SnippetTextEdit` pushed as text would
+     *   insert its placeholder syntax literally.
+     */
+    protected resolveDocumentEdit(uri: string, version: number | null, edits: readonly (TextEdit | AnnotatedTextEdit | SnippetTextEdit)[]): EditResolution;
+    /**
+     * Create a model for `uri` holding `text`, and tell the server the document is
+     * open. Returns the model this client already holds for the URI; a model
+     * another client of this page holds is refused, since this client would
+     * neither announce it nor send its changes.
+     *
+     * **`text` must be the bytes the server already has.** A browser host takes
+     * it from the worker's own filesystem, so `didOpen` carries what the heads
+     * came up on. Inventing placeholder text would not fail — it would
+     * OVERWRITE the server's copy through the text-document store and quietly
+     * change the diagnostics the server reports.
+     *
+     * `didOpen` carries the model's text rather than `text` itself: Monaco drops
+     * a BOM and rewrites mixed line endings to the majority form when it builds
+     * the model, as any editor does, and a server holding the bytes instead
+     * would be one character off every position and never match the buffer a
+     * save compares it with.
+     *
+     * Which is also why the second call for a URI is a no-op rather than a
+     * refresh: by then the buffer may hold a server write the snapshot never had,
+     * and the snapshot is the older claim.
+     *
+     * The URI is sent in Monaco's form: `Uri.parse(uri).toString()` encodes a
+     * space or a drive-letter colon, and the providers name the document by the
+     * model's URI, so a `didOpen` with the host's string would open a document
+     * no provider request ever addresses.
+     */
+    openDocument(uri: string, text: string): monaco.editor.ITextModel;
+    /**
+     * Dispose the model for `uri` and tell the server the document is closed, so
+     * the server drops this client's shadow of it and stops pushing to it. A URI
+     * this client never opened is left alone. An editor still showing the model
+     * is the host's to re-point first: Monaco detaches a disposed model from it.
+     * A model the host disposed itself is closed on the server all the same,
+     * here or by the next {@link openDocument} of its URI.
+     *
+     * The markers go first: Monaco drops a disposed model's markers only for its
+     * own schemes, so a `file:` document reopened later would start with the
+     * squiggles the server published before the close.
+     *
+     * The model goes before `didClose`, and a connection already closed does not
+     * fail the call: the page's side of the sync is this client's to release
+     * whatever became of the worker, and the server's side ends with its
+     * connection.
+     */
+    closeDocument(uri: string): void;
+    /**
+     * Close every open document and release every registration, in reverse
+     * order, the `workspace/applyEdit` handler included: a later request is
+     * answered as an unknown method, as for a client that never registered.
+     * The languages stay registered, since Monaco cannot unregister one.
+     */
+    dispose(): void;
+    /**
+     * Create one editor over `model`, with the settings a server-driven language
+     * needs under `options`: the host's theme, layout and chrome spread over
+     * them, so a host cannot lose one by spreading in the wrong order.
+     *
+     * Separate from {@link openDocument} because a host may hold a FIXED number
+     * of editors and swap their models rather than create an editor per
+     * document. That is what keeps a `didOpen` a statement about the workspace
+     * instead of about which pane happens to be showing what.
+     *
+     * `suggest` is merged one level deep: it is the one nested setting here, and
+     * a host's own suggest options would otherwise replace the insert mode the
+     * forwarded `InsertReplaceEdit` ranges depend on.
+     */
+    createEditor(container: HTMLElement, model: monaco.editor.ITextModel, options?: monaco.editor.IStandaloneEditorConstructionOptions): monaco.editor.IStandaloneCodeEditor;
+    /**
+     * The open documents whose buffer has moved since it was opened or last
+     * saved, with the text to persist.
+     *
+     * **The editor's buffer is the right source for a save**, not the host's copy
+     * of the workspace: a server write reaches this buffer through
+     * `workspace/applyEdit`, so Monaco's model is the one place both directions of
+     * the sync are already merged.
+     *
+     * **Dirty rather than every open document, and that is not cosmetic.** A save
+     * of an unmodified file writes its current bytes into the backing store, and
+     * a store that wins over a seed on the next load would then pin a file nobody
+     * changed.
+     *
+     * `getAlternativeVersionId` rather than `getVersionId`, because it is the one
+     * that returns to its old value when an edit is UNDONE — undoing a server
+     * write leaves nothing to save, which `getVersionId` (monotonic) would report
+     * as a change.
+     */
+    dirtyDocuments(): EditorDocument[];
+    /**
+     * The document at `uri`, in any form, if it has unsaved changes, read from
+     * its model alone; nothing for a document that is saved or that this client
+     * does not hold.
+     */
+    dirtyDocument(uri: string): EditorDocument | undefined;
+    /** The model this client holds for a URI in any form, if it still exists. */
+    protected modelOf(uri: string): monaco.editor.ITextModel | undefined;
+    /**
+     * Run one provider's request. A request nobody wants an answer to any more,
+     * since the server gave it up or the connection closed, rejects with
+     * Monaco's cancellation, which Monaco drops silently. Any other rejection
+     * reaches Monaco, which reports it as an uncaught page error.
+     */
+    protected request<R>(send: () => Promise<R>): Promise<R>;
+    /**
+     * Whether `model` is one this client opened. Monaco picks a provider by
+     * language id, so a second client of the same language is handed this
+     * client's models and this client the other's; a request for one of those
+     * would name a document this client's server never opened.
+     */
+    protected owns(model: monaco.editor.ITextModel): boolean;
+    /**
+     * Record that `document`'s content has been persisted.
+     *
+     * Takes the document rather than the URI so the version recorded is the one
+     * the TEXT was read at: a keystroke landing while the save was in flight must
+     * leave the document dirty, and marking it against the buffer's current
+     * version would silently swallow that edit. A record of a model since closed
+     * marks nothing: a reopened URI is a new model whose versions start over, so
+     * the old record's version could name an edit of the new one.
+     */
+    markSaved(document: EditorDocument): void;
+    /**
+     * Register one `DocumentSemanticTokensProvider` per language, reading the
+     * legend off the `initialize` result.
+     *
+     * The legend has to come from the server rather than being restated here: it
+     * is the index space the token stream is encoded in, so a client legend that
+     * merely LOOKS right renders every token as the wrong kind — a colouring bug
+     * with no error anywhere. Langium builds it by merging every registered
+     * language's provider options, which is why one legend serves them all.
+     *
+     * Absent capability means no provider at all rather than an empty legend: an
+     * empty one would decode every token index to nothing and produce a file with
+     * no highlighting, which is what a broken server looks like.
+     */
+    protected registerSemanticTokens(capabilities: ServerCapabilities): void;
+    /**
+     * Register one `CompletionItemProvider` per language.
+     *
+     * `triggerCharacters` is taken from the server rather than guessed. It is what
+     * makes the list appear on `.` without a letter after it; a client that
+     * invents its own set either misses a trigger the grammar defines or asks on a
+     * character the server has nothing to say about.
+     */
+    protected registerCompletion(capabilities: ServerCapabilities): void;
+    /**
+     * Register one `HoverProvider` per language.
+     *
+     * Registered unconditionally rather than behind `capabilities.hoverProvider`,
+     * unlike the semantic-token provider above, because the two failure modes are
+     * not alike: a hover request a server does not implement answers `null` and
+     * Monaco shows nothing, whereas a semantic-token provider without the
+     * server's legend would decode the token stream against the wrong index space
+     * and mis-colour the file.
+     */
+    protected registerHover(): void;
+    /**
+     * Route a definition target in ANOTHER document to `open`, which answers
+     * whether it could show it.
+     *
+     * **Monaco's standalone editor service can only navigate within the editor
+     * that was clicked in**, and it declines the rest by doing nothing: it looks
+     * the target resource up on the source editor alone, finds a different model,
+     * and returns — no message, no marker, no console line. That is the same
+     * observable as a server that resolved no reference, which is what makes the
+     * seam worth stating rather than discovering. A host with a workbench behind
+     * it supplies this step; a plain page supplies it by hand.
+     *
+     * `false` from `open` leaves the reader where they are, and that is the
+     * honest answer for a target the host holds no text for rather than a
+     * failure: a `virtual:` in-code contribution is a document to the server and
+     * no file to anyone.
+     *
+     * **A source editor on a model this client does not own is left to the next
+     * opener.** Monaco calls every opener for every editor, so on a page with
+     * two clients this one would otherwise claim a jump the other client's
+     * server resolved, and hand its host a document that host never opened.
+     *
+     * **A target in the SOURCE editor's own model is deliberately NOT routed
+     * here.** Monaco calls the last-registered opener first and falls through to
+     * its own on a `false`, and its own is better for that case: it selects the
+     * declaration's whole range where this seam could only place a caret, and it
+     * is the path the editor's navigation history is recorded on.
+     *
+     * Released by {@link dispose} as well as by the returned disposable.
+     */
+    registerEditorOpener(open: (uri: string, position: monaco.IPosition) => boolean): monaco.IDisposable;
+    /**
+     * Register one `DefinitionProvider` per language.
+     *
+     * **This is half of go-to-definition, and on its own it moves nothing for a
+     * target in another document.** A provider answers where the declaration is;
+     * going there is the host's job, and {@link registerEditorOpener} is the
+     * other half. Registered unconditionally, for the reason {@link registerHover}
+     * states.
+     */
+    protected registerDefinition(): void;
+    /**
+     * Register one `DocumentHighlightProvider` per language.
+     *
+     * **Document-scoped by the protocol, unlike every other reference-following
+     * request here**, so it answers what a name does in the file being read
+     * rather than where it comes from — the declaration and its uses in one view,
+     * with no jump and nothing opened. Registered unconditionally, for the reason
+     * {@link registerHover} states.
+     */
+    protected registerDocumentHighlight(): void;
+}
+/** The two calls of a data session {@link saveDirtyDocuments} makes, which `DataSession` satisfies. */
+export interface DocumentPersister {
+    /** Open `args.uri`, run `fn` with the opened document, whose `text` is the server's state of it, and close it after. */
+    withOpenDocument<T>(args: {
+        readonly uri: string;
+    }, fn: (document: {
+        readonly text?: TextState;
+    }) => Promise<T>): Promise<T>;
+    persistDocument(args: {
+        readonly uri: string;
+        readonly baseVersion: BaseVersion;
+    }): Promise<unknown>;
+}
+/**
+ * Persist the dirty documents of `client`, or those of them `uris` names, in
+ * the host's form or Monaco's, through `session`, one after another, and
+ * return what was saved.
+ *
+ * **A save persists; it does not author.** Every keystroke already reached the
+ * server as a `didChange`, and every server write reached the buffer as a
+ * `workspace/applyEdit`, so the server's text is the buffer and disk is the
+ * only thing behind. `persistDocument` at `'any'` writes that text without a
+ * model: a write of the buffer's text would be authored against no read, so
+ * no `ModelVersion` could gate it, and `'any'` on such a write could put an
+ * older buffer over a server write still in flight.
+ *
+ * **The open's text hash is the gate.** A `didChange` travels the LSP port and
+ * the persist the data port, and nothing orders one port's messages before
+ * the other's, so the open can answer with text a keystroke has not reached.
+ * The open answer's hash is `textHash` of the server's text; when it is not
+ * the buffer's, the save throws, naming the document, and the document stays
+ * dirty for the next save. A keystroke landing after the open persists as
+ * newer text, which leaves the buffer dirty the same way.
+ *
+ * Each document's text is read just before its own open, not once for the
+ * set: an earlier document's persist takes time, and a keystroke in a later
+ * one during it would otherwise fail that one's hash check for nothing. Each
+ * is marked saved at the version its text was read at, one at a time, so a
+ * failure part-way through leaves the documents it never reached dirty and a
+ * second call retries exactly those. Sequential, not concurrent: each persist
+ * runs over the server's shared store.
+ */
+export declare function saveDirtyDocuments(client: MonacoLspClient, session: DocumentPersister, uris?: readonly string[]): Promise<EditorDocument[]>;
+//# sourceMappingURL=monaco-lsp-client.d.ts.map

package/lib/monaco/monaco-lsp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monaco-lsp-client.d.ts","sourceRoot":"","sources":["../../src/monaco/monaco-lsp-client.ts"],"names":[],"mappings":"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"}