@globalpayments/vega 2.58.0 → 2.59.0

package/dist/collection/helpers/calendar/test/calendar-event.test.js

@@ -130,4 +130,61 @@ describe('calendar-event', () => {
     expect(copyEvent2.endDate.getDate()).toEqual(17);
     expect(copyEvent2.eventKey).toEqual('test');
   });
+  it('should return proper when call generateDateTimeString', () => {
+    const calendarEvent = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startTime: '10:00', endTime: '11:00' }));
+    expect(calendarEvent.generateDateTimeString(new CalendarDate(2024, 6, 14), '12-hour')).toBe('Friday, 14 Jun 2024 10:00 am - 11:00 am');
+    expect(calendarEvent.generateDateTimeString(new CalendarDate(2024, 6, 14), '24-hour')).toBe('Friday, 14 Jun 2024 10:00 - 11:00');
+  });
+  it('should return proper when call generateRepeatString', () => {
+    const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'daily',
+        interval: 2,
+      } }));
+    expect(calendarEvent1.generateRepeatString()).toBe('Repeat every 2 days');
+    const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'daily',
+      } }));
+    expect(calendarEvent2.generateRepeatString()).toBe('Repeat daily');
+    const calendarEvent3 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'weekly',
+        interval: 2,
+        byWeekDay: ['Thu', 'Fri'],
+      } }));
+    expect(calendarEvent3.generateRepeatString()).toBe('Repeat every 2 weeks on Thursday, Friday');
+    const calendarEvent4 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'weekly',
+        byWeekDay: ['Thu', 'Fri'],
+      } }));
+    expect(calendarEvent4.generateRepeatString()).toBe('Repeat weekly on Thursday, Friday');
+    const calendarEvent5 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', repeatOptions: {
+        frequency: 'monthly',
+        interval: 2,
+      } }));
+    expect(calendarEvent5.generateRepeatString()).toBe('Repeat every 2 months on day 14');
+    const calendarEvent6 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', repeatOptions: {
+        frequency: 'monthly',
+      } }));
+    expect(calendarEvent6.generateRepeatString()).toBe('Repeat monthly on day 14');
+    const calendarEvent7 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', repeatOptions: {
+        frequency: 'yearly',
+        interval: 2,
+      } }));
+    expect(calendarEvent7.generateRepeatString()).toBe('Repeat every 2 years on June 14');
+    const calendarEvent8 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', repeatOptions: {
+        frequency: 'yearly',
+      } }));
+    expect(calendarEvent8.generateRepeatString()).toBe('Repeat yearly on June 14');
+    const calendarEvent9 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'daily',
+        until: '06/20/2024',
+      } }));
+    expect(calendarEvent9.generateRepeatString()).toBe('Repeat daily until June 20, 2024');
+    const calendarEvent10 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'daily',
+        count: 20,
+      } }));
+    expect(calendarEvent10.generateRepeatString()).toBe('Repeat daily after 20 occurrences');
+    const calendarEvent11 = new CalendarEvent(Object.assign({}, rawEvent));
+    expect(calendarEvent11.generateRepeatString()).toBe('');
+  });
 });

package/dist/collection/helpers/calendar/utils.js

@@ -1,3 +1,4 @@
+import { VegaInternalTranslation } from '../translation';
 /**
  * Get a week days array
  *
@@ -8,3 +9,40 @@ export const getWeekdays = (firstWeekDay = 0) => {
   const weekdays = [0, 1, 2, 3, 4, 5, 6];
   return weekdays.concat(weekdays).slice(firstWeekDay, firstWeekDay + 7);
 };
+export var WeekdayLongNames;
+(function (WeekdayLongNames) {
+  WeekdayLongNames["sun"] = "Sunday";
+  WeekdayLongNames["mon"] = "Monday";
+  WeekdayLongNames["tue"] = "Tuesday";
+  WeekdayLongNames["wed"] = "Wednesday";
+  WeekdayLongNames["thu"] = "Thursday";
+  WeekdayLongNames["fri"] = "Friday";
+  WeekdayLongNames["sat"] = "Saturday";
+})(WeekdayLongNames || (WeekdayLongNames = {}));
+/**
+ * Format display time
+ *
+ * @param {TimeFormat} timeFormat - The time format (24-hour or 12-hour)
+ * @param {string} timeString - The time string to format
+ * @returns {string} - The formatted time string
+ */
+export const formatDisplayTime = (timeFormat, timeString) => {
+  const [hour, minutes] = timeString.split(':');
+  if (timeFormat === '24-hour') {
+    return `${hour.padStart(2, '0')}:${minutes.padStart(2, '0')}`;
+  }
+  else {
+    const hourNum = Number(hour);
+    const amPm = hourNum >= 12 ? 'pm' : 'am';
+    const minutesResult = minutes.padStart(2, '0');
+    if (hourNum > 12) {
+      return `${hourNum - 12}:${minutesResult} ${VegaInternalTranslation.t('pm')}`;
+    }
+    else if (hourNum === 0) {
+      return `12:${minutesResult} ${VegaInternalTranslation.t('am')}`;
+    }
+    else {
+      return `${hourNum}:${minutesResult} ${VegaInternalTranslation.t(amPm)}`;
+    }
+  }
+};

package/dist/collection/helpers/change-manager/subject/static-subject/static-subject-title.js

@@ -28,3 +28,4 @@ export const DARK_MODE_CHANGE = new StaticSubject('DARK_MODE_CHANGE');
 export const SHADOW_ROOT_ELEMENT_SCROLLING = new StaticSubject('SHADOW_ROOT_ELEMENT_SCROLLING');
 export const FLAG_ICON_LOADED = new StaticSubject('FLAG_ICON_LOADED');
 export const GP_BRAND_CHANGE = new StaticSubject('GP_BRAND_CHANGE');
+export const CALENDAR_EVENT_PREVIEW_POPOVER_HIDE = new StaticSubject('CALENDAR_EVENT_PREVIEW_POPOVER_HIDE');

package/dist/collection/helpers/code-format/code-formatter.js

@@ -0,0 +1,116 @@
+/**
+ * Class to format HTML code with proper indentation and style cleanup.
+ */
+class CodeFormatter {
+  constructor() {
+    /**
+     * Formats a given HTML source string by applying indentation and cleaning up styles.
+     *
+     * @param {string} source - The HTML source string to format.
+     * @param {CodeFormatOptions} options - Formatting options.
+     * @returns {string} The formatted HTML string.
+     */
+    this.format = (source, options = {}) => {
+      const { tabWidth = 4, useTabs = true } = options;
+      const indentUnit = useTabs ? '\t' : ' ';
+      const INDENT = indentUnit.repeat(tabWidth);
+      const tagRegex = /(<\/?[^>]+>)/g;
+      // Split source into tokens using tag boundaries while filtering out empty strings
+      const tokens = source.split(tagRegex).filter((t) => t.length > 0);
+      let indentLevel = 0;
+      let output = '';
+      for (let i = 0; i < tokens.length; i++) {
+        let token = tokens[i];
+        // Decrease indentation for closing tags
+        if (token.startsWith('</')) {
+          indentLevel = Math.max(0, indentLevel - 1);
+        }
+        const indent = INDENT.repeat(indentLevel);
+        if (token.startsWith('<')) {
+          // Clean and normalize inline style attributes
+          token = token.replace(/style\s*=\s*"([^"]*)"/g, (_, styleContent) => {
+            return `style="${this.formatStyle(styleContent)}"`;
+          });
+          const tagName = CodeFormatter.getTagName(token);
+          const isInline = CodeFormatter.INLINE_TAGS.has(tagName);
+          // Inline tag grouping: e.g., <strong>Text</strong> stays on one line
+          if (isInline && i + 2 < tokens.length && tokens[i + 2] === `</${tagName}>`) {
+            // Group consecutive inline tags
+            let inlineGroup = `${token}${tokens[i + 1]}${tokens[i + 2]}`;
+            i += 2;
+            // Keep merging consecutive inline tag pairs
+            while (i + 2 < tokens.length &&
+              tokens[i + 1].startsWith('<') &&
+              CodeFormatter.INLINE_TAGS.has(CodeFormatter.getTagName(tokens[i + 1])) &&
+              tokens[i + 3] === `</${CodeFormatter.getTagName(tokens[i + 1])}>`) {
+              inlineGroup += `${tokens[i + 1]}${tokens[i + 2]}${tokens[i + 3]}`;
+              i += 3;
+            }
+            output += `${indent}${inlineGroup}\n`;
+          }
+          else {
+            output += `${indent}${token}\n`;
+            // Increase indentation for non-void opening tags
+            if (!token.startsWith('</') &&
+              !token.endsWith('/>') &&
+              !/^<br|^<img|^<meta|^<input|^<hr/i.test(token)) {
+              indentLevel++;
+            }
+          }
+        }
+        else {
+          // Add plain text content with current indentation
+          const text = token;
+          if (text.length > 0) {
+            output += `${INDENT.repeat(indentLevel)}${text}\n`;
+          }
+        }
+      }
+      return output.trim();
+    };
+  }
+  /**
+   * Extracts the tag name from an HTML tag string.
+   *
+   * @param {string} tag - A raw HTML tag string
+   * @returns {string} The lowercase tag name, or an empty string if no match is found.
+   */
+  static getTagName(tag) {
+    var _a;
+    const match = tag.match(/^<\/?([a-z0-9]+)/i);
+    return (_a = match === null || match === void 0 ? void 0 : match[1].toLowerCase()) !== null && _a !== void 0 ? _a : '';
+  }
+  /**
+   * Formats a CSS style string by trimming white space and ensuring consistent semicolon spacing.
+   *
+   * @param {string} style - The CSS style string to format.
+   * @returns {string} The formatted style string.
+   */
+  formatStyle(style) {
+    return style
+      .split(';')
+      .map((s) => s.trim())
+      .filter(Boolean)
+      .join('; ');
+  }
+}
+CodeFormatter.INLINE_TAGS = new Set([
+  'span',
+  'strong',
+  'em',
+  'a',
+  'b',
+  'i',
+  'u',
+  'small',
+  'abbr',
+  'code',
+  'b',
+  'u',
+  's',
+  'mark',
+  'time',
+  'del',
+  'ins',
+]);
+export default new CodeFormatter();

package/dist/collection/helpers/code-format/test/code-formatter.test.js

@@ -0,0 +1,362 @@
+import { VegaRTEContent } from '../../../components/vega-rich-text-editor/dto/content-state';
+import CodeFormatter from '../code-formatter';
+describe('Code formatter', () => {
+  it('should format simple HTML with option useTabs', () => {
+    const input = `<p><span>Text</span></p>`;
+    expect(CodeFormatter.format(input)).toMatchSnapshot('useTabs: true');
+    expect(CodeFormatter.format(input, { useTabs: false })).toMatchSnapshot('useTabs: false');
+  });
+  it('should format nested HTML with styles', () => {
+    const input = `<p style="color: red; font-size: 12px;"><span style="margin:0;">Hello</span><br/></p>`;
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should format self-closing and void elements', () => {
+    const input = `<div><img src="img.png"/><br><input type="text"></div>`;
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should handle text nodes and white space', () => {
+    const input = `<div>   Text   <span>  More  </span>   </div>`;
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should handle empty input', () => {
+    const input = '';
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should handle only text nodes', () => {
+    const input = 'Just some text without tags';
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should handle deeply nested elements', () => {
+    const input = `<div><section><article><p>Deep</p></article></section></div>`;
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should handle multiple sibling elements', () => {
+    const input = `<ul><li>One</li><li>Two</li><li>Three</li></ul>`;
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should handle multiple block elements', () => {
+    const input = `<p>First block</p><p>Second block</p><section><h1>Header</h1><p>Paragraph</p></section>`;
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should handle a block with multiple text nodes separated by span', () => {
+    const input = `<div><span>Text1</span><span>Middle</span><span>Text2</span><span>End</span></div>`;
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should return as string for invalid input', () => {
+    expect(CodeFormatter.format('<>')).toBe(`<>`);
+    expect(CodeFormatter.format('<input <button')).toBe(`<input <button`);
+  });
+  it('should format a complex content as expect', () => {
+    const input = VegaRTEContent.fromJSON([
+      {
+        id: expect.anything(),
+        type: 'title',
+        annotations: { textStyle: 'title' },
+        nodes: [
+          {
+            id: expect.anything(),
+            text: 'Title',
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'subtitle',
+        annotations: { textStyle: 'subtitle' },
+        nodes: [
+          {
+            id: expect.anything(),
+            text: 'Subtitle',
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'heading-1',
+        annotations: { textStyle: 'heading-1' },
+        nodes: [
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+            text: 'Heading 1',
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'heading-2',
+        annotations: { textStyle: 'heading-2' },
+        nodes: [
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+            text: 'Heading 2',
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'heading-3',
+        annotations: { textStyle: 'heading-3' },
+        nodes: [
+          {
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+            id: expect.anything(),
+            text: 'Heading 3',
+            type: 'text',
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'paragraph',
+        annotations: { textStyle: 'paragraph' },
+        nodes: [{ id: expect.anything(), text: 'Paragraph', type: 'text' }],
+      },
+      {
+        id: expect.anything(),
+        type: 'paragraph',
+        annotations: { textStyle: 'paragraph' },
+        nodes: [
+          {
+            annotations: {
+              bold: true,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+            id: expect.anything(),
+            text: 'Bold text',
+            type: 'text',
+          },
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: true,
+              strikethrough: false,
+              underline: false,
+            },
+            text: 'Italic text',
+          },
+          {
+            id: expect.anything(),
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: true,
+            },
+            text: 'Underline text',
+            type: 'text',
+          },
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: true,
+              underline: false,
+            },
+            text: 'Strikethrough text',
+          },
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: { code: true },
+            text: 'Code text',
+          },
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              textColor: 'green',
+              underline: false,
+            },
+            text: 'Color text',
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'bullet-list',
+        blocks: [
+          {
+            id: expect.anything(),
+            type: 'list-item',
+            annotations: { textStyle: 'paragraph' },
+            nodes: [{ id: expect.anything(), text: 'List item 1', type: 'text' }],
+            children: [],
+          },
+          {
+            id: expect.anything(),
+            type: 'list-item',
+            annotations: { textStyle: 'paragraph' },
+            nodes: [{ id: expect.anything(), text: 'List item 2', type: 'text' }],
+            children: [],
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'number-list',
+        blocks: [
+          {
+            id: expect.anything(),
+            type: 'list-item',
+            annotations: { textStyle: 'paragraph' },
+            nodes: [{ id: expect.anything(), text: 'List item 1', type: 'text' }],
+            children: [],
+          },
+          {
+            id: expect.anything(),
+            type: 'list-item',
+            annotations: { textStyle: 'paragraph' },
+            nodes: [{ id: expect.anything(), text: 'List item 2', type: 'text' }],
+            children: [],
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'paragraph',
+        annotations: { textAlign: 'left', textStyle: 'paragraph' },
+        nodes: [
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+            text: 'Left align',
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'paragraph',
+        annotations: { textAlign: 'right', textStyle: 'paragraph' },
+        nodes: [
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+            text: 'Right align',
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'paragraph',
+        annotations: { indent: 1, textAlign: 'left', textStyle: 'paragraph' },
+        nodes: [
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+            text: 'More indent 1',
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'paragraph',
+        annotations: { indent: 2, textAlign: 'left', textStyle: 'paragraph' },
+        nodes: [
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+            },
+            text: 'More indent 2',
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'paragraph',
+        annotations: { textStyle: 'paragraph' },
+        nodes: [
+          {
+            id: expect.anything(),
+            type: 'text',
+            annotations: {
+              bold: false,
+              italic: false,
+              link: { groupKey: expect.anything(), href: 'https://www.google.com' },
+              strikethrough: false,
+              underline: false,
+            },
+            text: 'Link text',
+          },
+        ],
+      },
+      {
+        id: expect.anything(),
+        type: 'image',
+        nodes: [
+          {
+            id: expect.anything(),
+            type: 'image',
+            annotations: { size: 'md' },
+            url: 'mock-img-url',
+          },
+        ],
+      },
+    ]).toHtml();
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+});

package/dist/collection/helpers/event-manager/event-id/vega-internal-event-id.js

@@ -49,7 +49,10 @@ export const VegaInternalPaginationCurrentChange = new VegaInternalEventID('pagi
 export const VegaInternalPasteEvent = new VegaInternalEventID('pasteEvent');
 export const VegaInternalNestEAHierarchyTreeChange = new VegaInternalEventID('nestEAHierarchyTreeChange');
 export const VegaInternalTableHeadCellSortEvent = new VegaInternalEventID('tableHeadCellSortEvent');
-export const VegaInternalCodeBlockSelectionChange = new VegaInternalEventID('nestEAHierarchyTreeChange');
+export const VegaInternalCodeBlockSelectionChange = new VegaInternalEventID('internalCodeBlockSelectionChange');
 export const VegaInternalColumnHeadRowRenderInputRIC = new VegaInternalEventID('tableHeadRowRenderInputRIC');
 export const VegaInternalColumnHeadCellRenderInputRIC = new VegaInternalEventID('tableHeadCellRenderInputRIC');
 export const VegaInternalColumnBodyCellRenderInputRIC = new VegaInternalEventID('tableCellRenderInputRIC');
+export const VegaInternalCalendarEventPreviewUpdate = new VegaInternalEventID('calendarEventPreviewUpdate');
+export const VegaInternalCalendarEventPreviewClear = new VegaInternalEventID('calendarEventPreviewClear');
+export const VegaInternalUpdateRTECursorPosition = new VegaInternalEventID('InternalUpdateRTECursorPosition');

package/dist/collection/helpers/rte-manager/dto-action-strategy-manager.js

@@ -0,0 +1,37 @@
+import { ActionHandleStrategyRegistry } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/action-handle-strategy-registry';
+import { AppendChildrenStrategy } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/append-children-strategy';
+import { BlockDeleteTextOrDecoratorNodeStrategy } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-delete-text-or-decorator-node-strategy';
+import { BlockInsertNewParagraphStrategy } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-new-paragraph-strategy';
+import { InsertChildrenAfterStrategy } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/insert-children-after-strategy';
+import { InsertChildrenBeforeStrategy } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/insert-children-before-strategy';
+import { InsertTextToDecoratorNodeStrategy } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/insert-text-to-decorator-node-strategy';
+import { ListItemInsertNewParagraphStrategy } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-item-insert-new-paragraph-strategy';
+import { ListRemoveListItemStrategy } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-remove-list-item-strategy';
+import { RemoveChildrenStrategy } from '../../components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/remove-children-strategy';
+import { ModifyContentActionType } from '../../components/vega-rich-text-editor/dto/actions/modify-content-action.abstract';
+import { RTEListBlock } from '../../components/vega-rich-text-editor/dto/blocks/list-block';
+import { RTEListItemBlock } from '../../components/vega-rich-text-editor/dto/blocks/list-item-block';
+/**
+ * Manager class for registering DTO action strategies.
+ */
+class RTEDTOActionStrategyManager {
+  /**
+   * Registers basic strategies for a given DTO class.
+   *
+   * @param {string} dtoClassName - The name of the RTE block class name.
+   */
+  registerBlockBasicStrategies(dtoClassName) {
+    ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILDREN, dtoClassName, dtoClassName === RTEListBlock.name
+      ? new ListRemoveListItemStrategy()
+      : new RemoveChildrenStrategy());
+    ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILDREN, dtoClassName, new AppendChildrenStrategy());
+    ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_CHILDREN_BEFORE, dtoClassName, new InsertChildrenBeforeStrategy());
+    ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_CHILDREN_AFTER, dtoClassName, new InsertChildrenAfterStrategy());
+    ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_BLOCK_CONTENT, dtoClassName, new BlockDeleteTextOrDecoratorNodeStrategy());
+    ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NEW_PARAGRAPH, dtoClassName, dtoClassName === RTEListItemBlock.name
+      ? new ListItemInsertNewParagraphStrategy()
+      : new BlockInsertNewParagraphStrategy());
+    ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_TEXT_TO_DECORATOR_NODE, dtoClassName, new InsertTextToDecoratorNodeStrategy());
+  }
+}
+export default new RTEDTOActionStrategyManager();