@heartlandone/vega 2.34.1 → 2.35.0-RTE-preview

package/dist/cjs/text-node-494856f3.js

@@ -1,955 +0,0 @@
-'use strict';
-
-const node_abstract = require('./node.abstract-f8075f84.js');
-const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-093462f1.js');
-const changeManager = require('./change-manager-bda1d107.js');
-const vegaInternalEventId = require('./vega-internal-event-id-85b68849.js');
-const globalSlimmerRegistry = require('./global-slimmer-registry-dd2691b8.js');
-const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtime-metrics-slimmer-8c6a8fb7.js');
-const typeGuard = require('./type-guard-4ba85fdc.js');
-const accessibility = require('./accessibility-bfa227f6.js');
-
-/* istanbul ignore next */
-/**
- * Wait for all vega elements to be ready.
- *
- * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
- */
-const waitForVega = async () => {
-  return node_abstract.WaitForVega.handle();
-};
-/**
- * Wait for the component has been rendered.
- *
- * @param {HTMLStencilElement} componentRef - The reference to the component that needs to be rendered.
- * @returns {Promise<unknown>} A promise that resolves when the component has been rendered.
- */
-const waitForComponentDidRender = async (componentRef) => {
-  return new Promise((resolve) => {
-    const observer = new domNodeSubjectObserverFactory.Observer(isAcceptableComponentDidRender.bind(null), () => {
-      changeManager.ChangeManager.unregister(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(componentRef, vegaInternalEventId.VegaInternalComponentDidRender), observer);
-      resolve(null);
-    });
-    changeManager.ChangeManager.register(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(componentRef, vegaInternalEventId.VegaInternalComponentDidRender), observer);
-  });
-};
-/**
- * Determines whether the observer should accept changes.
- *
- * @returns {boolean} Always returns true in the current implementation.
- */
-const isAcceptableComponentDidRender = () => {
-  return true;
-};
-
-const RTE_TEXT_COLORS = [
-  {
-    key: 'black',
-    light: '#111128',
-    dark: '#E3E3E8',
-  },
-  {
-    key: 'gray',
-    light: '#5E5E6D',
-    dark: '#B9B9C1',
-  },
-  {
-    key: 'green',
-    light: '#01801F',
-    dark: '#59D977',
-  },
-  {
-    key: 'red',
-    light: '#BD2947',
-    dark: '#FFB2B5',
-  },
-  {
-    key: 'purple',
-    light: '#563D82',
-    dark: '#BEB2FF',
-  },
-  {
-    key: 'teal',
-    light: '#17758F',
-    dark: '#4CD8FF',
-  },
-];
-const ZERO_WIDTH_SPACE = '\u200b';
-
-/**
- * Abstract class for annotation actions
- */
-class AnnotationAction {
-}
-
-/**
- * Abstract class for which can be splittable
- */
-class TextSplittableAction extends AnnotationAction {
-  constructor() {
-    super(...arguments);
-    /**
-     * Whether the action should split the node
-     */
-    this.doSplit = true;
-  }
-}
-
-/**
- * Annotation to represent a selection range
- */
-class SelectionRangeAnnotation extends node_abstract.Annotation {
-  constructor(range) {
-    super();
-    this.type = node_abstract.InternalAnnotationTypeEnum.SELECTION_RANGE;
-    this.range = range;
-  }
-}
-
-/**
- * This class is responsible for keeping track of the DOM elements.
- */
-class TextNodeRenderingRegistry {
-  constructor() {
-    this.textNodeElements = new Map();
-  }
-  /**
-   * Registers a DOM element and the color annotation of the DOM element.
-   *
-   * @param {HTMLElement} dom The DOM element to register.
-   * @param {TextColorAnnotation} textColorAnnotation The text color annotation of text node to register.
-   */
-  register(dom, textColorAnnotation) {
-    this.textNodeElements.set(dom, textColorAnnotation);
-  }
-  /**
-   * Retrieves the text node elements.
-   *
-   * @returns {HTMLElement[]} The text node elements, or empty array.
-   */
-  getTextNodeElements() {
-    return this.textNodeElements;
-  }
-}
-const TextNodeRenderingRegistry$1 = new TextNodeRenderingRegistry();
-
-/**
- * Annotation to make text with strikethrough
- */
-class StrikethroughAnnotation extends node_abstract.NodeAnnotation {
-  constructor(underline) {
-    super();
-    this.type = node_abstract.NodeAnnotationTypeEnum.STRIKETHROUGH;
-    this.strikethrough = underline;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {Nullable<boolean>} strikethrough - Strikethrough annotation
-   * @returns {[NodeAnnotationTypeEnum.STRIKETHROUGH, StrikethroughAnnotation]} Map item for the annotation
-   */
-  static from(strikethrough) {
-    return [node_abstract.NodeAnnotationTypeEnum.STRIKETHROUGH, new StrikethroughAnnotation(strikethrough)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      strikethrough: this.strikethrough,
-    };
-  }
-  /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
-   */
-  renderClass() {
-    return this.strikethrough ? 'v-rte--strikethrough' : null;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
-   */
-  render() {
-    return null;
-  }
-}
-
-/**
- * Annotation to make text with underline
- */
-class UnderlineAnnotation extends node_abstract.NodeAnnotation {
-  constructor(underline) {
-    super();
-    this.type = node_abstract.NodeAnnotationTypeEnum.UNDERLINE;
-    this.underline = underline;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {boolean} underline - Underline annotation
-   * @returns {[NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation]} Map item for the annotation
-   */
-  static from(underline) {
-    return [node_abstract.NodeAnnotationTypeEnum.UNDERLINE, new UnderlineAnnotation(underline)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      underline: this.underline,
-    };
-  }
-  /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
-   */
-  renderClass() {
-    return this.underline ? 'v-rte--underline' : null;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
-   */
-  render() {
-    return null;
-  }
-}
-
-/**
- * Annotation to make text Italic
- */
-class ItalicAnnotation extends node_abstract.NodeAnnotation {
-  constructor(italic) {
-    super();
-    this.type = node_abstract.NodeAnnotationTypeEnum.ITALIC;
-    this.italic = italic;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {boolean} italic - Italic annotation
-   * @returns {Nullable<[NodeAnnotationTypeEnum.ITALIC, ItalicAnnotation]>} Map item for the annotation
-   */
-  static from(italic) {
-    return [node_abstract.NodeAnnotationTypeEnum.ITALIC, new ItalicAnnotation(italic)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      italic: this.italic,
-    };
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Italic style
-   */
-  render() {
-    return this.italic ? { 'font-style': 'italic' } : null;
-  }
-}
-
-/**
- * Annotation to make text bold
- */
-class BoldAnnotation extends node_abstract.NodeAnnotation {
-  constructor(bold) {
-    super();
-    this.type = node_abstract.NodeAnnotationTypeEnum.BOLD;
-    this.bold = bold;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {boolean} bold - Bold annotation
-   * @returns {[NodeAnnotationTypeEnum.BOLD, BoldAnnotation]} Map item for the annotation
-   */
-  static from(bold) {
-    return [node_abstract.NodeAnnotationTypeEnum.BOLD, new BoldAnnotation(bold)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      bold: this.bold,
-    };
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Bold style
-   */
-  render() {
-    return this.bold ? { 'font-weight': '700' } : null;
-  }
-}
-
-/**
- * Annotation to host which annotations will be clear formatting
- */
-class ClearFormattingAnnotation extends node_abstract.Annotation {
-  constructor() {
-    super(...arguments);
-    this.type = node_abstract.InternalAnnotationTypeEnum.CLEAR_FORMATTING;
-    this.items = [
-      node_abstract.NodeAnnotationTypeEnum.BOLD,
-      node_abstract.NodeAnnotationTypeEnum.ITALIC,
-      node_abstract.NodeAnnotationTypeEnum.UNDERLINE,
-      node_abstract.NodeAnnotationTypeEnum.STRIKETHROUGH,
-      node_abstract.NodeAnnotationTypeEnum.TEXT_COLOR,
-      node_abstract.NodeAnnotationTypeEnum.CODE,
-    ];
-  }
-}
-
-/**
- * Annotation to make text code
- */
-class CodeAnnotation extends node_abstract.NodeAnnotation {
-  constructor(code) {
-    super();
-    this.type = node_abstract.NodeAnnotationTypeEnum.CODE;
-    this.code = code;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {boolean} code - Bold annotation
-   * @returns {[NodeAnnotationTypeEnum.CODE, CodeAnnotation]} Map item for the annotation
-   */
-  static from(code) {
-    return [node_abstract.NodeAnnotationTypeEnum.CODE, new CodeAnnotation(code)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      code: this.code,
-    };
-  }
-  /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
-   */
-  renderClass() {
-    return this.code ? 'v-rte--code' : null;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Bold style
-   */
-  render() {
-    return null;
-  }
-}
-
-/**
- * Annotation to make text with text color
- */
-class TextColorAnnotation extends node_abstract.NodeAnnotation {
-  constructor(textColor) {
-    super();
-    this.type = node_abstract.NodeAnnotationTypeEnum.TEXT_COLOR;
-    this.textColor = this.formatTextColor(textColor);
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {string} textColor - text color annotation
-   * @returns {[NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation]} Map item for the annotation
-   */
-  static from(textColor) {
-    return [node_abstract.NodeAnnotationTypeEnum.TEXT_COLOR, new TextColorAnnotation(textColor)];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return {
-      textColor: this.textColor.key,
-    };
-  }
-  /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
-   */
-  renderClass() {
-    return null;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
-   */
-  render() {
-    return {
-      color: node_abstract.VegaThemeManager.isDarkMode() ? this.textColor.dark : this.textColor.light,
-    };
-  }
-  /**
-   * format text color
-   *
-   * @param {string} textColor - text color
-   * @returns {VegaRTEColorSchema} - VegaRTEColorSchema
-   */
-  formatTextColor(textColor) {
-    return (RTE_TEXT_COLORS.find((item) => item.key === textColor) || RTE_TEXT_COLORS[0]);
-  }
-}
-
-/**
- * Annotation to make text a link
- */
-class LinkAnnotation extends node_abstract.NodeAnnotation {
-  constructor(link) {
-    super();
-    this.type = node_abstract.NodeAnnotationTypeEnum.LINK;
-    this.link = link;
-  }
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {VegaRTELink} link - Bold annotation
-   * @returns {[NodeAnnotationTypeEnum.LINK, LinkAnnotation]} Map item for the annotation
-   */
-  static from(link) {
-    return [
-      node_abstract.NodeAnnotationTypeEnum.LINK,
-      new LinkAnnotation({ href: link.href, groupKey: link.groupKey }),
-    ];
-  }
-  /**
-   * Generate the JSON representation of the annotation
-   *
-   * @returns {Record<string, unknown>} JSON representation of the annotation
-   */
-  toJSON() {
-    return { link: { href: this.link.href, groupKey: this.link.groupKey } };
-  }
-  /**
-   * Verify whether two link annotation is same or not
-   *
-   * @param {LinkAnnotation} annotation - Compared annotation
-   * @returns {boolean} Whether two link annotation is same or not
-   */
-  toEqual(annotation) {
-    return this.link.groupKey === annotation.link.groupKey;
-  }
-  /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Link style
-   */
-  render() {
-    return null;
-  }
-}
-
-/**
- * Action to toggle link annotation
- */
-class LinkAnnotationAction extends TextSplittableAction {
-  constructor({ link, newText, needMergeNode, doSplit, }) {
-    super();
-    this.isFlushable = true;
-    this.link = link;
-    this.needMergeNode = needMergeNode;
-    this.newText = newText;
-    if (typeGuard.isNonNullable(doSplit)) {
-      this.doSplit = doSplit;
-    }
-  }
-  /**
-   * Converts the action to an annotation
-   *
-   * @returns {LinkAnnotation} the annotation
-   */
-  toAnnotation() {
-    return new LinkAnnotation(this.link);
-  }
-}
-
-/**
- * Action to toggle code annotation
- */
-class CodeAnnotationAction extends TextSplittableAction {
-  constructor(code) {
-    super();
-    this.isFlushable = true;
-    this.code = code;
-  }
-  /**
-   * Converts the action to an annotation
-   *
-   * @returns {CodeAnnotation} the annotation
-   */
-  toAnnotation() {
-    return new CodeAnnotation(this.code);
-  }
-}
-
-/**
- * Action to toggle clear formatting
- */
-class ClearFormattingAnnotationAction extends TextSplittableAction {
-  constructor() {
-    super(...arguments);
-    this.isFlushable = true;
-  }
-  /**
-   * Converts the action to an annotation
-   *
-   * @returns {ClearFormattingAnnotation} the annotation
-   */
-  toAnnotation() {
-    return new ClearFormattingAnnotation();
-  }
-}
-
-/**
- * Update the text node property text action
- *
- * @example textNode.apply(new UpdateTextAction(newText))
- */
-class UpdateTextAction extends node_abstract.ModifyContentAction {
-  constructor(text) {
-    super();
-    this.type = node_abstract.ModifyContentActionType.UPDATE_TEXT;
-    this.newTextContent = '';
-    this.newTextContent = text;
-  }
-}
-
-/**
- * Annotation to represent a link of grouped nodes
- */
-class LinkGroupAnnotation extends node_abstract.Annotation {
-  constructor(groupKey) {
-    super();
-    this.type = node_abstract.InternalAnnotationTypeEnum.LINK_GROUP;
-    this.linkGroups = new Map();
-    this.linkGroups = new Map([[groupKey, []]]);
-  }
-  renderNodes(nodes, { editable }) {
-    const blockNodes = this.groupNodesByLink(nodes);
-    return blockNodes.flatMap((item) => {
-      if (this.isLinkGroup(item)) {
-        const linkAnnotation = item[0].getAnnotationByType(node_abstract.NodeAnnotationTypeEnum.LINK);
-        return editable
-          ? this.renderLinkEditorWrapper(item, linkAnnotation)
-          : this.renderLink(item, linkAnnotation);
-      }
-      return item.render();
-    });
-  }
-  renderLinkEditorWrapper(linkNodes, linkAnnotation) {
-    const { href } = linkAnnotation.link;
-    const textFromNodes = linkNodes.map((node) => node.text).join('');
-    const handleChange = ({ detail, }) => {
-      switch (detail.action) {
-        case 'link': {
-          const { url, text } = detail.payload;
-          const textChanged = text !== textFromNodes;
-          const groupKey = createPublicApiRuntimeMetricsSlimmer.generateUUID();
-          linkNodes.forEach((node) => {
-            const linkAnnotationAction = new LinkAnnotationAction({
-              link: { href: url, groupKey: groupKey },
-              newText: textChanged ? text : undefined,
-              needMergeNode: textChanged && linkNodes.length > 1,
-              doSplit: false,
-            });
-            node.apply(linkAnnotationAction);
-          });
-          return;
-        }
-        case 'unlink': {
-          linkNodes.forEach((node) => node.deleteAnnotationByType(node_abstract.NodeAnnotationTypeEnum.LINK));
-          return;
-        }
-      }
-    };
-    let linkWrapperRef;
-    return (globalSlimmerRegistry.h("span", { class: "link-editor-wrapper", role: "link", tabIndex: 0, onKeyDown: accessibility.createEnterKeyHandlerToTriggerClick(), ref: (ref) => {
-        if (ref) {
-          linkWrapperRef = ref;
-        }
-      } },
-      this.renderLink(linkNodes, linkAnnotation),
-      globalSlimmerRegistry.h("vega-rich-text-link-editor", { record: {
-          text: textFromNodes,
-          url: href,
-        }, ref: (ref) => {
-          if (ref) {
-            ref.target = linkWrapperRef;
-            domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, domNodeSubjectObserverFactory.VegaChange, handleChange);
-          }
-        } })));
-  }
-  renderLink(linkNodes, linkAnnotation) {
-    const { href } = linkAnnotation.link;
-    return (globalSlimmerRegistry.h("a", { class: "v-rte--link", href: href, target: "_blank" }, linkNodes.map((node) => node.render())));
-  }
-  isLinkGroup(item) {
-    return Array.isArray(item);
-  }
-  groupNodesByLink(nodes) {
-    return nodes.reduce((acc, node) => {
-      const nodeLinkAnnotation = node.getAnnotationByType(node_abstract.NodeAnnotationTypeEnum.LINK);
-      const lastGroup = acc[acc.length - 1];
-      if (typeGuard.isNonNullable(nodeLinkAnnotation)) {
-        if (lastGroup &&
-          this.isLinkGroup(lastGroup) &&
-          lastGroup[0].getAnnotationByType(node_abstract.NodeAnnotationTypeEnum.LINK).toEqual(nodeLinkAnnotation)) {
-          lastGroup.push(node);
-        }
-        else {
-          acc.push([node]);
-        }
-      }
-      else {
-        acc.push(node);
-      }
-      return acc;
-    }, []);
-  }
-}
-
-/**
- * Action to link a group of nodes
- */
-class LinkGroupAnnotationAction extends AnnotationAction {
-  constructor(groupKey, nodes) {
-    super();
-    this.isFlushable = false;
-    this.groupKey = groupKey;
-    this.nodes = nodes;
-  }
-  /**
-   * Converts the action to an annotation
-   *
-   * @returns {LinkGroupAnnotation} The annotation
-   */
-  toAnnotation() {
-    return new LinkGroupAnnotation(this.groupKey);
-  }
-}
-
-/**
- * Sync up selection action
- */
-class SyncUpSelectionAction extends AnnotationAction {
-  constructor() {
-    super();
-    this.isFlushable = false;
-  }
-  /**
-   * annotation null
-   *
-   * @returns {Nullable<Annotation>} null
-   */
-  toAnnotation() {
-    return null;
-  }
-}
-
-/**
- * Delete the node annotation by type
- */
-class DeleteNodeAnnotationAction extends AnnotationAction {
-  constructor(annotationType) {
-    super();
-    this.isFlushable = true;
-    this.annotationType = annotationType;
-  }
-  /**
-   * Don't need this for this action
-   *
-   * @returns {Nullable<Annotation>} undefined
-   */
-  toAnnotation() {
-    return undefined;
-  }
-}
-
-class RTETextNode extends node_abstract.RTENode {
-  constructor(id, text, parentBlock, annotationMap) {
-    super(id, annotationMap);
-    this.type = node_abstract.NodeTypeEnum.TEXT;
-    this.parentBlock = parentBlock;
-    this.text = text;
-  }
-  static from(richText, parentBlock) {
-    const textNode = new RTETextNode(richText.id, richText.text, parentBlock);
-    const { annotations } = richText;
-    if (annotations) {
-      textNode.annotationMap = new Map(Object.keys(annotations)
-        .map((type) => {
-        if (annotations.link) {
-          parentBlock.apply(new LinkGroupAnnotationAction(annotations.link.groupKey, [textNode]));
-        }
-        return this.createAnnotationEntity(type, annotations[type]);
-      })
-        .filter(typeGuard.isNonNullable));
-    }
-    return textNode;
-  }
-  static createAnnotationEntity(type, value) {
-    switch (type) {
-      case 'bold':
-        return BoldAnnotation.from(value);
-      case 'italic':
-        return ItalicAnnotation.from(value);
-      case 'underline':
-        return UnderlineAnnotation.from(value);
-      case 'strikethrough':
-        return StrikethroughAnnotation.from(value);
-      case 'code':
-        return CodeAnnotation.from(value);
-      case 'textColor':
-        return TextColorAnnotation.from(value);
-      case 'link':
-        return LinkAnnotation.from(value);
-    }
-  }
-  toJSON() {
-    const annotations = Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof node_abstract.NodeAnnotation)
-      .reduce((record, annotation) => {
-      return Object.assign(Object.assign({}, record), annotation.toJSON());
-    }, {});
-    return Object.assign(Object.assign({ id: this.id }, (Object.keys(annotations).length > 0 ? { annotations } : {})), { type: 'text', text: this.text });
-  }
-  cloneWithText(text) {
-    return new RTETextNode(createPublicApiRuntimeMetricsSlimmer.generateUUID(), text, this.parentBlock, new Map(this.annotationMap));
-  }
-  isEmpty() {
-    return !this.text || this.text === ZERO_WIDTH_SPACE || this.text === '\n';
-  }
-  render() {
-    const codeAnnotation = this.annotationMap.get(node_abstract.NodeAnnotationTypeEnum.CODE);
-    if (codeAnnotation === null || codeAnnotation === void 0 ? void 0 : codeAnnotation.code) {
-      return (globalSlimmerRegistry.h("code", { style: this.getStyles(), class: this.getClasses(), ref: this.registerRef.bind(this) }, this.text || ZERO_WIDTH_SPACE));
-    }
-    return (globalSlimmerRegistry.h("span", { style: this.getStyles(), class: this.getClasses(), ref: this.registerRef.bind(this) }, this.text || ZERO_WIDTH_SPACE));
-  }
-  doAnnotationActionApply(action) {
-    const selectionRangeAnnotation = this.getAnnotationByType(node_abstract.InternalAnnotationTypeEnum.SELECTION_RANGE);
-    if (action instanceof TextSplittableAction && action.doSplit && selectionRangeAnnotation) {
-      const { startContainer, endContainer, startOffset, endOffset } = selectionRangeAnnotation.range;
-      const noTextRangeSelected = startContainer === endContainer && startOffset === endOffset;
-      this.parentBlock.nodes = this.parentBlock.nodes.flatMap((item) => {
-        if (item.id === this.id) {
-          if (noTextRangeSelected) {
-            return this.insertNewNode(startOffset, action);
-          }
-          if (this.shouldSplitSelection(selectionRangeAnnotation.range)) {
-            return this.splitTextNode(action, selectionRangeAnnotation.range);
-          }
-          else {
-            this.applyActionToNode(this, action);
-            return this;
-          }
-        }
-        return item;
-      });
-    }
-    else {
-      this.applyActionToNode(this, action);
-    }
-    this.parentBlock.mergeNodes(action);
-  }
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case node_abstract.ModifyContentActionType.UPDATE_TEXT:
-        this.updateText(action.newTextContent);
-        break;
-      case node_abstract.ModifyContentActionType.REPLACE_SELECTED_TEXT:
-        this.replaceSelectedText(action.textToBeInsert, action.currentRange);
-        break;
-    }
-  }
-  registerRef(ref) {
-    if (ref) {
-      node_abstract.stateEntityRenderingRegistry.register(ref, this);
-      const textColorAnnotation = this.getAnnotationByType('TEXT_COLOR');
-      if (textColorAnnotation) {
-        TextNodeRenderingRegistry$1.register(ref, textColorAnnotation);
-      }
-    }
-  }
-  splitTextNode(action, range) {
-    const { startContainer, endContainer, startOffset } = range;
-    const startNode = startContainer.parentElement;
-    const endNode = endContainer.parentElement;
-    const splitText = (text, startOffset, endOffset) => {
-      const beforeText = text.substring(0, startOffset);
-      const selectedText = text.substring(startOffset, endOffset);
-      const afterText = text.substring(endOffset);
-      return [
-        this.cloneWithText(beforeText),
-        this.cloneWithText(selectedText),
-        this.cloneWithText(afterText),
-      ];
-    };
-    const startItemDto = startNode && node_abstract.stateEntityRenderingRegistry.getEntityByDOM(startNode);
-    const endItemDto = endNode && node_abstract.stateEntityRenderingRegistry.getEntityByDOM(endNode);
-    if (startItemDto && startItemDto.id === this.id) {
-      const endOffset = startContainer === endContainer ? range.endOffset : this.text.length;
-      const [beforeNode, selectedNode, afterNode] = splitText(this.text, startOffset, endOffset);
-      this.applyActionToNode(selectedNode, action);
-      return [beforeNode, selectedNode, afterNode].filter((node) => !!node.text);
-    }
-    else if (endItemDto && endItemDto.id === this.id) {
-      const [beforeNode, selectedNode, afterNode] = splitText(this.text, 0, range.endOffset);
-      this.applyActionToNode(selectedNode, action);
-      return [beforeNode, selectedNode, afterNode].filter((node) => !!node.text);
-    }
-    else {
-      this.applyActionToNode(this, action);
-      return this;
-    }
-  }
-  applyActionToNode(node, action) {
-    const annotation = action.toAnnotation();
-    if (action instanceof SyncUpSelectionAction) {
-      this.syncUpSelectedNodes(node);
-      return;
-    }
-    // Sync up RTETextNode selected state to selection controller for any action apply, except selection range change.
-    if (!(annotation instanceof SelectionRangeAnnotation)) {
-      this.syncUpSelectedNodes(node);
-    }
-    if (action instanceof DeleteNodeAnnotationAction) {
-      this.annotationMap.delete(action.annotationType);
-      return;
-    }
-    if (annotation instanceof ClearFormattingAnnotation) {
-      annotation.items.forEach((item) => {
-        node.deleteAnnotationByType(item);
-      });
-      return;
-    }
-    if (annotation instanceof node_abstract.NodeAnnotation || annotation instanceof SelectionRangeAnnotation) {
-      if (action instanceof LinkAnnotationAction) {
-        if (typeGuard.isNonNullable(action.newText)) {
-          node.text = action.newText;
-        }
-        this.parentBlock.apply(new LinkGroupAnnotationAction(action.link.groupKey, [node]));
-      }
-      if (action instanceof CodeAnnotationAction) {
-        this.applyActionToNode(node, new ClearFormattingAnnotationAction());
-      }
-      node.annotationMap.set(annotation.type, annotation);
-      return;
-    }
-  }
-  replaceSelectedText(text, currentRange) {
-    if (currentRange && currentRange.startContainer && currentRange.endContainer) {
-      const { startContainer, endContainer, startOffset, endOffset } = currentRange;
-      const startNode = startContainer.parentElement;
-      const endNode = endContainer.parentElement;
-      const startItemDto = startNode && node_abstract.stateEntityRenderingRegistry.getEntityByDOM(startNode);
-      const endItemDto = endNode && node_abstract.stateEntityRenderingRegistry.getEntityByDOM(endNode);
-      let startIndex = 0, endIndex = this.text.length;
-      if (startItemDto && startItemDto === this) {
-        startIndex = startOffset;
-        endIndex = startContainer === endContainer ? endOffset : endIndex;
-      }
-      else if (endItemDto && endItemDto === this) {
-        endIndex = endOffset;
-      }
-      this.apply(new UpdateTextAction(this.text.slice(0, startIndex) + text + this.text.slice(endIndex)));
-    }
-  }
-  updateText(newText) {
-    this.text = newText;
-    // The link node should be unlink when delete all text
-    if (!this.text && this.isLinkNode()) {
-      this.annotationMap.delete(node_abstract.NodeAnnotationTypeEnum.LINK);
-    }
-  }
-  isLinkNode() {
-    return this.annotationMap.has('LINK');
-  }
-  shouldSplitSelection(range) {
-    const { startContainer, endContainer, startOffset, endOffset } = range;
-    const isCrossNode = startContainer !== endContainer;
-    const isPartialStart = startOffset > 0;
-    const isPartialEnd = endOffset < (endContainer.textContent ? endContainer.textContent.length : 0);
-    const isPartialSelection = isPartialStart || isPartialEnd;
-    return isCrossNode || isPartialSelection;
-  }
-  syncUpSelectedNodes(selectedNode) {
-    const currentNodeDom = node_abstract.stateEntityRenderingRegistry.getDOMByEntity(this);
-    if (currentNodeDom) {
-      const nodeSubject = domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubjectFromParentNodeByEventId(currentNodeDom, vegaInternalEventId.VegaInternalRichTextEditorSelectionRangeChange);
-      if (nodeSubject) {
-        changeManager.ChangeManager.notify(nodeSubject, { node: selectedNode });
-      }
-    }
-  }
-  insertNewNode(startOffset, action) {
-    if (startOffset === 0) {
-      const newNode = this.cloneWithText('');
-      this.applyActionToNode(newNode, action);
-      return [newNode, this];
-    }
-    if (startOffset === this.text.length) {
-      const newNode = this.cloneWithText('');
-      this.applyActionToNode(newNode, action);
-      return [this, newNode];
-    }
-    const beforeNode = this.cloneWithText(this.text.substring(0, startOffset));
-    const newNode = this.cloneWithText('');
-    const afterNode = this.cloneWithText(this.text.substring(startOffset));
-    this.applyActionToNode(newNode, action);
-    return [beforeNode, newNode, afterNode];
-  }
-}
-
-exports.AnnotationAction = AnnotationAction;
-exports.BoldAnnotation = BoldAnnotation;
-exports.ClearFormattingAnnotationAction = ClearFormattingAnnotationAction;
-exports.CodeAnnotationAction = CodeAnnotationAction;
-exports.DeleteNodeAnnotationAction = DeleteNodeAnnotationAction;
-exports.ItalicAnnotation = ItalicAnnotation;
-exports.LinkAnnotationAction = LinkAnnotationAction;
-exports.LinkGroupAnnotationAction = LinkGroupAnnotationAction;
-exports.RTETextNode = RTETextNode;
-exports.RTE_TEXT_COLORS = RTE_TEXT_COLORS;
-exports.SelectionRangeAnnotation = SelectionRangeAnnotation;
-exports.StrikethroughAnnotation = StrikethroughAnnotation;
-exports.SyncUpSelectionAction = SyncUpSelectionAction;
-exports.TextColorAnnotation = TextColorAnnotation;
-exports.TextNodeRenderingRegistry = TextNodeRenderingRegistry$1;
-exports.TextSplittableAction = TextSplittableAction;
-exports.UnderlineAnnotation = UnderlineAnnotation;
-exports.UpdateTextAction = UpdateTextAction;
-exports.ZERO_WIDTH_SPACE = ZERO_WIDTH_SPACE;
-exports.waitForComponentDidRender = waitForComponentDidRender;
-exports.waitForVega = waitForVega;