@adecore/editor-react 0.39.0 → 0.40.1

package/src/rendered-docs.ts

@@ -1,7 +1,9 @@
 import { findDocComments, type DocComment, type EditorPosition, type EditorRange, type EditorReplacement, type EditorTrackedRange } from '@adecore/editor';
+import { comparePositions } from './diagnostics-model.ts';
 import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { parseDocComment, type ParsedDocComment } from './doc-comment-model.ts';
+import { lineTextOf } from './line-text.ts';
 import { isShortcut } from './shortcut-keys.ts';
 import { realTimers, type Timers } from './timers.ts';
 
@@ -9,8 +11,10 @@ const OWNER = 'rendered-docs';
 const DOCS_PREFIX = 'docs-';
 const SUMMARY_WORDS = 6;
 const SETTLE_MS = 100;
+
 /* What a row is taken to be tall until its content is in and measured. */
 const ESTIMATED_LINE_HEIGHT = 20;
+
 const MAX_ESTIMATED_LINES = 8;
 const MAX_PARSED = 200;
 
@@ -43,23 +47,31 @@ function touches(range: EditorRange, comment: DocComment): boolean {
     if (range.end.line < comment.startLine || range.start.line > comment.endLine) {
         return false;
     }
-    const empty = range.start.line === range.end.line && range.start.character === range.end.character;
+
+    const empty = comparePositions(range.start, range.end) === 0;
+
     if (!empty && range.end.line === comment.startLine && range.end.character === 0) {
         return false;
     }
+
     return empty || range.start.line >= comment.startLine || range.end.line <= comment.endLine;
 }
 
 /* The first words of what a comment says, to tell its row from the others for a person who hears it. */
 function summaryOf(body: string): string {
-    const lead = body.split('\n').findIndex((line) => /^\s*@/.test(line));
-    const text = (lead === -1 ? body : body.split('\n').slice(0, lead).join('\n')).replace(/[`*_#>[\]()]/g, ' ');
-    const words = text.split(/\s+/).filter((word) => word !== '');
-    return words.slice(0, SUMMARY_WORDS).join(' ');
+    const lines = body.split('\n');
+    const lead = lines.findIndex((line) => /^\s*@/.test(line));
+    const text = (lead === -1 ? body : lines.slice(0, lead).join('\n')).replace(/[`*_#>[\]()]/g, ' ');
+
+    return text
+        .split(/\s+/)
+        .filter((word) => word !== '')
+        .slice(0, SUMMARY_WORDS)
+        .join(' ');
 }
 
 function samePlace(range: EditorRange | null, position: EditorPosition): boolean {
-    return range !== null && range.start.line === position.line && range.start.character === position.character;
+    return range !== null && comparePositions(range.start, position) === 0;
 }
 
 /*
@@ -79,8 +91,10 @@ export class RenderedDocsFeature {
     private readonly markerLines = new Map<string, number>();
     private readonly parsed = new Map<string, ParsedDocComment>();
     private indexes = new Map<DocComment, number>();
+
     /* Comments a reveal showed as source until the caret has settled where it was going, or the comment has scrolled out of view if the caret never moves. */
     private readonly revealed = new Set<DocComment>();
+
     private readonly listeners = new Set<() => void>();
     private version = 0;
     private shown: { version: number; entries: readonly RenderedDocEntry[] } | null = null;
@@ -88,14 +102,17 @@ export class RenderedDocsFeature {
     private caretTimer: unknown;
     private drawn = '';
     private marked = '';
+
     /* The comments are from before the last edit, so nothing is decided from them until they are read again. */
     private stale = false;
+
     private disposed = false;
 
     constructor(language: EditorLanguage, timers: Timers = realTimers) {
         this.language = language;
         this.timers = timers;
         const { editor } = language;
+
         const offs = [
             editor.onTextChange(() => {
                 this.stale = true;
@@ -105,6 +122,7 @@ export class RenderedDocsFeature {
             // The caret is told before the text change that moved it, so what the lines are is decided a moment later.
             editor.onCaret(() => {
                 this.timers.clear(this.caretTimer);
+
                 this.caretTimer = this.timers.set(() => {
                     this.revealed.clear();
                     this.publish();
@@ -112,6 +130,7 @@ export class RenderedDocsFeature {
             }),
             editor.onGutterMarker((id) => {
                 const line = this.markerLines.get(id);
+
                 if (line !== undefined) {
                     this.toggleAt(line);
                 }
@@ -124,37 +143,42 @@ export class RenderedDocsFeature {
                 this.releaseRevealed();
             })
         ];
+
         language.onDispose(() => {
             this.disposed = true;
+
             for (const off of offs) {
                 off();
             }
+
             this.timers.clear(this.settleTimer);
             this.timers.clear(this.caretTimer);
-            for (const override of this.overrides) {
-                override.tracked.dispose();
-            }
-            this.overrides = [];
+            this.clearOverrides();
             editor.setReplacements?.([], OWNER);
             editor.setGutterMarkers([], OWNER);
             this.containers.clear();
             this.bump();
         });
+
         this.read();
     }
 
     /* Whether every documentation comment is drawn as text until a person switches it. Changing it puts every comment back under it. */
     configure(settings: RenderedDocsSettings): void {
         const enabled = settings.enabled !== false;
+
         if (settings.renderDocComments === this.settings.renderDocComments && enabled === this.enabled) {
             return;
         }
+
         const sameRendering = settings.renderDocComments === this.settings.renderDocComments;
         this.settings = settings;
         this.enabled = enabled;
+
         if (!sameRendering) {
             this.clearOverrides();
         }
+
         this.publish();
     }
 
@@ -171,34 +195,39 @@ export class RenderedDocsFeature {
     /* Switches the comment the caret is in between formatted and source. False when the caret is in none. */
     toggle(): boolean {
         this.settle();
-        const comment = this.at(this.language.editor.getCaret().line);
-        if (!this.enabled || comment === undefined || !this.canRender(comment)) {
-            return false;
-        }
-        this.setRendered(comment, !this.wantsRendered(comment));
-        return true;
+
+        return this.switch(this.at(this.language.editor.getCaret().line));
     }
 
     /* Switches the comment that starts on a line, which is what its gutter button does. */
     toggleAt(startLine: number): boolean {
         this.settle();
-        const comment = this.comments.find((candidate) => candidate.startLine === startLine);
+
+        return this.switch(this.comments.find((candidate) => candidate.startLine === startLine));
+    }
+
+    private switch(comment: DocComment | undefined): boolean {
         if (!this.enabled || comment === undefined || !this.canRender(comment)) {
             return false;
         }
+
         this.setRendered(comment, !this.wantsRendered(comment));
+
         return true;
     }
 
     /* The elements of the rows now in view, for a host that draws them itself; `RenderedDocs` does. */
     entries(): readonly RenderedDocEntry[] {
         const result: RenderedDocEntry[] = [];
+
         for (const [id, container] of this.containers) {
             const comment = this.comments[Number(id.slice(DOCS_PREFIX.length))];
+
             if (comment !== undefined) {
                 result.push({ id, comment, parsed: this.parse(comment), container });
             }
         }
+
         return result;
     }
 
@@ -211,11 +240,13 @@ export class RenderedDocsFeature {
         if (this.shown?.version !== this.version) {
             this.shown = { version: this.version, entries: this.entries() };
         }
+
         return this.shown.entries;
     }
 
     subscribe(listener: () => void): () => void {
         this.listeners.add(listener);
+
         return () => {
             this.listeners.delete(listener);
         };
@@ -224,6 +255,7 @@ export class RenderedDocsFeature {
     /* Whether names in `{@link}` and `@see` can be followed, which takes a server that finds symbols by name. */
     get canFollow(): boolean {
         const { project, uri } = this.language;
+
         return project.service.supports('workspace/symbol', uri);
     }
 
@@ -248,8 +280,10 @@ export class RenderedDocsFeature {
         if (!this.enabled || !this.canRender(comment)) {
             return false;
         }
+
         const start = startOf(comment);
         const override = this.overrides.find((candidate) => samePlace(candidate.tracked.get(), start));
+
         return override?.rendered ?? this.settings.renderDocComments;
     }
 
@@ -264,17 +298,21 @@ export class RenderedDocsFeature {
     private setRendered(comment: DocComment, rendered: boolean): void {
         const start = startOf(comment);
         const existing = this.overrides.find((candidate) => samePlace(candidate.tracked.get(), start));
+
         if (existing !== undefined) {
             existing.tracked.dispose();
             this.overrides = this.overrides.filter((candidate) => candidate !== existing);
         }
+
         if (rendered !== this.settings.renderDocComments) {
             const { editor } = this.language;
             this.overrides.push({ tracked: editor.trackRange({ start, end: editor.positionAt(comment.to) }), rendered });
         }
+
         if (rendered) {
             this.leave(comment);
         }
+
         this.publish();
     }
 
@@ -282,15 +320,19 @@ export class RenderedDocsFeature {
     private leave(comment: DocComment): void {
         const { editor } = this.language;
         const selections = editor.getSelections();
+
         if (!selections.some((range) => touches(range, comment))) {
             return;
         }
+
         const count = editor.positionAt(Number.MAX_SAFE_INTEGER).line + 1;
         const line = comment.endLine + 1 < count ? comment.endLine + 1 : comment.startLine - 1;
+
         if (line < 0) {
             return;
         }
-        const text = editor.textInRange({ start: { line, character: 0 }, end: { line, character: Number.MAX_SAFE_INTEGER } });
+
+        const text = lineTextOf(editor, line);
         const character = line > comment.endLine ? (/^[ \t]*/.exec(text)?.[0].length ?? 0) : text.length;
         const place = { line, character };
         editor.setSelections(selections.map((range) => (touches(range, comment) ? { start: place, end: place } : range)));
@@ -306,8 +348,10 @@ export class RenderedDocsFeature {
         if (this.revealed.size === 0) {
             return;
         }
+
         const { start, end } = this.language.editor.getVisibleRange();
         const away = [...this.revealed].filter((comment) => comment.endLine < start.line || comment.startLine > end.line);
+
         if (away.length > 0) {
             away.forEach((comment) => this.revealed.delete(comment));
             this.publish();
@@ -318,6 +362,7 @@ export class RenderedDocsFeature {
         for (const override of this.overrides) {
             override.tracked.dispose();
         }
+
         this.overrides = [];
     }
 
@@ -333,34 +378,42 @@ export class RenderedDocsFeature {
         if (this.disposed) {
             return;
         }
+
         this.stale = false;
         const { editor, languageId } = this.language;
         this.comments = findDocComments(editor.getText(), languageId);
         this.indexes = new Map(this.comments.map((comment, index) => [comment, index]));
         this.revealed.clear();
         const starts = this.comments.map(startOf);
+
         this.overrides = this.overrides.filter((override) => {
             const kept = starts.some((start) => samePlace(override.tracked.get(), start));
+
             if (!kept) {
                 override.tracked.dispose();
             }
+
             return kept;
         });
+
         // An edit that replaced everything leaves the rows on offsets at the end, which only a new set of rows repairs.
         this.publish(true);
         this.bump();
     }
 
     private parse(comment: DocComment): ParsedDocComment {
-        const key = `${comment.body}`;
+        const key = comment.body;
         let result = this.parsed.get(key);
+
         if (result === undefined) {
             if (this.parsed.size >= MAX_PARSED) {
                 this.parsed.delete(this.parsed.keys().next().value!);
             }
+
             result = parseDocComment(comment.body, { php: /^php$/i.test(this.language.languageId) });
             this.parsed.set(key, result);
         }
+
         return result;
     }
 
@@ -369,13 +422,18 @@ export class RenderedDocsFeature {
         if (this.disposed || this.stale) {
             return;
         }
+
         const { editor } = this.language;
+
         const t = (key: string, options?: Record<string, string>): string => this.language.project.i18n.t(`editor:language.docs.${key}`, options);
+
         const rendered = this.comments.filter((comment) => this.isRendered(comment));
         const signature = rendered.map((comment) => `${this.idOf(comment)}@${comment.startLine}-${comment.endLine}`).join('|');
+
         if (force || signature !== this.drawn) {
             this.drawn = signature;
             const lineHeight = Math.max(editor.getBaseLineHeight?.() ?? 0, ESTIMATED_LINE_HEIGHT);
+
             const rows = rendered.map((comment): EditorReplacement => ({
                 id: this.idOf(comment),
                 startLine: comment.startLine,
@@ -385,23 +443,31 @@ export class RenderedDocsFeature {
                 onReveal: () => this.reveal(comment),
                 render: (container) => this.mounted(this.idOf(comment), container)
             }));
+
             const kept = new Set(rows.map((row) => row.id));
+
             for (const id of [...this.containers.keys()]) {
                 if (!kept.has(id)) {
                     this.containers.delete(id);
                 }
             }
+
             editor.setReplacements?.(rows, OWNER);
             this.bump();
         }
+
         this.markerLines.clear();
+
         const markers = (this.enabled ? this.comments : []).map((comment) => {
             const id = `docs:${comment.startLine}`;
             this.markerLines.set(id, comment.startLine);
             const on = this.wantsRendered(comment);
+
             return { id, line: comment.startLine, label: t(on ? 'showSource' : 'render'), icon: 'book-open' as const, pressed: on };
         });
+
         const marking = markers.map((marker) => `${marker.line}${marker.pressed}`).join('|');
+
         if (marking !== this.marked) {
             this.marked = marking;
             editor.setGutterMarkers(markers, OWNER);
@@ -410,6 +476,7 @@ export class RenderedDocsFeature {
 
     private labelOf(comment: DocComment, t: (key: string, options?: Record<string, string>) => string): string {
         const summary = summaryOf(comment.body);
+
         return summary === '' ? t('label') : t('labelNamed', { summary });
     }
 
@@ -422,12 +489,14 @@ export class RenderedDocsFeature {
     /* The editor drops the element of a row that scrolled out of view, and what React drew into it goes with it. The element just made is not in the page yet. */
     private sweep(fresh?: HTMLElement): void {
         let removed = false;
+
         for (const [id, container] of this.containers) {
             if (container !== fresh && !container.isConnected) {
                 this.containers.delete(id);
                 removed = true;
             }
         }
+
         if (removed && fresh === undefined) {
             this.bump();
         }
@@ -435,6 +504,7 @@ export class RenderedDocsFeature {
 
     private bump(): void {
         this.version++;
+
         for (const listener of [...this.listeners]) {
             listener();
         }

package/src/review-group.ts

@@ -17,6 +17,7 @@ export class ReviewGroup {
 
     join(member: ReviewMember): () => void {
         this.members.add(member);
+
         return () => {
             this.members.delete(member);
         };
@@ -50,14 +51,17 @@ export function joinReviewGroup(key: string): { group: ReviewGroup; leave(): voi
     groups.set(key, held);
     held.holders++;
     let left = false;
+
     return {
         group: held.group,
         leave: () => {
             if (left) {
                 return;
             }
+
             left = true;
             held.holders--;
+
             if (held.holders === 0 && groups.get(key) === held) {
                 groups.delete(key);
             }

package/src/row-host.ts

@@ -40,11 +40,13 @@ abstract class ContainerHost {
         if (this.shown?.version !== this.version) {
             this.shown = { version: this.version, containers: new Map(this.containers) };
         }
+
         return this.shown.containers;
     }
 
     subscribe(listener: () => void): () => void {
         this.listeners.add(listener);
+
         return () => {
             this.listeners.delete(listener);
         };
@@ -59,13 +61,16 @@ abstract class ContainerHost {
         if (signature === this.signature) {
             return false;
         }
+
         this.signature = signature;
         const kept = new Set(ids);
+
         for (const id of [...this.containers.keys()]) {
             if (!kept.has(id)) {
                 this.containers.delete(id);
             }
         }
+
         return true;
     }
 
@@ -76,6 +81,7 @@ abstract class ContainerHost {
 
     protected bump(): void {
         this.version++;
+
         for (const listener of [...this.listeners]) {
             listener();
         }
@@ -90,6 +96,7 @@ abstract class ContainerHost {
 export class RowHost extends ContainerHost {
     set(rows: readonly HostedRow[]): void {
         const signature = rows.map((row) => `${row.id}@${row.line}${row.placement}:${row.height}:${row.fixed}:${row.filler}`).join('|');
+
         if (
             !this.replace(
                 signature,
@@ -98,6 +105,7 @@ export class RowHost extends ContainerHost {
         ) {
             return;
         }
+
         this.editor.setWidgets(
             rows.map((row) => ({
                 id: row.filler ? `${row.id}-filler` : row.id,
@@ -115,6 +123,7 @@ export class RowHost extends ContainerHost {
             })),
             this.owner
         );
+
         this.bump();
     }
 
@@ -131,6 +140,7 @@ export class RowHost extends ContainerHost {
 export class LineActionHost extends ContainerHost {
     set(actions: readonly HostedAction[]): void {
         const signature = actions.map((action) => `${action.id}@${action.line}`).join('|');
+
         if (
             !this.replace(
                 signature,
@@ -139,6 +149,7 @@ export class LineActionHost extends ContainerHost {
         ) {
             return;
         }
+
         this.editor.setLineActions(
             actions.map((action) => ({
                 id: action.id,
@@ -147,6 +158,7 @@ export class LineActionHost extends ContainerHost {
             })),
             this.owner
         );
+
         this.bump();
     }
 

package/src/selection-ranges.ts

@@ -7,9 +7,11 @@ const METHOD = 'textDocument/selectionRange';
 /* The links of one answer, the smallest range first. */
 export function selectionChainOf(selection: SelectionRange): EditorRange[] {
     const chain: EditorRange[] = [];
+
     for (let link: SelectionRange | undefined = selection; link; link = link.parent) {
         chain.push(link.range);
     }
+
     return chain;
 }
 
@@ -20,13 +22,17 @@ export function selectionChainOf(selection: SelectionRange): EditorRange[] {
 export class SelectionRangesFeature {
     constructor(language: EditorLanguage) {
         const { editor, project, uri } = language;
+
         editor.setSelectionRanges(async (positions) => {
             if (!project.service.supports(METHOD, uri)) {
                 return null;
             }
+
             const chains = await project.service.selectionRanges(uri, positions);
+
             return chains === null || chains.length !== positions.length ? null : chains.map(selectionChainOf);
         });
+
         language.onDispose(() => editor.setSelectionRanges(null));
     }
 }

package/src/semantic-delta.ts

@@ -8,22 +8,29 @@ import type { SemanticTokensDelta } from '@adecore/lsp';
 export function applySemanticEdits(data: readonly number[], edits: SemanticTokensDelta['edits']): number[] | null {
     const result: number[] = [];
     let cursor = 0;
+
     for (const edit of edits) {
         const { start, deleteCount } = edit;
         const inserted = edit.data ?? [];
+
         if (!Number.isInteger(start) || !Number.isInteger(deleteCount) || start < cursor || deleteCount < 0 || start + deleteCount > data.length) {
             return null;
         }
+
         for (let at = cursor; at < start; at++) {
             result.push(data[at]!);
         }
+
         for (const value of inserted) {
             result.push(value);
         }
+
         cursor = start + deleteCount;
     }
+
     for (let at = cursor; at < data.length; at++) {
         result.push(data[at]!);
     }
+
     return result.length % 5 === 0 ? result : null;
 }

package/src/semantic-model.ts

@@ -34,9 +34,11 @@ export function scopesOf(type: string, modifiers: ReadonlySet<string>, scoped =
             if (modifiers.has('static')) {
                 return ['entity.name.function.static'];
             }
+
             if (modifiers.has('declaration')) {
                 return ['entity.name.function'];
             }
+
             return [type === 'method' ? 'entity.name.function.method' : 'entity.name.function.call'];
         case 'decorator':
             return ['meta.decorator'];
@@ -46,6 +48,7 @@ export function scopesOf(type: string, modifiers: ReadonlySet<string>, scoped =
             if (scoped) {
                 return modifiers.has('local') ? null : ['variable.other.constant'];
             }
+
             return modifiers.has('readonly') ? ['variable.other.constant'] : null;
         default:
             return null;
@@ -71,25 +74,33 @@ export function decodeSemanticTokens(tokens: SemanticTokens, legend: SemanticTok
     const scoped = legend.tokenModifiers.includes('local');
     let line = 0;
     let character = 0;
+
     for (let at = 0; at + 4 < data.length; at += 5) {
         const deltaLine = data[at]!;
         line += deltaLine;
         character = deltaLine === 0 ? character + data[at + 1]! : data[at + 1]!;
         const type = legend.tokenTypes[data[at + 3]!];
+
         if (type === undefined) {
             continue;
         }
+
         const bits = data[at + 4]!;
         const modifiers = new Set(legend.tokenModifiers.filter((_, index) => (bits & (1 << index)) !== 0));
         const scopes = scopesOf(type, modifiers, scoped);
+
         if (scopes !== null) {
             result.push({ line, character, length: data[at + 2]!, scopes });
+
             continue;
         }
+
         const embedded = EMBEDDED_SCOPES[type];
+
         if (embedded !== undefined) {
             result.push({ line, character, length: data[at + 2]!, scopes: embedded, within: 'string' });
         }
     }
+
     return result;
 }