@adecore/editor-react 0.22.1 → 0.23.1

package/dist/editor-react.css

@@ -17,6 +17,36 @@
     color: var(--accent);
     text-decoration: underline;
 }
+/* Documentation drawn in place of a comment: lists and quotes that the base layer strips of their marks. */
+.adecore-rendered-doc ul,
+.adecore-rendered-doc ol {
+    margin: 4px 0;
+    padding-inline-start: 20px;
+}
+.adecore-rendered-doc ul {
+    list-style: disc;
+}
+.adecore-rendered-doc ol {
+    list-style: decimal;
+}
+.adecore-rendered-doc blockquote {
+    margin: 4px 0;
+    padding-inline-start: 8px;
+    border-inline-start: 2px solid var(--border);
+}
+.adecore-rendered-doc :not(pre) > code {
+    font-family: var(--font-mono);
+}
+.adecore-rendered-doc h1,
+.adecore-rendered-doc h2,
+.adecore-rendered-doc h3,
+.adecore-rendered-doc h4,
+.adecore-rendered-doc h5,
+.adecore-rendered-doc h6 {
+    margin: 4px 0;
+    font-size: inherit;
+    font-weight: 600;
+}
 .adecore-editor-find {
     display: flex;
     flex-direction: column;
@@ -41,3 +71,52 @@
 .adecore-editor-find output {
     font-variant-numeric: tabular-nums;
 }
+
+.adecore-editor-diff-gap {
+    display: flex;
+    align-items: center;
+    min-height: 32px;
+    padding: 4px 8px;
+    font-family: var(--font-sans);
+    color: var(--text-muted);
+    background: var(--surface-raised);
+}
+.adecore-editor-diff-no-newline {
+    padding-inline: 8px;
+    color: var(--text-muted);
+    font-family: var(--font-sans);
+    font-size: var(--text-sm);
+}
+
+.adecore-editor-diff .se-viewport {
+    overscroll-behavior-y: auto;
+}
+
+.adecore-editor-diff[data-scroll='false'] .se-viewport {
+    overflow-y: hidden;
+}
+
+.adecore-editor-diff-split {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+    min-height: 0;
+}
+.adecore-editor-diff-side {
+    position: relative;
+    min-width: 0;
+    min-height: 0;
+}
+.adecore-editor-diff-side + .adecore-editor-diff-side {
+    border-inline-start: 1px solid var(--border);
+}
+.adecore-editor-diff-surface {
+    position: absolute;
+    inset: 0;
+}
+.adecore-editor-diff-split .se-viewport {
+    scrollbar-gutter: stable;
+}
+.adecore-editor-diff-filler {
+    background: repeating-linear-gradient(135deg, transparent 0 6px, var(--editor-hatch) 6px 7px);
+    pointer-events: none;
+}

package/dist/format-on-type.d.ts

@@ -0,0 +1,14 @@
+import type { EditorLanguage } from './editor-language.ts';
+export declare class FormatOnTypeFeature {
+    private readonly language;
+    private enabled;
+    private revision;
+    private controller;
+    constructor(language: EditorLanguage);
+    get isEnabled(): boolean;
+    get supported(): boolean;
+    configure(enabled: boolean): void;
+    triggerCharacters(): readonly string[];
+    private typed;
+    private ask;
+}

package/dist/format-on-type.js

@@ -0,0 +1,96 @@
+import { comparePositions } from './diagnostics-model.js';
+const METHOD = 'textDocument/onTypeFormatting';
+/* A line break with the indentation the editor put after it, which is how Enter reaches the server. */
+const LINE_BREAK = /^\r?\n[ \t]*(\r?\n[ \t]*)?$/;
+/* A closer with the whitespace the editor replaced in front of it when it moved the closer back to its opener's indentation. */
+const DEDENTED = /^[ \t]+(\S)$/u;
+/* The overlapping edits of a server answer have no single meaning, so an answer that has them is not applied. */
+function overlaps(edits) {
+    const ordered = [...edits].sort((left, right) => comparePositions(left.range.start, right.range.start));
+    return ordered.some((edit, index) => index > 0 && comparePositions(ordered[index - 1].range.end, edit.range.start) > 0);
+}
+/*
+ * Formatting while typing: after a person types one of the characters the server named in
+ * `firstTriggerCharacter` and `moreTriggerCharacter`, the server is asked what to change around the caret, and its
+ * edits are applied.
+ *
+ * Only typing counts: one change that is the trigger character alone, the closer the editor moved back to its
+ * opener's indentation, or a line break with its indentation for `\n`, which the editor reports as typed though
+ * Enter runs as a command. A character the editor types over an existing closer changes no text and asks nothing. A paste, undo, a completion or an external change does not ask, and neither does a
+ * second caret, a read-only editor or a snippet session, whose tab stops an edit could move. An answer is applied
+ * only while the text is exactly what it was asked about, and the caret where it was.
+ *
+ * The edits join the undo step of the typed character, so one undo takes both back. On by default where the server offers it; `configure(false)`
+ * turns it off for a host that has a setting for it.
+ */
+export class FormatOnTypeFeature {
+    language;
+    enabled = true;
+    /* Raised by every change of the text, so an answer for an older text is told from the one for the text that is. */
+    revision = 0;
+    controller = new AbortController();
+    constructor(language) {
+        this.language = language;
+        const off = language.editor.onTextChange((change) => this.typed(change));
+        language.onDispose(() => {
+            off();
+            this.controller.abort();
+        });
+    }
+    get isEnabled() {
+        return this.enabled;
+    }
+    /* Whether the server of this document formats on type and the service can ask it. */
+    get supported() {
+        const { project, uri } = this.language;
+        return project.service.onTypeFormatting !== undefined && project.service.supports(METHOD, uri);
+    }
+    configure(enabled) {
+        this.enabled = enabled;
+        if (!enabled) {
+            this.controller.abort();
+        }
+    }
+    /* The characters that ask the server, the first one and the more. */
+    triggerCharacters() {
+        const options = this.language.project.service.providerOptions(METHOD, this.language.uri);
+        return options === undefined
+            ? []
+            : [...(options.firstTriggerCharacter === undefined ? [] : [options.firstTriggerCharacter]), ...(options.moreTriggerCharacter ?? [])];
+    }
+    typed(change) {
+        const revision = ++this.revision;
+        this.controller.abort();
+        if (!this.enabled || (change.source !== 'input' && change.typed !== true) || change.changes.length !== 1 || !this.supported) {
+            return;
+        }
+        const { editor, snippets } = this.language;
+        const { text } = change.changes[0];
+        const typed = LINE_BREAK.test(text) ? '\n' : Array.from(text).length === 1 ? text : (DEDENTED.exec(text)?.[1] ?? null);
+        if (typed === null || !this.triggerCharacters().includes(typed)) {
+            return;
+        }
+        if (snippets.isActive || editor.isReadOnly?.() === true || editor.getSelections().length !== 1) {
+            return;
+        }
+        this.controller = new AbortController();
+        void this.ask(revision, typed, editor.getCaret(), this.controller.signal);
+    }
+    async ask(revision, typed, caret, signal) {
+        const { editor, project, uri, document } = this.language;
+        try {
+            // The change of the typed character reaches the server before this question does.
+            await document.ready;
+            const edits = await project.service.onTypeFormatting(uri, caret, typed, { ...editor.getIndentation() }, { signal });
+            const here = editor.getCaret();
+            const stale = revision !== this.revision || this.language.isDisposed || comparePositions(here, caret) !== 0;
+            if (stale || edits === null || edits.length === 0 || overlaps(edits)) {
+                return;
+            }
+            editor.applyEdits(edits.map((edit) => ({ range: edit.range, text: edit.newText })), { mergeUndo: true });
+        }
+        catch {
+            // A refusal or a failing server is not worth a notice per keystroke; the next trigger character asks again.
+        }
+    }
+}

package/dist/host-types.d.ts

@@ -1,3 +1,5 @@
+import type { WorkerRequestPort } from '@adecore/editor/worker-client';
+import type { EditorPosition, EditorRange } from '@adecore/editor';
 import type { i18n } from 'i18next';
 import type { Keymap } from '@adecore/editor/keymap';
 import type { ProjectFiles } from './workspace-edit.ts';
@@ -31,15 +33,32 @@ export interface RenameSuggestionsRequest {
     context: string;
     uses: readonly string[];
 }
+export interface SnippetVariableContext {
+    readonly uri: string;
+    readonly languageId: string;
+    readonly position: EditorPosition;
+    readonly selection: EditorRange;
+    readonly selectedText: string;
+    readonly currentLine: string;
+    readonly currentWord: string;
+    readonly cursorIndex: number;
+    readonly cursorCount: number;
+    readonly folder?: string;
+    readonly path?: string;
+}
 export interface LanguageHost {
+    readonly snippetTransformWorker?: () => WorkerRequestPort;
     readonly i18n?: i18n;
     readonly folder?: string;
     readonly files?: ProjectFiles;
     readonly apple?: boolean;
     readonly keymap?: Keymap;
+    readonly panelBodyHeight?: number;
+    onPanelResize?(height: number): void;
     openPlace?(place: Place): void;
     pathOfUri?(uri: string): string | null;
     serverNames?(uri: string): readonly string[];
     notify?(notification: EditorNotification): void;
+    resolveSnippetVariable?(name: string, context: SnippetVariableContext): string | undefined;
     suggestNames?(request: RenameSuggestionsRequest, signal: AbortSignal): Promise<readonly string[]>;
 }

package/dist/hover.d.ts

@@ -1,6 +1,8 @@
 import type { EditorPosition, EditorRange } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
+import { type HoverText } from './hover-content.ts';
 import { type Timers } from './timers.ts';
+export declare const SHOW_DELAY_MS = 300;
 export declare class HoverFeature {
     private readonly language;
     private readonly timers;
@@ -19,6 +21,8 @@ export declare class HoverFeature {
     showProblemsAt(position: EditorPosition): boolean;
     keep(): void;
     showRange(range: EditorRange): void;
+    showText(position: EditorPosition, text: HoverText): void;
+    release(): void;
     hide(): void;
     private moved;
     private scheduleHide;

package/dist/hover.js

@@ -4,7 +4,7 @@ import { lineTextOf } from './line-text.js';
 import { wordRangeAt } from './rename-model.js';
 import { isShortcut } from './shortcut-keys.js';
 import { realTimers } from './timers.js';
-const SHOW_DELAY_MS = 300;
+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;
@@ -61,7 +61,7 @@ export class HoverFeature {
                     this.quickInfo();
                     return true;
                 }
-                if (event.key === 'Escape' && this.language.popups.getState().hover !== null) {
+                if (event.key === 'Escape' && this.language.popups.getState().hover !== null && this.language.popups.getState().callHierarchy == null) {
                     this.hide();
                     return true;
                 }
@@ -114,6 +114,15 @@ export class HoverFeature {
         this.keep();
         this.present(range.start, [], null, range);
     }
+    /* A card of text another feature brings, such as the tooltip of an inlay hint, which goes the way any hover card does. */
+    showText(position, text) {
+        this.hide();
+        this.present(position, [], { text, definition: null, word: '', references: null, plain: true }, null);
+    }
+    /* The pointer left what a card was opened for: it closes unless the pointer reaches the card in time. */
+    release() {
+        this.scheduleHide();
+    }
     hide() {
         this.pinned = false;
         this.held = false;
@@ -199,6 +208,10 @@ export class HoverFeature {
         }
         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') });
             }

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export { EditorLanguage } from './editor-language.ts';
-export { ProjectLanguage } from './project-language.ts';
+export { EditorLanguage, type EditorLanguageOptions } from './editor-language.ts';
+export { DEFAULT_RANGE_LINES, DEFAULT_RANGE_CHARACTERS, type SemanticTokensOptions } from './semantic-tokens.ts';
+export { ProjectLanguage, type FileOperationTarget } from './project-language.ts';
 export type { LanguageDocumentHandle } from './project-language.ts';
-export type { LanguageHost, DiskText, GitBlameCommit, GitBlameResult, EditorNotification, RenameSuggestionsRequest } from './host-types.ts';
+export type { SnippetVariableContext, LanguageHost, DiskText, GitBlameCommit, GitBlameResult, EditorNotification, RenameSuggestionsRequest } from './host-types.ts';
 export { EditorView } from './EditorView.tsx';
 export { createHolder } from './holder.ts';
 export type { EditorViewProps } from './EditorView.tsx';
@@ -13,8 +14,14 @@ export { SignatureCard } from './SignatureCard.tsx';
 export { RenameCard } from './RenameCard.tsx';
 export { PickPopup } from './PickPopup.tsx';
 export { PeekPanel } from './PeekPanel.tsx';
+export { CallHierarchyPanel } from './CallHierarchyPanel.tsx';
 export { SymbolPicker } from './SymbolPicker.tsx';
 export { CodeAuthorsCard } from './CodeAuthorsCard.tsx';
+export { RenderedDocs } from './RenderedDocs.tsx';
+export { RenderedDocsFeature } from './rendered-docs.ts';
+export type { RenderedDocEntry, RenderedDocsSettings } from './rendered-docs.ts';
+export { parseDocComment, sectionsOf, htmlToMarkdown, DOC_LINK_PREFIX } from './doc-comment-model.ts';
+export type { DocTagEntry, DocTagSection, ParsedDocComment } from './doc-comment-model.ts';
 export { EditorContextMenu } from './EditorContextMenu.tsx';
 export { EditorRenderingProvider } from './rendering.tsx';
 export type { EditorRendering } from './rendering-context.ts';
@@ -23,13 +30,13 @@ export { ChangeReview } from './ChangeReview.tsx';
 export type { ChangeReviewProps } from './ChangeReview.tsx';
 export { ProjectProblems, countsOf, compareRows } from './project-problems.ts';
 export type { ProblemFile, ProblemRow } from './project-problems.ts';
-export { applyWorkspaceEdit } from './workspace-edit.ts';
+export { applyWorkspaceEdit, supportedResourceOperations } from './workspace-edit.ts';
 export type { ProjectFiles, StagedFile, WorkspaceEditHost } from './workspace-edit.ts';
 export { useProblemCounts } from './use-problem-counts.ts';
 export type { ProblemCounts } from './diagnostics.ts';
 export type { BlameSource, CodeVisionSettings } from './code-vision.ts';
 export type { Problem } from './diagnostics-model.ts';
-export type { PopupState, PopupStore, HoverInfo, HoverView, CompletionView, CompletionDocs, CompletionRow, SignatureView, RenameView, RenameFileView, PeekView, PickView, PickGroup, PickRow, PickPreview, SymbolsView, MenuView, AuthorsView } from './popups.ts';
+export type { PopupState, PopupStore, HoverInfo, HoverView, CompletionView, CompletionDocs, CompletionRow, SignatureView, RenameView, RenameFileView, PeekView, CallHierarchyView, PickView, PickGroup, PickRow, PickPreview, SymbolsView, MenuView, AuthorsView } from './popups.ts';
 export { RowHost, LineActionHost } from './row-host.ts';
 export type { HostedRow, HostedAction } from './row-host.ts';
 export { HighlightLayers, highlightLayers } from './highlight-layers.ts';
@@ -42,3 +49,10 @@ export { AttributionCard } from './AttributionCard.tsx';
 export type { AttributionCardProps } from './AttributionCard.tsx';
 export { ReviewGroup, joinReviewGroup } from './review-group.ts';
 export type { ReviewMember } from './review-group.ts';
+export { DiffView } from './DiffView.tsx';
+export type { DiffViewProps } from './DiffView.tsx';
+export type { DiffLimits } from './diff-expansion.ts';
+export { diffSyntaxDocument } from './diff-syntax.ts';
+export type { DiffSourceSide, DiffSourceTokens, DiffSyntaxSources } from './diff-syntax.ts';
+export { decoratePatch, usePatchDecorations } from './patch-decorations.ts';
+export type { PatchDecoration, PatchDecorationOptions, PatchLineLabels, PatchTimer } from './patch-decorations.ts';

package/dist/index.js

@@ -1,4 +1,5 @@
 export { EditorLanguage } from './editor-language.js';
+export { DEFAULT_RANGE_LINES, DEFAULT_RANGE_CHARACTERS } from './semantic-tokens.js';
 export { ProjectLanguage } from './project-language.js';
 export { EditorView } from './EditorView.js';
 export { createHolder } from './holder.js';
@@ -10,14 +11,18 @@ export { SignatureCard } from './SignatureCard.js';
 export { RenameCard } from './RenameCard.js';
 export { PickPopup } from './PickPopup.js';
 export { PeekPanel } from './PeekPanel.js';
+export { CallHierarchyPanel } from './CallHierarchyPanel.js';
 export { SymbolPicker } from './SymbolPicker.js';
 export { CodeAuthorsCard } from './CodeAuthorsCard.js';
+export { RenderedDocs } from './RenderedDocs.js';
+export { RenderedDocsFeature } from './rendered-docs.js';
+export { parseDocComment, sectionsOf, htmlToMarkdown, DOC_LINK_PREFIX } from './doc-comment-model.js';
 export { EditorContextMenu } from './EditorContextMenu.js';
 export { EditorRenderingProvider } from './rendering.js';
 export { FindReplace } from './FindReplace.js';
 export { ChangeReview } from './ChangeReview.js';
 export { ProjectProblems, countsOf, compareRows } from './project-problems.js';
-export { applyWorkspaceEdit } from './workspace-edit.js';
+export { applyWorkspaceEdit, supportedResourceOperations } from './workspace-edit.js';
 export { useProblemCounts } from './use-problem-counts.js';
 export { RowHost, LineActionHost } from './row-host.js';
 export { HighlightLayers, highlightLayers } from './highlight-layers.js';
@@ -26,3 +31,6 @@ export { openingPlace, viewStates, followViewStates, viewStateKey, forgetMovesFr
 export { lspLanguageIdOf, shikiLanguageOf, shikiLanguageOfPath } from './language-ids.js';
 export { AttributionCard } from './AttributionCard.js';
 export { ReviewGroup, joinReviewGroup } from './review-group.js';
+export { DiffView } from './DiffView.js';
+export { diffSyntaxDocument } from './diff-syntax.js';
+export { decoratePatch, usePatchDecorations } from './patch-decorations.js';

package/dist/inlay-hints.d.ts

@@ -1,13 +1,58 @@
-import type { EditorInlayHint, EditorPosition, EditorRange } from '@adecore/editor';
-import type { InlayHint } from '@adecore/lsp';
+import type { Editor, EditorInlayClick, EditorInlayHint, EditorPosition, EditorRange } from '@adecore/editor';
+import type { Command, InlayHint, InlayHintLabelPart, Location, MarkupContent, TextEdit } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
+import { type HoverText } from './hover-content.ts';
 import { type Timers } from './timers.ts';
 export declare function hintLabelOf(hint: InlayHint): string;
+export declare function drawableHints(hints: readonly InlayHint[]): InlayHint[];
+export declare function editorHintOf(hint: InlayHint, id: string): EditorInlayHint;
 export declare function editorHintsOf(hints: readonly InlayHint[]): EditorInlayHint[];
 export declare function withMargin(visible: EditorRange, endOfDocument: EditorPosition, endOfLine: (line: number) => EditorPosition): EditorRange;
 export declare function covers(asked: EditorRange, visible: EditorRange): boolean;
+export declare function tooltipTextOf(tooltip: string | MarkupContent | undefined): HoverText | null;
+export declare function partOf(hint: InlayHint, index: number | null): InlayHintLabelPart | null;
+export declare function tooltipOf(hint: InlayHint, index: number | null): HoverText | null;
+export declare function lacksInfo(hint: InlayHint, index: number | null): boolean;
+export declare function editsFit(editor: Editor, edits: readonly TextEdit[]): boolean;
+type Action = {
+    readonly kind: 'go';
+    readonly location: Location;
+} | {
+    readonly kind: 'run';
+    readonly command: Command;
+} | {
+    readonly kind: 'insert';
+    readonly edits: TextEdit[];
+};
+export declare function actionOf(hint: InlayHint, click: Pick<EditorInlayClick, 'part' | 'mod' | 'clicks'>): Action | null;
 export declare class InlayHintsFeature {
+    private readonly language;
+    private readonly timers;
     private readonly refresher;
     private asked;
+    private readonly entries;
+    private shown;
+    private generation;
+    private epoch;
+    private target;
+    private modHeld;
+    private showTimer;
+    private commandTimer;
+    private pressCount;
+    private request;
     constructor(language: EditorLanguage, timers?: Timers);
+    setModHeld(held: boolean): void;
+    showTooltipAt(position: EditorPosition): Promise<boolean>;
+    private install;
+    private hovered;
+    private cancelHover;
+    private cardOpen;
+    private showTooltip;
+    private resolve;
+    private resolvable;
+    private updateLink;
+    private pressed;
+    private press;
+    private perform;
 }
+export {};