@heartlandone/vega 2.49.1 → 2.50.0-RTE-preview

package/dist/collection/components/vega-rich-text-editor/dto/annotations/image-annotation.js

@@ -42,20 +42,29 @@ export class ImageAnnotation extends NodeAnnotation {
     return new ImageAnnotation(this.size, this.alt);
   }
   /**
-   * Generate the style for the image
-   *
-   * @returns {Nullable<AnnotationStyle>} image style
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return `v-rte--image-size-${this.size}`;
+  }
+  /**
+   * @inheritDoc
    */
-  render() {
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    const baseStyle = { verticalAlign: 'bottom' };
     switch (this.size) {
       case 'sm': {
-        return { width: '25%' };
+        return Object.assign(Object.assign({}, baseStyle), { width: '25%' });
       }
       case 'md': {
-        return { width: '50%' };
+        return Object.assign(Object.assign({}, baseStyle), { width: '50%' });
       }
       case 'lg': {
-        return { width: '100%' };
+        return Object.assign(Object.assign({}, baseStyle), { width: '100%' });
       }
     }
   }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/indent-annotation.js

@@ -31,12 +31,18 @@ export class IndentAnnotation extends BlockAnnotation {
   clone() {
     return new IndentAnnotation(this.indent);
   }
+  /**
+   * @inheritDoc
+   */
+  renderClass() {
+    return null;
+  }
   /**
    * Generate the style for the annotation
    *
    * @returns {Nullable<AnnotationStyle>} - Annotation style
    */
-  render() {
-    return this.indent > 0 ? { 'margin-left': `${this.indent * 16}px` } : null;
+  renderStyle() {
+    return this.indent > 0 ? { marginLeft: `${this.indent * 16}px` } : null;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/italic-annotation.js

@@ -34,11 +34,19 @@ export class ItalicAnnotation extends NodeAnnotation {
     return new ItalicAnnotation(this.italic);
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Italic style
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return this.italic ? 'v-rte--italic' : null;
+  }
+  /**
+   * @inheritDoc
    */
-  render() {
-    return this.italic ? { 'font-style': 'italic' } : null;
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return this.italic ? { fontStyle: 'italic' } : null;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/link-annotation.js

@@ -15,10 +15,7 @@ export class LinkAnnotation extends NodeAnnotation {
    * @returns {[NodeAnnotationTypeEnum.LINK, LinkAnnotation]} Map item for the annotation
    */
   static from(link) {
-    return [
-      NodeAnnotationTypeEnum.LINK,
-      new LinkAnnotation({ href: link.href, groupKey: link.groupKey }),
-    ];
+    return [NodeAnnotationTypeEnum.LINK, new LinkAnnotation(link)];
   }
   /**
    * Generate the JSON representation of the annotation
@@ -26,7 +23,9 @@ export class LinkAnnotation extends NodeAnnotation {
    * @returns {Record<'link', VegaRTELink>} JSON representation of the annotation
    */
   toJSON() {
-    return { link: { href: this.link.href, groupKey: this.link.groupKey } };
+    return {
+      link: this.link,
+    };
   }
   /**
    * @inheritDoc
@@ -44,11 +43,15 @@ export class LinkAnnotation extends NodeAnnotation {
     return this.link.groupKey === annotation.link.groupKey;
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Link style
+   * @inheritDoc
+   */
+  renderClass() {
+    return null;
+  }
+  /**
+   * @inheritDoc
    */
-  render() {
+  renderStyle() {
     return null;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/link-group-annotation.js

@@ -1,4 +1,5 @@
 import { Annotation, InternalAnnotationTypeEnum } from './annotation.abstract';
+import { camelToDashCase } from '../../../../utils/string';
 /**
  * Annotation to represent a link of grouped nodes
  */
@@ -16,4 +17,92 @@ export class LinkGroupAnnotation extends Annotation {
     });
     return clonedAnnotation;
   }
+  /**
+   * Convert the custom style, class and attribute to string which html can used
+   *
+   * @param {linkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @param {RTERenderContext} options - options.
+   * @returns {string} - string.
+   */
+  toString(linkAnnotation, options) {
+    const attributes = this.toJsx(linkAnnotation, options);
+    return Object.entries(attributes)
+      .map(([key, value]) => {
+      const valueString = typeof value === 'string' ? value : this.formatStyleToString(value);
+      return `${camelToDashCase(key)}="${valueString}"`;
+    })
+      .join(' ');
+  }
+  /**
+   * Convert the custom style, class and attribute to JSX attributes
+   *
+   * @param {linkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @param {RTERenderContext} options - options.
+   * @returns {Record<string, string | AnnotationStyle>} JSX used attributes.
+   */
+  toJsx(linkAnnotation, options) {
+    const linkStyle = this.getStyle(linkAnnotation, options);
+    const linkClass = this.getClass(linkAnnotation, options);
+    const attributes = this.getAttribute(linkAnnotation);
+    if (linkClass.length > 0) {
+      attributes.class = linkClass.join(' ');
+    }
+    if (linkStyle && Object.keys(linkStyle).length > 0) {
+      attributes.style = linkStyle;
+    }
+    return attributes;
+  }
+  /**
+   * Get the custom class for the annotation
+   *
+   * @param {linkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @param {RTERenderContext} options - options.
+   * @returns {string[]} Link class
+   */
+  getClass(linkAnnotation, options) {
+    const linkClass = [];
+    if (linkAnnotation.link.customClass)
+      linkClass.push(...linkAnnotation.link.customClass);
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      linkClass.push('v-rte--link');
+    return linkClass;
+  }
+  /**
+   * Get the custom style for the annotation
+   *
+   * @param {LinkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @param {RTERenderContext} options - options.
+   * @returns {AnnotationStyle} Link style
+   */
+  getStyle(linkAnnotation, options) {
+    const linkStyle = {};
+    if (linkAnnotation.link.customStyle)
+      Object.assign(linkStyle, linkAnnotation.link.customStyle);
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      linkStyle.color = 'rgba(var(--v-text-link, 19, 98, 226, 1))';
+    return linkStyle;
+  }
+  /**
+   * Get the custom attribute for the annotation
+   *
+   * @param {LinkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @returns {Record<string, string>} Link attributes
+   */
+  getAttribute(linkAnnotation) {
+    const { href, customAttribute = {} } = linkAnnotation.link;
+    customAttribute.href = href;
+    customAttribute.target = customAttribute.target || '_blank';
+    return customAttribute;
+  }
+  /**
+   * Convert style to string which can be used to html string.
+   *
+   * @param {AnnotationStyle} style Style object.
+   * @returns {string} Style string
+   */
+  formatStyleToString(style) {
+    return Object.entries(style)
+      .map(([key, value]) => `${camelToDashCase(key)}: ${value};`)
+      .join(' ');
+  }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/list-annotation.js

@@ -0,0 +1,41 @@
+import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
+/**
+ * List annotation
+ */
+export class ListAnnotation extends BlockAnnotation {
+  constructor() {
+    super(...arguments);
+    this.type = BlockAnnotationTypeEnum.LIST;
+  }
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return {
+      paddingLeft: '8px',
+      marginLeft: '16px',
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return 'v-rte--list';
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    return new ListAnnotation();
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return undefined;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/strikethrough-annotation.js

@@ -34,19 +34,19 @@ export class StrikethroughAnnotation extends NodeAnnotation {
     return new StrikethroughAnnotation(this.strikethrough);
   }
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
+   * @inheritDoc
    */
-  renderClass() {
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
     return this.strikethrough ? 'v-rte--strikethrough' : null;
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   * @inheritDoc
    */
-  render() {
-    return null;
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return this.strikethrough ? { textDecoration: 'line-through' } : null;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/text-color-annotation.js

@@ -36,19 +36,15 @@ export class TextColorAnnotation extends NodeAnnotation {
     return new TextColorAnnotation(this.textColor.key);
   }
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
+   * @inheritDoc
    */
   renderClass() {
     return null;
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   * @inheritDoc
    */
-  render() {
+  renderStyle() {
     return {
       color: VegaInternalThemeManager.isDarkMode() ? this.textColor.dark : this.textColor.light,
     };

package/dist/collection/components/vega-rich-text-editor/dto/annotations/text-style-annotation.js

@@ -32,44 +32,106 @@ export class TextStyleAnnotation extends BlockAnnotation {
     return new TextStyleAnnotation(this.textStyle);
   }
   /**
-   * Render the styles by block type
-   *
-   * @returns {AnnotationStyle} the styles to apply
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return `v-rte--text-style-${this.textStyle}`;
+  }
+  /**
+   * @inheritDoc
    */
-  render() {
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
     const paragraphStyle = {
       fontFamily: 'Inter',
       fontSize: '16px',
       lineHeight: '22px',
       fontWeight: '500',
+      marginTop: '0px',
+      marginBottom: '0px',
     };
     switch (this.textStyle) {
       case 'paragraph': {
         return paragraphStyle;
       }
       case 'title': {
-        return { fontFamily: 'Inter', fontSize: '36px', lineHeight: '40px', fontWeight: '500' };
+        return {
+          fontFamily: 'Inter',
+          fontSize: '36px',
+          lineHeight: '40px',
+          fontWeight: '500',
+        };
       }
       case 'subtitle': {
-        return { fontFamily: 'Inter', fontSize: '28px', lineHeight: '32px', fontWeight: '500' };
+        return {
+          fontFamily: 'Inter',
+          fontSize: '28px',
+          lineHeight: '32px',
+          fontWeight: '500',
+        };
       }
       case 'heading-1': {
-        return { fontFamily: 'Inter', fontSize: '22px', lineHeight: '24px', fontWeight: '500' };
+        return {
+          fontFamily: 'Inter',
+          fontSize: '22px',
+          lineHeight: '24px',
+          fontWeight: '500',
+          marginTop: '0px',
+          marginBottom: '0px',
+        };
       }
       case 'heading-2': {
-        return { fontFamily: 'Inter', fontSize: '20px', lineHeight: '24px', fontWeight: '500' };
+        return {
+          fontFamily: 'Inter',
+          fontSize: '20px',
+          lineHeight: '24px',
+          fontWeight: '500',
+          marginTop: '0px',
+          marginBottom: '0px',
+        };
       }
       case 'heading-3': {
-        return { fontFamily: 'Inter', fontSize: '18px', lineHeight: '22px', fontWeight: '500' };
+        return {
+          fontFamily: 'Inter',
+          fontSize: '18px',
+          lineHeight: '22px',
+          fontWeight: '500',
+          marginTop: '0px',
+          marginBottom: '0px',
+        };
       }
       case 'heading-4': {
-        return { fontFamily: 'Inter', fontSize: '16px', lineHeight: '22px', fontWeight: '500' };
+        return {
+          fontFamily: 'Inter',
+          fontSize: '16px',
+          lineHeight: '22px',
+          fontWeight: '500',
+          marginTop: '0px',
+          marginBottom: '0px',
+        };
       }
       case 'heading-5': {
-        return { fontFamily: 'Inter', fontSize: '14px', lineHeight: '22px', fontWeight: '500' };
+        return {
+          fontFamily: 'Inter',
+          fontSize: '14px',
+          lineHeight: '22px',
+          fontWeight: '500',
+          marginTop: '0px',
+          marginBottom: '0px',
+        };
       }
       case 'heading-6': {
-        return { fontFamily: 'Inter', fontSize: '12px', lineHeight: '22px', fontWeight: '500' };
+        return {
+          fontFamily: 'Inter',
+          fontSize: '12px',
+          lineHeight: '22px',
+          fontWeight: '500',
+          marginTop: '0px',
+          marginBottom: '0px',
+        };
       }
     }
   }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/underline-annotation.js

@@ -34,19 +34,19 @@ export class UnderlineAnnotation extends NodeAnnotation {
     return new UnderlineAnnotation(this.underline);
   }
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
+   * @inheritDoc
    */
-  renderClass() {
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
     return this.underline ? 'v-rte--underline' : null;
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   * @inheritDoc
    */
-  render() {
-    return null;
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return this.underline ? { textDecoration: 'underline' } : null;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/blocks/block.abstract.js

@@ -7,6 +7,12 @@ import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { HorizontalAlignmentAnnotation } from '../annotations/horizontal-alignment-annotation';
 import { IndentAnnotation } from '../annotations/indent-annotation';
 import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
+import { isNonNullable } from '../../../../types/type-guard';
+import { camelToDashCase } from '../../../../utils/string';
+import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annotation';
+import { CustomClassAnnotation } from '../annotations/custom-class-annotation';
+import { CommonAnnotation, CommonAnnotationTypeEnum } from '../annotations/common-annotation.abstract';
+import { CustomStyleAnnotation } from '../annotations/custom-style-annotation';
 /**
  * Abstract class for block
  */
@@ -24,7 +30,7 @@ export class RTEBlock {
    * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
    * that will be used to create the annotation entity. It can be of any type depending on the specific
    * annotation being created.
-   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} The `createAnnotationEntity` function returns a nullable tuple containing a
+   * @returns {Nullable<BlockAnnotationsEntity>} The `createAnnotationEntity` function returns a nullable tuple containing a
    * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
    */
   static createAnnotationEntity(type, value) {
@@ -33,6 +39,12 @@ export class RTEBlock {
         return HorizontalAlignmentAnnotation.from(value);
       case 'indent':
         return IndentAnnotation.from(value);
+      case 'customAttribute':
+        return CustomAttributeAnnotation.from(value);
+      case 'customClass':
+        return CustomClassAnnotation.from(value);
+      case 'customStyle':
+        return CustomStyleAnnotation.from(value);
     }
   }
   /**
@@ -42,7 +54,7 @@ export class RTEBlock {
    */
   toJSON() {
     const annotations = Array.from(this.annotationMap.values())
-      .filter((annotation) => annotation instanceof BlockAnnotation)
+      .filter((annotation) => annotation instanceof BlockAnnotation || annotation instanceof CommonAnnotation)
       .reduce((record, annotation) => {
       return Object.assign(Object.assign({}, record), annotation.toJSON());
     }, {});
@@ -75,6 +87,61 @@ export class RTEBlock {
       }
     }
   }
+  /**
+   * Get styles from annotations
+   *
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control style mode
+   * @returns {AnnotationStyle} - Annotation styles
+   */
+  getStyles(options = { standalone: false }) {
+    return Array.from(this.annotationMap.values())
+      .filter((annotation) => annotation instanceof BlockAnnotation || annotation instanceof CustomStyleAnnotation)
+      .map((annotation) => annotation.renderStyle(options))
+      .filter(isNonNullable)
+      .reduce((current, obj) => (Object.assign(Object.assign({}, current), obj)), {});
+  }
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control standalone mode
+   * @returns {string} - Annotation style
+   */
+  getClasses(options = { standalone: false }) {
+    return Array.from(this.annotationMap.values())
+      .filter((annotation) => annotation instanceof BlockAnnotation || annotation instanceof CustomClassAnnotation)
+      .map((annotation) => annotation.renderClass(options))
+      .filter(isNonNullable)
+      .reduce((pre, cur) => [pre, cur].join(' ').trim(), '');
+  }
+  /**
+   * Get custom attribute annotation, excluding "class" and "style"
+   *
+   * @returns {Nullable<CustomAttributeAnnotation>} - custom attribute annotation
+   */
+  getCustomAttributesAnnotation() {
+    return this.annotationMap.get(CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE);
+  }
+  /**
+   * Generate attributes as string
+   *
+   * @param {...string} attrs - Additional attributes to include
+   * @returns {string} - Attributes as string
+   */
+  generateAttributeString(...attrs) {
+    var _a;
+    const styles = Object.entries(Object.assign({}, this.getStyles({ standalone: true })))
+      .map(([key, value]) => `${camelToDashCase(key)}: ${value};`)
+      .join('');
+    const customClassAnnotation = this.annotationMap.get(CommonAnnotationTypeEnum.CUSTOM_CLASS);
+    const customAttributeString = ((_a = this.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.toString(attrs)) || [];
+    const attributes = [
+      ...customAttributeString,
+      customClassAnnotation === null || customClassAnnotation === void 0 ? void 0 : customClassAnnotation.toString(),
+      styles ? `style="${styles}"` : null,
+      ...attrs,
+    ].filter(isNonNullable);
+    return attributes.length ? ` ${attributes.join(' ')}` : '';
+  }
   /**
    * Apply action to block
    *

package/dist/collection/components/vega-rich-text-editor/dto/blocks/code-block.js

@@ -0,0 +1,106 @@
+import { RTEBlock } from './block.abstract';
+import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
+import { ModifyContentAction, ModifyContentActionType } from '../actions/modify-content-action.abstract';
+import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
+import domNodeSubjectFactory from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
+import { VegaInternalRichTextEditorFlushChanges } from '../../../../helpers/event-manager/event-id/vega-internal-event-id';
+import changeManager from '../../../../helpers/change-manager/change-manager';
+import { CodeBlockRemoveSelfStrategy } from '../action-handle-strategies/modify-content-strategies/code-block-remove-self-strategy';
+import { SwitchOutFromCodeBlockStrategy } from '../action-handle-strategies/modify-content-strategies/switch-out-from-code-block-strategy';
+import { RTECodeBlockNode } from '../nodes/code-block-node';
+import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
+import { CodeBlockInsertImageStrategy } from '../action-handle-strategies/modify-content-strategies/code-block-insert-image-strategy';
+import { BlockRemoveNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-remove-node-strategy';
+import { CodeLanguage } from '../../../vega-code-block/types';
+/**
+ * The code block DTO class.
+ */
+export class RTECodeBlock extends RTEBlock {
+  constructor(id, content, language) {
+    super(id);
+    this.type = 'code-block';
+    this.nodes = [new RTECodeBlockNode(`${id}-1`, content, language, this)];
+  }
+  /**
+   * Converts a VegaRTECodeBlock into an RTECodeBlock.
+   *
+   * @param {VegaRTECodeBlock} block - The block object
+   * @returns {RTECodeBlock} A RTECodeBlock class
+   */
+  static from(block) {
+    return new RTECodeBlock(block.id, block.content, block.language);
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    const { language, text } = this.nodes[0];
+    return {
+      id: this.id,
+      type: 'code-block',
+      content: text,
+      language,
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml() {
+    const { language = CodeLanguage['Plain Text'] } = this.nodes[0];
+    return `<pre data-language="${language}" style="background-color: rgba(var(--v-bg-secondary, 245, 247, 247, 1)); padding: 12px">${this.nodes.map((node) => node.toHtml())}</pre>`;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    const cloneCodeBlock = RTECodeBlock.from(this.toJSON());
+    cloneCodeBlock.parent = this.parent;
+    return cloneCodeBlock;
+  }
+  /**
+   * Apply action to block
+   *
+   * @param {ModifyContentAction} action - modify content action.
+   */
+  apply(action) {
+    if (action instanceof ModifyContentAction) {
+      ActionHandleStrategyRegistry.executeTheStrategy(action, this);
+    }
+    if (action.isFlushable) {
+      const domNode = stateEntityRenderingRegistry.getDOMByEntity(this);
+      if (domNode) {
+        const nodeSubject = domNodeSubjectFactory.getSubjectFromParentNodeByEventId(domNode, VegaInternalRichTextEditorFlushChanges);
+        if (nodeSubject) {
+          changeManager.notify(nodeSubject, {});
+        }
+      }
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty() {
+    return !!this.nodes.length;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    return this.nodes[0];
+  }
+  /**
+   * The code block is selected or not.
+   *
+   * @returns {boolean} - The boolean result.
+   */
+  isSelected() {
+    return this.nodes[0].annotationMap.has(InternalAnnotationTypeEnum.SELECTION_RANGE);
+  }
+}
+(() => {
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CODE_BLOCK, RTECodeBlock.name, new CodeBlockRemoveSelfStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTECodeBlock.name, new BlockRemoveNodeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.SWITCH_OUT_FROM_CODE_BLOCK, RTECodeBlock.name, new SwitchOutFromCodeBlockStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTECodeBlock.name, new CodeBlockInsertImageStrategy());
+})();
+RTECodeBlock.CODE_BLOCK_PLACEHOLDER_CLASS_NAME = 'code-block-placeholder-element';