@adecore/editor-react 0.31.12 → 0.32.0

package/dist/signature.js

@@ -10,142 +10,190 @@ const PAUSE_MS = 60;
  * so the active parameter follows; the server answering nothing is the caret leaving the call.
  */
 export class SignatureFeature {
-    language;
-    timers;
-    timer;
-    request = 0;
-    controller = null;
-    help = null;
-    anchor = null;
-    constructor(language, timers = realTimers) {
-        this.language = language;
-        this.timers = timers;
-        const { editor } = language;
-        const offs = [
-            editor.onTextChange((change) => this.edited(change)),
-            editor.onCaret(() => this.retrigger()),
-            editor.onBlur(() => this.close()),
-            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();
-        });
-    }
-    get isOpen() {
-        return this.language.popups.getState().signature !== null;
+  language;
+  timers;
+  timer;
+  request = 0;
+  controller = null;
+  help = null;
+  anchor = null;
+  constructor(language, timers = realTimers) {
+    this.language = language;
+    this.timers = timers;
+    const {
+      editor
+    } = language;
+    const offs = [editor.onTextChange(change => this.edited(change)), editor.onCaret(() => this.retrigger()), editor.onBlur(() => this.close()), 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();
+    });
+  }
+  get isOpen() {
+    return this.language.popups.getState().signature !== null;
+  }
+  /* Asks for the parameters of the call at the caret, as its key does. */
+  invoke() {
+    this.ask({
+      triggerKind: 1,
+      isRetrigger: false
+    });
+  }
+  /* Asks for the parameters as if `(` had just been typed, which is what a call opened by a completion is. */
+  trigger() {
+    this.ask({
+      triggerKind: 2,
+      triggerCharacter: '(',
+      isRetrigger: false
+    });
+  }
+  /* Shows the next or previous overload; false when the card has fewer than two, which leaves the arrow to the caret. */
+  cycle(step) {
+    const {
+      help
+    } = this;
+    if (help === null || help.signatures.length < 2 || !this.isOpen) {
+      return false;
     }
-    /* Asks for the parameters of the call at the caret, as its key does. */
-    invoke() {
-        this.ask({ triggerKind: 1, isRetrigger: 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;
     }
-    /* Asks for the parameters as if `(` had just been typed, which is what a call opened by a completion is. */
-    trigger() {
-        this.ask({ triggerKind: 2, triggerCharacter: '(', isRetrigger: false });
+    this.help = next;
+    this.language.popups.setState({
+      signature: {
+        anchor: this.anchor,
+        model
+      }
+    });
+    return true;
+  }
+  close() {
+    this.request++;
+    this.controller?.abort();
+    this.timers.clear(this.timer);
+    this.help = null;
+    this.anchor = null;
+    if (this.isOpen) {
+      this.language.popups.setState({
+        signature: null
+      });
     }
-    /* Shows the next or previous overload; false when the card has fewer than two, which leaves the arrow to the caret. */
-    cycle(step) {
-        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;
+  }
+  options() {
+    const {
+      project,
+      uri
+    } = this.language;
+    const options = project.service.providerOptions(METHOD, uri);
+    return options === undefined ? null : {
+      triggers: options.triggerCharacters ?? [],
+      retriggers: options.retriggerCharacters ?? []
+    };
+  }
+  edited(change) {
+    const options = this.options();
+    if (change.source !== 'input' || options === null) {
+      this.close();
+      return;
     }
-    close() {
-        this.request++;
-        this.controller?.abort();
-        this.timers.clear(this.timer);
-        this.help = null;
-        this.anchor = null;
-        if (this.isOpen) {
-            this.language.popups.setState({ signature: null });
-        }
+    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) {
+      this.ask({
+        triggerKind: text.length === 1 && options.retriggers.includes(last) ? 2 : 3,
+        ...(options.retriggers.includes(last) ? {
+          triggerCharacter: last
+        } : {}),
+        isRetrigger: true
+      });
     }
-    options() {
-        const { project, uri } = this.language;
-        const options = project.service.providerOptions(METHOD, uri);
-        return options === undefined ? null : { triggers: options.triggerCharacters ?? [], retriggers: options.retriggerCharacters ?? [] };
+  }
+  retrigger() {
+    if (this.isOpen) {
+      this.ask({
+        triggerKind: 3,
+        isRetrigger: true
+      });
     }
-    edited(change) {
-        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) {
-            this.ask({
-                triggerKind: text.length === 1 && options.retriggers.includes(last) ? 2 : 3,
-                ...(options.retriggers.includes(last) ? { triggerCharacter: last } : {}),
-                isRetrigger: true
-            });
-        }
+  }
+  ask(context) {
+    const {
+      project,
+      uri
+    } = this.language;
+    if (!project.service.supports(METHOD, uri)) {
+      return;
     }
-    retrigger() {
-        if (this.isOpen) {
-            this.ask({ triggerKind: 3, isRetrigger: true });
-        }
+    this.timers.clear(this.timer);
+    const request = ++this.request;
+    const full = {
+      ...context,
+      ...(this.help === null ? {} : {
+        activeSignatureHelp: this.help
+      })
+    };
+    this.timer = this.timers.set(() => void this.fetch(full, request), PAUSE_MS);
+  }
+  async fetch(context, request) {
+    const {
+      editor,
+      project,
+      uri
+    } = this.language;
+    const caret = editor.getCaret();
+    this.controller?.abort();
+    const controller = new AbortController();
+    this.controller = controller;
+    let help;
+    try {
+      help = await project.service.signatureHelp(uri, caret, context, {
+        signal: controller.signal
+      });
+    } catch {
+      return;
     }
-    ask(context) {
-        const { project, uri } = this.language;
-        if (!project.service.supports(METHOD, uri)) {
-            return;
-        }
-        this.timers.clear(this.timer);
-        const request = ++this.request;
-        const full = { ...context, ...(this.help === null ? {} : { activeSignatureHelp: this.help }) };
-        this.timer = this.timers.set(() => void this.fetch(full, request), PAUSE_MS);
+    if (request !== this.request) {
+      return;
     }
-    async fetch(context, request) {
-        const { editor, project, uri } = this.language;
-        const caret = editor.getCaret();
-        this.controller?.abort();
-        const controller = new AbortController();
-        this.controller = controller;
-        let help;
-        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 } });
+    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/dist/snippet-field-transforms.js

@@ -1,116 +1,128 @@
 import { comparePositions, shiftPosition } from './diagnostics-model.js';
 /* Navigation frames can pop before a worker replies; their tracked targets live independently. */
 export class SnippetFieldTransforms {
-    entries = new Set();
-    applying = null;
-    editor;
-    lease;
-    apply;
-    constructor(editor, lease, apply) {
-        this.editor = editor;
-        this.lease = lease;
-        this.apply = apply;
+  entries = new Set();
+  applying = null;
+  editor;
+  lease;
+  apply;
+  constructor(editor, lease, apply) {
+    this.editor = editor;
+    this.lease = lease;
+    this.apply = apply;
+  }
+  get pending() {
+    return this.entries.size > 0;
+  }
+  get ranges() {
+    return [...this.entries].reduce((sum, entry) => sum + entry.targets.length, 0);
+  }
+  async settle() {
+    await Promise.all([...this.entries].map(entry => entry.done));
+  }
+  enqueue(targets, current) {
+    if (targets.length === 0 || this.lease === null) {
+      return;
     }
-    get pending() {
-        return this.entries.size > 0;
+    let finish;
+    const done = new Promise(resolve => {
+      finish = resolve;
+    });
+    const entry = {
+      targets,
+      current,
+      done,
+      finish,
+      cancelled: false
+    };
+    this.entries.add(entry);
+    const jobs = [],
+      keys = new Map();
+    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 valid = () => !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, slots.map(slot => values[slot]));
+      } finally {
+        this.applying = null;
+      }
+    }).catch(() => {
+      /* Failed exits retain the raw field value without retrying. */
+    }).finally(() => {
+      this.entries.delete(entry);
+      finish();
+    });
+  }
+  prune() {
+    for (const entry of this.entries) {
+      if (!entry.current()) {
+        this.cancel(entry);
+      }
     }
-    get ranges() {
-        return [...this.entries].reduce((sum, entry) => sum + entry.targets.length, 0);
+  }
+  clear() {
+    for (const entry of this.entries) {
+      this.cancel(entry);
     }
-    async settle() {
-        await Promise.all([...this.entries].map((entry) => entry.done));
-    }
-    enqueue(targets, current) {
-        if (targets.length === 0 || this.lease === null) {
-            return;
-        }
-        let finish;
-        const done = new Promise((resolve) => {
-            finish = resolve;
-        });
-        const entry = { targets, current, done, finish, cancelled: false };
-        this.entries.add(entry);
-        const jobs = [], keys = new Map();
-        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 valid = () => !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, slots.map((slot) => values[slot]));
-            }
-            finally {
-                this.applying = null;
-            }
-        })
-            .catch(() => {
-            /* Failed exits retain the raw field value without retrying. */
-        })
-            .finally(() => {
-            this.entries.delete(entry);
-            finish();
-        });
-    }
-    prune() {
-        for (const entry of this.entries) {
-            if (!entry.current()) {
-                this.cancel(entry);
-            }
-        }
-    }
-    clear() {
-        for (const entry of this.entries) {
+  }
+  cancel(entry) {
+    entry.cancelled = true;
+    this.entries.delete(entry);
+    entry.finish();
+  }
+  edited(changes, detached) {
+    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 : comparePositions(start, change.range.start) < 0 && comparePositions(change.range.start, end) < 0 : 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);
         }
-    }
-    cancel(entry) {
-        entry.cancelled = true;
-        this.entries.delete(entry);
-        entry.finish();
-    }
-    edited(changes, detached) {
-        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
-                            : comparePositions(start, change.range.start) < 0 && comparePositions(change.range.start, end) < 0
-                        : 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;
-                }
-            }
+        target.range = detached === undefined ? {
+          start,
+          end
+        } : detached({
+          ...target.range,
+          order: target.order
+        });
+        if (entry.cancelled) {
+          break;
         }
+      }
     }
-}
+  }
+}

package/dist/snippet-indent.js

@@ -2,48 +2,53 @@ import { snippetOrderOf, withSnippetOrder } from './snippet-range-order.js';
 import { MAX_SNIPPET_TEXT } from './snippet.js';
 /* Indentation edits map the offsets once, including child projections in copied parents. */
 export function indentSnippet(parsed, before) {
-    const prefix = /^[\t ]*/.exec(before)?.[0] ?? '';
-    if (prefix === '' || !parsed.text.includes('\n')) {
-        return parsed;
-    }
-    const insertions = [];
-    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, after = true) => {
-        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) => withSnippetOrder({
-        ...range,
-        start: shift(range.start),
-        end: shift(range.end, range.start === range.end || range.tail === true)
-    }, snippetOrderOf(range));
+  const prefix = /^[\t ]*/.exec(before)?.[0] ?? '';
+  if (prefix === '' || !parsed.text.includes('\n')) {
+    return parsed;
+  }
+  const insertions = [];
+  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.replace(/\n/g, '\n' + prefix),
-        stops: parsed.stops.map((stop) => range(stop)),
-        ...(parsed.transforms === undefined ? {} : { transforms: parsed.transforms.map((transform) => range(transform)) }),
-        ...(parsed.fields === undefined
-            ? {}
-            : {
-                fields: parsed.fields.map((field) => ({
-                    ...field,
-                    ranges: field.ranges.map((child) => range(child)),
-                    ...(field.linked === undefined ? {} : { linked: field.linked.map((child) => range(child)) })
-                }))
-            })
+      text: parsed.text,
+      stops: [],
+      limited: true
     };
-}
+  }
+  const shift = (offset, after = true) => {
+    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 => withSnippetOrder({
+    ...range,
+    start: shift(range.start),
+    end: shift(range.end, range.start === range.end || range.tail === true)
+  }, snippetOrderOf(range));
+  return {
+    text: parsed.text.replace(/\n/g, '\n' + prefix),
+    stops: parsed.stops.map(stop => range(stop)),
+    ...(parsed.transforms === undefined ? {} : {
+      transforms: parsed.transforms.map(transform => range(transform))
+    }),
+    ...(parsed.fields === undefined ? {} : {
+      fields: parsed.fields.map(field => ({
+        ...field,
+        ranges: field.ranges.map(child => range(child)),
+        ...(field.linked === undefined ? {} : {
+          linked: field.linked.map(child => range(child))
+        })
+      }))
+    })
+  };
+}