@adecore/editor-react 0.22.0 → 0.23.0

package/src/locales/nl.json

@@ -9,6 +9,9 @@
             "line": "Regel {{line}}",
             "none": "Geen informatie voor deze plek"
         },
+        "inlay": {
+            "failed": "De actie van de hint is mislukt: {{message}}"
+        },
         "edit": {
             "staged_one": "{{count}} bestand gewijzigd en nog niet opgeslagen",
             "staged_other": "{{count}} bestanden gewijzigd en nog niet opgeslagen",
@@ -30,6 +33,10 @@
             "otherFiles_other": "en nog {{count}} bestanden",
             "moves_one": "verplaatst {{count}} bestand",
             "moves_other": "verplaatst {{count}} bestanden",
+            "creates_one": "maakt {{count}} bestand aan",
+            "creates_other": "maakt {{count}} bestanden aan",
+            "deletes_one": "verwijdert {{count}} bestand",
+            "deletes_other": "verwijdert {{count}} bestanden",
             "groups": {
                 "quickfix": "Quick fix",
                 "rewrite": "Herschrijven",
@@ -56,7 +63,12 @@
             "cancel": "Annuleer",
             "apply": "Hernoem",
             "suggestions": "Voorgestelde namen",
-            "useSuggestion": "Suggestie gebruiken"
+            "useSuggestion": "Suggestie gebruiken",
+            "operations": {
+                "create": "Maakt aan",
+                "rename": "Verplaatst",
+                "delete": "Verwijdert"
+            }
         },
         "navigation": {
             "unavailable": "Geen language server die dat hier beantwoordt",
@@ -84,6 +96,33 @@
             "noDefinition": "Geen definitie gevonden",
             "unavailableDefinition": "Geen language server vindt definities in dit bestand"
         },
+        "callHierarchy": {
+            "unavailable": "Geen language server vindt aanroepen in dit bestand",
+            "none": "Hier is geen symbool met aanroepen gevonden",
+            "failed": "Aanroepen opzoeken mislukt: {{message}}",
+            "label": "Aanroephiërarchie",
+            "direction": "Richting",
+            "incoming": "Aanroepers",
+            "outgoing": "Aangeroepen",
+            "close": "Sluit",
+            "loading": "Laden…",
+            "noIncoming": "Geen aanroepers",
+            "noOutgoing": "Roept niets aan",
+            "retry": "Aanroepen laden mislukt: {{message}}. Druk om opnieuw te proberen",
+            "more_one": "Toon nog {{formatted}} aanroep ({{hidden}} over)",
+            "more_other": "Toon nog {{formatted}} aanroepen ({{hidden}} over)",
+            "sites_one": "{{formatted}} aanroep",
+            "sites_other": "{{formatted}} aanroepen",
+            "site": "Aanroep {{current}} van {{total}}",
+            "previousSite": "Vorige aanroep",
+            "nextSite": "Volgende aanroep",
+            "announce": {
+                "incoming_one": "{{count}} aanroeper van {{name}}",
+                "incoming_other": "{{count}} aanroepers van {{name}}",
+                "outgoing_one": "{{count}} aangeroepen door {{name}}",
+                "outgoing_other": "{{count}} aangeroepen door {{name}}"
+            }
+        },
         "codeVision": {
             "usagesNone": "Niet gebruikt",
             "usages_one": "{{formatted}} keer gebruikt",
@@ -126,20 +165,65 @@
             "copy": "Kopieer",
             "paste": "Plak"
         },
+        "snippet": {
+            "choices": "Snippetkeuze"
+        },
         "completion": {
+            "tooLarge": "Deze aanvulling is te groot om in te voegen",
             "insert": "Invoegen",
             "replace": "Vervangen",
             "details": "Details",
-            "none": "Geen suggesties"
+            "none": "Geen suggesties",
+            "transformBusy": "Snippettransformaties zijn bezig; probeer het opnieuw",
+            "transformFailed": "Snippettransformatie kon niet worden toegepast"
         },
         "history": {
             "recent": "Recente plekken"
+        },
+        "announce": {
+            "problem": "{{severity}}: {{message}}",
+            "severity": {
+                "error": "Fout",
+                "warning": "Waarschuwing",
+                "info": "Informatie",
+                "hint": "Hint"
+            },
+            "field": "Veld {{current}} van {{total}}",
+            "fieldChoices_one": "Veld {{current}} van {{total}}, {{count}} keuze",
+            "fieldChoices_other": "Veld {{current}} van {{total}}, {{count}} keuzes"
+        },
+        "fold": {
+            "fold": "Regels {{start}} tot {{end}} invouwen",
+            "unfold": "Regels {{start}} tot {{end}} uitvouwen"
+        },
+        "docs": {
+            "label": "Weergegeven documentatie",
+            "labelNamed": "Weergegeven documentatie: {{- summary}}",
+            "render": "Toon weergegeven documentatie",
+            "showSource": "Toon bron van documentatie",
+            "tags": {
+                "deprecated": "Verouderd",
+                "template": "Typeparameters",
+                "param": "Parameters",
+                "property": "Eigenschappen",
+                "type": "Type",
+                "var": "Variabele",
+                "return": "Geeft terug",
+                "yield": "Levert op",
+                "throws": "Gooit",
+                "see": "Zie ook",
+                "example": "Voorbeeld",
+                "since": "Sinds",
+                "version": "Versie",
+                "author": "Auteur"
+            }
         }
     },
     "commands": {
         "goToDefinition": "Ga naar definitie",
         "goToTypeDefinition": "Ga naar typedefinitie",
         "goToImplementation": "Ga naar implementatie",
+        "callHierarchy": "Aanroephiërarchie",
         "peekReferences": "Bekijk referenties",
         "renameSymbol": "Symbool hernoemen",
         "codeActions": "Codeacties",
@@ -148,6 +232,7 @@
     "find": {
         "label": "Zoeken",
         "count": "{{current}} / {{total}}",
+        "countLimited": "{{current}} / {{total}}+",
         "none": "Geen resultaten",
         "invalid": "Ongeldige reguliere expressie",
         "caseSensitive": "Hoofdlettergevoelig",
@@ -166,7 +251,33 @@
             "allLabel": "Alles vervangen",
             "preserveCase": "Hoofdletters behouden",
             "toggle": "Vervangen tonen",
-            "hide": "Vervangen verbergen"
+            "hide": "Vervangen verbergen",
+            "failed": {
+                "limit": "Te veel om ineens te vervangen ({{edits}} edits of {{characters}} uitvoertekens)",
+                "timeout": "Vervangen duurde te lang; de tekst is niet gewijzigd",
+                "unavailable": "Vervangen vereist de zoekworker",
+                "error": "Vervangen is niet gelukt; de tekst is niet gewijzigd"
+            }
+        },
+        "countMore": "{{total}}+ resultaten",
+        "searching": "Zoeken…",
+        "large": "Groot document: druk op Enter om te zoeken",
+        "replaced": "{{count}} resultaten vervangen",
+        "failed": {
+            "timeout": "Zoeken duurde te lang; druk op Enter om opnieuw te proberen",
+            "unavailable": "Zoeken met regex is niet beschikbaar",
+            "invalid": "Ongeldige reguliere expressie",
+            "error": "Zoeken kon niet worden voltooid"
         }
+    },
+    "diff": {
+        "hidden": "Toon {{count}} verborgen regels",
+        "contextLimit": "Limiet voor context bereikt",
+        "oldSide": "Voor de wijziging",
+        "newSide": "Na de wijziging",
+        "noNewline": "Geen afsluitende nieuwe regel",
+        "added": "Toegevoegd, nieuwe regel {{number}}",
+        "removed": "Verwijderd, oude regel {{number}}",
+        "unchanged": "Oude regel {{old}}, nieuwe regel {{new}}"
     }
 }

package/src/models.ts

@@ -19,6 +19,7 @@ export {
     CLASS_KIND,
     SNIPPET_FORMAT,
     type Insertion,
+    type SnippetInsertionOptions,
     insertionOf,
     mirroredInsertions,
     documentationText,
@@ -84,6 +85,20 @@ export {
     distinguishingFolders,
     visualColumnOf
 } from './peek-model.ts';
+export {
+    type CallDirection,
+    type CallLoad,
+    type CallNode,
+    type CallRow,
+    CALL_LEVEL_LIMIT,
+    rootsOf,
+    childrenOf,
+    rowsOf,
+    stepsOf,
+    targetOf,
+    statusIdOf,
+    moreIdOf
+} from './call-hierarchy-model.ts';
 export {
     type SymbolGroup,
     SYMBOL_GROUPS,
@@ -104,6 +119,7 @@ export {
 } from './symbol-picker-model.ts';
 export { SYMBOL_LINK_CLASS, isTypeName, linkTypeNames, declaredNameOf, placesOfName } from './symbol-links.ts';
 export { scopesOf, decodeSemanticTokens } from './semantic-model.ts';
+export { applySemanticEdits } from './semantic-delta.ts';
 export {
     type ActionGroup,
     ACTION_GROUPS,
@@ -118,9 +134,21 @@ export {
     type EditPreview,
     previewOf
 } from './code-actions-model.ts';
+export { resourceOperationsOf, type ResourceOperationView } from './workspace-edit.ts';
 export { MAX_DECLARATIONS, type CodeVisionDeclaration, type DeclarationSource, startAfterComments, declarationsOf, usagesText } from './code-vision-model.ts';
 export { UNCOMMITTED, mapBlame, type CodeAuthor, type CodeAuthorship, shortName, authorshipOf, authorsText } from './code-authors.ts';
-export { type SnippetStop, type ParsedSnippet, parseSnippet, tabOrder } from './snippet.ts';
+export {
+    type SnippetTransform,
+    type SnippetStop,
+    type SnippetRange,
+    type SnippetField,
+    type SnippetVariableResolver,
+    type SnippetTemplate,
+    compileSnippet,
+    type ParsedSnippet,
+    parseSnippet,
+    tabOrder
+} from './snippet.ts';
 export {
     type LineSpan,
     lineSpanOf,
@@ -155,3 +183,14 @@ export {
 } from './find-query.ts';
 export { type PopupSize, type PopupPlacement, type PlaceOptions, placePopup, placeBeside } from './popup-placement.ts';
 export { planConflict, type ConflictStretch, type ConflictPlan } from './conflict-model.ts';
+export {
+    patchLayoutOf,
+    DEFAULT_PATCH_LIMITS,
+    type PatchLayout,
+    type PatchLayoutLine,
+    type PatchLineRole,
+    type PatchFileLayout,
+    type PatchFileStatus,
+    type PatchHunkLayout,
+    type PatchLimits
+} from './patch-layout.ts';

package/src/patch-decorations.ts

@@ -0,0 +1,224 @@
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import type { Editor, EditorChangeMark, EditorLineHighlight } from '@adecore/editor';
+import { patchLayoutOf, type PatchLayout, type PatchLayoutLine, type PatchLimits } from './patch-layout.ts';
+
+/* The sentences a screen reader reads with a line of the patch, in the host's words. */
+export interface PatchLineLabels {
+    added(number: number): string;
+    removed(number: number): string;
+    unchanged(old: number, fresh: number): string;
+}
+
+export interface PatchDecorationOptions {
+    /* One number per line, the old one for a removed line and the new one otherwise, or both side by side. Defaults to `single`. */
+    numbers?: 'single' | 'both';
+    labels?: PatchLineLabels;
+    limits?: PatchLimits;
+    /* Called with the layout after the first read and after `refresh()`, and once the edits have rested for `delay` ms, so a file list is not rebuilt per keystroke. */
+    onLayout?(layout: PatchLayout): void;
+    /* Milliseconds of rest before `onLayout` follows edits, and before a patch of `immediateBelow` characters or more is decorated again. Defaults to 150. */
+    delay?: number;
+    /* Up to this many characters (of the last read) the decorations follow an edit on the same microtask. Defaults to 100000. */
+    immediateBelow?: number;
+    /* Replaces `setTimeout` and `clearTimeout`, for a test that drives the clock. */
+    timer?: PatchTimer;
+}
+
+export interface PatchTimer {
+    set(callback: () => void, delay: number): unknown;
+    clear(handle: unknown): void;
+}
+
+const DEFAULT_TIMER: PatchTimer = {
+    set: (callback, delay) => setTimeout(callback, delay),
+    clear: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>)
+};
+
+export interface PatchDecoration {
+    readonly layout: PatchLayout;
+    /* Reads the text again, such as after the options changed. */
+    refresh(): void;
+    /* Takes the decorations off the editor and stops following it. */
+    dispose(): void;
+}
+
+const CHANGE_LAYER = 'patch';
+
+function numberOf(line: PatchLayoutLine, numbers: 'single' | 'both', width: number): string | null {
+    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)}`;
+}
+
+/* Runs of one role become one highlight, so the bar of consecutive changed lines is one stripe. */
+function highlightsOf(layout: PatchLayout): { highlights: EditorLineHighlight[]; marks: EditorChangeMark[] } {
+    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 };
+}
+
+/*
+ * Draws a patch in the editor the way the diff views draw a change: tinted lines, numbers from the hunk
+ * headers in the gutter and styled file and hunk headers. The editor stays editable. A small patch is read
+ * again on the microtask after an edit, so its decorations are right within a frame; a large one waits for
+ * the edits to rest, and `onLayout` always does. Typing costs one pass over the text (bounded by the limits).
+ */
+export function decoratePatch(editor: Editor, options: PatchDecorationOptions = {}): PatchDecoration {
+    let layout = patchLayoutOf('', options.limits);
+    let pending = false;
+    let disposed = false;
+    let length = 0;
+    let wait: unknown = null;
+    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;
+        },
+        refresh: read,
+        dispose() {
+            disposed = true;
+            clearWait();
+            stop();
+            editor.setLineNumbers(null);
+            editor.setLineLabels(null);
+            editor.setLineHighlights([]);
+            editor.setChangeMarks([], CHANGE_LAYER);
+        }
+    };
+}
+
+/* Decorates a mounted editor as a patch for as long as it stands, in the editor namespace's words, and returns the layout for a file tree. */
+export function usePatchDecorations(editor: Editor | null, options: Omit<PatchDecorationOptions, 'labels' | 'onLayout'> = {}): PatchLayout | null {
+    const { t } = useTranslation('editor');
+    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 }) },
+            labels: {
+                added: (number) => t('diff.added', { number }),
+                removed: (number) => t('diff.removed', { number }),
+                unchanged: (old, fresh) => t('diff.unchanged', { old, new: fresh })
+            },
+            onLayout: (layout) => setState({ editor, layout })
+        });
+        return () => decoration.dispose();
+    }, [editor, numbers, maxLines, maxCharacters, t]);
+    return state !== null && state.editor === editor ? state.layout : null;
+}