@adecore/editor-react 0.31.12 → 0.33.0

package/dist/proposal-model.js

@@ -1,48 +1,64 @@
 import { diffLines } from '@adecore/merge';
 import { replacedWords } from './word-diff.js';
 export function lineSpanOf(range) {
-    const endsOnBreak = range.end.character === 0 && range.end.line > range.start.line;
-    return { startLine: range.start.line + 1, endLine: endsOnBreak ? range.end.line : range.end.line + 1 };
+  const endsOnBreak = range.end.character === 0 && range.end.line > range.start.line;
+  return {
+    startLine: range.start.line + 1,
+    endLine: endsOnBreak ? range.end.line : range.end.line + 1
+  };
 }
 export function isEmptyRange(range) {
-    return range.start.line === range.end.line && range.start.character === range.end.character;
+  return range.start.line === range.end.line && range.start.character === range.end.character;
 }
 /* The selection, or the whole line under the caret while nothing is selected. */
 export function inlineRangeOf(selection, lineLength) {
-    if (!isEmptyRange(selection)) {
-        return selection;
+  if (!isEmptyRange(selection)) {
+    return selection;
+  }
+  const {
+    line
+  } = selection.start;
+  return {
+    start: {
+      line,
+      character: 0
+    },
+    end: {
+      line,
+      character: lineLength(line)
     }
-    const { line } = selection.start;
-    return { start: { line, character: 0 }, end: { line, character: lineLength(line) } };
+  };
 }
 export function problemsOnLines(diagnostics, span, describe) {
-    return diagnostics
-        .filter((diagnostic) => diagnostic.range.start.line + 1 <= span.endLine && diagnostic.range.end.line + 1 >= span.startLine)
-        .map((diagnostic) => ({ line: Math.max(diagnostic.range.start.line + 1, span.startLine), ...describe(diagnostic) }))
-        .sort((left, right) => left.line - right.line);
+  return diagnostics.filter(diagnostic => diagnostic.range.start.line + 1 <= span.endLine && diagnostic.range.end.line + 1 >= span.startLine).map(diagnostic => ({
+    line: Math.max(diagnostic.range.start.line + 1, span.startLine),
+    ...describe(diagnostic)
+  })).sort((left, right) => left.line - right.line);
 }
 const OPENING = /^( {0,3})(`{3,}|~{3,})(.*)$/;
 function openingOf(line) {
-    const match = OPENING.exec(line);
-    if (match === null) {
-        return null;
-    }
-    const [, indent = '', marks = '', info = ''] = match;
-    // The info string of a backtick fence holds no backtick, which is what keeps a line of inline code from opening one.
-    if (marks.startsWith('`') && info.includes('`')) {
-        return null;
-    }
-    return { char: marks[0], length: marks.length, indent: indent.length, info: info.trim() };
+  const match = OPENING.exec(line);
+  if (match === null) {
+    return null;
+  }
+  const [, indent = '', marks = '', info = ''] = match;
+  // The info string of a backtick fence holds no backtick, which is what keeps a line of inline code from opening one.
+  if (marks.startsWith('`') && info.includes('`')) {
+    return null;
+  }
+  return {
+    char: marks[0],
+    length: marks.length,
+    indent: indent.length,
+    info: info.trim()
+  };
 }
 function closes(line, start) {
-    const match = /^ {0,3}(`+|~+)\s*$/.exec(line);
-    return match !== null && match[1][0] === start.char && match[1].length >= start.length;
+  const match = /^ {0,3}(`+|~+)\s*$/.exec(line);
+  return match !== null && match[1][0] === start.char && match[1].length >= start.length;
 }
 function isReplacement(info) {
-    return info
-        .toLowerCase()
-        .split(/[\s,:=]+/)
-        .includes('replacement');
+  return info.toLowerCase().split(/[\s,:=]+/).includes('replacement');
 }
 /*
  * Reads the answer the way a markdown reader does: a fence closes at a line of at least as many marks,
@@ -50,53 +66,60 @@ function isReplacement(info) {
  * applying half of it would be worse than showing the answer as text, so it counts as no block.
  */
 export function parseAnswer(text) {
-    const lines = text.replace(/\r\n/g, '\n').split('\n');
-    let open = null;
-    let found = null;
-    for (const [index, line] of lines.entries()) {
-        if (open === null) {
-            const start = openingOf(line);
-            if (start !== null) {
-                open = { start, from: index, body: [] };
-            }
-            continue;
-        }
-        if (closes(line, open.start)) {
-            if (isReplacement(open.start.info)) {
-                found = { from: open.from, to: index, body: open.body };
-            }
-            open = null;
-            continue;
-        }
-        open.body.push(line.replace(new RegExp(`^ {0,${open.start.indent}}`), ''));
+  const lines = text.replace(/\r\n/g, '\n').split('\n');
+  let open = null;
+  let found = null;
+  for (const [index, line] of lines.entries()) {
+    if (open === null) {
+      const start = openingOf(line);
+      if (start !== null) {
+        open = {
+          start,
+          from: index,
+          body: []
+        };
+      }
+      continue;
     }
-    if (found === null) {
-        return { replacement: null, rest: text.trim() };
+    if (closes(line, open.start)) {
+      if (isReplacement(open.start.info)) {
+        found = {
+          from: open.from,
+          to: index,
+          body: open.body
+        };
+      }
+      open = null;
+      continue;
     }
+    open.body.push(line.replace(new RegExp(`^ {0,${open.start.indent}}`), ''));
+  }
+  if (found === null) {
     return {
-        replacement: found.body.join('\n'),
-        rest: [...lines.slice(0, found.from), ...lines.slice(found.to + 1)]
-            .join('\n')
-            .replace(/\n{3,}/g, '\n\n')
-            .trim()
+      replacement: null,
+      rest: text.trim()
     };
+  }
+  return {
+    replacement: found.body.join('\n'),
+    rest: [...lines.slice(0, found.from), ...lines.slice(found.to + 1)].join('\n').replace(/\n{3,}/g, '\n\n').trim()
+  };
 }
 /* The proposal in the shape of the text it replaces: its line breaks and whether it ends on one. */
 export function fitReplacement(selected, replacement) {
-    const breaks = selected.includes('\r\n') ? '\r\n' : '\n';
-    let fitted = replacement.replace(/\r\n/g, '\n');
-    const endsOnBreak = selected.endsWith('\n');
-    if (fitted !== '' && endsOnBreak && !fitted.endsWith('\n')) {
-        fitted += '\n';
-    }
-    else if (!endsOnBreak && fitted.endsWith('\n')) {
-        fitted = fitted.slice(0, -1);
-    }
-    return breaks === '\n' ? fitted : fitted.replace(/\n/g, breaks);
+  const breaks = selected.includes('\r\n') ? '\r\n' : '\n';
+  let fitted = replacement.replace(/\r\n/g, '\n');
+  const endsOnBreak = selected.endsWith('\n');
+  if (fitted !== '' && endsOnBreak && !fitted.endsWith('\n')) {
+    fitted += '\n';
+  } else if (!endsOnBreak && fitted.endsWith('\n')) {
+    fitted = fitted.slice(0, -1);
+  }
+  return breaks === '\n' ? fitted : fitted.replace(/\n/g, breaks);
 }
 function linesOf(text) {
-    const lines = text.replace(/\r\n/g, '\n').split('\n');
-    return lines.length > 1 && lines.at(-1) === '' ? lines.slice(0, -1) : lines;
+  const lines = text.replace(/\r\n/g, '\n').split('\n');
+  return lines.length > 1 && lines.at(-1) === '' ? lines.slice(0, -1) : lines;
 }
 /*
  * The proposal against the selection, line by line. Lines the proposal changes show as added, since
@@ -104,86 +127,100 @@ function linesOf(text) {
  * only removed ones, because nothing in the proposal would show them gone.
  */
 export function diffSegments(selected, proposal, startLine) {
-    const base = linesOf(selected);
-    const other = linesOf(proposal);
-    const segments = [];
-    let cursor = 0;
-    const same = (until) => {
-        if (until > cursor) {
-            segments.push({ kind: 'same', text: other.slice(cursor, until).join('\n'), firstLine: startLine + cursor });
-        }
-    };
-    for (const change of diffLines(base, other)) {
-        same(change.otherStart);
-        if (change.otherEnd > change.otherStart) {
-            segments.push({
-                kind: 'added',
-                text: other.slice(change.otherStart, change.otherEnd).join('\n'),
-                firstLine: startLine + change.otherStart,
-                ...(change.baseEnd > change.baseStart ? { replaces: base.slice(change.baseStart, change.baseEnd).join('\n') } : {})
-            });
-        }
-        else {
-            segments.push({ kind: 'removed', text: base.slice(change.baseStart, change.baseEnd).join('\n') });
-        }
-        cursor = change.otherEnd;
+  const base = linesOf(selected);
+  const other = linesOf(proposal);
+  const segments = [];
+  let cursor = 0;
+  const same = until => {
+    if (until > cursor) {
+      segments.push({
+        kind: 'same',
+        text: other.slice(cursor, until).join('\n'),
+        firstLine: startLine + cursor
+      });
+    }
+  };
+  for (const change of diffLines(base, other)) {
+    same(change.otherStart);
+    if (change.otherEnd > change.otherStart) {
+      segments.push({
+        kind: 'added',
+        text: other.slice(change.otherStart, change.otherEnd).join('\n'),
+        firstLine: startLine + change.otherStart,
+        ...(change.baseEnd > change.baseStart ? {
+          replaces: base.slice(change.baseStart, change.baseEnd).join('\n')
+        } : {})
+      });
+    } else {
+      segments.push({
+        kind: 'removed',
+        text: base.slice(change.baseStart, change.baseEnd).join('\n')
+      });
     }
-    same(other.length);
-    return segments;
+    cursor = change.otherEnd;
+  }
+  same(other.length);
+  return segments;
 }
 /* Per line of an added stretch, the character ranges of the words that differ from the line it replaces, for the stronger tint; undefined when none do. */
 export function emphasisOf(segment) {
-    if (segment.kind !== 'added' || segment.replaces === undefined) {
-        return undefined;
-    }
-    const ranges = replacedWords(linesOf(segment.text), linesOf(segment.replaces));
-    return ranges.some((line) => line.length > 0) ? ranges : undefined;
+  if (segment.kind !== 'added' || segment.replaces === undefined) {
+    return undefined;
+  }
+  const ranges = replacedWords(linesOf(segment.text), linesOf(segment.replaces));
+  return ranges.some(line => line.length > 0) ? ranges : undefined;
 }
 /* The offset of a position in a text whose lines end in `\n` or `\r\n`; null when the text is not that long. */
 export function offsetOf(text, position) {
-    let offset = 0;
-    for (let line = 0; line < position.line; line++) {
-        const end = text.indexOf('\n', offset);
-        if (end === -1) {
-            return null;
-        }
-        offset = end + 1;
+  let offset = 0;
+  for (let line = 0; line < position.line; line++) {
+    const end = text.indexOf('\n', offset);
+    if (end === -1) {
+      return null;
     }
-    const lineEnd = text.indexOf('\n', offset);
-    const length = (lineEnd === -1 ? text.length : lineEnd) - offset;
-    return position.character > length ? null : offset + position.character;
+    offset = end + 1;
+  }
+  const lineEnd = text.indexOf('\n', offset);
+  const length = (lineEnd === -1 ? text.length : lineEnd) - offset;
+  return position.character > length ? null : offset + position.character;
 }
 /* The text in a range of `text`, or null when the range is not in it. */
 export function textInRange(text, range) {
-    const from = offsetOf(text, range.start);
-    const to = offsetOf(text, range.end);
-    return from === null || to === null || to < from ? null : text.slice(from, to);
+  const from = offsetOf(text, range.start);
+  const to = offsetOf(text, range.end);
+  return from === null || to === null || to < from ? null : text.slice(from, to);
 }
 /* `text` with the range replaced; null when the range is not in it. */
 export function replaceRange(text, range, replacement) {
-    const from = offsetOf(text, range.start);
-    const to = offsetOf(text, range.end);
-    return from === null || to === null || to < from ? null : `${text.slice(0, from)}${replacement}${text.slice(to)}`;
+  const from = offsetOf(text, range.start);
+  const to = offsetOf(text, range.end);
+  return from === null || to === null || to < from ? null : `${text.slice(0, from)}${replacement}${text.slice(to)}`;
 }
 /*
  * Where `selected` stands in `text` now: its own range while it still holds, and otherwise the one
  * place it occurs when lines moved. Null when it is gone or ambiguous, which is a selection that changed.
  */
 export function locateSelection(text, range, selected) {
-    if (textInRange(text, range) === selected) {
-        return range;
-    }
-    if (selected === '') {
-        return null;
-    }
-    const first = text.indexOf(selected);
-    if (first === -1 || text.indexOf(selected, first + 1) !== -1) {
-        return null;
-    }
-    return { start: positionAt(text, first), end: positionAt(text, first + selected.length) };
+  if (textInRange(text, range) === selected) {
+    return range;
+  }
+  if (selected === '') {
+    return null;
+  }
+  const first = text.indexOf(selected);
+  if (first === -1 || text.indexOf(selected, first + 1) !== -1) {
+    return null;
+  }
+  return {
+    start: positionAt(text, first),
+    end: positionAt(text, first + selected.length)
+  };
 }
 function positionAt(text, offset) {
-    const before = text.slice(0, offset);
-    const line = before.split('\n').length - 1;
-    return { line, character: offset - (before.lastIndexOf('\n') + 1) };
-}
+  const before = text.slice(0, offset);
+  const line = before.split('\n').length - 1;
+  return {
+    line,
+    character: offset - (before.lastIndexOf('\n') + 1)
+  };
+}

package/dist/recent-choices.js

@@ -5,35 +5,35 @@ const LIMIT = 200;
  * memory only, one per language, and forgets the oldest choice past a few hundred.
  */
 export class RecentChoices {
-    order = new Map();
-    tick = 0;
-    /* An item is told by its label, its kind and where it comes from, so two `Property` of two namespaces are two choices. */
-    static keyOf(item) {
-        return `${item.label}\0${item.kind ?? ''}\0${qualifierOf(item)}`;
-    }
-    record(item) {
-        const key = RecentChoices.keyOf(item);
-        this.order.delete(key);
-        this.order.set(key, ++this.tick);
-        if (this.order.size > LIMIT) {
-            this.order.delete(this.order.keys().next().value);
-        }
-    }
-    /* Higher for a later choice, 0 for an item never chosen. */
-    recency(item) {
-        return this.order.get(RecentChoices.keyOf(item)) ?? 0;
+  order = new Map();
+  tick = 0;
+  /* An item is told by its label, its kind and where it comes from, so two `Property` of two namespaces are two choices. */
+  static keyOf(item) {
+    return `${item.label}\0${item.kind ?? ''}\0${qualifierOf(item)}`;
+  }
+  record(item) {
+    const key = RecentChoices.keyOf(item);
+    this.order.delete(key);
+    this.order.set(key, ++this.tick);
+    if (this.order.size > LIMIT) {
+      this.order.delete(this.order.keys().next().value);
     }
+  }
+  /* Higher for a later choice, 0 for an item never chosen. */
+  recency(item) {
+    return this.order.get(RecentChoices.keyOf(item)) ?? 0;
+  }
 }
 const stores = new Map();
 export function recentChoicesOf(languageId) {
-    let store = stores.get(languageId);
-    if (store === undefined) {
-        store = new RecentChoices();
-        stores.set(languageId, store);
-    }
-    return store;
+  let store = stores.get(languageId);
+  if (store === undefined) {
+    store = new RecentChoices();
+    stores.set(languageId, store);
+  }
+  return store;
 }
 /* For a test that must not hear the choices an earlier one made. */
 export function forgetRecentChoices() {
-    stores.clear();
-}
+  stores.clear();
+}

package/dist/refresher.js

@@ -5,56 +5,51 @@ import { realTimers } from './timers.js';
  * A newer ask aborts the one before it, and an answer for a text that moved on is dropped.
  */
 export class Refresher {
-    timer;
-    controller = null;
-    disposed = false;
-    timers;
-    delay;
-    run;
-    constructor(run, delay, timers = realTimers) {
-        this.run = run;
-        this.delay = delay;
-        this.timers = timers;
-    }
-    /* After a pause: every call starts the wait again. */
-    later() {
-        this.timers.clear(this.timer);
-        this.timer = this.timers.set(() => this.now(), this.delay);
-    }
-    now() {
-        if (this.disposed) {
-            return;
-        }
-        this.timers.clear(this.timer);
-        this.controller?.abort();
-        const controller = new AbortController();
-        this.controller = controller;
-        this.run(controller.signal).catch((error) => {
-            // A server that cannot answer yet is asked again when it says it can; a stale text is asked again by its own change.
-            if (!(error instanceof StaleResultError) && !controller.signal.aborted && !isQuiet(error)) {
-                console.warn('Language request failed', error);
-            }
-        });
-    }
-    /* Drops the wait and the ask in flight, and keeps the refresher usable. */
-    cancel() {
-        this.timers.clear(this.timer);
-        this.controller?.abort();
-    }
-    dispose() {
-        this.disposed = true;
-        this.timers.clear(this.timer);
-        this.controller?.abort();
+  timer;
+  controller = null;
+  disposed = false;
+  timers;
+  delay;
+  run;
+  constructor(run, delay, timers = realTimers) {
+    this.run = run;
+    this.delay = delay;
+    this.timers = timers;
+  }
+  /* After a pause: every call starts the wait again. */
+  later() {
+    this.timers.clear(this.timer);
+    this.timer = this.timers.set(() => this.now(), this.delay);
+  }
+  now() {
+    if (this.disposed) {
+      return;
     }
+    this.timers.clear(this.timer);
+    this.controller?.abort();
+    const controller = new AbortController();
+    this.controller = controller;
+    this.run(controller.signal).catch(error => {
+      // A server that cannot answer yet is asked again when it says it can; a stale text is asked again by its own change.
+      if (!(error instanceof StaleResultError) && !controller.signal.aborted && !isQuiet(error)) {
+        console.warn('Language request failed', error);
+      }
+    });
+  }
+  /* Drops the wait and the ask in flight, and keeps the refresher usable. */
+  cancel() {
+    this.timers.clear(this.timer);
+    this.controller?.abort();
+  }
+  dispose() {
+    this.disposed = true;
+    this.timers.clear(this.timer);
+    this.controller?.abort();
+  }
 }
-const QUIET_CODES = new Set([
-    ErrorCodes.ServerNotInitialized,
-    ErrorCodes.MethodNotFound,
-    ErrorCodes.RequestCancelled,
-    ErrorCodes.ContentModified
-]);
+const QUIET_CODES = new Set([ErrorCodes.ServerNotInitialized, ErrorCodes.MethodNotFound, ErrorCodes.RequestCancelled, ErrorCodes.ContentModified]);
 /* A server that is not up, does not offer the feature or was asked to stop is not worth a line in the console. */
 function isQuiet(error) {
-    const code = error?.code;
-    return code !== undefined && QUIET_CODES.has(code);
-}
+  const code = error?.code;
+  return code !== undefined && QUIET_CODES.has(code);
+}