@globalpayments/vega 2.33.0 → 2.34.1

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

@@ -0,0 +1,955 @@
+'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;