@globalpayments/vega 2.57.1 → 2.59.0

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/color-annotation-handler.d.ts

@@ -0,0 +1,25 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle color annotation */
+export declare class ColorAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement, parentAnnotations?: VegaRTETextAnnotations): VegaRTETextAnnotations;
+  /**
+   * Get current color of element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<string>} - color.
+   */
+  private getColor;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/custom-attribute-annotation-handler.d.ts

@@ -0,0 +1,35 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { HtmlElementToAnnotationGenerateOptions, RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle custom attribute annotation */
+export declare class CustomAttributeAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * Can be handle.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
+   * @returns {boolean} - .
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T, options: HtmlElementToAnnotationGenerateOptions): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement): VegaRTETextAnnotations;
+  /**
+   * Obtain the custom attributes of element, excluding 'style' and 'class'.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Record<string, string>} - Record<string, string>.
+   */
+  private getAttributes;
+  /**
+   * Check if the attribute name is valid.
+   *
+   * @param {string} attr - Attribute name.
+   * @returns {boolean} - True if valid, false otherwise.
+   */
+  private isValidAttr;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/custom-class-annotation-handler.d.ts

@@ -0,0 +1,28 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { HtmlElementToAnnotationGenerateOptions, RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle custom class annotation */
+export declare class CustomClassAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * Can be handle.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
+   * @returns {boolean} - .
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T, options: HtmlElementToAnnotationGenerateOptions): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement): VegaRTETextAnnotations;
+  /**
+   * Get the custom class
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {string[]} - the class after .
+   */
+  private getCustomClass;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/custom-style-annotation-handler.d.ts

@@ -0,0 +1,28 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { HtmlElementToAnnotationGenerateOptions, RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle custom style annotation */
+export declare class CustomStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * Can be handle.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options for annotation generator.
+   * @returns {boolean} - .
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T, options: HtmlElementToAnnotationGenerateOptions): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement): VegaRTETextAnnotations;
+  /**
+   * Obtain and format the style of element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {AnnotationStyle} - Record<string, string>.
+   */
+  private generateCustomStyleAnnotations;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator.d.ts

@@ -0,0 +1,26 @@
+import { VegaRTEAnnotations, VegaRTETextAnnotations, VegaRTETransformOptions } from '../../../../../interface';
+import { RTEBlock } from '../../../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../../../dto/nodes/node.abstract';
+import { ClassPrototype } from '../../../../../../../types/class.type';
+export declare type RTEDtoClassPrototype = ClassPrototype<RTEBlock | RTENode>;
+export declare type HtmlElementToAnnotationGenerateOptions = {
+  parentAnnotations?: VegaRTETextAnnotations;
+} & Partial<Pick<VegaRTETransformOptions, 'autoMatchFormat' | 'skipCustomAnnotations'>>;
+/** Html element to annotations generator */
+declare class HtmlElementToAnnotationGenerator {
+  private handlers;
+  /**
+   * The function generates annotations for a given target DTO and HTML element based on a set of
+   * strategies.
+   *
+   * @typedef T class name of target DTO
+   * @typedef V generated annotations type
+   * @param {T} targetDto - Which DTO is the generated annotations to set.
+   * @param {HTMLElement} element - Current html element.
+   * @param {HtmlElementToAnnotationGenerateOptions} [options] - Options
+   * @returns {V} Generated annotations.
+   */
+  generate<T extends RTEDtoClassPrototype, V extends VegaRTEAnnotations>(targetDto: T, element: HTMLElement, options?: HtmlElementToAnnotationGenerateOptions): V;
+}
+declare const _default: HtmlElementToAnnotationGenerator;
+export default _default;

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/image-alt-annotation-handler.d.ts

@@ -0,0 +1,17 @@
+import { VegaRTEImageAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle image alt annotation */
+export declare class ImageAltAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTEImageAnnotations} - Annotation.
+   */
+  handle(element: HTMLImageElement): VegaRTEImageAnnotations;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/image-size-annotation-handler.d.ts

@@ -0,0 +1,24 @@
+import { VegaRTEImageAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle image size annotation */
+export declare class ImageSizeAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTEImageAnnotations} - Annotation.
+   */
+  handle(element: HTMLImageElement): VegaRTEImageAnnotations;
+  /**
+   * Determine the image display size based on the width of the current element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<VegaRichTextImageEditorSizeType>} -Image size, default 'md'.
+   */
+  private getImageSize;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/indent-annotation-handler.d.ts

@@ -0,0 +1,24 @@
+import { VegaRTEBlockAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle indent annotation */
+export declare class IndentAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTEBlockAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement): VegaRTEBlockAnnotations;
+  /**
+   * Get indent of current element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<number>} - Indent.
+   */
+  private getIndent;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/inline-html-annotation-handler.d.ts

@@ -0,0 +1,28 @@
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { HtmlElementToAnnotationGenerateOptions, RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+import { VegaRTEAnnotations } from '../../../../../interface';
+/**
+ * Handle inline html annotation
+ */
+export declare class InlineHtmlAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  static canHandleTags: string[];
+  private customAttributeHandler;
+  private customStyleAnnotationHandler;
+  private customClassAnnotationHandler;
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T, options: HtmlElementToAnnotationGenerateOptions): boolean;
+  /**
+   * @inheritDoc
+   */
+  handle(element: HTMLElement, parentAnnotations?: VegaRTEAnnotations): VegaRTEAnnotations;
+  /**
+   * Generate inline html annotation.
+   *
+   * @param {HTMLElement} child - Current element.
+   * @param {VegaRTETextAnnotations} annotations - Current annotations.
+   * @returns {Nullable<VegaInlineHtmlSchema>} - Inline html annotation.
+   */
+  private generateInlineHtmlAnnotation;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/italic-annotation-handler.d.ts

@@ -0,0 +1,25 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle italic annotation */
+export declare class ItalicAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement, parentAnnotations?: VegaRTETextAnnotations): VegaRTETextAnnotations;
+  /**
+   * Is italic element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isItalic;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/link-annotation-handler.d.ts

@@ -0,0 +1,29 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle link annotation */
+export declare class LinkAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  private handlers;
+  /**
+   * Can be handle.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @returns {boolean} - .
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement, parentAnnotations?: VegaRTETextAnnotations): VegaRTETextAnnotations;
+  /**
+   * Generate link annotations.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTELink} - link annotations.
+   */
+  private generateLinkAnnotations;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/strike-through-annotation-handler.d.ts

@@ -0,0 +1,25 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle strike through annotation */
+export declare class StrikeThroughAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement, parentAnnotations?: VegaRTETextAnnotations): VegaRTETextAnnotations;
+  /**
+   * Is strikethrough element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isStrikethrough;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/text-align-annotation-handler.d.ts

@@ -0,0 +1,27 @@
+import { VegaRTEBlockAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle text align annotation */
+export declare class TextAlignAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * Can be handle.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @returns {boolean} - .
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTEBlockAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement): VegaRTEBlockAnnotations;
+  /**
+   * Get text align of current element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<VegaRTEBlockAlignment>} - Text align.
+   */
+  private getTextAlign;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/text-style-annotation-handler.d.ts

@@ -0,0 +1,57 @@
+import { VegaRTETextBlockAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { HtmlElementToAnnotationGenerateOptions, RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle text style annotation */
+export declare class TextStyleAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * Can be handle.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @param {HtmlElementToAnnotationGenerateOptions} options - Options for annotation generator.
+   * @returns {boolean} - .
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T, options: HtmlElementToAnnotationGenerateOptions): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @returns {VegaRTETextBlockAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement): VegaRTETextBlockAnnotations;
+  /**
+   * Get the node type of element. The element type is determined in the following
+   * order: "data-type" attribute, node name, font size and class name.
+   *
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - node type.
+   */
+  private getTextStyle;
+  /**
+   * Get the element type by data-type attribute.
+   *
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
+   */
+  private getElementTypeByDataType;
+  /**
+   * Get the element type by font size.
+   *
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
+   */
+  private getElementTypeByFontSize;
+  /**
+   * Get the element type by node name.
+   *
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
+   */
+  private getElementTypeByNodeName;
+  /**
+   * Get the element type by class name.
+   *
+   * @param {HTMLElement} element - element.
+   * @returns {Nullable<VegaRTETextStyleType>} - element type or null if not found.
+   */
+  private getElementTypeByClassName;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/underline-annotation-handler.d.ts

@@ -0,0 +1,25 @@
+import { VegaRTETextAnnotations } from '../../../../../interface';
+import { AnnotationGeneratorStrategyAbstract } from './annotation-generator-strategy.abstract';
+import { RTEDtoClassPrototype } from './html-element-to-annotation-generator';
+/** Handle underline annotation */
+export declare class UnderlineAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation.
+   *
+   * @param {HTMLElement} element - Current elements.
+   * @param {VegaRTETextAnnotations} parentAnnotations - Parent annotations.
+   * @returns {VegaRTETextAnnotations} - Annotation.
+   */
+  handle(element: HTMLElement, parentAnnotations?: VegaRTETextAnnotations): VegaRTETextAnnotations;
+  /**
+   * Is underline element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isUnderline;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract.d.ts

@@ -1,7 +1,8 @@
-import { VegaRTEBlockAnnotations, VegaRTECodeAnnotations, VegaRTETextAnnotations, VegaRTETextNode } from '../../../../interface';
+import { VegaRTETextAnnotations, VegaRTETextBlockType, VegaRTETextNode, VegaRTETransformOptions } from '../../../../interface';
 import { ElementToDTOStrategy } from './element-to-dto-strategy.abstract';
 /** Abstract class for block html element to RTE block dto */
 export declare abstract class BlockToRTEBlockStrategyAbstract extends ElementToDTOStrategy {
+  private annotationHandler;
   /**
    * Generate child nodes of block element, this will inherit all annotations from parent to text node and
    *   flat the child nodes.
@@ -9,104 +10,30 @@ export declare abstract class BlockToRTEBlockStrategyAbstract extends ElementToD
    * Example:
    *   <li>
    *     <u><i>text1</i></u>
+   *     <span></span>
    *     <span style='font-weight: bold;'><span>text2</span></span>
    *     text3
    *   </li>
    * will tranform to:
    *   <li>
    *     <span>text1</span> // with underline and italic annotations
+   *     <span></span>      // empty span
    *     <span>text2</span> // with bold annotations
    *     <span>text3</span> // no annotations
    *   </li>
    *
    * @param {HTMLElement[]} elements - Child elements.
-   * @param {VegaRTETextAnnotations | VegaRTECodeAnnotations} annotations - Parent annotations.
+   * @param {VegaRTETextAnnotations} annotations - Parent annotations.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {VegaRTETextNode[]} - Text node DTO.
    */
-  protected generateChildNodes(elements: HTMLElement[], annotations?: VegaRTETextAnnotations | VegaRTECodeAnnotations): VegaRTETextNode[];
+  protected generateChildNodes(elements: HTMLElement[], annotations?: VegaRTETextAnnotations, options?: VegaRTETransformOptions): VegaRTETextNode[];
   /**
-   * Generate annotations map for block element.
+   * Get the node type of element. The element type is determined in the following
+   * order: "data-type" attribute, node name, font size and class name.
    *
-   * @param {HTMLElement} element - current element.
-   * @returns {VegaRTEBlockAnnotations} - Text block annotations.
+   * @param {HTMLElement} element - element.
+   * @returns {VegaRTETextBlockType} - Block type.
    */
-  protected generateBlockAnnotations(element: HTMLElement): VegaRTEBlockAnnotations;
-  /**
-   * Generate annotations map for text node element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @param {VegaRTETextAnnotations | VegaRTECodeAnnotations} parentAnnotations - parent annotations
-   * @returns {VegaRTETextAnnotations | VegaRTECodeAnnotations} - Text node annotations.
-   */
-  protected generateTextNodeAnnotations(element: HTMLElement, parentAnnotations?: VegaRTETextAnnotations | VegaRTECodeAnnotations): VegaRTETextAnnotations | VegaRTECodeAnnotations;
-  /**
-   * Check is a invalid text node.
-   *
-   * @param {HTMLElement} element - Current node element.
-   * @returns {boolean} - boolean.
-   */
-  private isInvalidTextNode;
-  /**
-   * Is code element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  private isCode;
-  /**
-   * Is bold element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  private isBold;
-  /**
-   * Is italic element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  private isItalic;
-  /**
-   * Is underline element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  private isUnderline;
-  /**
-   * Is strikethrough element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  private isStrikethrough;
-  /**
-   * Get current color of element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<string>} - color.
-   */
-  private getColor;
-  /**
-   * Get current link of element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<VegaRTELink>} - link.
-   */
-  private getLink;
-  /**
-   * Get text align of current element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<VegaRTEBlockAlignment>} - Text align.
-   */
-  private getTextAlign;
-  /**
-   * Get indent of current element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<number>} - Indent.
-   */
-  private getIndent;
+  protected matchTextBlockType(element: HTMLElement): VegaRTETextBlockType;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/continue-inline-to-rte-text-block-strategy.d.ts

@@ -1,5 +1,5 @@
 import { Nullable } from '../../../../../../types/general';
-import { RTEContentBlock } from '../../../../interface';
+import { RTEContentBlock, VegaRTETransformOptions } from '../../../../interface';
 import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
 /** Transform continue inline block elements to text block DTO */
 export declare class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBlockStrategyAbstract {
@@ -16,9 +16,10 @@ export declare class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBloc
    * Parse to a text block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - Text block.
    */
-  handle(elementsArray: HTMLElement[]): Nullable<RTEContentBlock>;
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEContentBlock>;
   /**
    * Append child blocks.
    */
@@ -29,4 +30,11 @@ export declare class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBloc
    * @returns {boolean} - boolean.
    */
   shouldProceedToElementChildren(): boolean;
+  /**
+   * Match the block type by tag name.
+   *
+   * @param {HTMLElement} element - Target element.
+   * @returns {Nullable<VegaRTETextBlockType>} - Block type.
+   */
+  private matchTextBlockTypeByTagName;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy-processor.d.ts

@@ -1,14 +1,15 @@
 import { ElementToDTOStrategyOutput } from './element-to-dto-strategy.abstract';
+import { VegaRTETransformOptions } from '../../../../interface';
 /** Element to DTO processor */
-export declare class ElementToDtoStrategyProcessor {
-  private elementStrategies;
+declare class ElementToDtoStrategyProcessor {
   /**
    * Transform process.
    *
    * @param {HTMLElement[]} elements - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {ElementToDTOStrategyOutput[]} - outputs.
    */
-  process(elements: HTMLElement[]): ElementToDTOStrategyOutput[];
+  process(elements: HTMLElement[], options?: VegaRTETransformOptions): ElementToDTOStrategyOutput[];
   /**
    * Checks if the given element is valid to parse.
    *
@@ -16,4 +17,12 @@ export declare class ElementToDtoStrategyProcessor {
    * @returns {boolean} Is valid
    */
   private isInvalidElement;
+  /**
+   * Get the register element to block strategies.
+   *
+   * @returns {ElementToDTOStrategy[]} - The register element to block strategies.
+   */
+  private getElementToBlockStrategies;
 }
+declare const _default: ElementToDtoStrategyProcessor;
+export default _default;

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract.d.ts

@@ -1,11 +1,12 @@
 import { Nullable } from '../../../../../../types/general';
-import { RTEContentBlock } from '../../../../interface';
+import { RTEContentBlock, VegaRTECustomNode, VegaRTETextAnnotations, VegaRTETransformOptions } from '../../../../interface';
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
 /**
  * Abstract class to define strategies for processing HTML elements
  */
 export declare abstract class ElementToDTOStrategy {
-  abstract canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
-  abstract handle(elementsArray: HTMLElement[]): Nullable<RTEContentBlock>;
+  abstract canHandle(elementsArray: HTMLElement[], currentIndex: number, options: VegaRTETransformOptions): number;
+  abstract handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions, parentTextAnnotations?: VegaRTETextAnnotations): Nullable<RTEBlock | VegaRTECustomNode>;
   abstract appendChildBlocks(currentBlock: RTEContentBlock, childBlocks: RTEContentBlock[]): void;
   abstract shouldProceedToElementChildren(): boolean;
 }
@@ -26,7 +27,8 @@ export declare class ElementToDTOStrategyOutput {
   /**
    * Transform current output and children output to DTO
    *
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - DTO.
    */
-  toDto(): Nullable<RTEContentBlock>;
+  toDto(options?: VegaRTETransformOptions): Nullable<RTEContentBlock>;
 }