@adecore/editor-react 0.39.0 → 0.40.1

package/src/semantic-tokens.ts

@@ -16,6 +16,7 @@ const SCROLL_PAUSE_MS = 100;
 
 /* A document with more lines or characters than this is first asked for what is in view, when the server answers ranges. */
 export const DEFAULT_RANGE_LINES = 5000;
+
 export const DEFAULT_RANGE_CHARACTERS = 500_000;
 
 /* What decides when a document is too large to wait for in full. */
@@ -45,10 +46,13 @@ export class SemanticTokensFeature {
     private readonly options: SemanticTokensOptions;
     private held: Held | null = null;
     private heldLegend = '';
+
     /* True once the whole document is drawn from a full answer; a range answer then no longer paints. */
     private complete = false;
+
     /* The lines a range answer drew, null when nothing of that kind is on screen. */
     private covered: EditorRange | null = null;
+
     private drawn: EditorSemanticToken[] = [];
     private epoch = 0;
 
@@ -58,22 +62,26 @@ export class SemanticTokensFeature {
         this.options = options;
         this.refresher = new Refresher((signal) => this.refresh(signal), PAUSE_MS, timers);
         this.scrolled = new Refresher((signal) => this.fillViewport(signal), SCROLL_PAUSE_MS, timers);
+
         const edits = editor.onTextChange(() => {
             this.epoch++;
             this.covered = null;
             this.refresher.later();
         });
+
         const view = editor.onViewChange(() => {
             if (!this.complete && this.covered !== null && !covers(this.covered, editor.getVisibleRange())) {
                 this.scrolled.later();
             }
         });
+
         const providers = language.onProvidersChanged(() => {
             this.epoch++;
             this.scrolled.cancel();
             this.forget();
             this.refresher.now();
         });
+
         language.onDispose(() => {
             edits();
             view();
@@ -97,16 +105,19 @@ export class SemanticTokensFeature {
         const { uri } = this.language;
         const legend = (service.providerOptions(FULL, uri) ?? service.providerOptions(RANGE, uri))?.legend;
         const key = legend === undefined ? '' : JSON.stringify(legend);
+
         if (key !== this.heldLegend) {
             this.heldLegend = key;
             this.forget();
         }
+
         return legend;
     }
 
     private isLarge(): boolean {
         const { editor } = this.language;
         const end = editor.positionAt(Number.MAX_SAFE_INTEGER);
+
         return (
             end.line + 1 > (this.options.rangeLines ?? DEFAULT_RANGE_LINES) || editor.offsetAt(end) > (this.options.rangeCharacters ?? DEFAULT_RANGE_CHARACTERS)
         );
@@ -114,6 +125,7 @@ export class SemanticTokensFeature {
 
     private viewport(): EditorRange {
         const { editor } = this.language;
+
         return withMargin(editor.getVisibleRange(), editor.positionAt(Number.MAX_SAFE_INTEGER), (line) => ({
             line,
             character: lineTextOf(editor, line).length
@@ -126,20 +138,26 @@ export class SemanticTokensFeature {
         const legend = this.legend();
         const full = service.supports(FULL, uri);
         const range = service.supports(RANGE, uri);
+
         if (legend === undefined || (!full && !range)) {
             return;
         }
+
         if (!full || (range && !this.complete && this.held === null && this.isLarge())) {
             await this.askRange(this.viewport(), legend, signal, true);
+
             if (!full) {
                 return;
             }
         }
+
         const epoch = this.epoch;
         const tokens = await this.askFull(signal);
+
         if (signal.aborted || epoch !== this.epoch) {
             return;
         }
+
         this.complete = tokens !== null;
         this.covered = null;
         this.drawn = [];
@@ -151,27 +169,36 @@ export class SemanticTokensFeature {
         const { service } = this.language.project;
         const { uri } = this.language;
         const base = this.held;
+
         if (base !== null && service.supports(DELTA, uri)) {
             const answer = await service.semanticTokensDelta(uri, base.resultId, { signal }).catch((error: unknown) => {
                 if (signal.aborted || error instanceof StaleResultError) {
                     throw error;
                 }
+
                 // A server that no longer knows our result id is asked in full instead, once.
                 return null;
             });
+
             signal.throwIfAborted();
+
             if (answer !== null && this.held === base) {
                 const tokens = this.fromDelta(base, answer);
+
                 if (tokens !== null) {
                     this.hold(tokens);
+
                     return tokens;
                 }
             }
+
             this.held = null;
         }
+
         const tokens = await service.semanticTokens(uri, { signal });
         signal.throwIfAborted();
         this.hold(tokens);
+
         return tokens;
     }
 
@@ -180,7 +207,9 @@ export class SemanticTokensFeature {
         if (!('edits' in answer)) {
             return answer;
         }
+
         const data = applySemanticEdits(base.data, answer.edits);
+
         return data === null ? null : { ...(answer.resultId === undefined ? {} : { resultId: answer.resultId }), data };
     }
 
@@ -195,22 +224,28 @@ export class SemanticTokensFeature {
         const epoch = this.epoch;
         const before = this.covered;
         const tokens = await service.semanticTokensRange(uri, range, { signal });
+
         if (signal.aborted || epoch !== this.epoch || this.complete) {
             return;
         }
+
         const decoded = tokens === null ? [] : decodeSemanticTokens(tokens, legend);
+
         if (fresh || before === null || range.start.line > before.end.line + 1 || range.end.line < before.start.line - 1) {
             this.covered = range;
             this.drawn = decoded;
         } else {
             const kept = this.drawn.filter((token) => token.line < range.start.line || token.line > range.end.line);
             this.drawn = [...kept, ...decoded];
+
             this.covered = {
                 start: before.start.line < range.start.line ? before.start : range.start,
                 end: before.end.line > range.end.line ? before.end : range.end
             };
         }
+
         editor.setSemanticTokens(this.drawn);
+
         if (!this.complete && this.covered !== null && !covers(this.covered, editor.getVisibleRange())) {
             this.scrolled.later();
         }
@@ -219,9 +254,11 @@ export class SemanticTokensFeature {
     private async fillViewport(signal: AbortSignal): Promise<void> {
         const { service } = this.language.project;
         const legend = this.legend();
+
         if (legend === undefined || !service.supports(RANGE, this.language.uri) || this.complete) {
             return;
         }
+
         await this.askRange(this.viewport(), legend, signal, false);
     }
 }

package/src/shortcut-keys.ts

@@ -10,9 +10,11 @@ export function shortcutsOf(keymap: Keymap, apple: boolean) {
     const shortcuts = Object.fromEntries(
         KEYMAP_IDS.map((id) => {
             const text = chordOf(id, apple, keymap);
+
             return [id, text === null ? null : { ...parseChord(text), apple }];
         })
     ) as Record<keyof Keymap, LanguageShortcut | null>;
+
     return { ...shortcuts, rename: shortcuts.renameSymbol };
 }
 
@@ -21,5 +23,6 @@ export function isShortcut(target: LanguageShortcut | null, event: KeyboardEvent
     if (target === null || typesInsteadOfChord(event, target.apple)) {
         return false;
     }
+
     return matchesShortcut(target, event, target.apple);
 }

package/src/signature-model.ts

@@ -17,14 +17,19 @@ export interface SignatureViewModel {
 /* Where a parameter's label stands in the signature's: given as a pair of offsets, or as the text to find in it. */
 function parameterSpan(signature: SignatureInformation, index: number): { start: number; end: number } | null {
     const parameter = signature.parameters?.[index];
+
     if (parameter === undefined) {
         return null;
     }
+
     if (typeof parameter.label !== 'string') {
         const [start, end] = parameter.label;
+
         return start >= 0 && end <= signature.label.length && start < end ? { start, end } : null;
     }
+
     const start = signature.label.indexOf(parameter.label);
+
     return start < 0 ? null : { start, end: start + parameter.label.length };
 }
 
@@ -32,11 +37,13 @@ export function signatureViewOf(help: SignatureHelp | null): SignatureViewModel
     if (help === null || help.signatures.length === 0) {
         return null;
     }
+
     const index = Math.min(Math.max(0, help.activeSignature ?? 0), help.signatures.length - 1);
     const signature = help.signatures[index]!;
     const parameterIndex = signature.activeParameter ?? help.activeParameter ?? 0;
     const active = parameterSpan(signature, parameterIndex);
     const parameter = signature.parameters?.[parameterIndex];
+
     return {
         label: signature.label,
         active,

package/src/signature.ts

@@ -27,6 +27,7 @@ export class SignatureFeature {
         this.language = language;
         this.timers = timers;
         const { editor } = language;
+
         const offs = [
             editor.onTextChange((change) => this.edited(change)),
             editor.onCaret(() => this.retrigger()),
@@ -34,22 +35,29 @@ export class SignatureFeature {
             language.onKey((event) => {
                 if (event.key === 'Escape' && this.isOpen && this.language.popups.getState().callHierarchy === null) {
                     this.close();
+
                     return true;
                 }
+
                 if (isShortcut(this.language.shortcuts.parameterInfo, event)) {
                     this.invoke();
+
                     return true;
                 }
+
                 if ((event.key === 'ArrowUp' || event.key === 'ArrowDown') && !event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey) {
                     return this.cycle(event.key === 'ArrowDown' ? 1 : -1);
                 }
+
                 return false;
             }, KEY_PRIORITY.signature)
         ];
+
         language.onDispose(() => {
             for (const off of offs) {
                 off();
             }
+
             this.close();
         });
     }
@@ -71,17 +79,22 @@ export class SignatureFeature {
     /* Shows the next or previous overload; false when the card has fewer than two, which leaves the arrow to the caret. */
     private cycle(step: 1 | -1): boolean {
         const { help } = this;
+
         if (help === null || help.signatures.length < 2 || !this.isOpen) {
             return false;
         }
+
         const count = help.signatures.length;
         const next = { ...help, activeSignature: (Math.min(Math.max(0, help.activeSignature ?? 0), count - 1) + step + count) % count };
         const model = signatureViewOf(next);
+
         if (model === null || this.anchor === null) {
             return false;
         }
+
         this.help = next;
         this.language.popups.setState({ signature: { anchor: this.anchor, model } });
+
         return true;
     }
 
@@ -91,6 +104,7 @@ export class SignatureFeature {
         this.timers.clear(this.timer);
         this.help = null;
         this.anchor = null;
+
         if (this.isOpen) {
             this.language.popups.setState({ signature: null });
         }
@@ -99,17 +113,22 @@ export class SignatureFeature {
     private options(): { triggers: readonly string[]; retriggers: readonly string[] } | null {
         const { project, uri } = this.language;
         const options = project.service.providerOptions(METHOD, uri);
+
         return options === undefined ? null : { triggers: options.triggerCharacters ?? [], retriggers: options.retriggerCharacters ?? [] };
     }
 
     private edited(change: EditorTextChange): void {
         const options = this.options();
+
         if (change.source !== 'input' || options === null) {
             this.close();
+
             return;
         }
+
         const text = change.changes.length === 1 ? change.changes[0]!.text : '';
         const last = Array.from(text).at(-1) ?? '';
+
         if (text.length === 1 && options.triggers.includes(last)) {
             this.ask({ triggerKind: 2, triggerCharacter: last, isRetrigger: this.isOpen });
         } else if (this.isOpen) {
@@ -129,9 +148,11 @@ export class SignatureFeature {
 
     private ask(context: Omit<SignatureHelpContext, 'activeSignatureHelp'>): void {
         const { project, uri } = this.language;
+
         if (!project.service.supports(METHOD, uri)) {
             return;
         }
+
         this.timers.clear(this.timer);
         const request = ++this.request;
         const full: SignatureHelpContext = { ...context, ...(this.help === null ? {} : { activeSignatureHelp: this.help }) };
@@ -145,19 +166,25 @@ export class SignatureFeature {
         const controller = new AbortController();
         this.controller = controller;
         let help: SignatureHelp | null;
+
         try {
             help = await project.service.signatureHelp(uri, caret, context, { signal: controller.signal });
         } catch {
             return;
         }
+
         if (request !== this.request) {
             return;
         }
+
         const model = signatureViewOf(help);
+
         if (model === null) {
             this.close();
+
             return;
         }
+
         this.help = help;
         this.anchor ??= caret;
         this.language.popups.setState({ signature: { anchor: this.anchor, model } });

package/src/snippet-field-transforms.ts

@@ -15,6 +15,28 @@ export interface FieldTransformTarget {
     readonly order: readonly number[];
     readonly ancestors?: readonly symbol[];
 }
+
+/* Each distinct job once, so a transform that several ranges share is computed once; `slotOf` is its index in `jobs`. */
+export function jobTable(): { readonly jobs: SnippetTransformJob[]; readonly slotOf: (job: SnippetTransformJob) => number } {
+    const jobs: SnippetTransformJob[] = [];
+    const keys = new Map<string, number>();
+
+    const slotOf = (job: SnippetTransformJob): number => {
+        const key = JSON.stringify(job);
+        let slot = keys.get(key);
+
+        if (slot === undefined) {
+            slot = jobs.length;
+            keys.set(key, slot);
+            jobs.push(job);
+        }
+
+        return slot;
+    };
+
+    return { jobs, slotOf };
+}
+
 interface Entry {
     readonly targets: FieldTransformTarget[];
     readonly current: () => boolean;
@@ -30,51 +52,52 @@ export class SnippetFieldTransforms {
     private readonly editor: Editor;
     private readonly lease: SnippetTransformLease | null;
     private readonly apply: (targets: readonly FieldTransformTarget[], values: readonly string[]) => void;
+
     constructor(editor: Editor, lease: SnippetTransformLease | null, apply: (targets: readonly FieldTransformTarget[], values: readonly string[]) => void) {
         this.editor = editor;
         this.lease = lease;
         this.apply = apply;
     }
+
     get pending(): boolean {
         return this.entries.size > 0;
     }
+
     get ranges(): number {
         return [...this.entries].reduce((sum, entry) => sum + entry.targets.length, 0);
     }
+
     async settle(): Promise<void> {
         await Promise.all([...this.entries].map((entry) => entry.done));
     }
+
     enqueue(targets: FieldTransformTarget[], current: () => boolean): void {
         if (targets.length === 0 || this.lease === null) {
             return;
         }
+
         let finish!: () => void;
+
         const done = new Promise<void>((resolve) => {
             finish = resolve;
         });
+
         const entry: Entry = { targets, current, done, finish, cancelled: false };
         this.entries.add(entry);
-        const jobs: SnippetTransformJob[] = [],
-            keys = new Map<string, number>();
-        const slots = targets.map((target) => {
-            const job = { ...target.transform, value: target.value },
-                key = JSON.stringify(job);
-            let slot = keys.get(key);
-            if (slot === undefined) {
-                slot = jobs.length;
-                keys.set(key, slot);
-                jobs.push(job);
-            }
-            return slot;
-        });
+        const { jobs, slotOf } = jobTable();
+        const slots = targets.map((target) => slotOf({ ...target.transform, value: target.value }));
+
         const valid = (): boolean => !entry.cancelled && entry.current() && targets.every((target) => this.editor.textInRange(target.range) === target.value);
+
         void this.lease
             .request(jobs, { kind: 'exit', current: valid })
             .then((values) => {
                 if (!valid()) {
                     return;
                 }
+
                 this.applying = entry;
+
                 try {
                     this.apply(
                         targets,
@@ -92,6 +115,7 @@ export class SnippetFieldTransforms {
                 finish();
             });
     }
+
     prune(): void {
         for (const entry of this.entries) {
             if (!entry.current()) {
@@ -99,26 +123,32 @@ export class SnippetFieldTransforms {
             }
         }
     }
+
     clear(): void {
         for (const entry of this.entries) {
             this.cancel(entry);
         }
     }
+
     private cancel(entry: Entry): void {
         entry.cancelled = true;
         this.entries.delete(entry);
         entry.finish();
     }
+
     edited(changes: readonly EditorContentChange[], detached?: <Range extends EditorRange>(range: Range) => Range): void {
         for (const entry of this.entries) {
             if (entry === this.applying) {
                 continue;
             }
+
             for (const target of entry.targets) {
                 let { start, end } = target.range;
+
                 for (const change of changes) {
                     const empty = comparePositions(start, end) === 0;
                     const insert = comparePositions(change.range.start, change.range.end) === 0;
+
                     const overlaps = insert
                         ? empty
                             ? comparePositions(start, change.range.start) === 0
@@ -126,15 +156,20 @@ export class SnippetFieldTransforms {
                         : empty
                           ? comparePositions(change.range.start, start) <= 0 && comparePositions(start, change.range.end) < 0
                           : comparePositions(change.range.start, end) < 0 && comparePositions(start, change.range.end) < 0;
+
                     if (overlaps && !(detached !== undefined && empty && insert)) {
                         this.cancel(entry);
+
                         break;
                     }
+
                     const insertAtEnd = insert && !empty && comparePositions(end, change.range.start) === 0;
                     start = shiftPosition(start, change);
                     end = insertAtEnd ? end : shiftPosition(end, change);
                 }
+
                 target.range = detached === undefined ? { start, end } : detached({ ...target.range, order: target.order });
+
                 if (entry.cancelled) {
                     break;
                 }

package/src/snippet-indent.ts

@@ -4,29 +4,38 @@ import { MAX_SNIPPET_TEXT, type ParsedSnippet, type SnippetRange } from './snipp
 /* Indentation edits map the offsets once, including child projections in copied parents. */
 export function indentSnippet(parsed: ParsedSnippet, before: string): ParsedSnippet {
     const prefix = /^[\t ]*/.exec(before)?.[0] ?? '';
+
     if (prefix === '' || !parsed.text.includes('\n')) {
         return parsed;
     }
+
     const insertions: number[] = [];
+
     for (let offset = parsed.text.indexOf('\n'); offset !== -1; offset = parsed.text.indexOf('\n', offset + 1)) {
         insertions.push(offset + 1);
     }
+
     if (parsed.text.length + insertions.length * prefix.length > MAX_SNIPPET_TEXT) {
         return { text: parsed.text, stops: [], limited: true };
     }
+
     const shift = (offset: number, after = true): number => {
         let low = 0;
         let high = insertions.length;
+
         while (low < high) {
             const middle = (low + high) >>> 1;
+
             if (insertions[middle]! < offset || (after && insertions[middle] === offset)) {
                 low = middle + 1;
             } else {
                 high = middle;
             }
         }
+
         return offset + low * prefix.length;
     };
+
     const range = <Range extends SnippetRange>(range: Range): Range =>
         withSnippetOrder(
             {
@@ -36,6 +45,7 @@ export function indentSnippet(parsed: ParsedSnippet, before: string): ParsedSnip
             },
             snippetOrderOf(range)
         );
+
     return {
         text: parsed.text.replace(/\n/g, '\n' + prefix),
         stops: parsed.stops.map((stop) => range(stop)),

package/src/snippet-range-order.ts

@@ -1,19 +1,24 @@
 /* Source order disambiguates empty stops without changing the public parsed range shape. */
 const orders = new WeakMap<object, number>();
+
 export function snippetOrderOf(range: object): number | undefined {
     return orders.get(range);
 }
+
 export function withSnippetOrder<Range extends object>(range: Range, order: number | undefined): Range {
     if (order !== undefined) {
         orders.set(range, order);
     }
+
     return range;
 }
+
 export function compareSnippetOrder(left: readonly number[], right: readonly number[]): number {
     for (let index = 0; index < Math.min(left.length, right.length); index++) {
         if (left[index] !== right[index]) {
             return left[index]! - right[index]!;
         }
     }
+
     return left.length - right.length;
 }