@adecore/editor-react 0.39.0 → 0.40.1

package/src/history.ts

@@ -9,21 +9,29 @@ export class HistoryFeature {
 
     constructor(language: EditorLanguage) {
         this.language = language;
+
         const off = language.onKey((event) => {
             if (isShortcut(this.language.shortcuts.historyBack, event)) {
                 this.back();
+
                 return true;
             }
+
             if (isShortcut(this.language.shortcuts.historyForward, event)) {
                 this.forward();
+
                 return true;
             }
+
             if (isShortcut(this.language.shortcuts.recentLocations, event)) {
                 this.recent();
+
                 return true;
             }
+
             return false;
         }, KEY_PRIORITY.history);
+
         language.onDispose(off);
     }
 
@@ -39,6 +47,7 @@ export class HistoryFeature {
     /* Lists the places of the history under the caret; choosing one jumps there like any other jump. */
     recent(): void {
         const places = this.language.project.history.recent(this.language.place);
+
         this.language.locations(
             places.map((place) => ({ uri: place.uri, range: { start: place.position, end: place.position } })),
             this.language.editor.getCaret(),
@@ -50,7 +59,9 @@ export class HistoryFeature {
         if (place === null) {
             return false;
         }
+
         this.language.visit(place);
+
         return true;
     }
 }

package/src/holder.ts

@@ -2,16 +2,19 @@
 export function createHolder<T>(): { get(): T | null; set(value: T | null): void; subscribe(listener: () => void): () => void } {
     let value: T | null = null;
     const listeners = new Set<() => void>();
+
     return {
         get: () => value,
         set: (next) => {
             value = next;
+
             for (const listener of [...listeners]) {
                 listener();
             }
         },
         subscribe: (listener) => {
             listeners.add(listener);
+
             return () => {
                 listeners.delete(listener);
             };

package/src/hover-content.ts

@@ -1,5 +1,5 @@
-import type { EditorRange } from '@adecore/editor';
 import type { Hover, Location, LocationLink, MarkedString, NavigationResult } from '@adecore/lsp';
+import { dedent } from './doc-comment-model.ts';
 
 export interface SignatureBlock {
     readonly language: string;
@@ -22,10 +22,12 @@ const FENCE = /^```([\w+#.-]*)[^\n]*\n([\s\S]*?)\n```[ \t]*(?:\n|$)/;
 export function splitSignatures(markdown: string): HoverText {
     const signatures: SignatureBlock[] = [];
     let rest = markdown.replace(/^\s+/, '');
+
     for (let match = FENCE.exec(rest); match !== null; match = FENCE.exec(rest)) {
         signatures.push({ language: match[1] || 'text', code: match[2]! });
         rest = rest.slice(match[0].length).replace(/^\s+/, '');
     }
+
     return { signatures, markdown: rest.replace(/^(?:-{3,}|\*{3,})\s*(?:\n|$)/, '').trim() };
 }
 
@@ -33,14 +35,17 @@ function markedStringText(content: MarkedString): HoverText {
     if (typeof content !== 'string') {
         return { signatures: [{ language: content.language || 'text', code: content.value }], markdown: '' };
     }
+
     return splitSignatures(content);
 }
 
 /* The text of a hover, whichever of the three shapes the protocol allows it in. */
 export function hoverTextOf(hover: Hover): HoverText {
     const { contents } = hover;
+
     if (Array.isArray(contents)) {
         const parts = contents.map(markedStringText);
+
         return {
             signatures: parts.flatMap((part) => part.signatures),
             markdown: parts
@@ -49,9 +54,11 @@ export function hoverTextOf(hover: Hover): HoverText {
                 .join('\n\n')
         };
     }
+
     if (typeof contents === 'string' || 'language' in contents) {
         return markedStringText(contents);
     }
+
     return contents.kind === 'plaintext' ? { signatures: [], markdown: escapeMarkdown(contents.value).trim() } : splitSignatures(contents.value);
 }
 
@@ -73,17 +80,10 @@ export function locationsOf(result: NavigationResult): Location[] {
     if (result === null) {
         return [];
     }
+
     const list = Array.isArray(result) ? (result as (Location | LocationLink)[]) : [result];
-    return list.map((entry) => (isLink(entry) ? { uri: entry.targetUri, range: entry.targetSelectionRange } : entry));
-}
 
-export function sameRange(left: EditorRange, right: EditorRange): boolean {
-    return (
-        left.start.line === right.start.line &&
-        left.start.character === right.start.character &&
-        left.end.line === right.end.line &&
-        left.end.character === right.end.character
-    );
+    return list.map((entry) => (isLink(entry) ? { uri: entry.targetUri, range: entry.targetSelectionRange } : entry));
 }
 
 /* One `@tag` of a docblock, the way a server writes it into a hover: `_@since_ 1.0` or `*@param* `name` - what it is`. */
@@ -105,20 +105,25 @@ const BLOCK_TAGS = new Set(['example']);
 export function splitDocTags(markdown: string): { readonly markdown: string; readonly tags: readonly DocTag[] } {
     const tags: DocTag[] = [];
     const kept: string[] = [];
+
     for (const paragraph of markdown.split(/\n{2,}/)) {
         const lines = paragraph.split('\n');
         const matches = lines.map((line) => TAG_LINE.exec(line.trim()));
         const names = matches.map((match) => (match === null ? null : (match[1] ?? match[2] ?? match[3])!));
+
         if (paragraph.trim() === '' || names.some((name) => name === null || BLOCK_TAGS.has(name))) {
             kept.push(paragraph);
+
             continue;
         }
+
         matches.forEach((match, index) => {
             // The TypeScript server puts a dash between a tag, its parameter and its text.
             const text = match![4]!.replace(/^[\u2014\u2013-]\s*/, '').replace(/^(`[^`]+`)\s+[\u2014\u2013-]\s+/, '$1 ');
             tags.push({ name: names[index]!, markdown: text.trim() });
         });
     }
+
     // By name, and in the order written within one name, so parameters keep the order of the signature.
     return { markdown: kept.join('\n\n').trim(), tags: tags.toSorted((left, right) => left.name.localeCompare(right.name)) };
 }
@@ -147,11 +152,14 @@ const BASELINE = /!\[Baseline icon\]\([^)\s]*\)[ \t]*_([^\n]+?)_[ \t]*(?:\n|$)/;
 /* The Baseline status a text carries, which the card draws with a mark of its own, and the text without it. */
 function takeBaseline(markdown: string): { baseline: Baseline | null; rest: string } {
     const match = BASELINE.exec(markdown);
+
     if (match === null) {
         return { baseline: null, rest: markdown };
     }
+
     const text = match[1]!.trim();
     const level = text.startsWith('Widely') ? 'widely' : text.startsWith('Newly') ? 'newly' : 'limited';
+
     return { baseline: { level, text }, rest: (markdown.slice(0, match.index) + markdown.slice(match.index + match[0].length)).replace(/\n{3,}/g, '\n\n') };
 }
 
@@ -176,13 +184,6 @@ function decodeEntities(text: string): string {
         .replace(/&/g, '&');
 }
 
-function dedent(text: string): string {
-    const lines = text.replace(/^\n+|\s+$/g, '').split('\n');
-    const indents = lines.filter((line) => line.trim() !== '').map((line) => line.length - line.trimStart().length);
-    const common = indents.length === 0 ? 0 : Math.min(...indents);
-    return lines.map((line) => line.slice(common)).join('\n');
-}
-
 /*
  * What a docblock writes for a reader of its source, written for one of a hover: a `<code>` or `<pre>`
  * example as a block in the symbol's language, and an inline `{@see Name}` or `{@link Name label}` as
@@ -192,6 +193,7 @@ export function docblockMarkdown(markdown: string, language: string): string {
     return markdown
         .replace(HTML_CODE, (_match, _tag: string, body: string) => {
             const code = decodeEntities(body);
+
             return code.includes('\n') ? `\n\n\`\`\`${language}\n${dedent(code)}\n\`\`\`\n\n` : `\`${code.trim()}\``;
         })
         .replace(INLINE_TAG, (_match, _tag: string, target: string, label: string | undefined) => (label === undefined ? `\`${target}\`` : label))
@@ -205,17 +207,22 @@ export type MarkdownPart = { readonly kind: 'prose'; readonly text: string } | {
 export function markdownParts(markdown: string): MarkdownPart[] {
     const parts: MarkdownPart[] = [];
     let rest = markdown;
+
     for (let match = ANY_FENCE.exec(rest); match !== null; match = ANY_FENCE.exec(rest)) {
         const prose = rest.slice(0, match.index).trim();
+
         if (prose !== '') {
             parts.push({ kind: 'prose', text: prose });
         }
+
         parts.push({ kind: 'code', block: { language: match[1] || 'text', code: match[2]! } });
         rest = rest.slice(match.index + match[0].length);
     }
+
     if (rest.trim() !== '') {
         parts.push({ kind: 'prose', text: rest.trim() });
     }
+
     return parts;
 }
 
@@ -227,18 +234,23 @@ function unescapeMarkdown(text: string): string {
 function sectionOf(chunk: string, leading: readonly SignatureBlock[]): HoverSection {
     let rest = chunk.trim();
     const title = TITLE.exec(rest);
+
     if (title !== null) {
         rest = rest.slice(title[0].length).trim();
     }
+
     const signatures = [...leading];
     // A section's own snippet is its first block; one further down after the prose, such as an example, stays prose.
     const fence = ANY_FENCE.exec(rest);
+
     if (fence !== null && !/@example/.test(rest.slice(0, fence.index))) {
         signatures.push({ language: fence[1] || 'text', code: fence[2]! });
         rest = (rest.slice(0, fence.index) + rest.slice(fence.index + fence[0].length)).trim();
     }
+
     const taken = takeBaseline(rest);
     const doc = splitDocTags(docblockMarkdown(taken.rest, signatures[0]?.language ?? 'text'));
+
     return {
         title: title === null ? null : unescapeMarkdown((title[1] ?? title[2])!.trim()),
         signatures: signatures.map(withoutOpenTag),
@@ -253,14 +265,19 @@ export function hoverSectionsOf(text: HoverText): HoverSection[] {
     const chunks = text.markdown === '' ? [''] : text.markdown.split(RULE);
     const sections = chunks.map((chunk, index) => sectionOf(chunk, index === 0 ? text.signatures : []));
     const seen = new Set<string>();
+
     return sections.filter((section) => {
         const empty =
             section.title === null && section.signatures.length === 0 && section.markdown === '' && section.tags.length === 0 && section.baseline === null;
+
         const key = JSON.stringify([section.title, section.signatures, section.markdown, section.baseline]);
+
         if (empty || seen.has(key)) {
             return false;
         }
+
         seen.add(key);
+
         return true;
     });
 }

package/src/hover.ts

@@ -10,9 +10,12 @@ import { isShortcut } from './shortcut-keys.ts';
 import { realTimers, type Timers } from './timers.ts';
 
 export const SHOW_DELAY_MS = 300;
+
 const HIDE_DELAY_MS = 250;
+
 /* How long a card has to stay up before the references of its symbol are counted, which can be a request over the whole project. */
 const COUNT_DELAY_MS = 500;
+
 const TOAST_ID = 'language-hover';
 
 export interface HoverSettings {
@@ -28,18 +31,24 @@ export interface HoverSettings {
 export class HoverFeature {
     private readonly language: EditorLanguage;
     private readonly timers: Timers;
+
     /* The counts asked for since the text last changed, by the symbol's position, so moving back to a name does not ask again. */
     private readonly counts = new Map<string, number>();
+
     private showTimer: unknown;
     private hideTimer: unknown;
     private countTimer: unknown;
     private inCard = false;
     private referenceCount = true;
+
     /* Counts every request, so an answer that arrives after the pointer moved on is dropped. */
     private request = 0;
+
     private lookup: AbortController | null = null;
+
     /* A card the keyboard opened: scrolling does not take it away, since it was never under a pointer. Moving the caret does. */
     private pinned = false;
+
     /* The card is being read: an explanation runs in it or is shown, so the pointer going elsewhere neither closes nor replaces it. */
     private held = false;
 
@@ -47,6 +56,7 @@ export class HoverFeature {
         this.language = language;
         this.timers = timers;
         const { editor } = language;
+
         const offs = [
             editor.onHover((hover) => this.moved(hover)),
             editor.onTextChange(() => {
@@ -57,6 +67,7 @@ export class HoverFeature {
                 if (this.held) {
                     this.hide();
                 }
+
                 return false;
             }),
             editor.onViewChange(() => {
@@ -72,25 +83,32 @@ export class HoverFeature {
             language.onKey((event) => {
                 if (isShortcut(this.language.shortcuts.quickInfo, event)) {
                     this.quickInfo();
+
                     return true;
                 }
+
                 if (event.key === 'Escape' && this.language.popups.getState().hover !== null && this.language.popups.getState().callHierarchy === null) {
                     this.hide();
+
                     return true;
                 }
+
                 return false;
             }, KEY_PRIORITY.hover)
         ];
+
         language.onDispose(() => {
             for (const off of offs) {
                 off();
             }
+
             this.hide();
         });
     }
 
     configure(settings: HoverSettings): void {
         this.referenceCount = settings.referenceCount !== false;
+
         if (!this.referenceCount) {
             this.timers.clear(this.countTimer);
         }
@@ -99,6 +117,7 @@ export class HoverFeature {
     /* The pointer entered or left the card, which is where a link in it is clicked. */
     holdCard(inside: boolean): void {
         this.inCard = inside;
+
         if (inside) {
             this.timers.clear(this.hideTimer);
         } else {
@@ -116,12 +135,15 @@ export class HoverFeature {
     /* The problems at a position as a card, at once; what the servers say about the symbol is left for the pointer and Quick Info. */
     showProblemsAt(position: EditorPosition): boolean {
         const problems = this.language.diagnostics.at(position);
+
         if (problems.length === 0) {
             return false;
         }
+
         this.hide();
         this.pinned = true;
         this.present(position, problems, null, problems[0]!.diagnostic.range);
+
         return true;
     }
 
@@ -159,6 +181,7 @@ export class HoverFeature {
         this.timers.clear(this.hideTimer);
         this.timers.clear(this.countTimer);
         this.inCard = false;
+
         if (this.language.popups.getState().hover !== null) {
             this.language.popups.setState({ hover: null });
         }
@@ -168,17 +191,24 @@ export class HoverFeature {
         if (this.held) {
             return;
         }
+
         this.timers.clear(this.showTimer);
+
         if (hover === null) {
             this.request++;
             this.scheduleHide();
+
             return;
         }
+
         const shown = this.language.popups.getState().hover;
+
         if (shown !== null && rangeHolds(shown.subject, hover.position)) {
             this.timers.clear(this.hideTimer);
+
             return;
         }
+
         this.scheduleHide();
         const request = ++this.request;
         this.showTimer = this.timers.set(() => void this.show(hover.position, request, false), SHOW_DELAY_MS);
@@ -186,9 +216,11 @@ export class HoverFeature {
 
     private scheduleHide(): void {
         this.timers.clear(this.hideTimer);
+
         if (this.language.popups.getState().hover === null || this.inCard || this.held) {
             return;
         }
+
         this.hideTimer = this.timers.set(() => {
             if (!this.inCard) {
                 this.hide();
@@ -200,23 +232,30 @@ export class HoverFeature {
     private async ask(position: EditorHover['position'], signal: AbortSignal): Promise<{ info: HoverInfo | null; range: EditorRange | null }> {
         const { service } = this.language.project;
         const { uri } = this.language;
+
         if (!service.supports('textDocument/hover', uri)) {
             return { info: null, range: null };
         }
+
         const [hover, definition] = await Promise.all([
             service.hover(uri, position, { signal }).catch(() => null),
             service.supports('textDocument/definition', uri) ? service.definition(uri, position, { signal }).catch(() => null) : null
         ]);
+
         if (hover === null) {
             return { info: null, range: null };
         }
+
         const text = hoverTextOf(hover);
+
         if (isEmptyHover(text)) {
             return { info: null, range: null };
         }
+
         const { editor } = this.language;
         const line = lineTextOf(editor, position.line);
         const word = wordRangeAt(line, position);
+
         return {
             info: {
                 text,
@@ -234,22 +273,30 @@ export class HoverFeature {
         const controller = new AbortController();
         this.lookup = controller;
         const { info, range } = await this.ask(position, controller.signal);
+
         if (request !== this.request) {
             return;
         }
+
         if (problems.length === 0 && info === null) {
             this.hide();
+
             if (pinned && (await this.language.inlayHints.showTooltipAt(position))) {
                 this.pinned = true;
+
                 return;
             }
+
             if (pinned) {
                 this.language.project.host.notify?.({ id: TOAST_ID, kind: 'error', title: this.language.project.i18n.t('editor:language.hover.none') });
             }
+
             return;
         }
+
         this.pinned = pinned;
         this.present(position, problems, info, problems[0]?.diagnostic.range ?? range);
+
         if (info !== null && this.referenceCount) {
             this.scheduleCount(position, request, controller.signal);
         }
@@ -258,6 +305,7 @@ export class HoverFeature {
     private present(position: EditorPosition, problems: readonly Problem[], info: HoverInfo | null, range: EditorRange | null): void {
         const subject = range ?? { start: position, end: position };
         this.timers.clear(this.hideTimer);
+
         this.language.popups.setState({
             hover: {
                 anchor: subject.start.line === position.line ? subject.start : position,
@@ -273,10 +321,13 @@ export class HoverFeature {
     private scheduleCount(position: EditorPosition, request: number, signal: AbortSignal): void {
         const key = `${position.line}:${this.wordStart(position)}`;
         const known = this.counts.get(key);
+
         if (known !== undefined) {
             this.showCount(known, request);
+
             return;
         }
+
         this.timers.clear(this.countTimer);
         this.countTimer = this.timers.set(() => void this.count(position, key, request, signal), COUNT_DELAY_MS);
     }
@@ -284,19 +335,24 @@ export class HoverFeature {
     /* How many places use the symbol, which can take a while in a large project and so arrives after the card does. */
     private async count(position: EditorPosition, key: string, request: number, signal: AbortSignal): Promise<void> {
         const { service } = this.language.project;
+
         if (request !== this.request || !this.referenceCount || !service.supports('textDocument/references', this.language.uri)) {
             return;
         }
+
         const found = await service.references(this.language.uri, position, false, { signal }).catch(() => null);
+
         if (found === null) {
             return;
         }
+
         this.counts.set(key, found.length);
         this.showCount(found.length, request);
     }
 
     private showCount(count: number, request: number): void {
         const shown = this.language.popups.getState().hover;
+
         if (request === this.request && shown?.info != null) {
             this.language.popups.setState({ hover: { ...shown, info: { ...shown.info, references: count } } });
         }
@@ -305,6 +361,7 @@ export class HoverFeature {
     /* Where the word at a position starts, which names the symbol for the cache. */
     wordStart(position: EditorPosition): number {
         const line = lineTextOf(this.language.editor, position.line);
+
         return wordRangeAt(line, position)?.start.character ?? position.character;
     }
 }

package/src/index.ts

@@ -4,6 +4,7 @@ export { realTimers, type Timers } from './timers.ts';
 export { type SemanticTokensOptions } from './semantic-tokens.ts';
 export { ProjectLanguage, type FileOperationTarget } from './project-language.ts';
 export type { LanguageDocumentHandle } from './project-language.ts';
+
 export type {
     SnippetVariableContext,
     LanguageHost,
@@ -13,6 +14,7 @@ export type {
     EditorNotification,
     RenameSuggestionsRequest
 } from './host-types.ts';
+
 export { EditorView } from './EditorView.tsx';
 export { createHolder } from './holder.ts';
 export type { EditorViewProps } from './EditorView.tsx';
@@ -36,6 +38,7 @@ export { useProblemCounts } from './use-problem-counts.ts';
 export type { ProblemCounts } from './diagnostics.ts';
 export type { BlameSource, CodeVisionSettings } from './code-vision.ts';
 export type { HoverSettings } from './hover.ts';
+
 export type {
     PopupState,
     PopupStore,
@@ -57,6 +60,7 @@ export type {
     MenuView,
     AuthorsView
 } from './popups.ts';
+
 export { RowHost, LineActionHost } from './row-host.ts';
 export type { HostedRow, HostedAction } from './row-host.ts';
 export { type HighlightLayers, highlightLayers } from './highlight-layers.ts';