@adecore/editor-react 0.41.1 → 0.43.0

package/dist/markup-context.js

@@ -0,0 +1,291 @@
+/* Above this a document is not read on a keystroke; the features then do nothing in it. */
+export const MAX_MARKUP_SCAN = 1_000_000;
+const VOID_ELEMENTS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+const RAW_ELEMENTS = new Set(['script', 'style', 'textarea', 'title']);
+const NAME_START = /[A-Za-z]/;
+const NAME = /[\w:.-]/;
+export function markupSyntaxOf(languageId) {
+  switch (languageId.toLowerCase()) {
+    case 'html':
+    case 'xhtml':
+      return 'html';
+    case 'xml':
+    case 'svg':
+    case 'xsl':
+      return 'xml';
+    case 'vue':
+      return 'vue';
+    case 'php':
+      return 'php';
+    default:
+      return null;
+  }
+}
+/* Whether an element of this name has no end tag, which only HTML has. */
+export function isVoidElement(name, syntax) {
+  return syntax !== 'xml' && VOID_ELEMENTS.has(name.toLowerCase());
+}
+class Stop {
+  place;
+  constructor(place) {
+    this.place = place;
+  }
+}
+/*
+ * A reader of markup that is no parser: it follows tags, comments, raw elements and the code blocks of
+ * PHP and Vue far enough to tell what an offset is in, and pairs a start tag with the end tag that closes it.
+ */
+class MarkupScanner {
+  pairs = [];
+  text;
+  syntax;
+  until;
+  open = [];
+  constructor(text, syntax, until) {
+    this.text = text;
+    this.syntax = syntax;
+    this.until = until;
+  }
+  run() {
+    try {
+      this.content();
+      return this.textPlace();
+    } catch (error) {
+      if (error instanceof Stop) {
+        return error.place;
+      }
+      throw error;
+    }
+  }
+  textPlace() {
+    return {
+      kind: 'text',
+      open: this.open.map(({
+        name,
+        nameFrom
+      }) => ({
+        name,
+        nameFrom
+      }))
+    };
+  }
+  /* Leaves the scan with what the offset is in when it lies in `from` to `to`, `to` included where the construct owns its last character. */
+  reached(from, to, place) {
+    if (from < this.until && this.until <= to) {
+      throw new Stop(place());
+    }
+  }
+  content() {
+    const {
+      text
+    } = this;
+    let at = 0;
+    while (at < text.length) {
+      if (at >= this.until) {
+        throw new Stop(this.textPlace());
+      }
+      const char = text[at];
+      if (char === '<') {
+        at = this.markup(at);
+      } else if (this.syntax === 'vue' && char === '{' && text[at + 1] === '{') {
+        at = this.skipTo(at, '}}');
+      } else {
+        at++;
+      }
+    }
+  }
+  /* Skips from `from` past `close`, the whole construct counting as something other than text. */
+  skipTo(from, close) {
+    const end = this.text.indexOf(close, from + 1);
+    const after = end === -1 ? this.text.length : end + close.length;
+    this.reached(from, end === -1 ? after : after - 1, () => ({
+      kind: 'other'
+    }));
+    return after;
+  }
+  markup(at) {
+    const {
+      text
+    } = this;
+    if (text.startsWith('<!--', at)) {
+      return this.skipTo(at, '-->');
+    }
+    if (text.startsWith('<![CDATA[', at)) {
+      return this.skipTo(at, ']]>');
+    }
+    if (text[at + 1] === '?') {
+      return this.skipTo(at, this.syntax === 'php' ? '?>' : '>');
+    }
+    if (text[at + 1] === '!') {
+      return this.skipTo(at, '>');
+    }
+    const closing = text[at + 1] === '/';
+    const nameFrom = at + (closing ? 2 : 1);
+    if (!NAME_START.test(text[nameFrom] ?? '')) {
+      return at + 1;
+    }
+    let nameTo = nameFrom;
+    while (nameTo < text.length && NAME.test(text[nameTo])) {
+      nameTo++;
+    }
+    const name = text.slice(nameFrom, nameTo);
+    const end = this.tagEnd(at, closing, name, nameFrom, nameTo);
+    if (closing) {
+      this.close(name, nameFrom, nameTo);
+      return end;
+    }
+    const selfClosing = text[end - 2] === '/' && text[end - 1] === '>';
+    if (selfClosing || isVoidElement(name, this.syntax)) {
+      return end;
+    }
+    if (this.syntax !== 'xml' && RAW_ELEMENTS.has(name.toLowerCase())) {
+      return this.rawContent(end, name, nameFrom, nameTo);
+    }
+    this.open.push({
+      name,
+      nameFrom,
+      nameTo
+    });
+    return end;
+  }
+  /* Reads the attributes of a tag up to the offset after its `>`, quotes and PHP blocks included. */
+  tagEnd(start, closing, name, nameFrom, nameTo) {
+    const {
+      text
+    } = this;
+    let at = nameTo;
+    let quote = null;
+    let valueFrom = -1;
+    while (at < text.length) {
+      const char = text[at];
+      if (this.syntax === 'php' && char === '<' && text[at + 1] === '?') {
+        at = this.skipTo(at, '?>');
+        continue;
+      }
+      if (quote !== null) {
+        if (char === quote) {
+          this.reached(valueFrom, at, () => ({
+            kind: 'tag',
+            tag: {
+              start,
+              closing,
+              name,
+              nameFrom,
+              nameTo,
+              inValue: true
+            }
+          }));
+          quote = null;
+        }
+      } else if (char === '"' || char === "'") {
+        quote = char;
+        valueFrom = at;
+      } else if (char === '>') {
+        this.reached(start, at, () => ({
+          kind: 'tag',
+          tag: {
+            start,
+            closing,
+            name,
+            nameFrom,
+            nameTo,
+            inValue: false
+          }
+        }));
+        return at + 1;
+      } else if (char === '<') {
+        // A tag that never closed ends where the next one starts.
+        this.reached(start, at, () => ({
+          kind: 'tag',
+          tag: {
+            start,
+            closing,
+            name,
+            nameFrom,
+            nameTo,
+            inValue: false
+          }
+        }));
+        return at;
+      }
+      at++;
+    }
+    this.reached(start, text.length, () => ({
+      kind: 'tag',
+      tag: {
+        start,
+        closing,
+        name,
+        nameFrom,
+        nameTo,
+        inValue: quote !== null && this.until > valueFrom
+      }
+    }));
+    return text.length;
+  }
+  /* The content of `script`, `style` and the like is not markup, up to the end tag of the element. */
+  rawContent(from, name, nameFrom, nameTo) {
+    const pattern = new RegExp(`</${name}(?=[\\s/>]|$)`, 'gi');
+    pattern.lastIndex = from;
+    const match = pattern.exec(this.text);
+    const end = match === null ? this.text.length : match.index;
+    this.reached(from - 1, end, () => ({
+      kind: 'other'
+    }));
+    if (match === null) {
+      return end;
+    }
+    const closeFrom = end + 2;
+    const closeTo = closeFrom + name.length;
+    const after = this.tagEnd(end, true, this.text.slice(closeFrom, closeTo), closeFrom, closeTo);
+    this.pairs.push({
+      open: {
+        from: nameFrom,
+        to: nameTo
+      },
+      close: {
+        from: closeFrom,
+        to: closeTo
+      }
+    });
+    return after;
+  }
+  /* An end tag closes the nearest open element of its name and every element left open inside it. */
+  close(name, nameFrom, nameTo) {
+    const caseless = this.syntax !== 'xml';
+    for (let index = this.open.length - 1; index >= 0; index--) {
+      const element = this.open[index];
+      if (element.name === name || caseless && element.name.toLowerCase() === name.toLowerCase()) {
+        this.pairs.push({
+          open: {
+            from: element.nameFrom,
+            to: element.nameTo
+          },
+          close: {
+            from: nameFrom,
+            to: nameTo
+          }
+        });
+        this.open.length = index;
+        return;
+      }
+    }
+  }
+}
+/* What `offset` is in; null for a document too large to read on a keystroke. */
+export function markupPlaceAt(text, offset, syntax) {
+  if (text.length > MAX_MARKUP_SCAN) {
+    return null;
+  }
+  return new MarkupScanner(text, syntax, offset).run();
+}
+/* The start and end tag names of the element whose name holds `offset`, either one, its edges included. */
+export function tagPairAt(text, offset, syntax) {
+  if (text.length > MAX_MARKUP_SCAN) {
+    return null;
+  }
+  const scanner = new MarkupScanner(text, syntax, Infinity);
+  scanner.run();
+  const holds = range => range.from <= offset && offset <= range.to;
+  return scanner.pairs.find(pair => holds(pair.open) || holds(pair.close)) ?? null;
+}

package/dist/markup.d.ts

@@ -0,0 +1,36 @@
+import type { EditorLanguage } from './editor-language.ts';
+export interface MarkupSettings {
+    readonly emmet?: boolean;
+    readonly closeTags?: boolean;
+    readonly linkedTags?: boolean;
+}
+export declare class MarkupFeature {
+    private readonly language;
+    private readonly syntax;
+    private settings;
+    private link;
+    private wrapping;
+    private revision;
+    private mirroring;
+    constructor(language: EditorLanguage);
+    get supported(): boolean;
+    configure(settings: MarkupSettings): void;
+    expand(): boolean;
+    startWrap(): boolean;
+    submitWrap(abbreviation: string): boolean;
+    cancelWrap(): void;
+    private key;
+    private editable;
+    private indent;
+    private wrapTarget;
+    private wrapLines;
+    private insert;
+    private apply;
+    private edited;
+    private follow;
+    private mirror;
+    private closeTag;
+    private completeEndTag;
+    private moved;
+    private linkAtCaret;
+}