Files
dbx/apps/desktop/src/components/editor/useQueryEditorCompletionKeys.ts
T

217 lines
12 KiB
TypeScript

import type { EditorView as EditorViewType } from "@codemirror/view";
import { type QueryCompletionOption } from "./useQueryEditorBatchSelection";
import { insertQueryEditorNewline } from "@/lib/editor/queryEditorNewline";
import { isBatchColumnSelectionCompletionActive } from "@/lib/editor/batchColumnSelection";
import { normalizeShortcutSettings, shortcutToCodeMirrorKey } from "@/lib/editor/shortcutRegistry";
import { acceptSelectedCompletionWithRetry, acceptSelectedOrFirstCompletion } from "@/lib/editor/queryEditorCompletionAcceptance";
import type { QueryEditorProps } from "./queryEditorTypes";
import type { QueryEditorCodeMirrorRuntime } from "./queryEditorCodeMirrorRuntime";
import type { useSettingsStore } from "@/stores/settingsStore";
import type { useQueryEditorCompletion } from "./useQueryEditorCompletion";
import type { useQueryEditorBatchSelection } from "./useQueryEditorBatchSelection";
interface QueryEditorCompletionKeysOptions {
props: Readonly<QueryEditorProps>;
settingsStore: ReturnType<typeof useSettingsStore>;
runtime: QueryEditorCodeMirrorRuntime;
completion: Pick<ReturnType<typeof useQueryEditorCompletion>, "suppressAutoStartUntil">;
batchSelection: Pick<ReturnType<typeof useQueryEditorBatchSelection>, "applySelectedBatchColumnSelection">;
isEditorComposing: (view: EditorViewType) => boolean;
retryDelayMs: number;
tabMaxWaitMs: number;
enterMaxWaitMs: number;
}
export function useQueryEditorCompletionKeys(options: QueryEditorCompletionKeysOptions) {
const { props, settingsStore, runtime: codeMirrorRuntime, completion, isEditorComposing } = options;
const { applySelectedBatchColumnSelection } = options.batchSelection;
const COMPLETION_TAB_RETRY_DELAY_MS = options.retryDelayMs;
const COMPLETION_TAB_MAX_WAIT_MS = options.tabMaxWaitMs;
const COMPLETION_ENTER_MAX_WAIT_MS = options.enterMaxWaitMs;
let pendingCompletionTabTimer: ReturnType<typeof setTimeout> | null = null;
let cancelPendingCompletionEnter: (() => void) | null = null;
// Resolve the indent unit (one Tab worth) from the SQL formatter settings so
// the Tab key, multi-line indent and auto-indent all honor the configured width.
function editorIndentUnit(): string {
const { useTabs, tabWidth } = settingsStore.editorSettings.sqlFormatter;
return useTabs ? "\t" : " ".repeat(tabWidth);
}
function handleTab(view: EditorViewType): boolean {
if (isEditorComposing(view)) return false;
if (view.state.selection.ranges.some((range) => !range.empty)) {
// Snippet navigation selects the whole field, including after Shift+Tab.
// Give that active session priority over ordinary selected-text indentation.
return (codeMirrorRuntime.codeMirrorNextSnippetField?.(view) ?? false) || (codeMirrorRuntime.codeMirrorIndentMore?.(view) ?? false);
}
if (tabKeyAcceptsCompletion()) {
return acceptCompletionOrNextSnippetField(view) || performNormalTab(view);
}
return handleTabWithoutAcceptingCompletion(view) || performNormalTab(view);
}
// The Tab key is always wired up for indentation and snippet-field navigation,
// but it must only accept an open completion popup when the user's configured
// "accept completion" shortcut is actually Tab — otherwise a user who remapped
// that shortcut (e.g. to Enter) would find Tab silently accepting completions
// anyway, ignoring their setting (dbx#6236).
function tabKeyAcceptsCompletion(): boolean {
const shortcuts = normalizeShortcutSettings(settingsStore.editorSettings.shortcuts);
return shortcutToCodeMirrorKey(shortcuts.acceptCompletion) === "Tab";
}
function handleTabWithoutAcceptingCompletion(view: EditorViewType): boolean {
if (codeMirrorRuntime.codeMirrorCompletionStatus?.(view.state)) return false;
return codeMirrorRuntime.codeMirrorNextSnippetField?.(view) ?? false;
}
function performNormalTab(view: EditorViewType): boolean {
const { state, dispatch } = view;
if (state.selection.ranges.some((range) => !range.empty)) return codeMirrorRuntime.codeMirrorIndentMore?.(view) ?? false;
const sel = state.selection.main;
const line = state.doc.lineAt(sel.from);
const before = line.text.slice(0, sel.from - line.from);
if (/^\s*$/.test(before)) return codeMirrorRuntime.codeMirrorIndentMore?.(view) ?? false;
dispatch(
state.update(state.replaceSelection(editorIndentUnit()), {
userEvent: "input.type",
}),
);
return true;
}
function handleEnter(view: EditorViewType): boolean {
// While an IME composition is active, Enter confirms the composition (the
// candidate list); intercepting it here would accept a completion popup on
// top of the composition instead of committing the typed text (issue #8029).
if (isEditorComposing(view)) return false;
clearPendingCompletionEnter();
if (isBatchColumnSelectionCompletionActive(codeMirrorRuntime.codeMirrorCompletionStatus?.(view.state) ?? null) && applySelectedBatchColumnSelection(view)) return true;
// CodeMirror's default completion keymap is disabled so batch selection can
// take precedence. Preserve its normal single-item acceptance here.
if (codeMirrorRuntime.codeMirrorAcceptCompletion?.(view)) return true;
if (settingsStore.editorSettings.selectFirstCompletionOnOpen && codeMirrorRuntime.codeMirrorCompletionStatus) {
let cancelRetry: (() => void) | null = null;
const result = acceptSelectedCompletionWithRetry(view, {
completionStatus: codeMirrorRuntime.codeMirrorCompletionStatus,
acceptCompletion: codeMirrorRuntime.codeMirrorAcceptCompletion,
selectedCompletionIndex: codeMirrorRuntime.codeMirrorSelectedCompletionIndex,
selectFirstCompletion: codeMirrorRuntime.codeMirrorSelectFirstCompletion,
retryDelayMs: COMPLETION_TAB_RETRY_DELAY_MS,
maxWaitMs: COMPLETION_ENTER_MAX_WAIT_MS,
isComposing: () => isEditorComposing(view),
onUnavailable: () => insertNewlineWithoutCompletion(view),
onSettled: () => {
if (cancelPendingCompletionEnter === cancelRetry) cancelPendingCompletionEnter = null;
},
});
if (result.handled) {
cancelRetry = result.cancel ?? null;
cancelPendingCompletionEnter = cancelRetry;
return true;
}
}
return insertNewlineWithoutCompletion(view);
}
function clearPendingCompletionEnter() {
cancelPendingCompletionEnter?.();
cancelPendingCompletionEnter = null;
}
function insertNewlineWithoutCompletion(view: EditorViewType): boolean {
codeMirrorRuntime.codeMirrorCloseCompletion?.(view);
completion.suppressAutoStartUntil = Date.now() + 750;
const handled = insertQueryEditorNewline(view, codeMirrorRuntime.codeMirrorInsertNewlineKeepIndent, props.databaseType);
if (!handled) completion.suppressAutoStartUntil = 0;
return handled;
}
function acceptCompletionOrNextSnippetField(view: EditorViewType): boolean {
// A non-empty selection belongs to snippet navigation or block indentation,
// not word completion. A popup opened by an indent edit must not hijack Tab.
if (isEditorComposing(view)) return false;
if (view.state.selection.ranges.every((range) => range.empty)) {
const completionStatus = codeMirrorRuntime.codeMirrorCompletionStatus?.(view.state) ?? null;
if (isBatchColumnSelectionCompletionActive(completionStatus) && applySelectedBatchColumnSelection(view)) return true;
if (completionStatus === "active" && acceptSelectedOrFirstCompletion(view, codeMirrorRuntime.codeMirrorAcceptCompletion, codeMirrorRuntime.codeMirrorSelectedCompletionIndex, codeMirrorRuntime.codeMirrorSelectFirstCompletion)) return true;
if (completionStatus) return waitForCompletionTab(view);
}
return codeMirrorRuntime.codeMirrorNextSnippetField?.(view) ?? false;
}
function acceptSqlServerCompletionOnSpace(view: EditorViewType): boolean {
if (isEditorComposing(view)) return false;
if (props.databaseType !== "sqlserver" || !settingsStore.editorSettings.sqlServerSpaceConfirmsCompletion) return false;
if (codeMirrorRuntime.codeMirrorCompletionStatus?.(view.state) !== "active") return false;
// A non-empty selection belongs to block editing, not word completion.
if (!view.state.selection.main.empty) return false;
const selected = codeMirrorRuntime.codeMirrorSelectedCompletion?.(view.state) as QueryCompletionOption | null | undefined;
const completionType = selected?.type;
if (completionType !== "keyword" && completionType !== "table" && completionType !== "column") return false;
// Batch-selection rows own Space for checkbox toggling; this Prec.highest binding outranks their keymap.
if (selected?.dbxBatchColumnSelection || selected?.dbxBatchColumnSelectionAction) return false;
if (!(codeMirrorRuntime.codeMirrorAcceptCompletion?.(view) ?? false)) return false;
const selection = view.state.selection.main;
if (!selection.empty) return true;
const cursor = selection.head;
const previousCharacter = cursor > 0 ? view.state.sliceDoc(cursor - 1, cursor) : "";
if (/\s/.test(previousCharacter)) return true;
const nextCharacter = view.state.sliceDoc(cursor, cursor + 1);
if (/\s/.test(nextCharacter)) {
view.dispatch({ selection: { anchor: cursor + 1 }, scrollIntoView: true });
} else {
view.dispatch({
changes: { from: cursor, insert: " " },
selection: { anchor: cursor + 1 },
scrollIntoView: true,
});
}
return true;
}
function clearPendingCompletionTab() {
if (pendingCompletionTabTimer === null) return;
clearTimeout(pendingCompletionTabTimer);
pendingCompletionTabTimer = null;
}
function waitForCompletionTab(view: EditorViewType): boolean {
clearPendingCompletionTab();
const initialDoc = view.state.doc;
const initialSelectionRanges = view.state.selection.ranges.map((range) => ({ anchor: range.anchor, head: range.head }));
const startedAt = Date.now();
const retry = () => {
pendingCompletionTabTimer = null;
// The user started an IME composition while waiting for the pending
// completion; Tab now belongs to the candidate list, so drop the queued
// acceptance (and the normal-Tab fallback) instead of fighting the IME.
if (isEditorComposing(view)) return;
const selectionRanges = view.state.selection.ranges;
if (view.state.doc !== initialDoc || selectionRanges.length !== initialSelectionRanges.length || selectionRanges.some((range, index) => !range.empty || range.anchor !== initialSelectionRanges[index]?.anchor || range.head !== initialSelectionRanges[index]?.head)) return;
const completionStatus = codeMirrorRuntime.codeMirrorCompletionStatus?.(view.state) ?? null;
if (completionStatus === "active" && acceptSelectedOrFirstCompletion(view, codeMirrorRuntime.codeMirrorAcceptCompletion, codeMirrorRuntime.codeMirrorSelectedCompletionIndex, codeMirrorRuntime.codeMirrorSelectFirstCompletion)) return;
if (completionStatus && Date.now() - startedAt < COMPLETION_TAB_MAX_WAIT_MS) {
pendingCompletionTabTimer = setTimeout(retry, COMPLETION_TAB_RETRY_DELAY_MS);
return;
}
// A pending completion may resolve without any applicable option. Preserve
// snippet navigation first, then fall back to the editor's normal Tab action.
if (codeMirrorRuntime.codeMirrorNextSnippetField?.(view)) return;
performNormalTab(view);
};
pendingCompletionTabTimer = setTimeout(retry, COMPLETION_TAB_RETRY_DELAY_MS);
return true;
}
return { editorIndentUnit, handleTab, handleEnter, acceptCompletionOrNextSnippetField, acceptSqlServerCompletionOnSpace, clearPendingCompletionEnter, clearPendingCompletionTab };
}