@adecore/lsp 0.38.0 → 0.40.0

package/src/document.ts

@@ -68,12 +68,15 @@ export class LspDocument {
         this.languageId = item.languageId;
         this.content = new TextMirror(item.text);
         this.revision = item.version ?? 1;
+
         if (!Number.isSafeInteger(this.revision) || this.revision < 0) {
             throw new LspError('Invalid document version');
         }
+
         this.ready = session.syncOptions.openClose
             ? session.notify('textDocument/didOpen', { textDocument: { ...item, version: this.revision } })
             : Promise.resolve();
+
         this.synced = this.ready;
         void this.ready.catch((error) => session.connection.reportError(error));
     }
@@ -94,9 +97,11 @@ export class LspDocument {
     updateText(text: string): Promise<void> {
         this.assertOpen();
         const current = this.content.text;
+
         if (text === current) {
             return this.synced;
         }
+
         return this.applyChanges([minimalChange(current, text)]);
     }
 
@@ -108,24 +113,32 @@ export class LspDocument {
     applyChanges(changes: readonly ContentChange[]): Promise<void> {
         this.assertOpen();
         const kind = this.session.syncOptions.change ?? 0;
+
         if (!kind) {
             return Promise.reject(new LspError('Server did not negotiate document changes', ErrorCodes.MethodNotFound));
         }
+
         try {
             this.content.applyChanges(changes);
         } catch (error) {
             return Promise.reject(error);
         }
+
         const version = ++this.revision;
         this.cancelRequests();
+
         if (kind === 1) {
             return this.queueFullText();
         }
+
         const contentChanges = changes.map((change) => ({ ...change }));
+
         this.synced = this.synced.then(() =>
             this.session.connection.notify('textDocument/didChange', { textDocument: { uri: this.uri, version }, contentChanges })
         );
+
         void this.synced.catch((error) => this.session.connection.reportError(error));
+
         return this.synced;
     }
 
@@ -138,6 +151,7 @@ export class LspDocument {
         await this.synced;
         this.assertCurrent(version);
         const save = this.session.syncOptions.save;
+
         if (save) {
             await this.session.notify('textDocument/didSave', {
                 textDocument: { uri: this.uri },
@@ -282,12 +296,15 @@ export class LspDocument {
         if (this.closePromise) {
             return this.closePromise;
         }
+
         if (this.closed) {
             return Promise.resolve();
         }
+
         this.closed = true;
         this.cancelRequests();
         this.sendFullText?.();
+
         this.closePromise = this.synced
             .then(async () => {
                 if (!this.session.connection.isClosed && this.session.syncOptions.openClose) {
@@ -295,6 +312,7 @@ export class LspDocument {
                 }
             })
             .finally(() => this.session.forgetDocument(this));
+
         return this.closePromise;
     }
 
@@ -312,29 +330,39 @@ export class LspDocument {
 
     private resolve<T extends object>(method: string, item: T, options?: DocumentRequestOptions): Promise<T> {
         const version = this.resultVersions.get(item);
+
         if (version !== undefined && version !== this.version) {
             return Promise.reject(new StaleResultError(this.uri));
         }
+
         return this.perform(method, item, options);
     }
 
     private async perform<T>(method: string, params: unknown, options: DocumentRequestOptions = {}): Promise<T> {
         this.assertOpen();
+
         if (!this.session.supports(method, this)) {
             throw new LspError(`Server does not support ${method}`, ErrorCodes.MethodNotFound);
         }
+
         const version = this.version;
         const controller = new AbortController();
+
         if (options.cancelPrevious !== false) {
             this.latest.get(method)?.abort();
         }
+
         this.latest.set(method, controller);
         this.inFlight.add(controller);
+
         const abort = (): void => controller.abort();
+
         options.signal?.addEventListener('abort', abort, { once: true });
+
         if (options.signal?.aborted) {
             abort();
         }
+
         try {
             this.sendFullText?.();
             await this.synced;
@@ -342,13 +370,16 @@ export class LspDocument {
             const result = await this.session.request<T>(method, params, { signal: controller.signal, timeoutMs: options.timeoutMs });
             this.assertCurrent(version);
             this.remember(result, version);
+
             return result;
         } catch (error) {
             this.assertCurrent(version);
+
             throw error;
         } finally {
             options.signal?.removeEventListener('abort', abort);
             this.inFlight.delete(controller);
+
             if (this.latest.get(method) === controller) {
                 this.latest.delete(method);
             }
@@ -360,7 +391,9 @@ export class LspDocument {
         if (!result || typeof result !== 'object') {
             return;
         }
+
         this.resultVersions.set(result, version);
+
         if (Array.isArray(result)) {
             for (const item of result) {
                 this.remember(item, version);
@@ -387,17 +420,21 @@ export class LspDocument {
         if (this.sendFullText) {
             return this.synced;
         }
+
         const due = new Promise<void>((resolve) => {
             const timer = setTimeout(resolve, this.session.options.fullSyncDelayMs ?? FULL_SYNC_DELAY_MS);
+
             this.sendFullText = () => {
                 clearTimeout(timer);
                 resolve();
             };
         });
+
         this.synced = this.synced
             .then(() => due)
             .then(async () => {
                 this.sendFullText = undefined;
+
                 if (!this.session.connection.isClosed) {
                     await this.session.connection.notify('textDocument/didChange', {
                         textDocument: { uri: this.uri, version: this.revision },
@@ -405,7 +442,9 @@ export class LspDocument {
                     });
                 }
             });
+
         void this.synced.catch((error) => this.session.connection.reportError(error));
+
         return this.synced;
     }
 

package/src/edits.ts

@@ -16,10 +16,10 @@ export interface PlannedDocumentEdit {
     created?: true;
 }
 
-const CR = 13;
-const LF = 10;
+export const CR = 13;
+export const LF = 10;
 
-function checkPosition(position: Position): void {
+export function checkPosition(position: Position): void {
     if (!Number.isInteger(position.line) || !Number.isInteger(position.character) || position.line < 0 || position.character < 0) {
         throw new LspError('Invalid edit position');
     }
@@ -30,27 +30,35 @@ export function offsetAt(text: string, position: Position): number {
     checkPosition(position);
     let line = 0;
     let offset = 0;
+
     while (line < position.line && offset < text.length) {
         const char = text.charCodeAt(offset++);
+
         if (char === CR) {
             if (text.charCodeAt(offset) === LF) {
                 offset++;
             }
+
             line++;
         } else if (char === LF) {
             line++;
         }
     }
+
     if (line !== position.line) {
         throw new LspError('Edit line is outside the document');
     }
+
     let end = offset;
+
     while (end < text.length && text[end] !== '\r' && text[end] !== '\n') {
         end++;
     }
+
     if (offset + position.character > end) {
         throw new LspError('Edit character is outside the line');
     }
+
     return offset + position.character;
 }
 
@@ -58,15 +66,19 @@ export function positionAt(text: string, offset: number): Position {
     if (!Number.isInteger(offset) || offset < 0 || offset > text.length) {
         throw new LspError('Offset is outside the document');
     }
+
     let line = 0;
     let lineStart = 0;
     let i = 0;
+
     while (i < offset) {
         const code = text.charCodeAt(i);
+
         if (code === CR && text.charCodeAt(i + 1) === LF) {
             if (i + 2 > offset) {
                 break;
             }
+
             i += 2;
             line++;
             lineStart = i;
@@ -78,6 +90,7 @@ export function positionAt(text: string, offset: number): Position {
             i++;
         }
     }
+
     return { line, character: offset - lineStart };
 }
 
@@ -89,8 +102,10 @@ export function endPosition(text: string): Position {
 /* `offsetAt` for many positions in one text: the starts of its lines are found once instead of on every call. */
 function offsetsIn(text: string): (position: Position) => number {
     const starts = [0];
+
     for (let i = 0; i < text.length; i++) {
         const code = text.charCodeAt(i);
+
         if (code === CR && text.charCodeAt(i + 1) === LF) {
             i++;
             starts.push(i + 1);
@@ -98,17 +113,22 @@ function offsetsIn(text: string): (position: Position) => number {
             starts.push(i + 1);
         }
     }
+
     return (position) => {
         checkPosition(position);
         const start = starts[position.line];
+
         if (start === undefined) {
             throw new LspError('Edit line is outside the document');
         }
+
         const next = starts[position.line + 1];
         const end = next === undefined ? text.length : next - (text.charCodeAt(next - 1) === LF && text.charCodeAt(next - 2) === CR ? 2 : 1);
+
         if (start + position.character > end) {
             throw new LspError('Edit character is outside the line');
         }
+
         return start + position.character;
     };
 }
@@ -116,6 +136,7 @@ function offsetsIn(text: string): (position: Position) => number {
 /* Edits are simultaneous and in the coordinates of `text`; two inserts at one place keep their order. */
 export function applyTextEdits(text: string, edits: readonly TextEdit[]): string {
     const offsetOf = offsetsIn(text);
+
     const spans = edits
         .map((edit, index) => ({
             start: offsetOf(edit.range.start),
@@ -124,37 +145,49 @@ export function applyTextEdits(text: string, edits: readonly TextEdit[]): string
             index
         }))
         .sort((a, b) => a.start - b.start || a.index - b.index);
+
     let cursor = 0;
     const parts: string[] = [];
+
     for (const span of spans) {
         if (span.end < span.start) {
             throw new LspError('Edit range is reversed');
         }
+
         if (span.start < cursor) {
             throw new LspError('Workspace edits overlap');
         }
+
         parts.push(text.slice(cursor, span.start), span.text);
         cursor = span.end;
     }
+
     parts.push(text.slice(cursor));
+
     return parts.join('');
 }
 
 /* `didChange` entries apply one after the other, each in the coordinates the one before left. */
 export function applyContentChanges(text: string, changes: readonly ContentChange[]): string {
     let result = text;
+
     for (const change of changes) {
         if (!change.range) {
             result = change.text;
+
             continue;
         }
+
         const start = offsetAt(result, change.range.start);
         const end = offsetAt(result, change.range.end);
+
         if (end < start) {
             throw new LspError('Change range is reversed');
         }
+
         result = result.slice(0, start) + change.text + result.slice(end);
     }
+
     return result;
 }
 
@@ -174,22 +207,28 @@ function isLowSurrogate(code: number): boolean {
 export function minimalChange(before: string, after: string): ContentChange {
     const shortest = Math.min(before.length, after.length);
     let start = 0;
+
     while (start < shortest && before.charCodeAt(start) === after.charCodeAt(start)) {
         start++;
     }
+
     if (start > 0 && (isHighSurrogate(before.charCodeAt(start - 1)) || (before[start - 1] === '\r' && before[start] === '\n'))) {
         start--;
     }
+
     let end = 0;
+
     while (end < shortest - start && before.charCodeAt(before.length - 1 - end) === after.charCodeAt(after.length - 1 - end)) {
         end++;
     }
+
     if (
         end > 0 &&
         (isLowSurrogate(before.charCodeAt(before.length - end)) || (before[before.length - end] === '\n' && before[before.length - end - 1] === '\r'))
     ) {
         end--;
     }
+
     return {
         range: { start: positionAt(before, start), end: positionAt(before, before.length - end) },
         text: after.slice(start, after.length - end)
@@ -201,9 +240,11 @@ type KeyedSnapshots = ReadonlyMap<string, { uri: string; snapshot: DocumentSnaps
 
 function snapshotEdit(uri: string, snapshots: KeyedSnapshots): PlannedDocumentEdit {
     const found = snapshots.get(fileUriKey(uri));
+
     if (!found) {
         throw new LspError(`Missing workspace snapshot: ${uri}`);
     }
+
     return { uri: found.uri, version: found.snapshot.version, before: found.snapshot.text, text: found.snapshot.text };
 }
 
@@ -211,6 +252,7 @@ function snapshotEdit(uri: string, snapshots: KeyedSnapshots): PlannedDocumentEd
 function planCreate(change: CreateFile, snapshots: KeyedSnapshots, planned: Map<string, PlannedDocumentEdit>): void {
     const key = fileUriKey(change.uri);
     const existing = planned.get(key) ?? (snapshots.has(key) ? snapshotEdit(change.uri, snapshots) : null);
+
     if (existing === null) {
         planned.set(key, { uri: change.uri, version: null, before: '', text: '', created: true });
     } else if (change.options?.overwrite) {
@@ -220,6 +262,11 @@ function planCreate(change: CreateFile, snapshots: KeyedSnapshots, planned: Map<
     }
 }
 
+/* The changes of an edit in order, with the older `changes` map read as unversioned text edits. */
+export function documentChangesOf(edit: WorkspaceEdit): NonNullable<WorkspaceEdit['documentChanges']> {
+    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.
@@ -227,22 +274,28 @@ function planCreate(change: CreateFile, snapshots: KeyedSnapshots, planned: Map<
 export function planWorkspaceEdit(edit: WorkspaceEdit, snapshots: ReadonlyMap<string, DocumentSnapshot>): PlannedDocumentEdit[] {
     const keyed: KeyedSnapshots = new Map([...snapshots].map(([uri, snapshot]) => [fileUriKey(uri), { uri, snapshot }]));
     const planned = new Map<string, PlannedDocumentEdit>();
-    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}`);
             }
+
             planCreate(change, keyed, planned);
+
             continue;
         }
+
         const { uri, version } = change.textDocument;
         const key = fileUriKey(uri);
         const current = planned.get(key) ?? snapshotEdit(uri, keyed);
+
         if (version !== null && current.version !== version) {
             throw new LspError(`Workspace edit version mismatch: ${uri}`, ErrorCodes.ContentModified);
         }
+
         planned.set(key, { ...current, text: applyTextEdits(current.text, change.edits) });
     }
+
     return [...planned.values()];
 }

package/src/file-operations.ts

@@ -18,33 +18,43 @@ export interface DeletedFile extends FileDelete {
 
 function filterTakes(filter: FileOperationFilter, uri: string, directory: boolean): boolean {
     const { matches, glob, options } = filter.pattern;
+
     if (matches !== undefined && (matches === 'folder') !== directory) {
         return false;
     }
+
     let url: URL;
+
     try {
         url = new URL(uri);
     } catch {
         return false;
     }
+
     if (filter.scheme !== undefined && filter.scheme !== url.protocol.slice(0, -1)) {
         return false;
     }
+
     const path = decodeURIComponent(url.pathname);
+
     return options?.ignoreCase === true ? globMatch(path.toLowerCase(), glob.toLowerCase()) : globMatch(path, glob);
 }
 
+function anyTakes(filters: readonly FileOperationFilter[], uri: string, directory: boolean): boolean {
+    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: readonly FileOperationFilter[], files: readonly RenamedFile[]): FileRename[] {
-    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: readonly FileOperationFilter[], files: readonly CreatedFile[]): FileCreate[] {
-    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: readonly FileOperationFilter[], files: readonly DeletedFile[]): FileDelete[] {
-    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/src/glob.ts

@@ -7,11 +7,14 @@ function escapeRegex(char: string): string {
 function compileGlob(pattern: string): RegExp | null {
     let expression = '';
     let depth = 0;
+
     for (let i = 0; i < pattern.length; i++) {
         const char = pattern[i];
+
         if (char === '*') {
             if (pattern[i + 1] === '*') {
                 i++;
+
                 if (pattern[i + 1] === '/') {
                     expression += '(?:.*/)?';
                     i++;
@@ -25,6 +28,7 @@ function compileGlob(pattern: string): RegExp | null {
             expression += '[^/]';
         } else if (char === '[') {
             const close = pattern.indexOf(']', i + 2);
+
             if (close === -1) {
                 expression += '\\[';
             } else {
@@ -44,6 +48,7 @@ function compileGlob(pattern: string): RegExp | null {
             expression += escapeRegex(char);
         }
     }
+
     try {
         return new RegExp(`^${expression}$`);
     } catch {
@@ -56,5 +61,6 @@ export function globMatch(path: string, pattern: string): boolean {
     if (!compiled.has(pattern)) {
         compiled.set(pattern, compileGlob(pattern));
     }
+
     return compiled.get(pattern)?.test(path) ?? false;
 }