@adecore/editor-react 0.42.0 → 0.44.0

package/dist/linked-editing.js

@@ -0,0 +1,215 @@
+import { realTimers } from './timers.js';
+const METHOD = 'textDocument/linkedEditingRange';
+/* How long the caret rests before the ranges around it are asked. */
+const DELAY_MS = 100;
+/* The server's word pattern, anchored, or null when it gave none or one that does not compile. */
+export function wordPatternOf(ranges) {
+  if (ranges.wordPattern === undefined) {
+    return null;
+  }
+  try {
+    return new RegExp(`^(?:${ranges.wordPattern})$`, 'u');
+  } catch {
+    return null;
+  }
+}
+/*
+ * Ranges a server says are edited together, such as the names of a start tag and its end tag: a change inside
+ * one goes into every other, in the undo step of the key. The ranges are asked once the caret rests, and the link
+ * ends when an edit falls outside them, the text stops matching the server's word pattern, or there is more
+ * than one caret.
+ */
+export class LinkedEditingFeature {
+  language;
+  timers;
+  session = null;
+  timer = null;
+  controller = null;
+  revision = 0;
+  mirroring = false;
+  enabled = true;
+  constructor(language, timers = realTimers) {
+    this.language = language;
+    this.timers = timers;
+    const {
+      editor
+    } = language;
+    const offs = [editor.onTextChange(change => this.edited(change)), editor.onCaret(() => this.moved())];
+    language.onDispose(() => {
+      this.stop();
+      for (const off of offs) {
+        off();
+      }
+    });
+  }
+  get supported() {
+    const {
+      service
+    } = this.language;
+    return this.enabled && service.linkedEditingRanges !== undefined && service.supports(METHOD, this.language.uri);
+  }
+  /* Whether ranges are linked now. */
+  get isActive() {
+    return this.session !== null;
+  }
+  /* Off, nothing is linked; on unless false. */
+  configure(settings) {
+    this.enabled = settings.enabled !== false;
+    if (!this.enabled) {
+      this.stop();
+    }
+  }
+  stop() {
+    this.session = null;
+    this.timers.clear(this.timer);
+    this.controller?.abort();
+  }
+  caretOffset() {
+    const {
+      editor
+    } = this.language;
+    const selections = editor.getSelections();
+    if (selections.length !== 1) {
+      return null;
+    }
+    const {
+      start,
+      end
+    } = selections[0];
+    return start.line === end.line && start.character === end.character ? editor.offsetAt(start) : null;
+  }
+  moved() {
+    if (this.mirroring) {
+      return;
+    }
+    // The caret moves before the text change of the same key is told, so the session is checked once both are in.
+    queueMicrotask(() => {
+      const offset = this.caretOffset();
+      if (offset !== null && this.session?.spans.some(span => span.from <= offset && offset <= span.to)) {
+        return;
+      }
+      this.stop();
+      if (offset !== null && this.supported) {
+        this.timer = this.timers.set(() => void this.ask(offset), DELAY_MS);
+      }
+    });
+  }
+  async ask(offset) {
+    const {
+      editor,
+      service,
+      uri
+    } = this.language;
+    const revision = this.revision;
+    const controller = new AbortController();
+    this.controller = controller;
+    try {
+      const ranges = await service.linkedEditingRanges(uri, editor.positionAt(offset), {
+        signal: controller.signal
+      });
+      if (ranges === null || ranges.ranges.length < 2 || revision !== this.revision || this.caretOffset() !== offset) {
+        return;
+      }
+      this.session = {
+        spans: ranges.ranges.map(range => ({
+          from: editor.offsetAt(range.start),
+          to: editor.offsetAt(range.end)
+        })),
+        pattern: wordPatternOf(ranges)
+      };
+    } catch {
+      // No ranges is no link; the next rest of the caret asks again.
+    }
+  }
+  edited(change) {
+    const revision = ++this.revision;
+    const session = this.session;
+    if (this.mirroring || session === null) {
+      return;
+    }
+    const edit = change.changes[0];
+    if (change.source === 'external' || change.changes.length !== 1 || edit === undefined || edit.range.start.line !== edit.range.end.line) {
+      this.stop();
+      return;
+    }
+    const from = this.language.editor.offsetAt(edit.range.start);
+    const removed = edit.range.end.character - edit.range.start.character;
+    const own = session.spans.findIndex(span => span.from <= from && from + removed <= span.to);
+    if (own === -1) {
+      this.stop();
+      return;
+    }
+    const delta = edit.text.length - removed;
+    const edited = session.spans[own];
+    session.spans = session.spans.map((span, index) => index === own ? {
+      from: span.from,
+      to: span.to + delta
+    } : span.from > edited.from ? {
+      from: span.from + delta,
+      to: span.to + delta
+    } : span);
+    queueMicrotask(() => this.mirror(own, revision));
+  }
+  mirror(own, revision) {
+    const session = this.session;
+    if (session === null || revision !== this.revision) {
+      return;
+    }
+    const {
+      editor
+    } = this.language;
+    const text = editor.getText();
+    const source = session.spans[own];
+    const value = text.slice(source.from, source.to);
+    if (session.pattern !== null && value !== '' && !session.pattern.test(value)) {
+      this.stop();
+      return;
+    }
+    const others = session.spans.map((span, index) => ({
+      span,
+      index
+    })).filter(({
+      span,
+      index
+    }) => index !== own && text.slice(span.from, span.to) !== value);
+    if (others.length === 0) {
+      return;
+    }
+    this.mirroring = true;
+    try {
+      const applied = editor.applyEdits(others.map(({
+        span
+      }) => ({
+        range: {
+          start: editor.positionAt(span.from),
+          end: editor.positionAt(span.to)
+        },
+        text: value
+      })), {
+        mergeUndo: true
+      });
+      if (!applied) {
+        this.stop();
+        return;
+      }
+    } finally {
+      this.mirroring = false;
+    }
+    // Each replaced span moves every span after it by what its length changed.
+    const changed = others.map(({
+      span
+    }) => ({
+      at: span.from,
+      delta: value.length - (span.to - span.from)
+    })).sort((left, right) => left.at - right.at);
+    const shift = offset => offset + changed.filter(entry => entry.at < offset).reduce((total, entry) => total + entry.delta, 0);
+    session.spans = session.spans.map((span, index) => {
+      const from = shift(span.from);
+      const replaced = others.some(other => other.index === index);
+      return {
+        from,
+        to: replaced ? from + value.length : shift(span.to)
+      };
+    });
+  }
+}

package/dist/live-templates.d.ts

@@ -0,0 +1,16 @@
+import type { EditorLanguage } from './editor-language.ts';
+export declare class TemplatesFeature {
+    private readonly language;
+    private readonly postfix;
+    constructor(language: EditorLanguage);
+    expand(): boolean;
+    insert(): void;
+    saveSelection(): boolean;
+    private customKey;
+    private matchAtCarets;
+    private matchAt;
+    private expandAtCarets;
+    private run;
+    private rows;
+    private row;
+}

package/dist/live-templates.js

@@ -0,0 +1,289 @@
+import { identifierPrefix, isIdentifierCharacter } from './completion-model.js';
+import { comparePositions } from './diagnostics-model.js';
+import { KEY_PRIORITY } from './key-priority.js';
+import { textBeforeOf } from './line-text.js';
+import { isShortcut } from './shortcut-keys.js';
+import { PostfixFeature } from './postfix.js';
+import { bodyWithIndentUnit, dedentLines, indentUnitOf, insertSnippet } from './snippet-insert.js';
+import { escapeSnippetText } from './snippet.js';
+import { SNIPPET_KIND, sortAfterServer, templateApplies, templateContextAt } from './template-context.js';
+const TOAST_ID = 'language-templates';
+const IDENTIFIER_START = /[\p{L}_$]/u;
+/* Sorts the rows of a list of templates by group, then key. */
+function grouped(template) {
+  return `${template.group ?? template.languages[0]}\u0000${template.key}`;
+}
+/* A key that starts in the middle of a word is no key, unless it starts with a character no word has. */
+function startsInsideWord(before, index) {
+  return index > 0 && IDENTIFIER_START.test(before[index]) && isIdentifierCharacter(before[index - 1]);
+}
+/* The longest start of `key` that the text before the caret ends with, as a number of characters; 0 when none. */
+function prefixLength(key, before) {
+  for (let length = Math.min(key.length, before.length); length >= 1; length--) {
+    if (before.endsWith(key.slice(0, length)) && !startsInsideWord(before, before.length - length)) {
+      return length;
+    }
+  }
+  return 0;
+}
+/*
+ * Live templates: a key typed before the caret and Tab expands a snippet, Insert Live Template lists the ones that
+ * apply, and Save as Live Template hands a selection to the host. The templates come from the registry of the
+ * project. Tab comes after a running snippet and before Emmet, and a key that starts before an Emmet abbreviation
+ * wins over it, as in IntelliJ.
+ */
+export class TemplatesFeature {
+  language;
+  postfix;
+  constructor(language) {
+    this.language = language;
+    this.postfix = new PostfixFeature(language);
+    language.onDispose(language.onKey(event => {
+      if (event.key === 'Tab' && !event.shiftKey && !event.altKey && !event.ctrlKey && !event.metaKey && !event.isComposing) {
+        return this.expand();
+      }
+      if (isShortcut(language.shortcuts.insertLiveTemplate, event)) {
+        this.insert();
+        return true;
+      }
+      if (isShortcut(language.shortcuts.saveAsLiveTemplate, event)) {
+        this.saveSelection();
+        return true;
+      }
+      return false;
+    }, KEY_PRIORITY.templates));
+    language.onDispose(language.completion.addSource({
+      items: request => [...this.rows(request.position), ...this.postfix.rows(request.position)]
+    }));
+  }
+  /*
+   * Expands the template whose key ends at the caret, or lists them when several share the key. False where Tab has
+   * nothing to expand, and where the key is an Emmet abbreviation, which the markup feature expands on the same Tab.
+   */
+  expand() {
+    const {
+      editor,
+      completion
+    } = this.language;
+    const selections = editor.getSelections();
+    if (editor.isReadOnly?.() === true || selections.some(selection => comparePositions(selection.start, selection.end) !== 0)) {
+      return false;
+    }
+    const match = this.matchAtCarets(selections.map(selection => selection.start));
+    const custom = selections.length === 1 ? this.customKey() : null;
+    if (custom !== null && (match === null || comparePositions(match.start, custom.start) >= 0)) {
+      return custom.expand?.() ?? false;
+    }
+    if (match === null) {
+      return false;
+    }
+    if (match.templates.length === 1) {
+      this.expandAtCarets(match.templates[0], match.start);
+      return true;
+    }
+    completion.showItems(match.templates.map(template => this.row(template, template.key, grouped(template), {
+      start: match.start,
+      end: editor.getCaret()
+    }, () => this.expandAtCarets(template, match.start))), match.start);
+    return true;
+  }
+  /* Lists the templates that apply, only the ones whose key or description fits the word before the caret when some do. */
+  insert() {
+    const {
+      editor,
+      completion,
+      project
+    } = this.language;
+    if (editor.isReadOnly?.() === true) {
+      return;
+    }
+    const selection = editor.getSelection();
+    const selected = comparePositions(selection.start, selection.end) !== 0;
+    const caret = editor.getCaret();
+    const before = textBeforeOf(editor, caret);
+    const word = selected ? '' : identifierPrefix(before);
+    const wordStart = {
+      line: caret.line,
+      character: caret.character - word.length
+    };
+    const context = templateContextAt(this.language, selected ? selection.start : wordStart);
+    const applicable = project.templates.live.filter(template => templateApplies(template, context));
+    if (applicable.length === 0) {
+      const title = project.i18n.t('editor:language.templates.none');
+      project.host.notify?.({
+        id: TOAST_ID,
+        kind: 'error',
+        title
+      });
+      editor.announce(title);
+      return;
+    }
+    const keyed = template => word !== '' && prefixLength(template.key, before) > 0;
+    const described = template => word !== '' && (template.description?.toLowerCase().includes(word.toLowerCase()) ?? false);
+    const matching = applicable.filter(template => keyed(template) || described(template));
+    const start = matching.length === 0 ? caret : wordStart;
+    const text = selected ? editor.textInRange(selection) : '';
+    const rows = (matching.length === 0 ? applicable : matching).map(template => this.row(template, keyed(template) || matching.length === 0 ? template.key : word, grouped(template), {
+      start,
+      end: caret
+    }, () => {
+      const range = selected ? selection : {
+        start,
+        end: editor.getCaret()
+      };
+      void this.run(template, [{
+        range,
+        selectedText: selected ? dedentLines(text) : undefined
+      }]);
+    }));
+    completion.showItems(rows, start);
+  }
+  /* Hands the selection to the host as a draft of a template; false without a selection or without a host that saves. */
+  saveSelection() {
+    const {
+      editor,
+      project
+    } = this.language;
+    const selection = editor.getSelection();
+    if (comparePositions(selection.start, selection.end) === 0) {
+      editor.announce(project.i18n.t('editor:language.templates.selectToSave'));
+      return false;
+    }
+    if (project.host.saveAsLiveTemplate === undefined) {
+      return false;
+    }
+    const context = templateContextAt(this.language, selection.start);
+    project.host.saveAsLiveTemplate({
+      body: escapeSnippetText(dedentLines(editor.textInRange(selection))),
+      languages: [context.families[0]],
+      places: [context.place]
+    });
+    return true;
+  }
+  /* The keys that compete with a live template for Tab: an Emmet abbreviation, then a postfix key. */
+  customKey() {
+    const abbreviation = this.language.markup.abbreviationAt();
+    return abbreviation === null ? this.postfix.key() : {
+      start: abbreviation,
+      expand: null
+    };
+  }
+  /* The templates every caret has the same key of, ending at the caret, in a context they apply in. */
+  matchAtCarets(carets) {
+    const matches = carets.map(caret => this.matchAt(caret));
+    const primary = matches.at(-1);
+    if (primary === null || primary === undefined) {
+      return null;
+    }
+    const templates = primary.templates.filter(template => matches.every(match => match?.templates.some(other => other.id === template.id) === true));
+    return templates.length === 0 ? null : {
+      start: primary.start,
+      templates
+    };
+  }
+  /*
+   * The templates whose key is the longest one that ends at the caret, as IntelliJ looks them up: when the longest
+   * key found applies nowhere, no shorter key is tried.
+   */
+  matchAt(caret) {
+    const {
+      editor,
+      project
+    } = this.language;
+    const {
+      live
+    } = project.templates;
+    const before = textBeforeOf(editor, caret);
+    const longest = live.reduce((length, template) => Math.max(length, template.key.length), 0);
+    for (let length = Math.min(longest, before.length); length >= 1; length--) {
+      const index = before.length - length;
+      const key = before.slice(index);
+      const found = live.filter(template => template.key === key);
+      if (found.length === 0 || startsInsideWord(before, index)) {
+        continue;
+      }
+      const start = {
+        line: caret.line,
+        character: index
+      };
+      const context = templateContextAt(this.language, start);
+      const templates = found.filter(template => templateApplies(template, context));
+      return templates.length === 0 ? null : {
+        start,
+        templates
+      };
+    }
+    return null;
+  }
+  /* Replaces the text between `start` and the caret, as far as the primary caret is from it, at every caret. */
+  expandAtCarets(template, start) {
+    const {
+      editor
+    } = this.language;
+    const length = Math.max(0, editor.getCaret().character - start.character);
+    void this.run(template, editor.getSelections().map(selection => ({
+      range: {
+        start: {
+          line: selection.end.line,
+          character: Math.max(0, selection.end.character - length)
+        },
+        end: selection.end
+      }
+    })));
+  }
+  run(template, placements) {
+    return insertSnippet(this.language, bodyWithIndentUnit(template.body, indentUnitOf(this.language.editor)), placements);
+  }
+  /* The rows for the word before the caret, each a template whose key starts with it. */
+  rows(position) {
+    const {
+      editor,
+      project
+    } = this.language;
+    if (!project.templates.settings.liveInCompletion) {
+      return [];
+    }
+    const before = textBeforeOf(editor, position);
+    if (identifierPrefix(before) === '') {
+      return [];
+    }
+    const contexts = new Map();
+    return project.templates.live.flatMap(template => {
+      const length = prefixLength(template.key, before);
+      if (length === 0) {
+        return [];
+      }
+      const start = {
+        line: position.line,
+        character: position.character - length
+      };
+      const context = contexts.get(length) ?? templateContextAt(this.language, start);
+      contexts.set(length, context);
+      return templateApplies(template, context) ? [this.row(template, template.key, sortAfterServer(template.key), {
+        start,
+        end: position
+      }, () => this.expandAtCarets(template, start))] : [];
+    });
+  }
+  row(template, filterText, sortText, range, accept) {
+    const item = {
+      label: template.key,
+      kind: SNIPPET_KIND,
+      detail: template.description,
+      documentation: {
+        kind: 'markdown',
+        value: `\`\`\`\n${template.body}\n\`\`\``
+      },
+      filterText,
+      sortText,
+      textEdit: {
+        range,
+        newText: template.key
+      }
+    };
+    return {
+      item,
+      accept
+    };
+  }
+}

package/dist/locales/en.json

@@ -70,6 +70,12 @@
                 "delete": "Deletes"
             }
         },
+        "markup": {
+            "wrap": "Wrap with abbreviation",
+            "placeholder": "Abbreviation, such as div.card>p",
+            "apply": "Wrap",
+            "invalid": "Not an abbreviation"
+        },
         "navigation": {
             "unavailable": "Not available here",
             "none": "Nothing found",
@@ -119,13 +125,30 @@
             "site": "Call {{current}} of {{total}}",
             "previousSite": "Previous call",
             "nextSite": "Next call",
+            "typesUnavailable": "Type hierarchy unavailable in this file",
+            "typesNone": "No type here",
+            "typesFailed": "Could not look up types: {{message}}",
+            "typesLabel": "Type hierarchy",
+            "supertypes": "Supertypes",
+            "subtypes": "Subtypes",
+            "noSupertypes": "No supertypes",
+            "noSubtypes": "No subtypes",
             "announce": {
                 "incoming_one": "{{count}} caller of {{name}}",
                 "incoming_other": "{{count}} callers of {{name}}",
                 "outgoing_one": "{{count}} callee of {{name}}",
-                "outgoing_other": "{{count}} callees of {{name}}"
+                "outgoing_other": "{{count}} callees of {{name}}",
+                "supertypes_one": "{{count}} supertype of {{name}}",
+                "supertypes_other": "{{count}} supertypes of {{name}}",
+                "subtypes_one": "{{count}} subtype of {{name}}",
+                "subtypes_other": "{{count}} subtypes of {{name}}"
             }
         },
+        "colors": {
+            "swatch": "Color {{color}}",
+            "title": "Color",
+            "other": "Pick another color…"
+        },
         "codeVision": {
             "usagesNone": "No usages",
             "usages_one": "{{formatted}} usage",
@@ -192,6 +215,40 @@
         "history": {
             "recent": "Recent locations"
         },
+        "pasteHistory": {
+            "title": "Choose Content to Paste",
+            "empty": "Nothing was copied yet"
+        },
+        "templates": {
+            "none": "No templates defined in this context",
+            "selectToSave": "Select the text to save as a live template"
+        },
+        "postfix": {
+            "expressions": "Expressions"
+        },
+        "surround": {
+            "title": "Surround With",
+            "selectTemplate": "Select Template",
+            "liveTemplates": "Live templates",
+            "configure": "Configure live templates…",
+            "comments": "{{construct}} Comments",
+            "none": "Couldn't find Surround With variants applicable to the current context",
+            "noTemplates": "No surround templates defined in this context",
+            "unwrap": {
+                "title": "Choose the statement to unwrap/remove",
+                "if": "Unwrap 'if...'",
+                "else": "Unwrap 'else...'",
+                "removeElse": "Remove 'else...'",
+                "for": "Unwrap 'for...'",
+                "while": "Unwrap 'while...'",
+                "do": "Unwrap 'do...'",
+                "try": "Unwrap 'try...'",
+                "removeCatch": "Remove 'catch...'",
+                "removeFinally": "Remove 'finally...'",
+                "braces": "Unwrap braces",
+                "tag": "Remove enclosing tag: {{name}}"
+            }
+        },
         "announce": {
             "problem": "{{severity}}: {{message}}",
             "severity": {
@@ -236,10 +293,12 @@
         "goToTypeDefinition": "Go to type definition",
         "goToImplementation": "Go to implementation",
         "callHierarchy": "Call hierarchy",
+        "typeHierarchy": "Type hierarchy",
         "peekReferences": "Peek references",
         "renameSymbol": "Rename symbol",
         "codeActions": "Code actions",
-        "formatDocument": "Format document"
+        "formatDocument": "Format document",
+        "formatSelection": "Format selection"
     },
     "find": {
         "label": "Find",