@adecore/editor-react 0.39.0 → 0.40.1

package/src/navigation.ts

@@ -7,6 +7,7 @@ import { rangeHolds } from './diagnostics-model.ts';
 import { placesOfName } from './symbol-links.ts';
 import { isShortcut } from './shortcut-keys.ts';
 import { messageOf } from './error-message.ts';
+import { placeKey, uniqueBy } from './unique.ts';
 
 export type NavigationKind = 'definition' | 'declaration' | 'typeDefinition' | 'implementation';
 
@@ -34,23 +35,16 @@ const TOAST_ID = 'language-navigation';
 
 /* The places of a result, each once: the two servers of a Vue file may both know the same one. `target` is the whole declaration when the server gave it. */
 export function uniquePlaces(result: NavigationResult): { location: Location; target: Range | null }[] {
-    const seen = new Set<string>();
     const list = result === null ? [] : Array.isArray(result) ? (result as (Location | LocationLink)[]) : [result];
-    return list
-        .map((entry) =>
+
+    return uniqueBy(
+        list.map((entry) =>
             'targetUri' in entry
                 ? { location: { uri: entry.targetUri, range: entry.targetSelectionRange }, target: entry.targetRange as Range | null }
                 : { location: entry, target: null }
-        )
-        .filter(({ location }) => {
-            const { start } = location.range;
-            const key = `${location.uri}\0${start.line}\0${start.character}`;
-            if (seen.has(key)) {
-                return false;
-            }
-            seen.add(key);
-            return true;
-        });
+        ),
+        ({ location }) => placeKey(location)
+    );
 }
 
 /* The places of a result, each once. */
@@ -69,23 +63,30 @@ export class NavigationFeature {
     constructor(language: EditorLanguage) {
         this.language = language;
         const { editor } = language;
+
         const offs = [
             editor.onClick((click) => {
                 if (!click.mod || click.alt || click.shift || !this.supports('definition')) {
                     return false;
                 }
+
                 void this.go('definition', click.position);
+
                 return true;
             }),
             language.onKey((event) => {
                 const found = SHORTCUT_KINDS.find(([, name]) => isShortcut(this.language.shortcuts[name], event));
+
                 if (found === undefined) {
                     return false;
                 }
+
                 void this.go(found[0]);
+
                 return true;
             }, KEY_PRIORITY.navigation)
         ];
+
         language.onDispose(() => {
             for (const off of offs) {
                 off();
@@ -99,20 +100,27 @@ export class NavigationFeature {
 
     async go(kind: NavigationKind, position: EditorPosition = this.language.editor.getCaret()): Promise<void> {
         const { project, uri, editor } = this.language;
+
         if (!this.supports(kind)) {
             this.tell(this.say('unavailable'));
+
             return;
         }
+
         let result: NavigationResult;
+
         try {
             result = await REQUESTS[kind](project.service, uri, position);
         } catch (error) {
             if (!(error instanceof StaleResultError)) {
                 this.tell(this.say('failed', { message: messageOf(error) }));
             }
+
             return;
         }
+
         const places = uniqueLocations(result);
+
         if (places.length === 0) {
             this.tell(this.say('none'));
         } else if (kind === 'definition' && places.length === 1 && places[0]!.uri === uri && rangeHolds(places[0]!.range, position)) {
@@ -123,6 +131,7 @@ export class NavigationFeature {
         } else {
             this.language.locations(places, position, this.say(`titles.${kind}`));
         }
+
         editor.focus();
     }
 
@@ -133,15 +142,20 @@ export class NavigationFeature {
      */
     async goToName(name: string, anchor: EditorPosition, own: Location | null): Promise<void> {
         const { project, uri, editor } = this.language;
+
         if (own !== null) {
             this.language.goTo(own);
+
             return;
         }
+
         if (!project.service.supports('workspace/symbol', uri)) {
             return;
         }
+
         try {
             const places = placesOfName(await project.service.workspaceSymbols(uri, name), name, editor.getText());
+
             if (places.length === 1) {
                 this.language.goTo(places[0]!);
             } else if (places.length > 1) {
@@ -166,5 +180,6 @@ export function locationRow(location: Location, stored: string | null): { label:
     const path = stored ?? fileUriToPath(location.uri) ?? location.uri;
     const name = basenameOf(path);
     const folder = path.slice(0, Math.max(0, path.length - name.length)).replace(/\/$/, '');
+
     return { label: `${name}:${location.range.start.line + 1}`, detail: folder, path: true };
 }

package/src/panel-size.ts

@@ -1,12 +1,17 @@
 /* The height of the list-and-preview area of a peek or a call hierarchy, which is what a person drags; the bands and the title bar around it stay. */
 export const PANEL_BODY_HEIGHT = 180;
+
 /* Four rows of 22px, so a list never shrinks to nothing. */
 export const PANEL_BODY_MIN = 88;
+
 /* What the bands and the title bar take of the panel, which the share of the editor has to leave room for. */
 const PANEL_CHROME = 63;
+
 /* The share of the editor's height a panel may take, so the line it belongs to stays in view. */
 const PANEL_MAX_SHARE = 0.8;
+
 const PANEL_FALLBACK_AVAILABLE = 800;
+
 export const PANEL_KEY_STEP = 22;
 
 /* The tallest body for an editor that is `available` pixels high; never below the minimum, so a tiny editor still gets a usable panel. */
@@ -18,11 +23,13 @@ export function clampPanelBody(height: number, available: number = PANEL_FALLBAC
     if (!Number.isFinite(height)) {
         return PANEL_BODY_HEIGHT;
     }
+
     return Math.min(panelBodyMax(available), Math.max(PANEL_BODY_MIN, Math.round(height)));
 }
 
 /* The height of the editor's scrolling area around a panel's row; the fallback stands in where nothing is laid out. */
 export function availableHeightOf(container: HTMLElement | null): number {
     const height = container?.closest<HTMLElement>('.se-viewport')?.clientHeight ?? 0;
+
     return height > 0 ? height : PANEL_FALLBACK_AVAILABLE;
 }

package/src/patch-decorations.ts

@@ -49,10 +49,13 @@ function numberOf(line: PatchLayoutLine, numbers: 'single' | 'both', width: numb
     if (line.old === null && line.new === null) {
         return null;
     }
+
     if (numbers === 'single') {
         return String(line.new ?? line.old);
     }
+
     const pad = (value: number | null): string => (value === null ? '' : String(value)).padStart(width, ' ');
+
     return `${pad(line.old)} ${pad(line.new)}`;
 }
 
@@ -61,28 +64,35 @@ function highlightsOf(layout: PatchLayout): { highlights: EditorLineHighlight[];
     const highlights: EditorLineHighlight[] = [];
     const marks: EditorChangeMark[] = [];
     const lines = layout.lines;
+
     for (let index = 0; index < lines.length; index++) {
         const role = lines[index]!.role;
+
         if (role === 'file-header') {
             highlights.push({ startLine: index + 1, endLine: index + 1, color: '--text-muted', fill: '--surface-raised' });
         } else if (role === 'hunk-header') {
             highlights.push({ startLine: index + 1, endLine: index + 1, color: '--accent' });
         } else if (role === 'added' || role === 'removed') {
             let end = index;
+
             while (end + 1 < lines.length && lines[end + 1]!.role === role) {
                 end++;
             }
+
             const removed = role === 'removed';
+
             highlights.push({
                 startLine: index + 1,
                 endLine: end + 1,
                 color: removed ? '--editor-deleted' : '--editor-added',
                 bar: removed ? 'hatched' : 'solid'
             });
+
             marks.push({ startLine: index + 1, endLine: end + 1, kind: removed ? 'deleted' : 'added' });
             index = end;
         }
     }
+
     return { highlights, marks };
 }
 
@@ -101,86 +111,111 @@ export function decoratePatch(editor: Editor, options: PatchDecorationOptions =
     const timer = options.timer ?? DEFAULT_TIMER;
     const delay = options.delay ?? 150;
     const immediateBelow = options.immediateBelow ?? 100_000;
+
     const clearWait = (): void => {
         if (wait !== null) {
             timer.clear(wait);
             wait = null;
         }
     };
+
     const after = (callback: () => void): void => {
         clearWait();
+
         wait = timer.set(() => {
             wait = null;
             callback();
         }, delay);
     };
+
     const apply = (): void => {
         const numbers = options.numbers ?? 'single';
         const lines = layout.lines;
         const width = lines.reduce((digits, line) => Math.max(digits, String(Math.max(line.old ?? 0, line.new ?? 0)).length), 1);
+
         editor.setLineNumbers((line) => {
             const entry = lines[line];
+
             return entry === undefined ? null : numberOf(entry, numbers, width);
         });
+
         const labels = options.labels;
+
         editor.setLineLabels(
             labels === undefined
                 ? null
                 : (line) => {
                       const entry = lines[line];
+
                       if (entry?.role === 'removed') {
                           return labels.removed(entry.old!);
                       }
+
                       if (entry?.role === 'added') {
                           return labels.added(entry.new!);
                       }
+
                       return entry?.role === 'context' ? labels.unchanged(entry.old!, entry.new!) : null;
                   }
         );
+
         const { highlights, marks } = highlightsOf(layout);
         editor.setLineHighlights(highlights);
         editor.setChangeMarks(marks, CHANGE_LAYER);
     };
+
     const decorate = (): void => {
         pending = false;
+
         if (disposed) {
             return;
         }
+
         const text = editor.getText();
         length = text.length;
         layout = patchLayoutOf(text, options.limits);
         apply();
     };
+
     const announce = (): void => {
         if (!disposed) {
             options.onLayout?.(layout);
         }
     };
+
     const read = (): void => {
         clearWait();
         decorate();
         announce();
     };
+
     const schedule = (): void => {
         if (length < immediateBelow) {
             if (pending) {
                 return;
             }
+
             pending = true;
+
             queueMicrotask(() => {
                 decorate();
                 after(announce);
             });
+
             return;
         }
+
         pending = true;
+
         after(() => {
             decorate();
             announce();
         });
     };
+
     const stop = editor.onTextChange(schedule);
     read();
+
     return {
         get layout() {
             return layout;
@@ -204,10 +239,12 @@ export function usePatchDecorations(editor: Editor | null, options: Omit<PatchDe
     const [state, setState] = useState<{ editor: Editor; layout: PatchLayout } | null>(null);
     const { numbers } = options;
     const { maxLines, maxCharacters } = options.limits ?? {};
+
     useEffect(() => {
         if (editor === null) {
             return;
         }
+
         const decoration = decoratePatch(editor, {
             ...(numbers === undefined ? {} : { numbers }),
             limits: { ...(maxLines === undefined ? {} : { maxLines }), ...(maxCharacters === undefined ? {} : { maxCharacters }) },
@@ -218,7 +255,9 @@ export function usePatchDecorations(editor: Editor | null, options: Omit<PatchDe
             },
             onLayout: (layout) => setState({ editor, layout })
         });
+
         return () => decoration.dispose();
     }, [editor, numbers, maxLines, maxCharacters, t]);
+
     return state !== null && state.editor === editor ? state.layout : null;
 }

package/src/patch-layout.ts

@@ -101,18 +101,23 @@ function unquote(raw: string): string {
     if (raw.length < 2 || !raw.startsWith('"') || !raw.endsWith('"')) {
         return raw;
     }
+
     const bytes: number[] = [];
     const encoder = new TextEncoder();
     const body = raw.slice(1, -1);
+
     for (let i = 0; i < body.length; i++) {
         if (body[i] !== '\\') {
             const point = String.fromCodePoint(body.codePointAt(i)!);
             bytes.push(...encoder.encode(point));
             i += point.length - 1;
+
             continue;
         }
+
         const octal = /^[0-3][0-7]{2}/.exec(body.slice(i + 1, i + 4));
         const escaped = ESCAPES[body[i + 1] ?? ''];
+
         if (octal !== null) {
             bytes.push(Number.parseInt(octal[0], 8));
             i += 3;
@@ -123,6 +128,7 @@ function unquote(raw: string): string {
             bytes.push(92);
         }
     }
+
     return new TextDecoder().decode(new Uint8Array(bytes));
 }
 
@@ -130,6 +136,7 @@ function unquote(raw: string): string {
 function pathOf(raw: string): string | null {
     const tab = raw.indexOf('\t');
     const name = unquote(tab === -1 ? raw : raw.slice(0, tab));
+
     return name === '/dev/null' ? null : name;
 }
 
@@ -141,23 +148,30 @@ function stripPrefix(path: string | null, prefix: 'a/' | 'b/'): string | null {
 function gitPaths(rest: string): { oldPath: string | null; newPath: string | null; prefixed: boolean } {
     if (rest.startsWith('"')) {
         const end = rest.indexOf('" ', 1);
+
         if (end !== -1) {
             const oldName = unquote(rest.slice(0, end + 1));
             const newName = unquote(rest.slice(end + 2));
             const prefixed = oldName.startsWith('a/') && newName.startsWith('b/');
+
             return prefixed ? { oldPath: oldName.slice(2), newPath: newName.slice(2), prefixed } : { oldPath: oldName, newPath: newName, prefixed };
         }
     }
+
     const middle = rest.indexOf(' b/');
+
     if (rest.startsWith('a/') && middle !== -1) {
         for (let at = middle; at !== -1; at = rest.indexOf(' b/', at + 1)) {
             if (rest.slice(2, at) === rest.slice(at + 3)) {
                 return { oldPath: rest.slice(2, at), newPath: rest.slice(at + 3), prefixed: true };
             }
         }
+
         return { oldPath: rest.slice(2, middle), newPath: unquote(rest.slice(middle + 3)), prefixed: true };
     }
+
     const split = rest.indexOf(' ');
+
     return split === -1
         ? { oldPath: unquote(rest), newPath: null, prefixed: false }
         : { oldPath: unquote(rest.slice(0, split)), newPath: unquote(rest.slice(split + 1)), prefixed: false };
@@ -187,30 +201,39 @@ function statusOf(section: Section): PatchFileStatus {
     if (section.binary) {
         return 'binary';
     }
+
     if (section.created || (!section.git && section.oldPath === null && section.newPath !== null)) {
         return 'added';
     }
+
     if (section.deleted || (!section.git && section.newPath === null && section.oldPath !== null)) {
         return 'deleted';
     }
+
     if (section.renamed) {
         return 'renamed';
     }
+
     return section.copied ? 'copied' : 'modified';
 }
 
 function linesOf(text: string, limits: Required<PatchLimits>): { lines: string[]; truncated: boolean } {
     const lines: string[] = [];
     let start = 0;
+
     while (lines.length < limits.maxLines && start <= limits.maxCharacters) {
         const end = text.indexOf('\n', start);
+
         if (end === -1) {
             lines.push(text.slice(start).replace(/\r$/, ''));
+
             return { lines, truncated: false };
         }
+
         lines.push(text.slice(start, end).replace(/\r$/, ''));
         start = end + 1;
     }
+
     // Stopping right after a final newline leaves nothing unread.
     return { lines, truncated: start < text.length };
 }
@@ -228,33 +251,42 @@ export function patchLayoutOf(text: string, limits: PatchLimits = {}): PatchLayo
     let section: Section | undefined;
     let hunk: OpenHunk | undefined;
     let binaryData = false;
+
     const seal = (): void => {
         if (hunk !== undefined && (hunk.oldLeft > 0 || hunk.newLeft > 0)) {
             hunk.layout.consistent = false;
         }
+
         hunk = undefined;
     };
+
     const open = (line: number, git: boolean): Section => {
         seal();
         binaryData = false;
         section = emptySection(line, git);
         sections.push(section);
+
         return section;
     };
+
     // A removed line can read `-- x`, so `---` starts a file only with `+++` under it.
     const startsFile = (index: number): boolean => source[index]!.startsWith('--- ') && (source[index + 1]?.startsWith('+++ ') ?? false);
+
     const push = (line: PatchLayoutLine, index: number): void => {
         lines.push(line);
+
         if (section !== undefined) {
             section.lastLine = index;
         }
     };
+
     for (let index = 0; index < source.length; index++) {
         const line = source[index]!;
         const remaining = hunk !== undefined && (hunk.oldLeft > 0 || hunk.newLeft > 0);
         const gitStart = line.startsWith('diff --git ');
         const header = line.startsWith('@@') ? parseHunkHeader(line) : undefined;
         const fileStart = startsFile(index) && (!remaining || source[index + 2]?.startsWith('@@') === true);
+
         if (remaining && !gitStart && header === undefined && !fileStart) {
             if (isContent(line) || line === '' || line.startsWith('\\')) {
                 push(contentLine(line, hunk!, section!), index);
@@ -262,14 +294,18 @@ export function patchLayoutOf(text: string, limits: PatchLimits = {}): PatchLayo
                 hunk!.layout.consistent = false;
                 push(OTHER, index);
             }
+
             continue;
         }
+
         if (gitStart) {
             const created = open(index, true);
             ({ oldPath: created.oldPath, newPath: created.newPath, prefixed: created.prefixed } = gitPaths(line.slice('diff --git '.length)));
             push(FILE_HEADER, index);
+
             continue;
         }
+
         if (fileStart) {
             const reuse = section !== undefined && section.git && !section.named && section.hunks.length === 0;
             const target = reuse ? section! : open(index, false);
@@ -278,8 +314,10 @@ export function patchLayoutOf(text: string, limits: PatchLimits = {}): PatchLayo
             push(FILE_HEADER, index);
             push(FILE_HEADER, index + 1);
             index++;
+
             continue;
         }
+
         if (header !== undefined) {
             seal();
             const target = section ?? open(index, false);
@@ -287,8 +325,10 @@ export function patchLayoutOf(text: string, limits: PatchLimits = {}): PatchLayo
             target.hunks.push(layout);
             hunk = { layout, oldLeft: header.oldCount, newLeft: header.newCount, oldNumber: header.oldStart, newNumber: header.newStart };
             push(HUNK_HEADER, index);
+
             continue;
         }
+
         if (section === undefined) {
             push(OTHER, index);
         } else if (hunk !== undefined && line.startsWith('\\')) {
@@ -312,7 +352,9 @@ export function patchLayoutOf(text: string, limits: PatchLimits = {}): PatchLayo
             push(OTHER, index);
         }
     }
+
     seal();
+
     return {
         lines,
         truncated,
@@ -338,21 +380,26 @@ function contentLine(line: string, hunk: OpenHunk, section: Section): PatchLayou
     if (line.startsWith('\\')) {
         return NO_NEWLINE;
     }
+
     const kind = line.startsWith('+') ? 'added' : line.startsWith('-') ? 'removed' : 'context';
     const takesOld = kind !== 'added';
     const takesNew = kind !== 'removed';
+
     if ((takesOld && hunk.oldLeft === 0) || (takesNew && hunk.newLeft === 0)) {
         hunk.layout.consistent = false;
     }
+
     if (kind === 'added') {
         section.added++;
     } else if (kind === 'removed') {
         section.removed++;
     }
+
     const oldNumber = takesOld ? hunk.oldNumber++ : null;
     const newNumber = takesNew ? hunk.newNumber++ : null;
     hunk.oldLeft = takesOld ? Math.max(0, hunk.oldLeft - 1) : hunk.oldLeft;
     hunk.newLeft = takesNew ? Math.max(0, hunk.newLeft - 1) : hunk.newLeft;
+
     return { role: kind, old: oldNumber, new: newNumber };
 }
 

package/src/peek-model.ts

@@ -30,7 +30,9 @@ function columnsOf(range: Range, line: number, length: number): NameRange | null
     if (range.start.line !== line) {
         return null;
     }
+
     const end = Math.min(length, range.end.line === line ? range.end.character : length);
+
     return range.start.character < end ? { start: range.start.character, end } : null;
 }
 
@@ -39,9 +41,11 @@ function trimmedNameOf(raw: string, range: Range, line: number): NameRange | nul
     const leading = raw.length - raw.trimStart().length;
     const columns = columnsOf(range, line, raw.length);
     const length = raw.trim().length;
+
     if (columns === null || columns.start < leading || columns.start >= leading + length) {
         return null;
     }
+
     return { start: columns.start - leading, end: Math.min(length, columns.end - leading) };
 }
 
@@ -52,22 +56,28 @@ function trimmedNameOf(raw: string, range: Range, line: number): NameRange | nul
 export function peekFilesOf(locations: readonly Location[], current: string, textOf: (uri: string) => string | null): PeekFile[] {
     const order: string[] = [];
     const byFile = new Map<string, Location[]>();
+
     for (const location of locations) {
         if (!byFile.has(location.uri)) {
             order.push(location.uri);
             byFile.set(location.uri, []);
         }
+
         byFile.get(location.uri)!.push(location);
     }
+
     const uris = [...order.filter((uri) => uri === current), ...order.filter((uri) => uri !== current)];
+
     return uris.map((uri, fileIndex) => {
         const text = textOf(uri);
         const lines = text === null ? null : text.split(/\r\n|\r|\n/);
+
         const places = [...byFile.get(uri)!]
             .sort((left, right) => left.range.start.line - right.range.start.line || left.range.start.character - right.range.start.character)
             .map((location, index) => {
                 const line = location.range.start.line;
                 const raw = lines?.[line] ?? '';
+
                 return {
                     id: `${fileIndex}:${index}`,
                     location,
@@ -76,6 +86,7 @@ export function peekFilesOf(locations: readonly Location[], current: string, tex
                     name: lines === null ? null : trimmedNameOf(raw, location.range, line)
                 };
             });
+
         return { uri, places };
     });
 }
@@ -97,6 +108,7 @@ export function snippetOf(text: string, line: number, range: Range): PeekSnippet
     const lines = text.split(/\r\n|\r|\n/);
     const startLine = Math.max(0, line - BEFORE);
     const end = Math.min(lines.length, line + AFTER + 1);
+
     return { startLine, text: lines.slice(startLine, end).join('\n'), active: line - startLine, name: columnsOf(range, line, (lines[line] ?? '').length) };
 }
 
@@ -110,6 +122,7 @@ export function definitionSnippetOf(text: string, line: number, declaration: Ran
     const lines = text.split(/\r\n|\r|\n/);
     const startLine = declaration === null ? Math.max(0, line - 2) : Math.min(declaration.start.line, line);
     const end = Math.min(lines.length - 1, declaration === null ? line + DEFINITION_LINES / 2 : Math.min(declaration.end.line, startLine + DEFINITION_LINES));
+
     return { startLine, text: lines.slice(startLine, end + 1).join('\n'), active: line - startLine, name: columnsOf(range, line, (lines[line] ?? '').length) };
 }
 
@@ -120,19 +133,25 @@ export function definitionSnippetOf(text: string, line: number, declaration: Ran
 export function distinguishingFolders(paths: readonly string[]): string[] {
     const folders = paths.map((path) => path.split('/').slice(0, -1));
     const names = paths.map((path) => path.slice(path.lastIndexOf('/') + 1));
+
     return paths.map((path, index) => {
         const same = paths.map((_, other) => other).filter((other) => names[other] === names[index] && paths[other] !== path);
+
         if (same.length === 0) {
             return '';
         }
+
         const rivals = [...new Set(same.map((other) => paths[other]!))].map((other) => folders[paths.indexOf(other)]!);
         const mine = folders[index]!;
+
         for (let depth = 1; depth <= mine.length; depth++) {
             const tail = mine.slice(-depth).join('/');
+
             if (rivals.every((rival) => rival.slice(-depth).join('/') !== tail)) {
                 return tail;
             }
         }
+
         return mine.join('/');
     });
 }
@@ -140,8 +159,10 @@ export function distinguishingFolders(paths: readonly string[]): string[] {
 /* The column a character stands at once tabs are expanded to their stops, which is where a monospace face draws it. */
 export function visualColumnOf(line: string, character: number, tabSize: number): number {
     let column = 0;
+
     for (let i = 0; i < Math.min(character, line.length); i++) {
         column += line[i] === '\t' ? tabSize - (column % tabSize) : 1;
     }
+
     return column;
 }