Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -41,6 +41,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p

### Fixed

- `<CodeAutocompleteField />` keeps validation errors in sync during editing and autocomplete, and avoids spurious `onChange` calls for equivalent line endings during multiline reinitialization
- Fix misused menu roles in selection popups and overlays
- `<MultiSuggestField />`
- improve keyboard navigation, tag removal and focus handling
Expand Down
221 changes: 132 additions & 89 deletions src/components/AutoSuggestion/AutoSuggestion.tsx
Original file line number Diff line number Diff line change
@@ -1,7 +1,8 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import React, { useEffect, useMemo, useState } from "react";
import { Classes as BlueprintClassNames, PopupKind } from "@blueprintjs/core";
import { EditorView, Rect } from "@codemirror/view";
import { StateEffect, StateField } from "@codemirror/state";
import { Decoration, DecorationSet, EditorView, Rect } from "@codemirror/view";
import { debounce } from "lodash";

import { IntentTypes } from "../../common/Intent";
Expand Down Expand Up @@ -85,6 +86,37 @@ export interface CodeAutocompleteFieldValidationResult {
};
}

type ParseError = NonNullable<CodeAutocompleteFieldValidationResult["parseError"]>;

const setValidationUnderline = StateEffect.define<ParseError | undefined>();

const validationUnderline = StateField.define<DecorationSet>({
create: () => Decoration.none,
update(marks, transaction) {
const effect = transaction.effects.find((effect) => effect.is(setValidationUnderline));
if (!effect) {
return transaction.docChanged ? Decoration.none : marks;
}

const error = effect.value;
if (!error || !Number.isInteger(error.start) || !Number.isInteger(error.end)) {
return Decoration.none;
}
const end = Math.min(error.end, transaction.newDoc.length);
if (error.start < 0 || error.start >= end) {
return Decoration.none;
}

return Decoration.set(
Decoration.mark({
class: `${eccgui}-autosuggestion__text--highlighted-error`,
attributes: { title: error.message },
}).range(error.start, end),
);
},
provide: (field) => EditorView.decorations.from(field),
});

export interface CodeAutocompleteFieldProps {
/** Additional class name.
*/
Expand Down Expand Up @@ -169,6 +201,15 @@ interface RequestMetaData {
requestId: string | undefined;
}

interface ValidationRequest {
input: string;
}

interface ValidationResponse {
request: ValidationRequest;
result: CodeAutocompleteFieldValidationResult | undefined;
}

/**
* Input component that allows partial, fine-grained auto-completion, i.e. of sub-strings of the input string.
* This is comparable to a one line code editor.
Expand Down Expand Up @@ -209,12 +250,12 @@ export const CodeAutocompleteField = ({
const [suggestions, setSuggestions] = React.useState<CodeAutocompleteFieldSuggestionWithReplacementInfo[]>([]);
const [suggestionsPending, setSuggestionsPending] = React.useState(false);
const suggestionRequestData = React.useRef<RequestMetaData>({ requestId: undefined });
const [pathValidationPending, setPathValidationPending] = React.useState(false);
const validationRequestData = React.useRef<RequestMetaData>({ requestId: undefined });
const errorMarkers = React.useRef<any[]>([]);
const [validationResponse, setValidationResponse] = useState<CodeAutocompleteFieldValidationResult | undefined>(
undefined,
);
const [validationStatus, setValidationStatus] = useState<"idle" | "queued" | "checking">("idle");
const currentValidationRequest = React.useRef<ValidationRequest>();
const [validationResponse, setValidationResponse] = useState<ValidationResponse>();
const currentCheckInput = React.useRef(checkInput);
currentCheckInput.current = checkInput;
const validationEnabled = !!checkInput;
const [suggestionResponse, setSuggestionResponse] = useState<
CodeAutocompleteFieldPartialAutoCompleteResult | undefined
>(undefined);
Expand Down Expand Up @@ -279,24 +320,69 @@ export const CodeAutocompleteField = ({
}, [cm, shouldShowDropdown, suggestionsPending, suggestions.length, focusedIndex, suggestionListId]);
const selectedTextRanges = React.useRef<IRange[]>([]);

const pathIsValid = validationResponse?.valid ?? true;
const validationResult = validationEnabled ? validationResponse?.result : undefined;
const pathIsValid = validationResult?.valid ?? true;

React.useEffect(() => {
if (reInitOnInitialValueChange && initialValue != null && currentCm.current) {
dispatch({
changes: { from: 0, to: currentCm.current.state?.doc.length, insert: initialValue },
});
// Validate initial value change
checkValuePathValidity(initialValue);
const validateInput = useMemo(
() =>
debounce(async (request: ValidationRequest) => {
const validate = currentCheckInput.current;
if (!validate || currentValidationRequest.current !== request) return;

setValidationStatus("checking");
let result: CodeAutocompleteFieldValidationResult | undefined;
try {
result = await validate(request.input);
} catch {
result = undefined;
}

if (currentValidationRequest.current !== request) return;
setValidationResponse({ request, result });
setValidationStatus("idle");
}, validationRequestDelay),
[validationRequestDelay],
);

const queueValidation = React.useCallback(
(input: string) => {
if (!validationEnabled) return;

// Give each edit its own identity, including edits that restore previously validated text.
const request = { input };
currentValidationRequest.current = request;
setValidationStatus("queued");
validateInput(request);
},
[validateInput, validationEnabled],
);

useEffect(() => {
if (!validationEnabled) setValidationStatus("idle");
return () => {
currentValidationRequest.current = undefined;
validateInput.cancel();
};
}, [validateInput, validationEnabled]);

useEffect(() => {
if (!reInitOnInitialValueChange || !cm || initialValue == null) return;

const nextDoc = cm.state.toText(initialValue);
if (!cm.state.doc.eq(nextDoc)) {
cm.dispatch({ changes: { from: 0, to: cm.state.doc.length, insert: nextDoc } });
}
}, [initialValue, reInitOnInitialValueChange]);
}, [cm, initialValue, reInitOnInitialValueChange]);

React.useEffect(() => {
if (currentCm.current) {
// Validate initial value
checkValuePathValidity(initialValue);
useEffect(() => {
if (!cm) return;

const input = cm.state.doc.toString();
value.current = input;
if (currentValidationRequest.current?.input !== input) {
queueValidation(input);
}
}, [!!currentCm.current]);
}, [cm, queueValidation]);

const setCurrentIndex = (newIndex: number) => {
editorState.index = newIndex;
Expand All @@ -308,10 +394,6 @@ export const CodeAutocompleteField = ({
editorState.cm = cm;
}, [cm, editorState]);

const dispatch = (
typeof editorState?.cm?.dispatch === "function" ? editorState?.cm?.dispatch : () => {}
) as EditorView["dispatch"];

// Handle replacement highlighting
useEffect(() => {
if (highlightedElement && cm) {
Expand All @@ -335,36 +417,26 @@ export const CodeAutocompleteField = ({
return;
}, [highlightedElement, selectedTextRanges, cm]);

//handle linting
React.useEffect(() => {
const parseError = validationResponse?.parseError;
if (cm) {
const clearCurrentErrorMarker = () => {
if (errorMarkers.current.length) {
const [from, to] = errorMarkers.current;
removeMarkFromText({ view: cm, from, to });
errorMarkers.current = [];
}
};
if (parseError) {
const { message, start, end } = parseError;
clearCurrentErrorMarker();
const { from, to } = markText({
view: cm,
from: start,
to: end,
className: `${eccgui}-autosuggestion__text--highlighted-error`,
title: message,
});
errorMarkers.current = [from, to];
} else {
clearCurrentErrorMarker();
}
}
useEffect(() => {
if (!cm) return;

const hasUnderlineField = cm.state.field(validationUnderline, false) !== undefined;
if (!validationEnabled && !hasUnderlineField) return;

const request = validationResponse?.request;
const parseError =
request && request === currentValidationRequest.current && request.input === cm.state.doc.toString()
? validationResult?.parseError
: undefined;
const underline = setValidationUnderline.of(parseError);
cm.dispatch({
effects: hasUnderlineField ? underline : [StateEffect.appendConfig.of(validationUnderline), underline],
});
}, [cm, validationEnabled, validationResponse, validationResult]);

const isValid = validationResponse?.valid === undefined || validationResponse.valid;
onInputChecked?.(isValid);
}, [validationResponse?.valid, validationResponse?.parseError, cm, onInputChecked]);
useEffect(() => {
onInputChecked?.(pathIsValid);
}, [onInputChecked, pathIsValid, validationResult]);

/** generate suggestions and also populate the replacement indexes dict */
React.useEffect(() => {
Expand Down Expand Up @@ -416,36 +488,6 @@ export const CodeAutocompleteField = ({
}
}, []);

const asyncCheckInput = useMemo(
() => async (inputString: string) => {
if (
!checkInput ||
inputString !== value.current ||
validationRequestData.current.requestId === inputString
) {
return;
}
validationRequestData.current.requestId = inputString;
setPathValidationPending(true);
try {
const result: CodeAutocompleteFieldValidationResult | undefined = await checkInput(inputString);
setValidationResponse(result);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
} catch (e) {
setValidationResponse(undefined);
// TODO: Error handling
} finally {
setPathValidationPending(false);
}
},
[checkInput],
);

const checkValuePathValidity = useMemo(
() => debounce((inputString: string) => asyncCheckInput(inputString), validationRequestDelay),
[asyncCheckInput, validationRequestDelay],
);

const asyncHandleEditorInputChange = useMemo(
() => async (inputString: string, cursorPosition: number) => {
const requestId = `${inputString} ${cursorPosition}`;
Expand Down Expand Up @@ -490,11 +532,10 @@ export const CodeAutocompleteField = ({
const handleChange = React.useMemo(() => {
return (val: string) => {
value.current = val;
checkValuePathValidity.cancel();
checkValuePathValidity(value.current);
queueValidation(val);
onChange(val);
};
}, [onChange, checkValuePathValidity]);
}, [onChange, queueValidation]);

const handleCursorChange = (cursor: number, coords: Rect, scrollinfo: HTMLElement, view: EditorView) => {
//cursor here is offset from line 1, autosuggestion works with cursor per-line.
Expand Down Expand Up @@ -692,7 +733,7 @@ export const CodeAutocompleteField = ({
[],
);

const hasError = !!value.current && !pathIsValid && !pathValidationPending;
const hasError = !!value.current && !pathIsValid && validationStatus === "idle";
const effectiveIntent = hasError ? "danger" : intent;
const blueprintIntent =
effectiveIntent && !["info", "accent", "neutral"].includes(effectiveIntent) ? effectiveIntent : undefined;
Expand Down Expand Up @@ -804,7 +845,9 @@ export const CodeAutocompleteField = ({
<>
{label}
&nbsp;
{(pathValidationPending || suggestionsPending) && <Spinner size="tiny" position="inline" />}
{(validationStatus === "checking" || suggestionsPending) && (
<Spinner size="tiny" position="inline" />
)}
</>
),
}}
Expand Down
Loading
Loading