@globalpayments/vega 2.33.0 → 2.34.1

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/vega-rich-text-editor-renderer.js

@@ -0,0 +1,126 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { h, Host } from '@stencil/core';
+import { VegaSlimmer, MapToComponentField, MapToComponentMethod } from 'vega-slimmer/core';
+import { createEnterKeyHandlerToTriggerClick } from '../../../../utils/accessibility';
+import ChangeManager from '../../../../helpers/change-manager/change-manager';
+import domNodeSubjectFactory from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
+import { VegaInternalComponentDidRender } from '../../../../helpers/event-manager/event-id/vega-internal-event-id';
+export class VegaRichTextEditorRenderer extends VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    this.renderHintMessage = () => {
+      return h("vega-text", null, this.hint);
+    };
+    this.renderTextContent = () => {
+      return (h("div", { class: {
+          'rich-text-editor-container': true,
+          'disabled': this.disabled,
+        }, style: { minHeight: `${this.rows * 24}px` }, onClick: this.richTextContentFocus, role: "textbox", tabIndex: !this.disabled ? -1 : 0, onKeyDown: createEnterKeyHandlerToTriggerClick(), ref: (node) => (this.richTextContainerRef = node) },
+        h("vega-rich-text-content", { ref: (ref) => (this.richTextContentRef = ref), content: this.value }),
+        this.renderCharacterCounter()));
+    };
+    this.renderCharacterCounter = () => {
+      return (h("div", { class: {
+          'text-editor-counter': true,
+          'counter-exceed-max-length': false,
+        }, style: { display: 'none' } },
+        h("span", null, "0"),
+        h("span", null, "/100")));
+    };
+    this.renderErrorMessage = () => {
+      return h("div", { class: "vega-error vega-hidden" });
+    };
+    this.richTextContentFocus = () => {
+      void this.richTextContentRef.vegaFocus();
+    };
+  }
+  /**
+   * Component lifecycle - [componentDidRender]{@link VegaRichTextEditor.componentDidRender}
+   */
+  componentDidRender() {
+    ChangeManager.notify(domNodeSubjectFactory.getSubject(this.host, VegaInternalComponentDidRender), {});
+  }
+  /**
+   * Returns the HTMLElement reference of the rich text container.
+   *
+   * @returns {HTMLDivElement} An HTMLElement representing the rich text container is being returned.
+   */
+  getRichTextContainerRef() {
+    return this.richTextContainerRef;
+  }
+  /**
+   * Returns the HTMLElement reference of the rich text content area.
+   *
+   * @returns {HTMLVegaRichTextContentElement} An HTMLVegaRichTextContentElement is being returned.
+   */
+  getRichTextContentRef() {
+    return this.richTextContentRef;
+  }
+  /**
+   * Returns the HTMLElement reference of the rich text outermost layer.
+   *
+   * @returns {HTMLVegaFlexElement} An HTMLVegaFlexElement is being returned.
+   */
+  getRichTextWrapperRef() {
+    return this.richTextWrapperRef;
+  }
+  /**
+   * Returns the rich text editor component editable element
+   *
+   * @returns {HTMLDivElement} The div element which has property contenteditable
+   */
+  getRTEEditableElementRef() {
+    if (this.richTextContentRef && this.richTextContentRef.shadowRoot) {
+      return this.richTextContentRef.shadowRoot.querySelector('.rich-text-content');
+    }
+  }
+  render() {
+    return h(Host, null, this.renderRichTextEditor());
+  }
+  renderRichTextEditor() {
+    return (h("vega-flex", { direction: "col", gap: "0", ref: (flex) => (this.richTextWrapperRef = flex) },
+      this.renderLabel(),
+      this.hint && this.renderHintMessage(),
+      this.toolbarRenderer.render(),
+      this.renderTextContent(),
+      this.renderErrorMessage()));
+  }
+  renderLabel() {
+    return (this.label && (h("vega-field-label", { onClick: this.richTextContentFocus, isFieldRequired: this.required, disabled: this.disabled, label: this.label })));
+  }
+}
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "host", void 0);
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "toolbarRenderer", void 0);
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "label", void 0);
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "required", void 0);
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "hint", void 0);
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "disabled", void 0);
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "rows", void 0);
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "placeholder", void 0);
+__decorate([
+  MapToComponentField()
+], VegaRichTextEditorRenderer.prototype, "value", void 0);
+__decorate([
+  MapToComponentMethod('componentDidRender')
+], VegaRichTextEditorRenderer.prototype, "componentDidRender", null);

package/dist/collection/components/vega-rich-text-editor/test/dto/annotation-actions.test.js

@@ -0,0 +1,38 @@
+import { BoldAnnotationAction } from '../../dto/actions/bold-annotation-action';
+import { ItalicAnnotationAction } from '../../dto/actions/italic-annotation-action';
+import { SelectionChangeAction } from '../../dto/actions/selection-change-action';
+import { TextStyleAnnotationAction } from '../../dto/actions/text-style-annotation-action';
+import { ImageAnnotationAction } from '../../dto/actions/image-annotation-action';
+import { UnderlineAnnotationAction } from '../../dto/actions/underline-annotation-action';
+import { StrikethroughAnnotationAction } from '../../dto/actions/strikethrough-annotation-action';
+import { HorizontalAlignmentAnnotationAction } from '../../dto/actions/horizontal-alignment-annotation-action';
+import { ClearFormattingAnnotationAction } from '../../dto/actions/clear-formatting-annotation-action';
+import { CodeAnnotationAction } from '../../dto/actions/code-annotation-action';
+import { TextColorAnnotationAction } from '../../dto/actions/text-color-annotation-action';
+import { IndentAnnotationAction } from '../../dto/actions/indent-annotation-action';
+import { LinkAnnotationAction } from '../../dto/actions/link-annotation-action';
+import { DeleteNodeAnnotationAction } from '../../dto/actions/delete-node-annotation-action';
+import { NodeAnnotationTypeEnum } from '../../dto/annotations/node-annotation.abstract';
+describe('annotation action', () => {
+  it('should create annotation by action', () => {
+    expect(new BoldAnnotationAction(true).toAnnotation()).toBeDefined();
+    expect(new ItalicAnnotationAction(true).toAnnotation()).toBeDefined();
+    expect(new SelectionChangeAction({}).toAnnotation()).toBeDefined();
+    expect(new TextStyleAnnotationAction('paragraph').toAnnotation()).toBeDefined();
+    expect(new ImageAnnotationAction('sm', 'mock-url').toAnnotation()).toBeDefined();
+    expect(new UnderlineAnnotationAction(true).toAnnotation()).toBeDefined();
+    expect(new StrikethroughAnnotationAction(true).toAnnotation()).toBeDefined();
+    expect(new HorizontalAlignmentAnnotationAction('left').toAnnotation()).toBeDefined();
+    expect(new ClearFormattingAnnotationAction().toAnnotation()).toBeDefined();
+    expect(new CodeAnnotationAction(true).toAnnotation()).toBeDefined();
+    expect(new TextColorAnnotationAction('black').toAnnotation()).toBeDefined();
+    expect(new TextColorAnnotationAction('other color key').toAnnotation()).toBeDefined();
+    expect(new IndentAnnotationAction(1).toAnnotation()).toBeDefined();
+    expect(new LinkAnnotationAction({
+      link: { href: 'www.google.com', groupKey: '123' },
+      newText: 'Example',
+      needMergeNode: true,
+    }).toAnnotation()).toBeDefined();
+    expect(new DeleteNodeAnnotationAction(NodeAnnotationTypeEnum.BOLD)).toBeDefined();
+  });
+});

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

@@ -0,0 +1,134 @@
+import { TextStyleAnnotation } from '../../dto/annotations/text-style-annotation';
+import { BoldAnnotation } from '../../dto/annotations/bold-annotation';
+import { ItalicAnnotation } from '../../dto/annotations/italic-annotation';
+import { SelectionRangeAnnotation } from '../../dto/annotations/selection-range-annotation';
+import { ImageAnnotation } from '../../dto/annotations/image-annotation';
+import { UnderlineAnnotation } from '../../dto/annotations/underline-annotation';
+import { StrikethroughAnnotation } from '../../dto/annotations/strikethrough-annotation';
+import { HorizontalAlignmentAnnotation } from '../../dto/annotations/horizontal-alignment-annotation';
+import { ClearFormattingAnnotation } from '../../dto/annotations/clear-formatting-annotation';
+import { CodeAnnotation } from '../../dto/annotations/code-annotation';
+import { TextColorAnnotation } from '../../dto/annotations/text-color-annotation';
+import { IndentAnnotation } from '../../dto/annotations/indent-annotation';
+import { LinkAnnotation } from '../../dto/annotations/link-annotation';
+describe('annotations', () => {
+  it('bold annotation', () => {
+    expect(new BoldAnnotation(true).render()).toEqual({
+      'font-weight': '700',
+    });
+    expect(new BoldAnnotation(false).render()).toEqual(null);
+  });
+  it('italic annotation', () => {
+    expect(new ItalicAnnotation(true).render()).toEqual({
+      'font-style': 'italic',
+    });
+    expect(new ItalicAnnotation(false).render()).toEqual(null);
+  });
+  it('text style annotation', () => {
+    expect(new TextStyleAnnotation('paragraph').render()).toEqual({
+      fontFamily: 'Inter',
+      fontSize: '16px',
+      fontWeight: '500',
+      lineHeight: '22px',
+    });
+    expect(new TextStyleAnnotation('title').render()).toEqual({
+      fontFamily: 'Inter',
+      fontSize: '36px',
+      fontWeight: '500',
+      lineHeight: '40px',
+    });
+    expect(new TextStyleAnnotation('subtitle').render()).toEqual({
+      fontFamily: 'Inter',
+      fontSize: '28px',
+      fontWeight: '500',
+      lineHeight: '32px',
+    });
+    expect(new TextStyleAnnotation('heading-1').render()).toEqual({
+      fontFamily: 'Inter',
+      fontSize: '22px',
+      fontWeight: '500',
+      lineHeight: '24px',
+    });
+    expect(new TextStyleAnnotation('heading-2').render()).toEqual({
+      fontFamily: 'Inter',
+      fontSize: '20px',
+      fontWeight: '500',
+      lineHeight: '24px',
+    });
+    expect(new TextStyleAnnotation('heading-3').render()).toEqual({
+      fontFamily: 'Inter',
+      fontSize: '18px',
+      fontWeight: '500',
+      lineHeight: '22px',
+    });
+  });
+  it('selection range annotation', () => {
+    expect(new SelectionRangeAnnotation({})).toBeDefined();
+  });
+  it('image annotation', () => {
+    expect(new ImageAnnotation('sm', 'mock-alt').render()).toEqual({ width: '25%' });
+    expect(new ImageAnnotation('md', 'mock-alt').render()).toEqual({ width: '50%' });
+    expect(new ImageAnnotation('lg', 'mock-alt').render()).toEqual({ width: '100%' });
+    expect(new ImageAnnotation('md', 'mock-alt').toJSON()).toEqual({ size: 'md', alt: 'mock-alt' });
+    expect(new ImageAnnotation(null, null).toJSON()).toEqual({ size: null });
+    expect(new ImageAnnotation(undefined, 'test').toJSON()).toEqual({ size: 'md', alt: 'test' });
+  });
+  it('underline annotation ', () => {
+    expect(new UnderlineAnnotation(true).render()).toEqual(null);
+    expect(new UnderlineAnnotation(true).renderClass()).toEqual('v-rte--underline');
+    expect(new UnderlineAnnotation(false).renderClass()).toEqual(null);
+  });
+  it('strikethrough annotation ', () => {
+    expect(new StrikethroughAnnotation(true).render()).toEqual(null);
+    expect(new StrikethroughAnnotation(true).renderClass()).toEqual('v-rte--strikethrough');
+    expect(new StrikethroughAnnotation(false).renderClass()).toEqual(null);
+  });
+  it('text color annotation ', () => {
+    expect(new TextColorAnnotation('black').renderClass()).toEqual(null);
+    expect(new TextColorAnnotation('black').render()).toEqual({
+      color: '#111128',
+    });
+    expect(new TextColorAnnotation('black').renderClass()).toEqual(null);
+    expect(new TextColorAnnotation('green').renderClass()).toEqual(null);
+    expect(new TextColorAnnotation('green').render()).toEqual({
+      color: '#01801F',
+    });
+    expect(new TextColorAnnotation('green').renderClass()).toEqual(null);
+  });
+  it('horizontal alignment annotation', () => {
+    expect(new HorizontalAlignmentAnnotation('left').render()).toEqual(null);
+    expect(new HorizontalAlignmentAnnotation('left').renderClass()).toEqual('v-rte--horizontal-alignment-left');
+  });
+  it('clear formatting annotation', () => {
+    expect(new ClearFormattingAnnotation().items).toEqual([
+      'BOLD',
+      'ITALIC',
+      'UNDERLINE',
+      'STRIKETHROUGH',
+      'TEXT_COLOR',
+      'CODE',
+    ]);
+  });
+  it('code annotation', () => {
+    expect(new CodeAnnotation(true).render()).toEqual(null);
+    expect(new CodeAnnotation(true).renderClass()).toEqual('v-rte--code');
+    expect(new CodeAnnotation(false).renderClass()).toEqual(null);
+  });
+  it('indent annotation', () => {
+    expect(new IndentAnnotation(0).render()).toEqual(null);
+    expect(new IndentAnnotation(1).render()).toEqual({ 'margin-left': `16px` });
+    expect(new IndentAnnotation(2).render()).toEqual({ 'margin-left': `32px` });
+    expect(new IndentAnnotation(-20).render()).toEqual(null);
+    expect(new IndentAnnotation(20).render()).toEqual({ 'margin-left': `320px` });
+  });
+  it('link annotation', () => {
+    expect(new LinkAnnotation({ href: 'www.google.com', groupKey: '123' }).render()).toEqual(null);
+    expect(new LinkAnnotation({ href: 'www.google.com', groupKey: '123' }).toJSON()).toEqual({
+      link: { href: 'www.google.com', groupKey: '123' },
+    });
+    expect(new LinkAnnotation({ href: 'www.google.com', groupKey: '123' }).toJSON()).toEqual({
+      link: { href: 'www.google.com', groupKey: '123' },
+    });
+    expect(new LinkAnnotation({ href: 'www.google.com', groupKey: '123' }).toEqual(new LinkAnnotation({ href: 'www.google.com', groupKey: '123' }))).toEqual(true);
+  });
+});

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

@@ -0,0 +1,90 @@
+import { BoldAnnotationAction } from '../../../dto/actions/bold-annotation-action';
+import { HorizontalAlignmentAnnotationAction } from '../../../dto/actions/horizontal-alignment-annotation-action';
+import { RTEImageBlock } from '../../../dto/blocks/image-block';
+import { RTEImageNode } from '../../../dto/nodes/image-node';
+describe('image block', () => {
+  it('new RTEImageBlock should work as expect', () => {
+    const imageBlock = new RTEImageBlock('block-1');
+    const imageNode = new RTEImageNode('1', 'mock-url', imageBlock);
+    imageBlock.nodes = [imageNode];
+    expect(imageBlock.toJSON()).toEqual({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image' }],
+    });
+  });
+  it('from method should work as expect', () => {
+    expect(RTEImageBlock.from({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image' }],
+    }) instanceof RTEImageBlock).toBe(true);
+  });
+  it('toJSON method should work as expect', () => {
+    expect(RTEImageBlock.from({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image' }],
+    }).toJSON()).toEqual({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image', annotations: { size: 'md' } }],
+    });
+    expect(RTEImageBlock.from({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image' }],
+      annotations: { textAlign: 'center' },
+    }).toJSON()).toEqual({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image', annotations: { size: 'md' } }],
+      annotations: { textAlign: 'center' },
+    });
+    expect(RTEImageBlock.from({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image' }],
+      annotations: { indent: 2 },
+    }).toJSON()).toEqual({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image', annotations: { size: 'md' } }],
+      annotations: { indent: 2 },
+    });
+    expect(RTEImageBlock.from({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image', annotations: { alt: 'test' } }],
+      annotations: { indent: 2 },
+    }).toJSON()).toEqual({
+      id: 'block-1',
+      type: 'image',
+      nodes: [{ id: '1', url: 'mock-url', type: 'image', annotations: { size: 'md', alt: 'test' } }],
+      annotations: { indent: 2 },
+    });
+  });
+  it('render method should work as expect', () => {
+    const imageBlock = new RTEImageBlock('block-1');
+    const imageNode = new RTEImageNode('1', 'mock-url', imageBlock);
+    imageBlock.nodes = [imageNode];
+    imageNode.apply(new BoldAnnotationAction(true));
+    imageBlock.apply(new HorizontalAlignmentAnnotationAction('right'));
+    expect(imageBlock.render()).toBeDefined();
+  });
+  it('isNotEmpty should work as expect', () => {
+    const imageBlock = new RTEImageBlock('block-1');
+    const imageNode = new RTEImageNode('1', 'mock-url', imageBlock);
+    imageBlock.nodes = [imageNode];
+    expect(imageBlock.isNotEmpty()).toEqual(true);
+    imageNode.url = '';
+    expect(imageBlock.isNotEmpty()).toEqual(false);
+  });
+  it('getLastNode should work as expect', () => {
+    const imageBlock = new RTEImageBlock('block-1');
+    const imageNode1 = new RTEImageNode('1', 'mock-url', imageBlock);
+    const imageNode2 = new RTEImageNode('2', 'mock-url', imageBlock);
+    imageBlock.nodes = [imageNode1, imageNode2];
+    expect(imageBlock.getLastNode()).toEqual(imageNode2);
+  });
+});

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

@@ -0,0 +1,224 @@
+import { RTEListBlock } from '../../../dto/blocks/list-block';
+import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
+describe('bullet list', () => {
+  it('new RTEBulletListBlock should work as expect', () => {
+    expect(new RTEListBlock('1', 'bullet-list')).toBeDefined();
+  });
+  it('from method should work as expect', () => {
+    expect(RTEListBlock.from({
+      id: '1-1-1',
+      type: 'bullet-list',
+      blocks: [
+        {
+          id: '1-1-1-1',
+          type: 'list-item',
+          nodes: [
+            {
+              id: '1-1-1-1-1',
+              type: 'text',
+              text: 'This is a bullet-list 3-1.',
+            },
+          ],
+        },
+      ],
+    })).toBeDefined();
+  });
+  it('toJSON method should work as expect', () => {
+    expect(new RTEListBlock('1', 'bullet-list').toJSON()).toEqual({
+      id: '1',
+      type: 'bullet-list',
+      blocks: [],
+    });
+    expect(RTEListBlock.from({
+      id: '1-1-1',
+      type: 'bullet-list',
+      blocks: [
+        {
+          id: '1-1-1-1',
+          type: 'list-item',
+          nodes: [
+            {
+              id: '1-1-1-1-1',
+              type: 'text',
+              text: 'This is a bullet-list 3-1.',
+            },
+          ],
+        },
+      ],
+    }).toJSON()).toEqual({
+      id: '1-1-1',
+      type: 'bullet-list',
+      blocks: [
+        {
+          id: '1-1-1-1',
+          type: 'list-item',
+          nodes: [{ id: '1-1-1-1-1', text: 'This is a bullet-list 3-1.', type: 'text' }],
+          annotations: {
+            textStyle: 'paragraph',
+          },
+          children: undefined,
+        },
+      ],
+    });
+  });
+  it('registerRef method should work as expect', () => {
+    const bulletListBlock = new RTEListBlock('1', 'bullet-list');
+    const mockDiv = document.createElement('div');
+    bulletListBlock['registerRef'](mockDiv);
+    expect(stateEntityRenderingRegistry.getDOMByEntity(bulletListBlock)).toEqual(mockDiv);
+    expect(stateEntityRenderingRegistry.getEntityByDOM(mockDiv)).toEqual(bulletListBlock);
+  });
+  it('render method should work as expect', () => {
+    expect(new RTEListBlock('1', 'bullet-list').render()).toBeDefined();
+    expect(RTEListBlock.from({
+      id: '1-1-1',
+      type: 'bullet-list',
+      blocks: [
+        {
+          id: '1-1-1-1',
+          type: 'list-item',
+          nodes: [
+            {
+              id: '1-1-1-1-1',
+              type: 'text',
+              text: 'This is a bullet-list 3-1.',
+            },
+          ],
+        },
+      ],
+    }).render()).toBeDefined();
+  });
+  it('isNotEmpty should work as expect', () => {
+    const bulletListBlock = RTEListBlock.from({
+      id: '1',
+      type: 'bullet-list',
+      blocks: [
+        {
+          id: '1-1',
+          type: 'list-item',
+          nodes: [
+            {
+              id: '1-1-1',
+              type: 'text',
+              text: 'This is a list item 1',
+            },
+          ],
+        },
+      ],
+    });
+    expect(bulletListBlock.isNotEmpty()).toEqual(true);
+    bulletListBlock.blocks[0].nodes[0].text = '';
+    expect(bulletListBlock.isNotEmpty()).toEqual(false);
+    const childrenListBlock = RTEListBlock.from({
+      id: '1-1-2',
+      type: 'bullet-list',
+      blocks: [
+        {
+          id: '1-1-2',
+          type: 'list-item',
+          nodes: [
+            {
+              id: '1-1-2-1',
+              type: 'text',
+              text: 'This is a list item 2',
+            },
+          ],
+        },
+      ],
+    });
+    bulletListBlock.blocks[0].children = [childrenListBlock];
+    expect(bulletListBlock.isNotEmpty()).toEqual(true);
+    childrenListBlock.blocks[0].nodes[0].text = '';
+    expect(bulletListBlock.isNotEmpty()).toEqual(false);
+  });
+});
+describe('number list', () => {
+  it('render method should work as expect', () => {
+    expect(new RTEListBlock('1', 'bullet-list').render()).toBeDefined();
+    expect(RTEListBlock.from({
+      id: '1-1-1',
+      type: 'number-list',
+      blocks: [
+        {
+          id: '1-1-1-1',
+          type: 'list-item',
+          nodes: [
+            {
+              id: '1-1-1-1-1',
+              type: 'text',
+              text: 'This is a bullet-list 3-1.',
+            },
+          ],
+        },
+      ],
+    }).render()).toBeDefined();
+  });
+  it('isNotEmpty should work as expect', () => {
+    const listBlock = RTEListBlock.from({
+      id: '1',
+      type: 'number-list',
+      blocks: [
+        {
+          id: '1-1',
+          type: 'list-item',
+          nodes: [
+            {
+              id: '1-1-1',
+              type: 'text',
+              text: 'This is a list item 1',
+            },
+          ],
+        },
+      ],
+    });
+    expect(listBlock.isNotEmpty()).toEqual(true);
+    listBlock.blocks[0].nodes[0].text = '';
+    expect(listBlock.isNotEmpty()).toEqual(false);
+    const childrenListBlock = RTEListBlock.from({
+      id: '1-1-2',
+      type: 'number-list',
+      blocks: [
+        {
+          id: '1-1-2',
+          type: 'list-item',
+          nodes: [
+            {
+              id: '1-1-2-1',
+              type: 'text',
+              text: 'This is a list item 2',
+            },
+          ],
+        },
+      ],
+    });
+    listBlock.blocks[0].children = [childrenListBlock];
+    expect(listBlock.isNotEmpty()).toEqual(true);
+    childrenListBlock.blocks[0].nodes[0].text = '';
+    expect(listBlock.isNotEmpty()).toEqual(false);
+  });
+  it('getLastNode should work as expect', () => {
+    const listBlock = RTEListBlock.from({
+      id: '1',
+      type: 'number-list',
+      blocks: [
+        {
+          id: '1-1',
+          type: 'list-item',
+          nodes: [
+            {
+              id: '1-1-1',
+              type: 'text',
+              text: 'This is a list item 1',
+            },
+            {
+              id: '1-1-2',
+              type: 'text',
+              text: 'This is a list item 2',
+            },
+          ],
+        },
+      ],
+    });
+    expect(listBlock.getLastNode()).toEqual(listBlock.blocks[0].nodes[1]);
+  });
+});