@adecore/lsp 0.39.0 → 0.40.1

package/dist/completion-defaults.js

@@ -3,12 +3,10 @@ function validRange(range, singleLine = true) {
         return false;
     }
     const { start, end } = range;
-    return (start !== undefined &&
+    return (typeof start === 'object' &&
         start !== null &&
-        typeof start === 'object' &&
-        end !== undefined &&
-        end !== null &&
         typeof end === 'object' &&
+        end !== null &&
         [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)));

package/dist/edits.d.ts

@@ -10,10 +10,14 @@ export interface PlannedDocumentEdit {
     text: string;
     created?: true;
 }
+export declare const CR = 13;
+export declare const LF = 10;
+export declare function checkPosition(position: Position): void;
 export declare function offsetAt(text: string, position: Position): number;
 export declare function positionAt(text: string, offset: number): Position;
 export declare function endPosition(text: string): Position;
 export declare function applyTextEdits(text: string, edits: readonly TextEdit[]): string;
 export declare function applyContentChanges(text: string, changes: readonly ContentChange[]): string;
 export declare function minimalChange(before: string, after: string): ContentChange;
+export declare function documentChangesOf(edit: WorkspaceEdit): NonNullable<WorkspaceEdit['documentChanges']>;
 export declare function planWorkspaceEdit(edit: WorkspaceEdit, snapshots: ReadonlyMap<string, DocumentSnapshot>): PlannedDocumentEdit[];

package/dist/edits.js

@@ -1,8 +1,8 @@
 import { ErrorCodes, LspError } from './connection.js';
 import { fileUriKey } from './uris.js';
-const CR = 13;
-const LF = 10;
-function checkPosition(position) {
+export const CR = 13;
+export const LF = 10;
+export function checkPosition(position) {
     if (!Number.isInteger(position.line) || !Number.isInteger(position.character) || position.line < 0 || position.character < 0) {
         throw new LspError('Invalid edit position');
     }
@@ -192,6 +192,10 @@ function planCreate(change, snapshots, planned) {
         throw new LspError(`${change.uri} already exists`);
     }
 }
+/* The changes of an edit in order, with the older `changes` map read as unversioned text edits. */
+export function documentChangesOf(edit) {
+    return edit.documentChanges ?? Object.entries(edit.changes ?? {}).map(([uri, edits]) => ({ textDocument: { uri, version: null }, edits }));
+}
 /*
  * Plans text edits and created files in memory, in the order the edit gives them. `snapshots` holds the
  * files that are there; a file the edit creates is absent from it. A rename or delete needs the host's own handling and is refused.
@@ -199,8 +203,7 @@ function planCreate(change, snapshots, planned) {
 export function planWorkspaceEdit(edit, snapshots) {
     const keyed = new Map([...snapshots].map(([uri, snapshot]) => [fileUriKey(uri), { uri, snapshot }]));
     const planned = new Map();
-    const changes = edit.documentChanges ?? Object.entries(edit.changes ?? {}).map(([uri, edits]) => ({ textDocument: { uri, version: null }, edits }));
-    for (const change of changes) {
+    for (const change of documentChangesOf(edit)) {
         if ('kind' in change) {
             if (change.kind !== 'create') {
                 throw new LspError(`A host file-operation handler is required for ${change.kind}`);

package/dist/file-operations.js

@@ -17,15 +17,18 @@ function filterTakes(filter, uri, directory) {
     const path = decodeURIComponent(url.pathname);
     return options?.ignoreCase === true ? globMatch(path.toLowerCase(), glob.toLowerCase()) : globMatch(path, glob);
 }
+function anyTakes(filters, uri, directory) {
+    return filters.some((filter) => filterTakes(filter, uri, directory));
+}
 /* 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.oldUri, file.directory))).map(({ oldUri, newUri }) => ({ oldUri, newUri }));
+    return files.filter((file) => anyTakes(filters, 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 }));
+    return files.filter((file) => anyTakes(filters, 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 }));
+    return files.filter((file) => anyTakes(filters, file.uri, file.directory)).map(({ uri }) => ({ uri }));
 }

package/dist/session.d.ts

@@ -80,6 +80,8 @@ export declare class LspSession {
     shutdown(): Promise<void>;
     forgetDocument(document: LspDocument): void;
     private assertReady;
+    private askBefore;
+    private tellAfter;
     private stop;
     private readConfiguration;
     private emitDiagnostics;

package/dist/session.js

@@ -307,39 +307,27 @@ export class LspSession {
     }
     /* What the server would change before these files move, or null when it takes none of them or has nothing to say. */
     async willRenameFiles(files, options) {
-        const taken = renamesTaken(this.fileOperationFilters('willRename'), files);
-        return taken.length === 0 || this.phase !== 'ready' ? null : this.request('workspace/willRenameFiles', { files: taken }, options);
+        return this.askBefore('willRename', renamesTaken(this.fileOperationFilters('willRename'), files), options);
     }
     /* Tells the server which of these files moved, those its filters take. */
     async didRenameFiles(files) {
-        const taken = renamesTaken(this.fileOperationFilters('didRename'), files);
-        if (taken.length > 0 && this.phase === 'ready') {
-            await this.notify('workspace/didRenameFiles', { files: taken });
-        }
+        await this.tellAfter('didRename', renamesTaken(this.fileOperationFilters('didRename'), files));
     }
     /* 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);
+        return this.askBefore('willCreate', createsTaken(this.fileOperationFilters('willCreate'), files), 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 });
-        }
+        await this.tellAfter('didCreate', createsTaken(this.fileOperationFilters('didCreate'), files));
     }
     /* 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);
+        return this.askBefore('willDelete', deletesTaken(this.fileOperationFilters('willDelete'), files), 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 });
-        }
+        await this.tellAfter('didDelete', deletesTaken(this.fileOperationFilters('didDelete'), files));
     }
     /* Registrations and the refresh requests of the server both land here, since each can change what a document may ask. */
     onCapabilitiesChanged(listener) {
@@ -367,6 +355,14 @@ export class LspSession {
             throw new LspError(`LSP session is ${this.phase}; await initialize() first`, ErrorCodes.ServerNotInitialized);
         }
     }
+    async askBefore(operation, files, options) {
+        return files.length === 0 || this.phase !== 'ready' ? null : this.request(`workspace/${operation}Files`, { files }, options);
+    }
+    async tellAfter(operation, files) {
+        if (files.length > 0 && this.phase === 'ready') {
+            await this.notify(`workspace/${operation}Files`, { files });
+        }
+    }
     async stop() {
         try {
             if (this.phase === 'initializing') {

package/dist/test-transport.js

@@ -42,7 +42,7 @@ export class ScriptedTransport {
     }
     /* The last request of `method` the client sent. */
     request(method) {
-        return [...this.sent].reverse().find((message) => 'method' in message && message.method === method && 'id' in message);
+        return this.sent.findLast((message) => 'method' in message && message.method === method && 'id' in message);
     }
     respond(method, result) {
         this.emit({ jsonrpc: '2.0', id: this.request(method).id, result });

package/dist/text-mirror.js

@@ -1,6 +1,5 @@
 import { LspError } from './connection.js';
-const CR = 13;
-const LF = 10;
+import { CR, LF, checkPosition } from './edits.js';
 /* Past this many lines a spread into `splice` could exceed the engine's argument limit. */
 const SPREAD_LIMIT = 10_000;
 /* Each line keeps its own break, so the last one is the only line without. */
@@ -92,9 +91,7 @@ export class TextMirror {
         return this.replace(first, end.line - first + 1, inserted);
     }
     lineAt(position) {
-        if (!Number.isInteger(position.line) || !Number.isInteger(position.character) || position.line < 0 || position.character < 0) {
-            throw new LspError('Invalid edit position');
-        }
+        checkPosition(position);
         const line = this.lines[position.line];
         if (line === undefined) {
             throw new LspError('Edit line is outside the document');

package/dist/transport.d.ts

@@ -1,6 +1,7 @@
 import type { Disposable, LspTransport, RpcMessage } from './protocol.ts';
 export declare class ContentLengthDecoder {
     private readonly maxMessageBytes;
+    private readonly utf8;
     private chunks;
     private size;
     private length;

package/dist/transport.js

@@ -84,6 +84,7 @@ function indexOfHeaderEnd(bytes) {
 /* Reads `Content-Length` framed messages, the way a language server speaks over stdio. */
 export class ContentLengthDecoder {
     maxMessageBytes;
+    utf8 = new TextDecoder();
     chunks = [];
     size = 0;
     length = null;
@@ -106,7 +107,7 @@ export class ContentLengthDecoder {
                     }
                     break;
                 }
-                const header = new TextDecoder().decode(buffer.subarray(0, boundary));
+                const header = this.utf8.decode(buffer.subarray(0, boundary));
                 const match = /^Content-Length:\s*(\d+)\s*$/im.exec(header);
                 if (!match || boundary > MAX_HEADER_BYTES) {
                     throw new Error('Invalid LSP Content-Length header');
@@ -123,7 +124,7 @@ export class ContentLengthDecoder {
                 break;
             }
             const buffer = concat(this.chunks, this.size);
-            messages.push(JSON.parse(new TextDecoder().decode(buffer.subarray(0, this.length))));
+            messages.push(JSON.parse(this.utf8.decode(buffer.subarray(0, this.length))));
             this.chunks = [buffer.subarray(this.length)];
             this.size = buffer.length - this.length;
             this.length = null;
@@ -131,9 +132,11 @@ export class ContentLengthDecoder {
         return messages;
     }
 }
+let utf8;
 export function encodeMessage(message) {
-    const body = new TextEncoder().encode(JSON.stringify(message));
-    const header = new TextEncoder().encode(`Content-Length: ${body.length}\r\n\r\n`);
+    utf8 ??= new TextEncoder();
+    const body = utf8.encode(JSON.stringify(message));
+    const header = utf8.encode(`Content-Length: ${body.length}\r\n\r\n`);
     const framed = new Uint8Array(header.length + body.length);
     framed.set(header, 0);
     framed.set(body, header.length);

package/dist/uris.d.ts

@@ -1,3 +1,4 @@
+export declare function isWindowsPath(path: string): boolean;
 export declare function pathToFileUri(path: string): string;
 export declare function fileUriToPath(uri: string): string | null;
 export declare function fileUriKey(uri: string): string;

package/dist/uris.js

@@ -1,10 +1,13 @@
 function isWindowsDrive(segment) {
     return /^[A-Za-z]:$/.test(segment);
 }
+/* A path with a drive or a UNC share. A backslash separates only in such a path; in a POSIX one it is part of a name. */
+export function isWindowsPath(path) {
+    return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith('\\\\');
+}
 /* An absolute path, POSIX, with a Windows drive or UNC, as the `file:` URI a language server names it by. */
 export function pathToFileUri(path) {
-    // A backslash separates only in a Windows path; in a POSIX one it is part of a name.
-    const windows = /^[A-Za-z]:[\\/]/.test(path) || path.startsWith('\\\\');
+    const windows = isWindowsPath(path);
     const normalized = windows ? path.replaceAll('\\', '/') : path;
     if (windows && normalized.startsWith('//')) {
         const [host = '', ...segments] = normalized.slice(2).split('/');

package/dist/watched-files.js

@@ -1,11 +1,11 @@
 import { globMatch } from './glob.js';
-import { fileUriToPath } from './uris.js';
+import { fileUriToPath, isWindowsPath } from './uris.js';
 const EVERY_CHANGE = 7;
 /* Folders whose files a server hears about only when a pattern of its own names the folder. */
 const SPARING_FOLDERS = ['node_modules', 'vendor', '.git'];
 /* A Windows path with forward slashes and its drive in capitals, so it compares with a pattern and a root however it was written. A POSIX path is left alone, a backslash being part of a name there. */
 function slashed(path) {
-    if (!/^[A-Za-z]:[\\/]/.test(path) && !path.startsWith('\\\\')) {
+    if (!isWindowsPath(path)) {
         return path;
     }
     const forward = path.replaceAll('\\', '/');

package/dist/workspace-operations.js

@@ -1,5 +1,5 @@
 import { ErrorCodes, LspError } from './connection.js';
-import { applyTextEdits } from './edits.js';
+import { applyTextEdits, documentChangesOf } from './edits.js';
 /* The key a URI is known by: a folder spelled with a trailing slash is the same folder, except the root. */
 function keyOf(uri) {
     const root = /^[^/:]+:\/\/[^/]*\/+$/.test(uri);
@@ -122,8 +122,7 @@ export async function planWorkspaceOperations(edit, source) {
         }
         return { ...change, uri: keyOf(change.uri) };
     };
-    const changes = edit.documentChanges ?? Object.entries(edit.changes ?? {}).map(([uri, edits]) => ({ textDocument: { uri, version: null }, edits }));
-    for (const original of changes) {
+    for (const original of documentChangesOf(edit)) {
         const change = keyed(original);
         if ('textDocument' in change) {
             const { uri, version } = change.textDocument;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/lsp",
-  "version": "0.39.0",
+  "version": "0.40.1",
   "type": "module",
   "exports": {
     ".": {
@@ -20,7 +20,7 @@
     "test": "bun test --conditions=source"
   },
   "devDependencies": {
-    "@types/bun": "^1.4.2",
+    "@types/bun": "^1.4.4",
     "typescript": "^7.0.2"
   },
   "license": "FSL-1.1-MIT",

package/src/completion-defaults.ts

@@ -4,14 +4,14 @@ function validRange(range: Range, singleLine = true): boolean {
     if (range === null || typeof range !== 'object') {
         return false;
     }
+
     const { start, end } = range;
+
     return (
-        start !== undefined &&
-        start !== null &&
         typeof start === 'object' &&
-        end !== undefined &&
-        end !== null &&
+        start !== null &&
         typeof end === 'object' &&
+        end !== null &&
         [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))
@@ -22,9 +22,11 @@ function validEditRange(range: Range | { insert: Range; replace: Range }, single
     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) &&
@@ -42,13 +44,16 @@ export function applyCompletionDefaults(
     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' ||
@@ -58,40 +63,55 @@ export function applyCompletionDefaults(
             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: string): CompletionItem => {
             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/src/connection.ts

@@ -66,6 +66,7 @@ export class JsonRpcConnection {
     constructor(transport: LspTransport, timeoutMs = 30_000) {
         this.transport = transport;
         this.timeoutMs = timeoutMs;
+
         this.subscriptions = [
             transport.onMessage((message) => {
                 void this.receive(message).catch((error) => this.reportError(error));
@@ -82,20 +83,27 @@ export class JsonRpcConnection {
         if (this.closed) {
             return Promise.reject(new LspError('LSP connection is closed'));
         }
+
         if (options.signal?.aborted) {
             return Promise.reject(cancelledError());
         }
+
         const id = ++this.nextId;
+
         return new Promise<T>((resolve, reject) => {
             let timer: ReturnType<typeof setTimeout> | undefined;
+
             const cancel = (error: LspError): void => {
                 if (!this.pending.has(id)) {
                     return;
                 }
+
                 this.settle(id, undefined, error);
                 void this.notify('$/cancelRequest', { id }).catch((failure) => this.reportError(failure));
             };
+
             const abort = (): void => cancel(cancelledError());
+
             this.pending.set(id, {
                 resolve: (value) => resolve(value as T),
                 reject,
@@ -104,11 +112,14 @@ export class JsonRpcConnection {
                     options.signal?.removeEventListener('abort', abort);
                 }
             });
+
             options.signal?.addEventListener('abort', abort, { once: true });
             const timeout = options.timeoutMs ?? this.timeoutMs;
+
             if (timeout > 0) {
                 timer = setTimeout(() => cancel(new LspError(`LSP request timed out: ${method}`, ErrorCodes.RequestCancelled)), timeout);
             }
+
             void this.send({ jsonrpc: '2.0', id, method, params }).catch((error) => this.settle(id, undefined, error));
         });
     }
@@ -121,7 +132,9 @@ export class JsonRpcConnection {
         if (this.handlers.has(method)) {
             throw new Error(`LSP request handler already registered: ${method}`);
         }
+
         this.handlers.set(method, handler);
+
         return {
             dispose: () => {
                 if (this.handlers.get(method) === handler) {
@@ -135,9 +148,11 @@ export class JsonRpcConnection {
         const listeners = this.notifications.get(method) ?? new Set<NotificationHandler>();
         this.notifications.set(method, listeners);
         listeners.add(listener);
+
         return {
             dispose: () => {
                 listeners.delete(listener);
+
                 if (listeners.size === 0) {
                     this.notifications.delete(method);
                 }
@@ -147,6 +162,7 @@ export class JsonRpcConnection {
 
     onError(listener: (error: Error) => void): Disposable {
         this.errors.add(listener);
+
         return {
             dispose: () => {
                 this.errors.delete(listener);
@@ -156,9 +172,11 @@ export class JsonRpcConnection {
 
     onClose(listener: (error?: Error) => void): Disposable {
         this.closes.add(listener);
+
         if (this.closed) {
             listener();
         }
+
         return {
             dispose: () => {
                 this.closes.delete(listener);
@@ -168,6 +186,7 @@ export class JsonRpcConnection {
 
     reportError(error: unknown): void {
         const normalized = asError(error);
+
         for (const listener of this.errors) {
             try {
                 listener(normalized);
@@ -187,19 +206,25 @@ export class JsonRpcConnection {
             if (this.closed) {
                 throw new LspError('LSP connection is closed');
             }
+
             await this.transport.send(message);
         });
+
         this.sendQueue = sent.catch((error) => this.finish(asError(error)));
+
         return sent;
     }
 
     private settle(id: RequestId, result?: unknown, error?: unknown): void {
         const request = this.pending.get(id);
+
         if (!request) {
             return;
         }
+
         this.pending.delete(id);
         request.cleanup();
+
         if (error !== undefined) {
             request.reject(error);
         } else {
@@ -211,21 +236,27 @@ export class JsonRpcConnection {
         if (this.closed) {
             return;
         }
+
         if (!value || typeof value !== 'object' || !('jsonrpc' in value) || value.jsonrpc !== '2.0') {
             throw new LspError('Invalid JSON-RPC message', ErrorCodes.InvalidRequest);
         }
+
         const message = value as RpcMessage;
+
         if ('method' in message) {
             if (typeof message.method !== 'string') {
                 throw new LspError('Invalid JSON-RPC method', ErrorCodes.InvalidRequest);
             }
+
             if ('id' in message) {
                 if (typeof message.id !== 'number' && typeof message.id !== 'string') {
                     throw new LspError('Invalid request id', ErrorCodes.InvalidRequest);
                 }
+
                 await this.handleRequest(message);
             } else if (message.method === '$/cancelRequest') {
                 const id = (message.params as { id?: RequestId } | undefined)?.id;
+
                 if (id !== undefined) {
                     this.incoming.get(id)?.abort();
                 }
@@ -254,18 +285,24 @@ export class JsonRpcConnection {
     private async handleRequest(message: RpcRequest): Promise<void> {
         const controller = new AbortController();
         this.incoming.set(message.id, controller);
+
         try {
             const handler = this.handlers.get(message.method);
+
             if (!handler) {
                 throw new LspError(`Unsupported server request: ${message.method}`, ErrorCodes.MethodNotFound);
             }
+
             const result = await handler(message.params, controller.signal);
+
             if (controller.signal.aborted) {
                 throw cancelledError();
             }
+
             await this.send({ jsonrpc: '2.0', id: message.id, result: result ?? null });
         } catch (error) {
             const failure = error instanceof LspError ? error : new LspError(asError(error).message);
+
             if (!this.closed) {
                 await this.send({ jsonrpc: '2.0', id: message.id, error: { code: failure.code, message: failure.message, data: failure.data } });
             }
@@ -278,18 +315,24 @@ export class JsonRpcConnection {
         if (this.closed) {
             return;
         }
+
         this.closed = true;
+
         for (const id of [...this.pending.keys()]) {
             this.settle(id, undefined, error ?? new LspError('LSP connection closed'));
         }
+
         for (const controller of this.incoming.values()) {
             controller.abort();
         }
+
         this.incoming.clear();
+
         // A transport that is closed already calls back from inside the constructor, before the subscriptions exist.
         for (const subscription of this.subscriptions ?? []) {
             subscription.dispose();
         }
+
         for (const listener of this.closes) {
             try {
                 listener(error);
@@ -297,9 +340,11 @@ export class JsonRpcConnection {
                 this.reportError(failure);
             }
         }
+
         this.handlers.clear();
         this.notifications.clear();
         this.closes.clear();
+
         if (error) {
             this.reportError(error);
         }