@adecore/editor-react 0.31.12 → 0.32.0

package/dist/format-on-type.js

@@ -6,8 +6,8 @@ const LINE_BREAK = /^\r?\n[ \t]*(\r?\n[ \t]*)?$/;
 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) {
-    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);
+  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
@@ -23,73 +23,92 @@ function overlaps(edits) {
  * The edits join the undo step of the typed character, so one undo takes both back. Off by default; a host enables it explicitly with `configure(true)`.
  */
 export class FormatOnTypeFeature {
-    language;
-    enabled = false;
-    /* Raised by every change of the text, so an answer for an older text is told from the one for the text that is. */
-    revision = 0;
-    controller = new AbortController();
-    constructor(language) {
-        this.language = language;
-        const off = language.editor.onTextChange((change) => this.typed(change));
-        language.onDispose(() => {
-            off();
-            this.controller.abort();
-        });
+  language;
+  enabled = false;
+  /* Raised by every change of the text, so an answer for an older text is told from the one for the text that is. */
+  revision = 0;
+  controller = new AbortController();
+  constructor(language) {
+    this.language = language;
+    const off = language.editor.onTextChange(change => this.typed(change));
+    language.onDispose(() => {
+      off();
+      this.controller.abort();
+    });
+  }
+  get isEnabled() {
+    return this.enabled;
+  }
+  /* Whether the server of this document formats on type and the service can ask it. */
+  get supported() {
+    const {
+      project,
+      uri
+    } = this.language;
+    return project.service.onTypeFormatting !== undefined && project.service.supports(METHOD, uri);
+  }
+  configure(enabled) {
+    this.enabled = enabled;
+    if (!enabled) {
+      this.controller.abort();
     }
-    get isEnabled() {
-        return this.enabled;
+  }
+  /* The characters that ask the server, the first one and the more. */
+  triggerCharacters() {
+    const options = this.language.project.service.providerOptions(METHOD, this.language.uri);
+    return options === undefined ? [] : [...(options.firstTriggerCharacter === undefined ? [] : [options.firstTriggerCharacter]), ...(options.moreTriggerCharacter ?? [])];
+  }
+  typed(change) {
+    const revision = ++this.revision;
+    this.controller.abort();
+    if (!this.enabled || change.source !== 'input' && change.typed !== true || change.changes.length !== 1 || !this.supported) {
+      return;
     }
-    /* Whether the server of this document formats on type and the service can ask it. */
-    get supported() {
-        const { project, uri } = this.language;
-        return project.service.onTypeFormatting !== undefined && project.service.supports(METHOD, uri);
+    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;
     }
-    configure(enabled) {
-        this.enabled = enabled;
-        if (!enabled) {
-            this.controller.abort();
-        }
+    if (snippets.isActive || editor.isReadOnly?.() === true || editor.getSelections().length !== 1) {
+      return;
     }
-    /* The characters that ask the server, the first one and the more. */
-    triggerCharacters() {
-        const options = this.language.project.service.providerOptions(METHOD, this.language.uri);
-        return options === undefined
-            ? []
-            : [...(options.firstTriggerCharacter === undefined ? [] : [options.firstTriggerCharacter]), ...(options.moreTriggerCharacter ?? [])];
+    this.controller = new AbortController();
+    void this.ask(revision, typed, editor.getCaret(), this.controller.signal);
+  }
+  async ask(revision, typed, caret, signal) {
+    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.
     }
-    typed(change) {
-        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);
-    }
-    async ask(revision, typed, caret, signal) {
-        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/dist/highlight-layers.js

@@ -4,27 +4,26 @@
  * another's from before an edit.
  */
 export class HighlightLayers {
-    editor;
-    owners = new Map();
-    constructor(editor) {
-        this.editor = editor;
-    }
-    set(owner, provider) {
-        if (provider === null) {
-            this.owners.delete(owner);
-        }
-        else {
-            this.owners.set(owner, provider);
-        }
-        this.editor.setLineHighlights([...this.owners.values()].flatMap((read) => read()));
+  editor;
+  owners = new Map();
+  constructor(editor) {
+    this.editor = editor;
+  }
+  set(owner, provider) {
+    if (provider === null) {
+      this.owners.delete(owner);
+    } else {
+      this.owners.set(owner, provider);
     }
+    this.editor.setLineHighlights([...this.owners.values()].flatMap(read => read()));
+  }
 }
 const layers = new WeakMap();
 export function highlightLayers(editor) {
-    let found = layers.get(editor);
-    if (found === undefined) {
-        found = new HighlightLayers(editor);
-        layers.set(editor, found);
-    }
-    return found;
-}
+  let found = layers.get(editor);
+  if (found === undefined) {
+    found = new HighlightLayers(editor);
+    layers.set(editor, found);
+  }
+  return found;
+}

package/dist/highlights.js

@@ -6,98 +6,120 @@ import { isShortcut } from './shortcut-keys.js';
 import { realTimers } from './timers.js';
 const METHOD = 'textDocument/documentHighlight';
 const PAUSE_MS = 150;
-const KINDS = { 1: 'text', 2: 'read', 3: 'write' };
+const KINDS = {
+  1: 'text',
+  2: 'read',
+  3: 'write'
+};
 export function editorHighlightsOf(highlights) {
-    return highlights
-        .filter((highlight) => comparePositions(highlight.range.start, highlight.range.end) < 0)
-        .map((highlight) => ({ range: highlight.range, kind: KINDS[highlight.kind ?? 1] ?? 'text' }))
-        .sort((left, right) => comparePositions(left.range.start, right.range.start));
+  return highlights.filter(highlight => comparePositions(highlight.range.start, highlight.range.end) < 0).map(highlight => ({
+    range: highlight.range,
+    kind: KINDS[highlight.kind ?? 1] ?? 'text'
+  })).sort((left, right) => comparePositions(left.range.start, right.range.start));
 }
 /* The range before the caret when stepping back, or after it when stepping forward, wrapping round the document; null for no ranges. */
 export function neighborRange(ranges, from, direction) {
-    if (ranges.length === 0) {
-        return null;
-    }
-    const ordered = [...ranges].sort((left, right) => comparePositions(left.start, right.start));
-    if (direction === 1) {
-        return ordered.find((range) => comparePositions(range.start, from) > 0) ?? ordered[0];
-    }
-    return [...ordered].reverse().find((range) => comparePositions(range.start, from) < 0) ?? ordered[ordered.length - 1];
+  if (ranges.length === 0) {
+    return null;
+  }
+  const ordered = [...ranges].sort((left, right) => comparePositions(left.start, right.start));
+  if (direction === 1) {
+    return ordered.find(range => comparePositions(range.start, from) > 0) ?? ordered[0];
+  }
+  return [...ordered].reverse().find(range => comparePositions(range.start, from) < 0) ?? ordered[ordered.length - 1];
 }
 /*
  * The other uses of the name at the caret, drawn softly in the text, which the next and previous highlight
  * keys step through. They are asked for when the caret rests on a name and go with the next edit.
  */
 export class HighlightsFeature {
-    language;
-    refresher;
-    current = [];
-    constructor(language, timers = realTimers) {
-        this.language = language;
-        const { editor, project, uri } = language;
-        this.refresher = new Refresher(async (signal) => {
-            if (!project.service.supports(METHOD, uri) || !this.onName()) {
-                this.clear();
-                return;
-            }
-            const result = await project.service.documentHighlights(uri, editor.getCaret(), { signal });
-            if (!signal.aborted) {
-                this.set(result === null ? [] : editorHighlightsOf(result));
-            }
-        }, PAUSE_MS, timers);
-        const offs = [
-            editor.onCaret((position) => {
-                // Moving along the same name keeps its marks, which is what makes stepping through them quiet.
-                if (!this.current.some((highlight) => rangeHolds(highlight.range, position))) {
-                    this.clear();
-                }
-                this.refresher.later();
-            }),
-            editor.onTextChange(() => {
-                // The editor drops its marks with the edit; this follows, and asks again when the caret settles.
-                this.current = [];
-                this.refresher.later();
-            }),
-            language.onKey((event) => {
-                const next = isShortcut(this.language.shortcuts.nextHighlight, event);
-                if (!next && !isShortcut(this.language.shortcuts.previousHighlight, event)) {
-                    return false;
-                }
-                return this.step(next ? 1 : -1);
-            }, KEY_PRIORITY.highlights)
-        ];
-        language.onDispose(() => {
-            for (const off of offs) {
-                off();
-            }
-            this.refresher.dispose();
-            editor.setHighlights([]);
-        });
-    }
-    /* Puts the caret on the next use of the name, or the one before; false when there are none. */
-    step(direction) {
-        const { editor } = this.language;
-        const target = neighborRange(this.current.map((highlight) => highlight.range), editor.getCaret(), direction);
-        if (target === null) {
-            return false;
-        }
-        editor.setCaret(target.start, comparePositions(target.start, editor.getCaret()) > 0 ? 'centerDown' : 'centerUp');
-        return true;
+  language;
+  refresher;
+  current = [];
+  constructor(language, timers = realTimers) {
+    this.language = language;
+    const {
+      editor,
+      project,
+      uri
+    } = language;
+    this.refresher = new Refresher(async signal => {
+      if (!project.service.supports(METHOD, uri) || !this.onName()) {
+        this.clear();
+        return;
+      }
+      const result = await project.service.documentHighlights(uri, editor.getCaret(), {
+        signal
+      });
+      if (!signal.aborted) {
+        this.set(result === null ? [] : editorHighlightsOf(result));
+      }
+    }, PAUSE_MS, timers);
+    const offs = [editor.onCaret(position => {
+      // Moving along the same name keeps its marks, which is what makes stepping through them quiet.
+      if (!this.current.some(highlight => rangeHolds(highlight.range, position))) {
+        this.clear();
+      }
+      this.refresher.later();
+    }), editor.onTextChange(() => {
+      // The editor drops its marks with the edit; this follows, and asks again when the caret settles.
+      this.current = [];
+      this.refresher.later();
+    }), language.onKey(event => {
+      const next = isShortcut(this.language.shortcuts.nextHighlight, event);
+      if (!next && !isShortcut(this.language.shortcuts.previousHighlight, event)) {
+        return false;
+      }
+      return this.step(next ? 1 : -1);
+    }, KEY_PRIORITY.highlights)];
+    language.onDispose(() => {
+      for (const off of offs) {
+        off();
+      }
+      this.refresher.dispose();
+      editor.setHighlights([]);
+    });
+  }
+  /* Puts the caret on the next use of the name, or the one before; false when there are none. */
+  step(direction) {
+    const {
+      editor
+    } = this.language;
+    const target = neighborRange(this.current.map(highlight => highlight.range), editor.getCaret(), direction);
+    if (target === null) {
+      return false;
     }
-    onName() {
-        const { editor } = this.language;
-        const caret = editor.getCaret();
-        const before = caret.character > 0 ? editor.textInRange({ start: { line: caret.line, character: caret.character - 1 }, end: caret }) : '';
-        const after = editor.textInRange({ start: caret, end: { line: caret.line, character: caret.character + 1 } });
-        return (before !== '' && isIdentifierCharacter(before)) || (after !== '' && isIdentifierCharacter(after));
+    editor.setCaret(target.start, comparePositions(target.start, editor.getCaret()) > 0 ? 'centerDown' : 'centerUp');
+    return true;
+  }
+  onName() {
+    const {
+      editor
+    } = this.language;
+    const caret = editor.getCaret();
+    const before = caret.character > 0 ? editor.textInRange({
+      start: {
+        line: caret.line,
+        character: caret.character - 1
+      },
+      end: caret
+    }) : '';
+    const after = editor.textInRange({
+      start: caret,
+      end: {
+        line: caret.line,
+        character: caret.character + 1
+      }
+    });
+    return before !== '' && isIdentifierCharacter(before) || after !== '' && isIdentifierCharacter(after);
+  }
+  set(highlights) {
+    this.current = highlights;
+    this.language.editor.setHighlights(highlights);
+  }
+  clear() {
+    if (this.current.length > 0) {
+      this.set([]);
     }
-    set(highlights) {
-        this.current = highlights;
-        this.language.editor.setHighlights(highlights);
-    }
-    clear() {
-        if (this.current.length > 0) {
-            this.set([]);
-        }
-    }
-}
+  }
+}

package/dist/history.js

@@ -2,43 +2,49 @@ import { KEY_PRIORITY } from './key-priority.js';
 import { isShortcut } from './shortcut-keys.js';
 /* Back, Forward and the list of recent locations over the history the whole project shares. */
 export class HistoryFeature {
-    language;
-    constructor(language) {
-        this.language = language;
-        const off = language.onKey((event) => {
-            if (isShortcut(this.language.shortcuts.historyBack, event)) {
-                this.back();
-                return true;
-            }
-            if (isShortcut(this.language.shortcuts.historyForward, event)) {
-                this.forward();
-                return true;
-            }
-            if (isShortcut(this.language.shortcuts.recentLocations, event)) {
-                this.recent();
-                return true;
-            }
-            return false;
-        }, KEY_PRIORITY.history);
-        language.onDispose(off);
-    }
-    /* Returns to where the caret was before the last jump; false when there is no such place. */
-    back() {
-        return this.visit(this.language.project.history.back(this.language.place));
-    }
-    forward() {
-        return this.visit(this.language.project.history.forward(this.language.place));
-    }
-    /* Lists the places of the history under the caret; choosing one jumps there like any other jump. */
-    recent() {
-        const places = this.language.project.history.recent(this.language.place);
-        this.language.locations(places.map((place) => ({ uri: place.uri, range: { start: place.position, end: place.position } })), this.language.editor.getCaret(), this.language.project.i18n.t('editor:language.history.recent'));
-    }
-    visit(place) {
-        if (place === null) {
-            return false;
-        }
-        this.language.visit(place);
+  language;
+  constructor(language) {
+    this.language = language;
+    const off = language.onKey(event => {
+      if (isShortcut(this.language.shortcuts.historyBack, event)) {
+        this.back();
+        return true;
+      }
+      if (isShortcut(this.language.shortcuts.historyForward, event)) {
+        this.forward();
+        return true;
+      }
+      if (isShortcut(this.language.shortcuts.recentLocations, event)) {
+        this.recent();
         return true;
+      }
+      return false;
+    }, KEY_PRIORITY.history);
+    language.onDispose(off);
+  }
+  /* Returns to where the caret was before the last jump; false when there is no such place. */
+  back() {
+    return this.visit(this.language.project.history.back(this.language.place));
+  }
+  forward() {
+    return this.visit(this.language.project.history.forward(this.language.place));
+  }
+  /* Lists the places of the history under the caret; choosing one jumps there like any other jump. */
+  recent() {
+    const places = this.language.project.history.recent(this.language.place);
+    this.language.locations(places.map(place => ({
+      uri: place.uri,
+      range: {
+        start: place.position,
+        end: place.position
+      }
+    })), this.language.editor.getCaret(), this.language.project.i18n.t('editor:language.history.recent'));
+  }
+  visit(place) {
+    if (place === null) {
+      return false;
     }
-}
+    this.language.visit(place);
+    return true;
+  }
+}

package/dist/holder.js

@@ -1,20 +1,20 @@
 /* One value that an effect sets and a render reads through `useSyncExternalStore`, without a state update inside the effect. */
 export function createHolder() {
-    let value = null;
-    const listeners = new Set();
-    return {
-        get: () => value,
-        set: (next) => {
-            value = next;
-            for (const listener of [...listeners]) {
-                listener();
-            }
-        },
-        subscribe: (listener) => {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        }
-    };
-}
+  let value = null;
+  const listeners = new Set();
+  return {
+    get: () => value,
+    set: next => {
+      value = next;
+      for (const listener of [...listeners]) {
+        listener();
+      }
+    },
+    subscribe: listener => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}

package/dist/host-types.js

@@ -1 +1 @@
-export {};
+export {};