@adecore/editor-react 0.22.1 → 0.23.1

package/src/format-on-type.ts

@@ -0,0 +1,111 @@
+import type { TextEdit } from '@adecore/lsp';
+import type { EditorTextChange } from '@adecore/editor';
+import { comparePositions } from './diagnostics-model.ts';
+import type { EditorLanguage } from './editor-language.ts';
+
+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: readonly TextEdit[]): boolean {
+    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 {
+    private readonly language: EditorLanguage;
+    private 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. */
+    private revision = 0;
+    private controller = new AbortController();
+
+    constructor(language: EditorLanguage) {
+        this.language = language;
+        const off = language.editor.onTextChange((change) => this.typed(change));
+        language.onDispose(() => {
+            off();
+            this.controller.abort();
+        });
+    }
+
+    get isEnabled(): boolean {
+        return this.enabled;
+    }
+
+    /* Whether the server of this document formats on type and the service can ask it. */
+    get supported(): boolean {
+        const { project, uri } = this.language;
+        return project.service.onTypeFormatting !== undefined && project.service.supports(METHOD, uri);
+    }
+
+    configure(enabled: boolean): void {
+        this.enabled = enabled;
+        if (!enabled) {
+            this.controller.abort();
+        }
+    }
+
+    /* The characters that ask the server, the first one and the more. */
+    triggerCharacters(): readonly string[] {
+        const options = this.language.project.service.providerOptions(METHOD, this.language.uri);
+        return options === undefined
+            ? []
+            : [...(options.firstTriggerCharacter === undefined ? [] : [options.firstTriggerCharacter]), ...(options.moreTriggerCharacter ?? [])];
+    }
+
+    private typed(change: EditorTextChange): void {
+        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);
+    }
+
+    private async ask(revision: number, typed: string, caret: { line: number; character: number }, signal: AbortSignal): Promise<void> {
+        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/src/host-types.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';
@@ -37,16 +39,37 @@ export interface RenameSuggestionsRequest {
     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;
     /* The instance the app hands `UIProvider`, which the features read their words from too; the default instance without one. */
     readonly i18n?: i18n;
     readonly folder?: string;
     readonly files?: ProjectFiles;
     readonly apple?: boolean;
     readonly keymap?: Keymap;
+    /* The height in pixels of the list-and-preview area of the peek and the call hierarchy, so a person's drag outlives the panel; 180 without one. */
+    readonly panelBodyHeight?: number;
+    /* A person finished resizing a peek or call hierarchy panel; the height is already within what the editor allows. */
+    onPanelResize?(height: number): void;
     openPlace?(place: Place): void;
     pathOfUri?(uri: string): string | null;
     serverNames?(uri: string): readonly string[];
     notify?(notification: EditorNotification): void;
+    /* Synchronous overrides; undefined delegates to built-ins or an editable unknown-variable placeholder. */
+    resolveSnippetVariable?(name: string, context: SnippetVariableContext): string | undefined;
     suggestNames?(request: RenameSuggestionsRequest, signal: AbortSignal): Promise<readonly string[]>;
 }

package/src/hover.ts

@@ -1,14 +1,14 @@
 import type { EditorHover, EditorPosition, EditorRange } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
 import { rangeHolds, type Problem } from './diagnostics-model.ts';
-import { hoverTextOf, isEmptyHover, locationsOf } from './hover-content.ts';
+import { hoverTextOf, isEmptyHover, locationsOf, type HoverText } from './hover-content.ts';
 import { lineTextOf } from './line-text.ts';
 import { wordRangeAt } from './rename-model.ts';
 import type { HoverInfo } from './popups.ts';
 import { isShortcut } from './shortcut-keys.ts';
 import { realTimers, type Timers } from './timers.ts';
 
-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;
@@ -67,7 +67,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;
                 }
@@ -125,6 +125,17 @@ export class HoverFeature {
         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: EditorPosition, text: HoverText): void {
+        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(): void {
+        this.scheduleHide();
+    }
+
     hide(): void {
         this.pinned = false;
         this.held = false;
@@ -214,6 +225,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/src/index.ts

@@ -1,7 +1,16 @@
-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 +22,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,7 +38,7 @@ 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';
@@ -41,6 +56,7 @@ export type {
     RenameView,
     RenameFileView,
     PeekView,
+    CallHierarchyView,
     PickView,
     PickGroup,
     PickRow,
@@ -61,3 +77,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';