@adecore/editor-react 0.22.1 → 0.23.1

package/dist/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",
@@ -70,6 +82,9 @@
                 "symbol": "Overeenkomsten"
             }
         },
+        "panel": {
+            "resize": "Paneel vergroten of verkleinen"
+        },
         "peek": {
             "unavailable": "Geen language server vindt referenties in dit bestand",
             "none": "Geen referenties gevonden",
@@ -84,6 +99,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 +168,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 +235,7 @@
     "find": {
         "label": "Zoeken",
         "count": "{{current}} / {{total}}",
+        "countLimited": "{{current}} / {{total}}+",
         "none": "Geen resultaten",
         "invalid": "Ongeldige reguliere expressie",
         "caseSensitive": "Hoofdlettergevoelig",
@@ -166,7 +254,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/dist/models.d.ts

@@ -1,20 +1,24 @@
-export { isIdentifierCharacter, identifierPrefix, type MatchDetail, matchDetail, matchScore, editRangeOf, itemsOf, prefixFor, type Ranked, rankCompletions, matchedCharacters, qualifierOf, qualifiersOf, snippetToText, METHOD_KIND, FUNCTION_KIND, CONSTRUCTOR_KIND, CLASS_KIND, SNIPPET_FORMAT, type Insertion, insertionOf, mirroredInsertions, documentationText, completionDocsOf, type KindTone, kindLetterOf, kindToneOf, type RowWindow, rowWindow } from './completion-model.ts';
+export { isIdentifierCharacter, identifierPrefix, type MatchDetail, matchDetail, matchScore, editRangeOf, itemsOf, prefixFor, type Ranked, rankCompletions, matchedCharacters, qualifierOf, qualifiersOf, snippetToText, METHOD_KIND, FUNCTION_KIND, CONSTRUCTOR_KIND, CLASS_KIND, SNIPPET_FORMAT, type Insertion, type SnippetInsertionOptions, insertionOf, mirroredInsertions, documentationText, completionDocsOf, type KindTone, kindLetterOf, kindToneOf, type RowWindow, rowWindow } from './completion-model.ts';
 export { PARAMETER_HINTS_COMMAND, type CallPlan, type CallSite, isCallItem, hasParameters, planCall, withParentheses } from './completion-call.ts';
 export { type Problem, severityOf, markerOf, comparePositions, shiftPosition, shiftRange, rangeHolds, problemsAt, neighborProblem, codeLabelOf } from './diagnostics-model.ts';
 export { type SignatureBlock, type HoverText, splitSignatures, hoverTextOf, isEmptyHover, locationsOf, sameRange, type DocTag, splitDocTags, type HoverSection, type BaselineLevel, type Baseline, docblockMarkdown, type MarkdownPart, markdownParts, hoverSectionsOf } from './hover-content.ts';
 export { type SignatureViewModel, parameterSpan, signatureViewOf } from './signature-model.ts';
 export { wordRangeAt, type RenameTarget, renameTargetOf, type Occurrences, occurrencesOf, type RenameRow, type RenameFile, renameRowsOf, renamePreviewOf } from './rename-model.ts';
 export { type NameRange, type PeekPlace, type PeekFile, PEEK_READ_FILES, peekFilesOf, type PeekSnippet, snippetOf, definitionSnippetOf, 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, groupOfKind, letterOfKind, type SymbolTone, toneOfKind, type SymbolEntry, entriesOf, scoreOf, filterEntries, type EntryGroup, groupEntries, type PickerMode, modeOf, type WorkspaceEntry, workspaceEntriesOf } 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, REFACTOR_GROUPS, type ActionEntry, groupOf, actionsOf, mergeEntries, isHint, fixableOnLine, diagnosticsAt, 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, isEmptyRange, inlineRangeOf, type InlineProblem, problemsOnLines, type InlineAnswer, parseAnswer, fitReplacement, endOfInsertion, type DiffSegment, diffSegments, emphasisOf, offsetOf, textInRange, replaceRange, locateSelection } from './proposal-model.ts';
 export { type LineReplacement, replaceLines, replaceAllLines } from './line-edits.ts';
 export { replacedWords } from './word-diff.ts';
 export { type FindOptions, type FindQuery, EMPTY_FIND_QUERY, type TextMatch, type CompiledFind, MATCH_LIMIT, compileFind, matchesIn, stepIndex } 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/dist/models.js

@@ -5,16 +5,20 @@ export { splitSignatures, hoverTextOf, isEmptyHover, locationsOf, sameRange, spl
 export { parameterSpan, signatureViewOf } from './signature-model.js';
 export { wordRangeAt, renameTargetOf, occurrencesOf, renameRowsOf, renamePreviewOf } from './rename-model.js';
 export { PEEK_READ_FILES, peekFilesOf, snippetOf, definitionSnippetOf, distinguishingFolders, visualColumnOf } from './peek-model.js';
+export { CALL_LEVEL_LIMIT, rootsOf, childrenOf, rowsOf, stepsOf, targetOf, statusIdOf, moreIdOf } from './call-hierarchy-model.js';
 export { SYMBOL_GROUPS, groupOfKind, letterOfKind, toneOfKind, entriesOf, scoreOf, filterEntries, groupEntries, modeOf, workspaceEntriesOf } from './symbol-picker-model.js';
 export { SYMBOL_LINK_CLASS, isTypeName, linkTypeNames, declaredNameOf, placesOfName } from './symbol-links.js';
 export { scopesOf, decodeSemanticTokens } from './semantic-model.js';
+export { applySemanticEdits } from './semantic-delta.js';
 export { ACTION_GROUPS, REFACTOR_GROUPS, groupOf, actionsOf, mergeEntries, isHint, fixableOnLine, diagnosticsAt, previewOf } from './code-actions-model.js';
+export { resourceOperationsOf } from './workspace-edit.js';
 export { MAX_DECLARATIONS, startAfterComments, declarationsOf, usagesText } from './code-vision-model.js';
 export { UNCOMMITTED, mapBlame, shortName, authorshipOf, authorsText } from './code-authors.js';
-export { parseSnippet, tabOrder } from './snippet.js';
+export { compileSnippet, parseSnippet, tabOrder } from './snippet.js';
 export { lineSpanOf, isEmptyRange, inlineRangeOf, problemsOnLines, parseAnswer, fitReplacement, endOfInsertion, diffSegments, emphasisOf, offsetOf, textInRange, replaceRange, locateSelection } from './proposal-model.js';
 export { replaceLines, replaceAllLines } from './line-edits.js';
 export { replacedWords } from './word-diff.js';
 export { EMPTY_FIND_QUERY, MATCH_LIMIT, compileFind, matchesIn, stepIndex } from './find-query.js';
 export { placePopup, placeBeside } from './popup-placement.js';
 export { planConflict } from './conflict-model.js';
+export { patchLayoutOf, DEFAULT_PATCH_LIMITS } from './patch-layout.js';

package/dist/panel-size.d.ts

@@ -0,0 +1,6 @@
+export declare const PANEL_BODY_HEIGHT = 180;
+export declare const PANEL_BODY_MIN = 88;
+export declare const PANEL_KEY_STEP = 22;
+export declare function panelBodyMax(available: number): number;
+export declare function clampPanelBody(height: number, available?: number): number;
+export declare function availableHeightOf(container: HTMLElement | null): number;

package/dist/panel-size.js

@@ -0,0 +1,25 @@
+/* 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. */
+export function panelBodyMax(available) {
+    return Math.max(PANEL_BODY_MIN, Math.floor(available * PANEL_MAX_SHARE) - PANEL_CHROME);
+}
+export function clampPanelBody(height, available = PANEL_FALLBACK_AVAILABLE) {
+    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) {
+    const height = container?.closest('.se-viewport')?.clientHeight ?? 0;
+    return height > 0 ? height : PANEL_FALLBACK_AVAILABLE;
+}

package/dist/patch-decorations.d.ts

@@ -0,0 +1,27 @@
+import type { Editor } from '@adecore/editor';
+import { type PatchLayout, type PatchLimits } from './patch-layout.ts';
+export interface PatchLineLabels {
+    added(number: number): string;
+    removed(number: number): string;
+    unchanged(old: number, fresh: number): string;
+}
+export interface PatchDecorationOptions {
+    numbers?: 'single' | 'both';
+    labels?: PatchLineLabels;
+    limits?: PatchLimits;
+    onLayout?(layout: PatchLayout): void;
+    delay?: number;
+    immediateBelow?: number;
+    timer?: PatchTimer;
+}
+export interface PatchTimer {
+    set(callback: () => void, delay: number): unknown;
+    clear(handle: unknown): void;
+}
+export interface PatchDecoration {
+    readonly layout: PatchLayout;
+    refresh(): void;
+    dispose(): void;
+}
+export declare function decoratePatch(editor: Editor, options?: PatchDecorationOptions): PatchDecoration;
+export declare function usePatchDecorations(editor: Editor | null, options?: Omit<PatchDecorationOptions, 'labels' | 'onLayout'>): PatchLayout | null;

package/dist/patch-decorations.js

@@ -0,0 +1,182 @@
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { patchLayoutOf } from './patch-layout.js';
+const DEFAULT_TIMER = {
+    set: (callback, delay) => setTimeout(callback, delay),
+    clear: (handle) => clearTimeout(handle)
+};
+const CHANGE_LAYER = 'patch';
+function numberOf(line, numbers, width) {
+    if (line.old === null && line.new === null) {
+        return null;
+    }
+    if (numbers === 'single') {
+        return String(line.new ?? line.old);
+    }
+    const pad = (value) => (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) {
+    const highlights = [];
+    const marks = [];
+    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, options = {}) {
+    let layout = patchLayoutOf('', options.limits);
+    let pending = false;
+    let disposed = false;
+    let length = 0;
+    let wait = null;
+    const timer = options.timer ?? DEFAULT_TIMER;
+    const delay = options.delay ?? 150;
+    const immediateBelow = options.immediateBelow ?? 100_000;
+    const clearWait = () => {
+        if (wait !== null) {
+            timer.clear(wait);
+            wait = null;
+        }
+    };
+    const after = (callback) => {
+        clearWait();
+        wait = timer.set(() => {
+            wait = null;
+            callback();
+        }, delay);
+    };
+    const apply = () => {
+        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 = () => {
+        pending = false;
+        if (disposed) {
+            return;
+        }
+        const text = editor.getText();
+        length = text.length;
+        layout = patchLayoutOf(text, options.limits);
+        apply();
+    };
+    const announce = () => {
+        if (!disposed) {
+            options.onLayout?.(layout);
+        }
+    };
+    const read = () => {
+        clearWait();
+        decorate();
+        announce();
+    };
+    const schedule = () => {
+        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, options = {}) {
+    const { t } = useTranslation('editor');
+    const [state, setState] = useState(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;
+}

package/dist/patch-layout.d.ts

@@ -0,0 +1,40 @@
+export type PatchLineRole = 'file-header' | 'hunk-header' | 'context' | 'added' | 'removed' | 'no-newline' | 'binary' | 'other';
+export type PatchFileStatus = 'added' | 'deleted' | 'renamed' | 'copied' | 'modified' | 'binary';
+export interface PatchLayoutLine {
+    readonly role: PatchLineRole;
+    readonly old: number | null;
+    readonly new: number | null;
+}
+export interface PatchHunkLayout {
+    readonly line: number;
+    readonly oldStart: number;
+    readonly oldCount: number;
+    readonly newStart: number;
+    readonly newCount: number;
+    readonly section: string;
+    readonly consistent: boolean;
+}
+export interface PatchFileLayout {
+    readonly oldPath: string | null;
+    readonly newPath: string | null;
+    readonly status: PatchFileStatus;
+    readonly firstLine: number;
+    readonly lastLine: number;
+    readonly added: number;
+    readonly removed: number;
+    readonly hunks: readonly PatchHunkLayout[];
+}
+export interface PatchLayout {
+    readonly lines: readonly PatchLayoutLine[];
+    readonly files: readonly PatchFileLayout[];
+    readonly truncated: boolean;
+}
+export interface PatchLimits {
+    readonly maxLines?: number;
+    readonly maxCharacters?: number;
+}
+export declare const DEFAULT_PATCH_LIMITS: {
+    readonly maxLines: 50000;
+    readonly maxCharacters: 4000000;
+};
+export declare function patchLayoutOf(text: string, limits?: PatchLimits): PatchLayout;