@adecore/lsp 0.22.1 → 0.23.0

package/dist/completion-defaults.d.ts

@@ -0,0 +1,4 @@
+import type { CompletionItem, CompletionList } from './protocol.ts';
+export declare function applyCompletionDefaults(item: CompletionItem, defaults?: CompletionList['itemDefaults'], options?: {
+    onInvalidRange?: (error: RangeError) => void;
+}): CompletionItem;

package/dist/completion-defaults.js

@@ -0,0 +1,83 @@
+function validRange(range, singleLine = true) {
+    if (range === null || typeof range !== 'object') {
+        return false;
+    }
+    const { start, end } = range;
+    return (start !== undefined &&
+        start !== null &&
+        typeof start === 'object' &&
+        end !== undefined &&
+        end !== null &&
+        typeof end === 'object' &&
+        [start.line, start.character, end.line, end.character].every((value) => Number.isSafeInteger(value) && value >= 0) &&
+        (!singleLine || start.line === end.line) &&
+        (start.line < end.line || (start.line === end.line && start.character <= end.character)));
+}
+function validEditRange(range, singleLine = true) {
+    if (range === null || typeof range !== 'object' || Array.isArray(range)) {
+        return false;
+    }
+    if ('start' in range) {
+        return validRange(range, singleLine);
+    }
+    return (validRange(range.insert) &&
+        validRange(range.replace) &&
+        range.insert.start.line === range.replace.start.line &&
+        range.insert.start.character === range.replace.start.character &&
+        range.insert.end.character <= range.replace.end.character);
+}
+export function applyCompletionDefaults(item, defaults, options) {
+    if (typeof item?.label !== 'string') {
+        throw new TypeError('A completion item must have a string label.');
+    }
+    for (const value of [item.filterText, item.sortText, item.insertText, item.textEditText]) {
+        if (value !== undefined && typeof value !== 'string') {
+            throw new TypeError('Completion ranking and insertion text must be strings.');
+        }
+    }
+    if (item.textEdit !== undefined) {
+        const edit = item.textEdit;
+        if (edit === null ||
+            typeof edit !== 'object' ||
+            typeof edit.newText !== 'string' ||
+            !('range' in edit ? validEditRange(edit.range, false) : validEditRange(edit))) {
+            throw new RangeError('Invalid completion item edit.');
+        }
+    }
+    if (defaults === undefined) {
+        return item;
+    }
+    const next = { ...item };
+    if (next.commitCharacters === undefined && defaults.commitCharacters !== undefined) {
+        next.commitCharacters = defaults.commitCharacters;
+    }
+    if (next.insertTextFormat === undefined && defaults.insertTextFormat !== undefined) {
+        next.insertTextFormat = defaults.insertTextFormat;
+    }
+    if (next.insertTextMode === undefined && defaults.insertTextMode !== undefined) {
+        next.insertTextMode = defaults.insertTextMode;
+    }
+    if (next.data === undefined && defaults.data !== undefined) {
+        next.data = defaults.data;
+    }
+    if (next.textEdit === undefined && defaults.editRange !== undefined) {
+        const range = defaults.editRange;
+        const newText = item.textEditText ?? item.label;
+        if (typeof newText !== 'string') {
+            throw new TypeError('Completion edit text must be a string.');
+        }
+        const invalid = (message) => {
+            const error = new RangeError(message);
+            if (options?.onInvalidRange === undefined) {
+                throw error;
+            }
+            options.onInvalidRange(error);
+            return next;
+        };
+        if (!validEditRange(range)) {
+            return invalid('Invalid completion default edit range.');
+        }
+        next.textEdit = 'start' in range ? { range, newText } : { insert: range.insert, replace: range.replace, newText };
+    }
+    return next;
+}

package/dist/document.d.ts

@@ -1,5 +1,5 @@
 import type { LspSession } from './session.ts';
-import type { CodeAction, CodeActionContext, CodeLens, Command, CompletionContext, CompletionItem, CompletionResult, ContentChange, DocumentDiagnosticReport, DocumentHighlight, DocumentItem, DocumentRequestOptions, DocumentSymbolResult, FoldingRange, FormattingOptions, Hover, InlayHint, Location, NavigationResult, Position, PrepareRenameResult, Range, SelectionRange, SemanticTokens, SemanticTokensDelta, SignatureHelp, SignatureHelpContext, TextEdit, WorkspaceEdit } from './protocol.ts';
+import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, CodeAction, CodeActionContext, CodeLens, Command, CompletionContext, CompletionItem, CompletionResult, ContentChange, DocumentDiagnosticReport, DocumentHighlight, DocumentItem, DocumentRequestOptions, DocumentSymbolResult, FoldingRange, FormattingOptions, Hover, InlayHint, Location, NavigationResult, Position, PrepareRenameResult, Range, SelectionRange, SemanticTokens, SemanticTokensDelta, SignatureHelp, SignatureHelpContext, TextEdit, WorkspaceEdit } from './protocol.ts';
 export declare class LspDocument {
     readonly session: LspSession;
     readonly uri: string;
@@ -39,6 +39,7 @@ export declare class LspDocument {
     resolveCodeLens(lens: CodeLens, options?: DocumentRequestOptions): Promise<CodeLens>;
     formatting(formatting: FormattingOptions, options?: DocumentRequestOptions): Promise<TextEdit[] | null>;
     rangeFormatting(range: Range, formatting: FormattingOptions, options?: DocumentRequestOptions): Promise<TextEdit[] | null>;
+    onTypeFormatting(position: Position, ch: string, formatting: FormattingOptions, options?: DocumentRequestOptions): Promise<TextEdit[] | null>;
     foldingRanges(options?: DocumentRequestOptions): Promise<FoldingRange[] | null>;
     selectionRanges(positions: readonly Position[], options?: DocumentRequestOptions): Promise<SelectionRange[] | null>;
     semanticTokens(options?: DocumentRequestOptions): Promise<SemanticTokens | null>;
@@ -46,6 +47,9 @@ export declare class LspDocument {
     semanticTokensRange(range: Range, options?: DocumentRequestOptions): Promise<SemanticTokens | null>;
     inlayHints(range: Range, options?: DocumentRequestOptions): Promise<InlayHint[] | null>;
     resolveInlayHint(hint: InlayHint, options?: DocumentRequestOptions): Promise<InlayHint>;
+    prepareCallHierarchy(position: Position, options?: DocumentRequestOptions): Promise<CallHierarchyItem[] | null>;
+    incomingCalls(item: CallHierarchyItem, options?: DocumentRequestOptions): Promise<CallHierarchyIncomingCall[] | null>;
+    outgoingCalls(item: CallHierarchyItem, options?: DocumentRequestOptions): Promise<CallHierarchyOutgoingCall[] | null>;
     diagnostics(previousResultId?: string, identifier?: string, options?: DocumentRequestOptions): Promise<DocumentDiagnosticReport>;
     request<T = unknown>(method: string, params: object, options?: DocumentRequestOptions): Promise<T>;
     close(): Promise<void>;

package/dist/document.js

@@ -149,6 +149,10 @@ export class LspDocument {
     rangeFormatting(range, formatting, options) {
         return this.feature('textDocument/rangeFormatting', { range, options: formatting }, options);
     }
+    /* `ch` is the character that was typed; `position` is where the caret is after it. */
+    onTypeFormatting(position, ch, formatting, options) {
+        return this.feature('textDocument/onTypeFormatting', { position, ch, options: formatting }, options);
+    }
     foldingRanges(options) {
         return this.feature('textDocument/foldingRange', {}, options);
     }
@@ -170,6 +174,16 @@ export class LspDocument {
     resolveInlayHint(hint, options) {
         return this.resolve('inlayHint/resolve', hint, options);
     }
+    prepareCallHierarchy(position, options) {
+        return this.feature('textDocument/prepareCallHierarchy', { position }, options);
+    }
+    /* The callers of an item the server gave. Neighbouring expansions run beside each other, so a newer one does not cancel an older unless `cancelPrevious` says so. */
+    incomingCalls(item, options) {
+        return this.perform('callHierarchy/incomingCalls', { item }, { cancelPrevious: false, ...options });
+    }
+    outgoingCalls(item, options) {
+        return this.perform('callHierarchy/outgoingCalls', { item }, { cancelPrevious: false, ...options });
+    }
     diagnostics(previousResultId, identifier, options) {
         return this.feature('textDocument/diagnostic', { previousResultId, identifier }, options);
     }

package/dist/file-operations.d.ts

@@ -1,5 +1,13 @@
-import type { FileOperationFilter, FileRename } from './protocol.ts';
+import type { FileCreate, FileDelete, FileOperationFilter, FileRename } from './protocol.ts';
 export interface RenamedFile extends FileRename {
     directory: boolean;
 }
+export interface CreatedFile extends FileCreate {
+    directory: boolean;
+}
+export interface DeletedFile extends FileDelete {
+    directory: boolean;
+}
 export declare function renamesTaken(filters: readonly FileOperationFilter[], files: readonly RenamedFile[]): FileRename[];
+export declare function createsTaken(filters: readonly FileOperationFilter[], files: readonly CreatedFile[]): FileCreate[];
+export declare function deletesTaken(filters: readonly FileOperationFilter[], files: readonly DeletedFile[]): FileDelete[];

package/dist/file-operations.js

@@ -1,12 +1,12 @@
 import { globMatch } from './glob.js';
-function filterTakes(filter, file) {
+function filterTakes(filter, uri, directory) {
     const { matches, glob, options } = filter.pattern;
-    if (matches !== undefined && (matches === 'folder') !== file.directory) {
+    if (matches !== undefined && (matches === 'folder') !== directory) {
         return false;
     }
     let url;
     try {
-        url = new URL(file.oldUri);
+        url = new URL(uri);
     }
     catch {
         return false;
@@ -19,5 +19,13 @@ function filterTakes(filter, file) {
 }
 /* The renames a server asked to hear about, by the filters it registered. A rename is matched on the place it leaves. */
 export function renamesTaken(filters, files) {
-    return files.filter((file) => filters.some((filter) => filterTakes(filter, file))).map(({ oldUri, newUri }) => ({ oldUri, newUri }));
+    return files.filter((file) => filters.some((filter) => filterTakes(filter, file.oldUri, file.directory))).map(({ oldUri, newUri }) => ({ oldUri, newUri }));
+}
+/* The files made that a server asked to hear about, by the filters it registered. */
+export function createsTaken(filters, files) {
+    return files.filter((file) => filters.some((filter) => filterTakes(filter, file.uri, file.directory))).map(({ uri }) => ({ uri }));
+}
+/* The files deleted that a server asked to hear about, by the filters it registered. A folder is matched as one, not by what was in it. */
+export function deletesTaken(filters, files) {
+    return files.filter((file) => filters.some((filter) => filterTakes(filter, file.uri, file.directory))).map(({ uri }) => ({ uri }));
 }

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export { ErrorCodes, JsonRpcConnection, LspError, StaleResultError, type RequestHandler } from './connection.ts';
+export { applyCompletionDefaults } from './completion-defaults.ts';
 export { LspDocument } from './document.ts';
 export { applyContentChanges, applyTextEdits, endPosition, minimalChange, offsetAt, planWorkspaceEdit, positionAt, type DocumentSnapshot, type PlannedDocumentEdit } from './edits.ts';
-export { renamesTaken, type RenamedFile } from './file-operations.ts';
+export { planWorkspaceOperations, type PlannedCreateStep, type PlannedDeleteStep, type PlannedRenameStep, type PlannedTextStep, type ResourceOperationKind, type WorkspaceEditPlan, type WorkspaceEditSource, type WorkspaceEditStep, type WorkspaceEditText } from './workspace-operations.ts';
+export { createsTaken, deletesTaken, renamesTaken, type CreatedFile, type DeletedFile, type RenamedFile } from './file-operations.ts';
 export { watchesFile, type FileChangeType } from './watched-files.ts';
 export { LspSession, type LspSessionOptions, type SessionState } from './session.ts';
 export type { DiagnosticsReport, LanguageDocument, LanguageRequestOptions, LanguageService } from './service.ts';

package/dist/index.js

@@ -1,7 +1,9 @@
 export { ErrorCodes, JsonRpcConnection, LspError, StaleResultError } from './connection.js';
+export { applyCompletionDefaults } from './completion-defaults.js';
 export { LspDocument } from './document.js';
 export { applyContentChanges, applyTextEdits, endPosition, minimalChange, offsetAt, planWorkspaceEdit, positionAt } from './edits.js';
-export { renamesTaken } from './file-operations.js';
+export { planWorkspaceOperations } from './workspace-operations.js';
+export { createsTaken, deletesTaken, renamesTaken } from './file-operations.js';
 export { watchesFile } from './watched-files.js';
 export { LspSession } from './session.js';
 export { ContentLengthDecoder, connectWebSocket, createMemoryTransportPair, createStreamTransport, encodeMessage } from './transport.js';

package/dist/protocol.d.ts

@@ -185,6 +185,24 @@ export interface WorkspaceSymbol {
     };
     data?: unknown;
 }
+export interface CallHierarchyItem {
+    name: string;
+    kind: SymbolKind;
+    tags?: 1[];
+    detail?: string;
+    uri: string;
+    range: Range;
+    selectionRange: Range;
+    data?: unknown;
+}
+export interface CallHierarchyIncomingCall {
+    from: CallHierarchyItem;
+    fromRanges: Range[];
+}
+export interface CallHierarchyOutgoingCall {
+    to: CallHierarchyItem;
+    fromRanges: Range[];
+}
 export type DocumentSymbolResult = DocumentSymbol[] | SymbolInformation[] | null;
 export type WorkspaceSymbolResult = SymbolInformation[] | WorkspaceSymbol[] | null;
 export interface ParameterInformation {
@@ -262,6 +280,13 @@ export interface FileRename {
     oldUri: string;
     newUri: string;
 }
+export interface FileCreate {
+    uri: string;
+}
+export interface FileDelete {
+    uri: string;
+}
+export type FileOperation = 'willRename' | 'didRename' | 'willCreate' | 'didCreate' | 'willDelete' | 'didDelete';
 export interface FileOperationFilter {
     scheme?: string;
     pattern: {
@@ -393,6 +418,8 @@ export interface ProviderOptions {
     resolveProvider?: boolean;
     prepareProvider?: boolean;
     triggerCharacters?: string[];
+    firstTriggerCharacter?: string;
+    moreTriggerCharacter?: string[];
     retriggerCharacters?: string[];
     commands?: string[];
     watchers?: FileSystemWatcher[];
@@ -440,6 +467,8 @@ export interface ServerCapabilities {
         legend: SemanticTokensLegend;
     };
     inlayHintProvider?: boolean | ProviderOptions;
+    callHierarchyProvider?: boolean | ProviderOptions;
+    documentOnTypeFormattingProvider?: ProviderOptions;
     diagnosticProvider?: ProviderOptions;
     [capability: string]: unknown;
 }

package/dist/service.d.ts

@@ -1,4 +1,5 @@
-import type { CodeAction, CodeActionContext, CodeLens, Command, CompletionContext, CompletionItem, CompletionResult, ContentChange, Diagnostic, Disposable, DocumentHighlight, DocumentSymbolResult, FoldingRange, FormattingOptions, Hover, InlayHint, Location, NavigationResult, Position, PrepareRenameResult, ProviderOptions, Range, SelectionRange, SemanticTokens, SemanticTokensDelta, SignatureHelp, SignatureHelpContext, TextEdit, WorkspaceEdit, WorkspaceSymbolResult } from './protocol.ts';
+import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, CodeAction, CodeActionContext, CodeLens, Command, CompletionContext, CompletionItem, CompletionResult, ContentChange, Diagnostic, Disposable, DocumentHighlight, DocumentSymbolResult, FoldingRange, FormattingOptions, Hover, InlayHint, Location, NavigationResult, Position, PrepareRenameResult, ProviderOptions, Range, SelectionRange, SemanticTokens, SemanticTokensDelta, SignatureHelp, SignatureHelpContext, TextEdit, WorkspaceEdit, WorkspaceSymbolResult } from './protocol.ts';
+import type { CreatedFile, DeletedFile } from './file-operations.ts';
 export interface LanguageDocument {
     uri: string;
     languageId: string;
@@ -18,6 +19,7 @@ export interface LanguageService {
     openDocument(document: LanguageDocument): Promise<void>;
     changeDocument(uri: string, changes: readonly ContentChange[]): Promise<void>;
     closeDocument(uri: string): Promise<void>;
+    versionOf?(uri: string): number | null;
     supports(method: string, uri: string): boolean;
     providerOptions(method: string, uri: string): ProviderOptions | undefined;
     onProvidersChanged(listener: (uri: string) => void): Disposable;
@@ -40,6 +42,7 @@ export interface LanguageService {
     executeCommand(uri: string, command: Command, options?: LanguageRequestOptions): Promise<unknown>;
     formatting(uri: string, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
     rangeFormatting(uri: string, range: Range, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    onTypeFormatting?(uri: string, position: Position, ch: string, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
     semanticTokens(uri: string, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
     semanticTokensDelta(uri: string, previousResultId: string, options?: LanguageRequestOptions): Promise<SemanticTokens | SemanticTokensDelta | null>;
     semanticTokensRange(uri: string, range: Range, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
@@ -48,6 +51,13 @@ export interface LanguageService {
     workspaceSymbols(uri: string, query: string, options?: LanguageRequestOptions): Promise<WorkspaceSymbolResult>;
     foldingRanges(uri: string, options?: LanguageRequestOptions): Promise<FoldingRange[] | null>;
     selectionRanges(uri: string, positions: readonly Position[], options?: LanguageRequestOptions): Promise<SelectionRange[] | null>;
+    prepareCallHierarchy?(uri: string, position: Position, options?: LanguageRequestOptions): Promise<CallHierarchyItem[] | null>;
+    incomingCalls?(uri: string, item: CallHierarchyItem, options?: LanguageRequestOptions): Promise<CallHierarchyIncomingCall[] | null>;
+    outgoingCalls?(uri: string, item: CallHierarchyItem, options?: LanguageRequestOptions): Promise<CallHierarchyOutgoingCall[] | null>;
+    willCreateFiles?(files: readonly CreatedFile[], options?: LanguageRequestOptions): Promise<WorkspaceEdit | null>;
+    didCreateFiles?(files: readonly CreatedFile[]): Promise<void>;
+    willDeleteFiles?(files: readonly DeletedFile[], options?: LanguageRequestOptions): Promise<WorkspaceEdit | null>;
+    didDeleteFiles?(files: readonly DeletedFile[]): Promise<void>;
     codeLenses(uri: string, options?: LanguageRequestOptions): Promise<CodeLens[] | null>;
     resolveCodeLens(uri: string, lens: CodeLens, options?: LanguageRequestOptions): Promise<CodeLens>;
 }

package/dist/session.d.ts

@@ -1,7 +1,8 @@
 import { JsonRpcConnection, type RequestHandler } from './connection.ts';
 import { LspDocument } from './document.ts';
-import { type RenamedFile } from './file-operations.ts';
-import type { ApplyWorkspaceEditParams, ApplyWorkspaceEditResult, Command, ConfigurationItem, Disposable, DocumentItem, FileEvent, FileOperationFilter, FileSystemWatcher, InitializeResult, LspTransport, ProgressParams, ProviderOptions, PublishDiagnosticsParams, RequestOptions, ServerCapabilities, TextDocumentSyncOptions, WorkspaceEdit, WorkspaceFolder, WorkspaceSymbol, WorkspaceSymbolResult } from './protocol.ts';
+import { type CreatedFile, type DeletedFile, type RenamedFile } from './file-operations.ts';
+import type { ResourceOperationKind } from './workspace-operations.ts';
+import type { ApplyWorkspaceEditParams, ApplyWorkspaceEditResult, Command, ConfigurationItem, Disposable, DocumentItem, FileEvent, FileOperation, FileOperationFilter, FileSystemWatcher, InitializeResult, LspTransport, ProgressParams, ProviderOptions, PublishDiagnosticsParams, RequestOptions, ServerCapabilities, TextDocumentSyncOptions, WorkspaceEdit, WorkspaceFolder, WorkspaceSymbol, WorkspaceSymbolResult } from './protocol.ts';
 export type SessionState = 'new' | 'initializing' | 'ready' | 'closing' | 'closed';
 export interface LspSessionOptions {
     rootUri?: string | null;
@@ -14,6 +15,9 @@ export interface LspSessionOptions {
     };
     timeoutMs?: number;
     snippetSupport?: boolean;
+    insertTextModes?: readonly (1 | 2)[];
+    completionItemDefaults?: readonly string[];
+    resourceOperations?: readonly ResourceOperationKind[];
     onConfiguration?: (item: ConfigurationItem) => unknown | Promise<unknown>;
     onApplyEdit?: (params: ApplyWorkspaceEditParams) => ApplyWorkspaceEditResult | Promise<ApplyWorkspaceEditResult>;
     onShowMessage?: (params: {
@@ -64,9 +68,13 @@ export declare class LspSession {
     onDiagnostics(listener: (params: PublishDiagnosticsParams) => void): Disposable;
     watchedFiles(): FileSystemWatcher[];
     didChangeWatchedFiles(changes: readonly FileEvent[]): Promise<void>;
-    fileOperationFilters(operation: 'willRename' | 'didRename'): FileOperationFilter[];
+    fileOperationFilters(operation: FileOperation): FileOperationFilter[];
     willRenameFiles(files: readonly RenamedFile[], options?: RequestOptions): Promise<WorkspaceEdit | null>;
     didRenameFiles(files: readonly RenamedFile[]): Promise<void>;
+    willCreateFiles(files: readonly CreatedFile[], options?: RequestOptions): Promise<WorkspaceEdit | null>;
+    didCreateFiles(files: readonly CreatedFile[]): Promise<void>;
+    willDeleteFiles(files: readonly DeletedFile[], options?: RequestOptions): Promise<WorkspaceEdit | null>;
+    didDeleteFiles(files: readonly DeletedFile[]): Promise<void>;
     onCapabilitiesChanged(listener: () => void): Disposable;
     shutdown(): Promise<void>;
     forgetDocument(document: LspDocument): void;

package/dist/session.js

@@ -1,6 +1,6 @@
 import { ErrorCodes, JsonRpcConnection, LspError } from './connection.js';
 import { LspDocument } from './document.js';
-import { renamesTaken } from './file-operations.js';
+import { createsTaken, deletesTaken, renamesTaken } from './file-operations.js';
 import { globMatch } from './glob.js';
 /* The capability that advertises each method statically. */
 const PROVIDERS = {
@@ -26,6 +26,7 @@ const PROVIDERS = {
     'workspace/executeCommand': 'executeCommandProvider',
     'textDocument/formatting': 'documentFormattingProvider',
     'textDocument/rangeFormatting': 'documentRangeFormattingProvider',
+    'textDocument/onTypeFormatting': 'documentOnTypeFormattingProvider',
     'textDocument/foldingRange': 'foldingRangeProvider',
     'textDocument/selectionRange': 'selectionRangeProvider',
     'textDocument/semanticTokens/full': 'semanticTokensProvider',
@@ -33,6 +34,9 @@ const PROVIDERS = {
     'textDocument/semanticTokens/range': 'semanticTokensProvider',
     'textDocument/inlayHint': 'inlayHintProvider',
     'inlayHint/resolve': 'inlayHintProvider',
+    'textDocument/prepareCallHierarchy': 'callHierarchyProvider',
+    'callHierarchy/incomingCalls': 'callHierarchyProvider',
+    'callHierarchy/outgoingCalls': 'callHierarchyProvider',
     'textDocument/diagnostic': 'diagnosticProvider'
 };
 /* A method whose dynamic registration is made under the name of another. */
@@ -41,6 +45,8 @@ const REGISTRATION_METHODS = {
     'codeAction/resolve': 'textDocument/codeAction',
     'codeLens/resolve': 'textDocument/codeLens',
     'inlayHint/resolve': 'textDocument/inlayHint',
+    'callHierarchy/incomingCalls': 'textDocument/prepareCallHierarchy',
+    'callHierarchy/outgoingCalls': 'textDocument/prepareCallHierarchy',
     'textDocument/prepareRename': 'textDocument/rename',
     'workspaceSymbol/resolve': 'workspace/symbol',
     'textDocument/semanticTokens/full': 'textDocument/semanticTokens',
@@ -287,7 +293,7 @@ export class LspSession {
     didChangeWatchedFiles(changes) {
         return this.notify('workspace/didChangeWatchedFiles', { changes });
     }
-    /* The files a server asked to hear about when they are renamed, from its capabilities and its registrations. */
+    /* The files a server asked to hear about when they are renamed, created or deleted, from its capabilities and its registrations. */
     fileOperationFilters(operation) {
         const fileOperations = this.serverCapabilities.workspace?.fileOperations;
         const method = `workspace/${operation}Files`;
@@ -310,6 +316,30 @@ export class LspSession {
             await this.notify('workspace/didRenameFiles', { files: taken });
         }
     }
+    /* What the server would change before these files are made, or null when it takes none of them or has nothing to say. */
+    async willCreateFiles(files, options) {
+        const taken = createsTaken(this.fileOperationFilters('willCreate'), files);
+        return taken.length === 0 || this.phase !== 'ready' ? null : this.request('workspace/willCreateFiles', { files: taken }, options);
+    }
+    /* Tells the server which of these files were made, those its filters take. */
+    async didCreateFiles(files) {
+        const taken = createsTaken(this.fileOperationFilters('didCreate'), files);
+        if (taken.length > 0 && this.phase === 'ready') {
+            await this.notify('workspace/didCreateFiles', { files: taken });
+        }
+    }
+    /* What the server would change before these files are deleted, or null when it takes none of them or has nothing to say. */
+    async willDeleteFiles(files, options) {
+        const taken = deletesTaken(this.fileOperationFilters('willDelete'), files);
+        return taken.length === 0 || this.phase !== 'ready' ? null : this.request('workspace/willDeleteFiles', { files: taken }, options);
+    }
+    /* Tells the server which of these files were deleted, those its filters take. */
+    async didDeleteFiles(files) {
+        const taken = deletesTaken(this.fileOperationFilters('didDelete'), files);
+        if (taken.length > 0 && this.phase === 'ready') {
+            await this.notify('workspace/didDeleteFiles', { files: taken });
+        }
+    }
     /* Registrations and the refresh requests of the server both land here, since each can change what a document may ask. */
     onCapabilitiesChanged(listener) {
         this.capabilityListeners.add(listener);
@@ -394,8 +424,16 @@ function clientCapabilities(options) {
         general: { positionEncodings: ['utf-16'] },
         workspace: {
             applyEdit: !!options.onApplyEdit,
-            workspaceEdit: { documentChanges: true, resourceOperations: ['create', 'rename'], failureHandling: 'abort' },
-            fileOperations: { dynamicRegistration: true, willRename: true, didRename: true },
+            workspaceEdit: { documentChanges: true, resourceOperations: [...(options.resourceOperations ?? ['create', 'rename'])], failureHandling: 'abort' },
+            fileOperations: {
+                dynamicRegistration: true,
+                willRename: true,
+                didRename: true,
+                willCreate: true,
+                didCreate: true,
+                willDelete: true,
+                didDelete: true
+            },
             configuration: true,
             workspaceFolders: true,
             executeCommand: dynamic,
@@ -419,8 +457,11 @@ function clientCapabilities(options) {
             completion: {
                 ...dynamic,
                 contextSupport: true,
+                insertTextMode: 1,
+                ...(options.completionItemDefaults?.length ? { completionList: { itemDefaults: [...options.completionItemDefaults] } } : {}),
                 completionItem: {
                     snippetSupport: options.snippetSupport ?? false,
+                    ...(options.insertTextModes?.length ? { insertTextModeSupport: { valueSet: [...options.insertTextModes] } } : {}),
                     commitCharactersSupport: true,
                     documentationFormat: ['markdown', 'plaintext'],
                     deprecatedSupport: true,
@@ -474,6 +515,7 @@ function clientCapabilities(options) {
             codeLens: dynamic,
             formatting: dynamic,
             rangeFormatting: dynamic,
+            onTypeFormatting: dynamic,
             foldingRange: { ...dynamic, lineFoldingOnly: false, foldingRange: { collapsedText: false } },
             selectionRange: dynamic,
             semanticTokens: {
@@ -521,6 +563,7 @@ function clientCapabilities(options) {
                 multilineTokenSupport: false
             },
             inlayHint: { ...dynamic, resolveSupport: { properties: ['tooltip', 'textEdits', 'label.tooltip', 'label.location', 'label.command'] } },
+            callHierarchy: { dynamicRegistration: false },
             diagnostic: { ...dynamic, relatedDocumentSupport: true }
         }
     };

package/dist/workspace-operations.d.ts

@@ -0,0 +1,45 @@
+import type { TextEdit, WorkspaceEdit } from './protocol.ts';
+export type ResourceOperationKind = 'create' | 'rename' | 'delete';
+export interface WorkspaceEditText {
+    readonly text: string;
+    readonly version: number | null;
+    readonly open: boolean;
+}
+export interface WorkspaceEditSource {
+    read(uri: string): Promise<WorkspaceEditText | null>;
+    exists?(uri: string): Promise<boolean>;
+    isFolder?(uri: string): Promise<boolean>;
+    readonly operations: readonly ResourceOperationKind[];
+}
+export interface PlannedTextStep {
+    readonly kind: 'edits';
+    readonly uri: string;
+    readonly readUri: string;
+    readonly edits: readonly TextEdit[];
+    readonly before: string;
+    readonly after: string;
+    readonly version: number | null;
+    readonly open: boolean;
+}
+export interface PlannedCreateStep {
+    readonly kind: 'create';
+    readonly uri: string;
+    readonly text: string;
+    readonly overwrite: boolean;
+}
+export interface PlannedRenameStep {
+    readonly kind: 'rename';
+    readonly oldUri: string;
+    readonly newUri: string;
+    readonly overwrite: boolean;
+}
+export interface PlannedDeleteStep {
+    readonly kind: 'delete';
+    readonly uri: string;
+    readonly recursive: boolean;
+}
+export type WorkspaceEditStep = PlannedTextStep | PlannedCreateStep | PlannedRenameStep | PlannedDeleteStep;
+export interface WorkspaceEditPlan {
+    readonly steps: readonly WorkspaceEditStep[];
+}
+export declare function planWorkspaceOperations(edit: WorkspaceEdit, source: WorkspaceEditSource): Promise<WorkspaceEditPlan>;