@heartlandone/vega 2.74.0 → 2.75.0-RTE-table-preview

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

@@ -0,0 +1,1094 @@
+import '../../../dto/setup';
+import { VegaRTETableExtension } from '../../../extensions/table/table-extension';
+import { RTETableBlock } from '../../../extensions/table/dto/table-block';
+import { RTETableBodyBlock } from '../../../extensions/table/dto/table-body-block';
+import { RTETableHeadBlock } from '../../../extensions/table/dto/table-head-block';
+import { RTETableHeadCellBlock } from '../../../extensions/table/dto/table-head-cell-block';
+import { RTETableRowBlock } from '../../../extensions/table/dto/table-row-block';
+import { RTETableCellBlock } from '../../../extensions/table/dto/table-cell-block';
+import { RTETableCaptionBlock, } from '../../../extensions/table/dto/table-caption-block';
+import { RTETableAnnotation, RTETableExtensionAnnotationTypeEnum, } from '../../../extensions/table/annotations/table-annotation';
+import { RTETableCellAnnotation } from '../../../extensions/table/annotations/table-cell-annotation';
+import { RTETableHeadCellAnnotation } from '../../../extensions/table/annotations/table-head-cell-annotation';
+describe('dto', () => {
+  const tableObj = {
+    id: '1764771896966',
+    type: 'table-block',
+    annotations: {
+      table: {
+        alignment: 'center',
+        borderCollapse: 'collapse',
+      },
+    },
+    children: [
+      {
+        id: '1764771904874',
+        type: 'table-head',
+        children: [
+          {
+            id: '1764771904632',
+            type: 'table-row',
+            children: [
+              {
+                id: '1764771898285',
+                type: 'table-head-cell',
+                annotations: {
+                  tableCell: {
+                    border: {
+                      color: '#ddd',
+                      style: 'solid',
+                      width: '1px',
+                    },
+                    padding: '12px',
+                    textAlign: 'left',
+                    verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
+                  },
+                },
+                children: [
+                  {
+                    id: '1764771904876',
+                    annotations: {
+                      textStyle: 'paragraph',
+                      internalWrapper: true,
+                    },
+                    type: 'paragraph',
+                    nodes: [
+                      {
+                        id: '1764771904525',
+                        annotations: {
+                          plainText: true,
+                        },
+                        type: 'text',
+                        text: '',
+                      },
+                    ],
+                  },
+                ],
+              },
+              {
+                id: '1764771899530',
+                type: 'table-head-cell',
+                annotations: {
+                  tableCell: {
+                    border: {
+                      color: '#ddd',
+                      style: 'solid',
+                      width: '1px',
+                    },
+                    padding: '12px',
+                    textAlign: 'left',
+                    verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
+                  },
+                },
+                children: [
+                  {
+                    id: '1764771896940',
+                    annotations: {
+                      textStyle: 'paragraph',
+                      internalWrapper: true,
+                    },
+                    type: 'paragraph',
+                    nodes: [
+                      {
+                        id: '1764771903833',
+                        annotations: {
+                          plainText: true,
+                        },
+                        type: 'text',
+                        text: '',
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: '1764771903981',
+        type: 'table-body',
+        children: [
+          {
+            id: '1764771905293',
+            type: 'table-row',
+            children: [
+              {
+                id: '1764771897032',
+                type: 'table-cell',
+                annotations: {
+                  tableCell: {
+                    border: {
+                      color: '#ddd',
+                      style: 'solid',
+                      width: '1px',
+                    },
+                    padding: '12px',
+                    textAlign: 'left',
+                    verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
+                  },
+                },
+                children: [
+                  {
+                    id: '1764771897783',
+                    annotations: {
+                      textStyle: 'paragraph',
+                      internalWrapper: true,
+                    },
+                    type: 'paragraph',
+                    nodes: [
+                      {
+                        id: '1764771906044',
+                        annotations: {
+                          plainText: true,
+                        },
+                        type: 'text',
+                        text: '',
+                      },
+                    ],
+                  },
+                ],
+              },
+              {
+                id: '1764771905790',
+                type: 'table-cell',
+                annotations: {
+                  tableCell: {
+                    border: {
+                      color: '#ddd',
+                      style: 'solid',
+                      width: '1px',
+                    },
+                    padding: '12px',
+                    textAlign: 'left',
+                    verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
+                  },
+                },
+                children: [
+                  {
+                    id: '1764771904845',
+                    annotations: {
+                      textStyle: 'paragraph',
+                      internalWrapper: true,
+                    },
+                    type: 'paragraph',
+                    nodes: [
+                      {
+                        id: '1764771904578',
+                        annotations: {
+                          plainText: true,
+                        },
+                        type: 'text',
+                        text: '',
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            id: '1764771904130',
+            type: 'table-row',
+            children: [
+              {
+                id: '1764771903073',
+                type: 'table-cell',
+                annotations: {
+                  tableCell: {
+                    border: {
+                      color: '#ddd',
+                      style: 'solid',
+                      width: '1px',
+                    },
+                    padding: '12px',
+                    textAlign: 'left',
+                    verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
+                  },
+                },
+                children: [
+                  {
+                    id: '1764771904171',
+                    annotations: {
+                      textStyle: 'paragraph',
+                      internalWrapper: true,
+                    },
+                    type: 'paragraph',
+                    nodes: [
+                      {
+                        id: '1764771905692',
+                        annotations: {
+                          plainText: true,
+                        },
+                        type: 'text',
+                        text: '',
+                      },
+                    ],
+                  },
+                ],
+              },
+              {
+                id: '1764771897331',
+                type: 'table-cell',
+                annotations: {
+                  tableCell: {
+                    border: {
+                      color: '#ddd',
+                      style: 'solid',
+                      width: '1px',
+                    },
+                    padding: '12px',
+                    textAlign: 'left',
+                    verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
+                  },
+                },
+                children: [
+                  {
+                    id: '1764771905732',
+                    annotations: {
+                      textStyle: 'paragraph',
+                      internalWrapper: true,
+                    },
+                    type: 'paragraph',
+                    nodes: [
+                      {
+                        id: '1764771903305',
+                        annotations: {
+                          plainText: true,
+                        },
+                        type: 'text',
+                        text: '',
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+  let tableBlock;
+  beforeAll(() => {
+    new VegaRTETableExtension().initialExtension(null);
+  });
+  beforeEach(() => {
+    tableBlock = RTETableBlock.from(tableObj);
+  });
+  describe('table-block', () => {
+    it('toJSON', () => {
+      expect(tableBlock.toJSON()).toEqual(tableObj);
+    });
+    it('clone', () => {
+      const cloned = tableBlock.clone(undefined);
+      expect(cloned).toEqual(tableBlock);
+      expect(cloned).not.toBe(tableBlock);
+    });
+    it('isNotEmpty', () => {
+      expect(tableBlock.isNotEmpty()).toBe(true);
+    });
+    it('toHtml', () => {
+      const html = tableBlock.toHtml();
+      expect(html).toEqualHtml(`
+		<table style="border-collapse: collapse; margin: 0 auto;">
+		  <thead>
+			<tr>
+			  <th style="padding: 12px; border: solid 1px #ddd; text-align: left; vertical-align: middle; min-width: 55px; box-sizing: border-box; background-color: #f2f2f2;">
+				<p style="font-family: Inter; font-size: 16px; line-height: 22px; min-height: 22px; min-height: 22px; font-weight: 500; margin-top: 0px; margin-bottom: 0px;"></p>
+			  </th>
+			  <th style="padding: 12px; border: solid 1px #ddd; text-align: left; vertical-align: middle; min-width: 55px; box-sizing: border-box; background-color: #f2f2f2;">
+				<p style="font-family: Inter; font-size: 16px; line-height: 22px; min-height: 22px; min-height: 22px; font-weight: 500; margin-top: 0px; margin-bottom: 0px;"></p>
+			  </th>
+			</tr>
+		  </thead>
+		  <tbody>
+			<tr>
+			  <td style="padding: 12px; border: solid 1px #ddd; text-align: left; vertical-align: middle; min-width: 55px; box-sizing: border-box;">
+				<p style="font-family: Inter; font-size: 16px; line-height: 22px; min-height: 22px; min-height: 22px; font-weight: 500; margin-top: 0px; margin-bottom: 0px;"></p>
+			  </td>
+			  <td style="padding: 12px; border: solid 1px #ddd; text-align: left; vertical-align: middle; min-width: 55px; box-sizing: border-box;">
+				<p style="font-family: Inter; font-size: 16px; line-height: 22px; min-height: 22px; min-height: 22px; font-weight: 500; margin-top: 0px; margin-bottom: 0px;"></p>
+			  </td>
+			</tr>
+			<tr>
+			  <td style="padding: 12px; border: solid 1px #ddd; text-align: left; vertical-align: middle; min-width: 55px; box-sizing: border-box;">
+				<p style="font-family: Inter; font-size: 16px; line-height: 22px; min-height: 22px; min-height: 22px; font-weight: 500; margin-top: 0px; margin-bottom: 0px;"></p>
+			  </td>
+			  <td style="padding: 12px; border: solid 1px #ddd; text-align: left; vertical-align: middle; min-width: 55px; box-sizing: border-box;">
+				<p style="font-family: Inter; font-size: 16px; line-height: 22px; min-height: 22px; min-height: 22px; font-weight: 500; margin-top: 0px; margin-bottom: 0px;"></p>
+			  </td>
+			</tr>
+		  </tbody>
+		</table>
+		`);
+    });
+    it('getLastNode', () => {
+      expect(tableBlock.getLastNode().toJSON()).toEqual({
+        id: '1764771903305',
+        annotations: {
+          plainText: true,
+        },
+        type: 'text',
+        text: '',
+      });
+    });
+    it('getFirstNode should return first cell last node when no caption', () => {
+      expect(tableBlock.getFirstNode().toJSON()).toEqual({
+        id: '1764771904525',
+        annotations: {
+          plainText: true,
+        },
+        type: 'text',
+        text: '',
+      });
+    });
+    it('getFirstNode should return caption last node when caption exists', () => {
+      const tableWithCaption = Object.assign(Object.assign({}, tableObj), { children: [
+          {
+            id: 'caption-1',
+            type: 'table-caption',
+            children: [
+              {
+                id: 'paragraph-1',
+                type: 'paragraph',
+                nodes: [
+                  {
+                    id: 'text-1',
+                    type: 'text',
+                    text: 'Caption text',
+                  },
+                ],
+              },
+            ],
+          },
+          ...tableObj.children,
+        ] });
+      const tableBlockWithCaption = RTETableBlock.from(tableWithCaption);
+      expect(tableBlockWithCaption.getFirstNode().toJSON()).toEqual(expect.objectContaining({
+        type: 'text',
+        text: 'Caption text',
+      }));
+    });
+  });
+  describe('table-body-block', () => {
+    let tableBodyBlock;
+    beforeAll(() => {
+      tableBodyBlock = tableBlock.children.find((child) => child.type === 'table-body');
+    });
+    it('isNotEmpty', () => {
+      expect(RTETableBodyBlock.from({
+        id: '1',
+        type: 'table-body',
+        children: [],
+      }).isNotEmpty()).toBe(false);
+      expect(tableBodyBlock.isNotEmpty()).toBe(true);
+    });
+  });
+  describe('table-head-block', () => {
+    let tableHeadBlock;
+    beforeAll(() => {
+      tableHeadBlock = tableBlock.children.find((child) => child.type === 'table-head');
+    });
+    it('isNotEmpty', () => {
+      expect(RTETableHeadBlock.from({
+        id: '1',
+        type: 'table-head',
+        children: [],
+      }).isNotEmpty()).toBe(false);
+      expect(tableHeadBlock.isNotEmpty()).toBe(true);
+    });
+    it('getLastNode', () => {
+      expect(tableHeadBlock.getLastNode().toJSON()).toEqual({
+        id: '1764771903833',
+        type: 'text',
+        annotations: { plainText: true },
+        text: '',
+      });
+    });
+  });
+  describe('table-head-cell-block', () => {
+    let tableHeadBlock;
+    beforeAll(() => {
+      tableHeadBlock = tableBlock.children.find((child) => child.type === 'table-head');
+    });
+    it('isNotEmpty', () => {
+      const tableHeadCellBlock = tableHeadBlock.children[0]
+        .children[0];
+      expect(tableHeadCellBlock.isNotEmpty()).toBe(true);
+      expect(RTETableHeadCellBlock.from({
+        id: '1764771899530',
+        type: 'table-head-cell',
+        children: [],
+      }).isNotEmpty()).toBe(false);
+    });
+    describe('RTETableHeadCellBlock.from with useInternalStyle options', () => {
+      const baseHeadCellJSON = {
+        id: 'head-cell-test-1',
+        type: 'table-head-cell',
+        children: [
+          {
+            id: 'para-1',
+            annotations: {
+              textStyle: 'paragraph',
+              internalWrapper: true,
+            },
+            type: 'paragraph',
+            nodes: [
+              {
+                id: 'text-1',
+                annotations: {
+                  plainText: true,
+                },
+                type: 'text',
+                text: 'Header',
+              },
+            ],
+          },
+        ],
+      };
+      it('should apply default head cell annotations when autoMatchFormat is true', () => {
+        const headCellBlock = RTETableHeadCellBlock.from(baseHeadCellJSON, {
+          autoMatchFormat: true,
+        });
+        const cellAnnotation = headCellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation).toBeInstanceOf(RTETableHeadCellAnnotation);
+        expect(cellAnnotation.padding).toBe(RTETableCellAnnotation.DEFAULT_PADDING);
+        expect(cellAnnotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+        expect(cellAnnotation.textAlign).toBe(RTETableCellAnnotation.DEFAULT_HORIZONTAL_TEXT_ALIGN);
+        expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+      });
+      it('should not apply default head cell annotations when autoMatchFormat is false', () => {
+        const headCellBlock = RTETableHeadCellBlock.from(baseHeadCellJSON, {
+          autoMatchFormat: false,
+        });
+        const cellAnnotation = headCellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeUndefined();
+      });
+      it('should preserve explicit null values in head cells when autoMatchFormat is true', () => {
+        const headCellWithNullAnnotations = Object.assign(Object.assign({}, baseHeadCellJSON), { annotations: {
+            tableCell: {
+              padding: null,
+              border: null,
+              textAlign: null,
+            },
+          } });
+        const headCellBlock = RTETableHeadCellBlock.from(headCellWithNullAnnotations, {
+          autoMatchFormat: true,
+        });
+        const cellAnnotation = headCellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation.padding).toBeNull();
+        expect(cellAnnotation.border).toBeNull();
+        expect(cellAnnotation.textAlign).toBeNull();
+        // Undefined properties should still get defaults
+        expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+      });
+      it('should apply defaults for undefined properties in head cells with autoMatchFormat true', () => {
+        const headCellWithPartialAnnotations = Object.assign(Object.assign({}, baseHeadCellJSON), { annotations: {
+            tableCell: {
+              padding: '15px',
+              backgroundColor: 'gray',
+            },
+          } });
+        const headCellBlock = RTETableHeadCellBlock.from(headCellWithPartialAnnotations, {
+          autoMatchFormat: true,
+        });
+        const cellAnnotation = headCellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation.padding).toBe('15px');
+        expect(cellAnnotation.backgroundColor).toBe('gray');
+        // Undefined properties should get defaults
+        expect(cellAnnotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+        expect(cellAnnotation.textAlign).toBe(RTETableCellAnnotation.DEFAULT_HORIZONTAL_TEXT_ALIGN);
+        expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+      });
+      it('should not apply defaults in head cells when autoMatchFormat is false', () => {
+        const headCellWithPartialAnnotations = Object.assign(Object.assign({}, baseHeadCellJSON), { annotations: {
+            tableCell: {
+              padding: '15px',
+              backgroundColor: 'gray',
+            },
+          } });
+        const headCellBlock = RTETableHeadCellBlock.from(headCellWithPartialAnnotations, {
+          autoMatchFormat: false,
+        });
+        const cellAnnotation = headCellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation.padding).toBe('15px');
+        expect(cellAnnotation.backgroundColor).toBe('gray');
+        // Undefined properties should remain undefined
+        expect(cellAnnotation.border).toBeUndefined();
+        expect(cellAnnotation.textAlign).toBeUndefined();
+        expect(cellAnnotation.verticalAlign).toBeUndefined();
+      });
+      it('should default to autoMatchFormat true for head cells when options not provided', () => {
+        const headCellBlock = RTETableHeadCellBlock.from(baseHeadCellJSON);
+        const cellAnnotation = headCellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation).toBeInstanceOf(RTETableHeadCellAnnotation);
+        expect(cellAnnotation.padding).toBe(RTETableCellAnnotation.DEFAULT_PADDING);
+        expect(cellAnnotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+      });
+    });
+  });
+  describe('table-row-block', () => {
+    let tableBodyBlock;
+    beforeAll(() => {
+      tableBodyBlock = tableBlock.children.find((child) => child.type === 'table-body');
+    });
+    it('isNotEmpty', () => {
+      expect(tableBodyBlock.children[0].isNotEmpty()).toBe(true);
+      expect(RTETableRowBlock.from({
+        id: '1764771905293',
+        type: 'table-row',
+        children: [],
+      }).isNotEmpty()).toBe(false);
+    });
+  });
+  describe('table-cell-block', () => {
+    let tableBodyBlock;
+    beforeAll(() => {
+      tableBodyBlock = tableBlock.children.find((child) => child.type === 'table-body');
+    });
+    it('isNotEmpty', () => {
+      const tableCellBlock = tableBodyBlock.children[0]
+        .children[0];
+      expect(tableCellBlock.isNotEmpty()).toBe(true);
+      expect(RTETableCellBlock.from({
+        id: '1',
+        type: 'table-cell',
+        children: [],
+      }).isNotEmpty()).toBe(false);
+    });
+    it('rowspan & colspan', () => {
+      const tableCellJSON = {
+        id: '1',
+        type: 'table-cell',
+        children: [],
+        annotations: {},
+      };
+      let tableCellBlock = RTETableCellBlock.from(tableCellJSON);
+      expect(tableCellBlock.rowSpan).toEqual(1);
+      expect(tableCellBlock.colSpan).toEqual(1);
+      tableCellJSON.annotations = {
+        customAttribute: {
+          rowspan: '3',
+          colspan: '2',
+        },
+      };
+      tableCellBlock = RTETableCellBlock.from(tableCellJSON);
+      expect(tableCellBlock.rowSpan).toEqual(3);
+      expect(tableCellBlock.colSpan).toEqual(2);
+    });
+    describe('RTETableCellBlock.from with useInternalStyle options', () => {
+      const baseCellJSON = {
+        id: 'cell-test-1',
+        type: 'table-cell',
+        children: [
+          {
+            id: 'para-1',
+            annotations: {
+              textStyle: 'paragraph',
+              internalWrapper: true,
+            },
+            type: 'paragraph',
+            nodes: [
+              {
+                id: 'text-1',
+                annotations: {
+                  plainText: true,
+                },
+                type: 'text',
+                text: 'Content',
+              },
+            ],
+          },
+        ],
+      };
+      it('should apply default cell annotations when autoMatchFormat is true', () => {
+        const cellBlock = RTETableCellBlock.from(baseCellJSON, {
+          autoMatchFormat: true,
+        });
+        const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation.padding).toBe(RTETableCellAnnotation.DEFAULT_PADDING);
+        expect(cellAnnotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+        expect(cellAnnotation.textAlign).toBe(RTETableCellAnnotation.DEFAULT_HORIZONTAL_TEXT_ALIGN);
+        expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+        expect(cellAnnotation.minWidth).toBe(RTETableCellAnnotation.DEFAULT_CELL_MIN_WIDTH);
+        expect(cellAnnotation.boxSizing).toBe(RTETableCellAnnotation.DEFAULT_BOX_SIZING);
+      });
+      it('should not apply default cell annotations when autoMatchFormat is false', () => {
+        const cellBlock = RTETableCellBlock.from(baseCellJSON, {
+          autoMatchFormat: false,
+        });
+        const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeUndefined();
+      });
+      it('should apply default values for undefined properties when autoMatchFormat is true', () => {
+        const cellWithPartialAnnotations = Object.assign(Object.assign({}, baseCellJSON), { annotations: {
+            tableCell: {
+              padding: '20px',
+              backgroundColor: 'blue',
+            },
+          } });
+        const cellBlock = RTETableCellBlock.from(cellWithPartialAnnotations, {
+          autoMatchFormat: true,
+        });
+        const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation.padding).toBe('20px');
+        expect(cellAnnotation.backgroundColor).toBe('blue');
+        // Undefined properties should get defaults
+        expect(cellAnnotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+        expect(cellAnnotation.textAlign).toBe(RTETableCellAnnotation.DEFAULT_HORIZONTAL_TEXT_ALIGN);
+        expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+      });
+      it('should preserve explicit null values when autoMatchFormat is true', () => {
+        const cellWithNullAnnotations = Object.assign(Object.assign({}, baseCellJSON), { annotations: {
+            tableCell: {
+              padding: null,
+              border: null,
+              textAlign: null,
+            },
+          } });
+        const cellBlock = RTETableCellBlock.from(cellWithNullAnnotations, {
+          autoMatchFormat: true,
+        });
+        const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation.padding).toBeNull();
+        expect(cellAnnotation.border).toBeNull();
+        expect(cellAnnotation.textAlign).toBeNull();
+        // Undefined properties should still get defaults
+        expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+      });
+      it('should not apply defaults when autoMatchFormat is false even with partial annotations', () => {
+        const cellWithPartialAnnotations = Object.assign(Object.assign({}, baseCellJSON), { annotations: {
+            tableCell: {
+              padding: '20px',
+              backgroundColor: 'blue',
+            },
+          } });
+        const cellBlock = RTETableCellBlock.from(cellWithPartialAnnotations, {
+          autoMatchFormat: false,
+        });
+        const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation.padding).toBe('20px');
+        expect(cellAnnotation.backgroundColor).toBe('blue');
+        // Undefined properties should remain undefined
+        expect(cellAnnotation.border).toBeUndefined();
+        expect(cellAnnotation.textAlign).toBeUndefined();
+        expect(cellAnnotation.verticalAlign).toBeUndefined();
+      });
+      it('should preserve all explicit values regardless of autoMatchFormat', () => {
+        const cellWithFullAnnotations = Object.assign(Object.assign({}, baseCellJSON), { annotations: {
+            tableCell: {
+              padding: '25px',
+              border: { style: 'dashed', width: '3px', color: 'red' },
+              textAlign: 'right',
+              verticalAlign: 'bottom',
+              minWidth: '150px',
+              boxSizing: 'content-box',
+              backgroundColor: 'green',
+            },
+          } });
+        const cellBlockWithFormat = RTETableCellBlock.from(cellWithFullAnnotations, {
+          autoMatchFormat: true,
+        });
+        const cellBlockWithoutFormat = RTETableCellBlock.from(cellWithFullAnnotations, {
+          autoMatchFormat: false,
+        });
+        const annotationWithFormat = cellBlockWithFormat.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        const annotationWithoutFormat = cellBlockWithoutFormat.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        // Both should have the same values
+        expect(annotationWithFormat.padding).toBe('25px');
+        expect(annotationWithFormat.border).toEqual({
+          style: 'dashed',
+          width: '3px',
+          color: 'red',
+        });
+        expect(annotationWithFormat.textAlign).toBe('right');
+        expect(annotationWithFormat.verticalAlign).toBe('bottom');
+        expect(annotationWithFormat.minWidth).toBe('150px');
+        expect(annotationWithFormat.boxSizing).toBe('content-box');
+        expect(annotationWithoutFormat.padding).toBe('25px');
+        expect(annotationWithoutFormat.border).toEqual({
+          style: 'dashed',
+          width: '3px',
+          color: 'red',
+        });
+        expect(annotationWithoutFormat.textAlign).toBe('right');
+        expect(annotationWithoutFormat.verticalAlign).toBe('bottom');
+        expect(annotationWithoutFormat.minWidth).toBe('150px');
+        expect(annotationWithoutFormat.boxSizing).toBe('content-box');
+      });
+      it('should default to autoMatchFormat true when options not provided', () => {
+        const cellBlock = RTETableCellBlock.from(baseCellJSON);
+        const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation.padding).toBe(RTETableCellAnnotation.DEFAULT_PADDING);
+        expect(cellAnnotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+      });
+      it('should handle constructor-level defaults when no annotations provided and autoMatchFormat is true', () => {
+        const cellBlock = RTETableCellBlock.from(baseCellJSON, {
+          autoMatchFormat: true,
+        });
+        const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        // Constructor should have created annotation with defaults
+        expect(cellAnnotation).toBeDefined();
+        expect(cellAnnotation.padding).toBe(RTETableCellAnnotation.DEFAULT_PADDING);
+        expect(cellAnnotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+        expect(cellAnnotation.textAlign).toBe(RTETableCellAnnotation.DEFAULT_HORIZONTAL_TEXT_ALIGN);
+        expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+      });
+      it('should not create annotation in constructor when autoMatchFormat is false', () => {
+        const cellBlock = RTETableCellBlock.from(baseCellJSON, {
+          autoMatchFormat: false,
+        });
+        // Constructor should not have created any annotation
+        const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+        expect(cellAnnotation).toBeUndefined();
+      });
+    });
+  });
+  describe('table-caption-block', () => {
+    it('clone', () => {
+      const captionJson = {
+        id: 'caption-1',
+        type: 'table-caption',
+        children: [
+          {
+            id: 'paragraph-1',
+            type: 'paragraph',
+            nodes: [
+              {
+                id: 'text-1',
+                type: 'text',
+                text: 'Caption text',
+              },
+            ],
+          },
+        ],
+      };
+      const tableWithCaption = Object.assign(Object.assign({}, tableObj), { children: [
+          {
+            id: 'caption-1',
+            type: 'table-caption',
+            children: captionJson.children,
+          },
+          ...tableObj.children,
+        ] });
+      const tableBlockWithCaption = RTETableBlock.from(tableWithCaption);
+      const captionBlock = tableBlockWithCaption.getCaption();
+      const cloned = captionBlock.clone(tableBlockWithCaption);
+      expect(cloned).toEqual(captionBlock);
+      expect(cloned).not.toBe(captionBlock);
+      expect(cloned.parent).toBe(tableBlockWithCaption);
+    });
+    it('toHtml', () => {
+      const captionJson = {
+        id: 'caption-1',
+        type: 'table-caption',
+        children: [
+          {
+            id: 'paragraph-1',
+            type: 'paragraph',
+            nodes: [
+              {
+                id: 'text-1',
+                type: 'text',
+                text: 'Caption text',
+              },
+            ],
+          },
+        ],
+      };
+      const captionBlock = RTETableCaptionBlock.from(captionJson);
+      const html = captionBlock.toHtml();
+      expect(html).toEqualHtml(`
+				<caption style="padding: 8px; border: 1px solid #ddd; border-bottom: none; background-color: #f7f7f7; position: relative; text-align: center; min-height: 22px;">
+				  <p style="font-family: Inter; font-size: 16px; line-height: 22px; min-height: 22px; font-weight: 500; margin-top: 0px; margin-bottom: 0px;">
+					<span>
+					  Caption text
+					</span>
+				  </p>
+				</caption>
+			`);
+    });
+  });
+  describe('RTETableBlock with useInternalStyle options', () => {
+    const tableWithoutAnnotations = {
+      id: 'table-1',
+      type: 'table-block',
+      children: [
+        {
+          id: 'tbody-1',
+          type: 'table-body',
+          children: [
+            {
+              id: 'row-1',
+              type: 'table-row',
+              children: [
+                {
+                  id: 'cell-1',
+                  type: 'table-cell',
+                  children: [
+                    {
+                      id: 'para-1',
+                      annotations: {
+                        textStyle: 'paragraph',
+                        internalWrapper: true,
+                      },
+                      type: 'paragraph',
+                      nodes: [
+                        {
+                          id: 'text-1',
+                          annotations: {
+                            plainText: true,
+                          },
+                          type: 'text',
+                          text: 'Content',
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+    it('should apply default table annotations when autoMatchFormat is true', () => {
+      const tableBlock = RTETableBlock.from(tableWithoutAnnotations, {
+        autoMatchFormat: true,
+      });
+      const tableAnnotation = tableBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.TABLE);
+      expect(tableAnnotation).toBeDefined();
+      expect(tableAnnotation.alignment).toBe(RTETableAnnotation.DEFAULT_ALIGNMENT);
+      expect(tableAnnotation.borderCollapse).toBe(RTETableAnnotation.DEFAULT_BORDER_COLLAPSE);
+      expect(tableAnnotation.useInternalStyle).toBe(true);
+    });
+    it('should not apply default table annotations when autoMatchFormat is false', () => {
+      const tableBlock = RTETableBlock.from(tableWithoutAnnotations, {
+        autoMatchFormat: false,
+      });
+      const tableAnnotation = tableBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.TABLE);
+      expect(tableAnnotation).toBeUndefined();
+    });
+    it('should preserve explicit table annotations with autoMatchFormat true', () => {
+      const tableWithAnnotations = Object.assign(Object.assign({}, tableWithoutAnnotations), { annotations: {
+          table: {
+            alignment: 'left',
+            borderCollapse: 'separate',
+            backgroundColor: 'orange',
+          },
+        } });
+      const tableBlock = RTETableBlock.from(tableWithAnnotations, {
+        autoMatchFormat: true,
+      });
+      const tableAnnotation = tableBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.TABLE);
+      expect(tableAnnotation).toBeDefined();
+      expect(tableAnnotation.alignment).toBe('left');
+      expect(tableAnnotation.borderCollapse).toBe('separate');
+      expect(tableAnnotation.backgroundColor).toBe('orange');
+      expect(tableAnnotation.useInternalStyle).toBe(true);
+    });
+    it('should preserve null values in table annotations with autoMatchFormat true', () => {
+      const tableWithNullAnnotations = Object.assign(Object.assign({}, tableWithoutAnnotations), { annotations: {
+          table: {
+            alignment: null,
+            borderCollapse: null,
+          },
+        } });
+      const tableBlock = RTETableBlock.from(tableWithNullAnnotations, {
+        autoMatchFormat: true,
+      });
+      const tableAnnotation = tableBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.TABLE);
+      expect(tableAnnotation).toBeDefined();
+      expect(tableAnnotation.alignment).toBeNull();
+      expect(tableAnnotation.borderCollapse).toBeNull();
+      expect(tableAnnotation.useInternalStyle).toBe(true);
+    });
+    it('should not apply defaults to table annotations when autoMatchFormat is false', () => {
+      const tableWithAnnotations = Object.assign(Object.assign({}, tableWithoutAnnotations), { annotations: {
+          table: {
+            backgroundColor: 'orange',
+          },
+        } });
+      const tableBlock = RTETableBlock.from(tableWithAnnotations, {
+        autoMatchFormat: false,
+      });
+      const tableAnnotation = tableBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.TABLE);
+      expect(tableAnnotation).toBeDefined();
+      expect(tableAnnotation.alignment).toBeUndefined();
+      expect(tableAnnotation.borderCollapse).toBeUndefined();
+      expect(tableAnnotation.backgroundColor).toBe('orange');
+      expect(tableAnnotation.useInternalStyle).toBe(false);
+    });
+    it('should default to autoMatchFormat true when options not provided', () => {
+      const tableBlock = RTETableBlock.from(tableWithoutAnnotations);
+      const tableAnnotation = tableBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.TABLE);
+      expect(tableAnnotation).toBeDefined();
+      expect(tableAnnotation.alignment).toBe(RTETableAnnotation.DEFAULT_ALIGNMENT);
+      expect(tableAnnotation.borderCollapse).toBe(RTETableAnnotation.DEFAULT_BORDER_COLLAPSE);
+    });
+    it('should apply default cell annotations when autoMatchFormat is true', () => {
+      const tableBlock = RTETableBlock.from(tableWithoutAnnotations, {
+        autoMatchFormat: true,
+      });
+      const cellBlock = tableBlock.children[0].children[0]
+        .children[0];
+      const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+      expect(cellAnnotation).toBeDefined();
+      expect(cellAnnotation.padding).toBe(RTETableCellAnnotation.DEFAULT_PADDING);
+      expect(cellAnnotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+      expect(cellAnnotation.textAlign).toBe(RTETableCellAnnotation.DEFAULT_HORIZONTAL_TEXT_ALIGN);
+      expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+    });
+    it('should not apply default cell annotations when autoMatchFormat is false', () => {
+      const tableBlock = RTETableBlock.from(tableWithoutAnnotations, {
+        autoMatchFormat: false,
+      });
+      const cellBlock = tableBlock.children[0].children[0]
+        .children[0];
+      const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+      expect(cellAnnotation).toBeUndefined();
+    });
+    it('should preserve explicit cell annotations with autoMatchFormat true', () => {
+      const tableWithCellAnnotations = Object.assign(Object.assign({}, tableWithoutAnnotations), { children: [
+          {
+            id: 'tbody-1',
+            type: 'table-body',
+            children: [
+              {
+                id: 'row-1',
+                type: 'table-row',
+                children: [
+                  {
+                    id: 'cell-1',
+                    type: 'table-cell',
+                    annotations: {
+                      tableCell: {
+                        padding: '20px',
+                        textAlign: 'center',
+                        backgroundColor: 'blue',
+                      },
+                    },
+                    children: [
+                      {
+                        id: 'para-1',
+                        annotations: {
+                          textStyle: 'paragraph',
+                          internalWrapper: true,
+                        },
+                        type: 'paragraph',
+                        nodes: [
+                          {
+                            id: 'text-1',
+                            annotations: {
+                              plainText: true,
+                            },
+                            type: 'text',
+                            text: 'Content',
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ] });
+      const tableBlock = RTETableBlock.from(tableWithCellAnnotations, {
+        autoMatchFormat: true,
+      });
+      const cellBlock = tableBlock.children[0].children[0]
+        .children[0];
+      const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+      expect(cellAnnotation).toBeDefined();
+      expect(cellAnnotation.padding).toBe('20px');
+      expect(cellAnnotation.textAlign).toBe('center');
+      expect(cellAnnotation.backgroundColor).toBe('blue');
+      // Border and verticalAlign should get defaults since they're undefined
+      expect(cellAnnotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+      expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+    });
+    it('should preserve null cell annotations with autoMatchFormat true', () => {
+      const tableWithNullCellAnnotations = Object.assign(Object.assign({}, tableWithoutAnnotations), { children: [
+          {
+            id: 'tbody-1',
+            type: 'table-body',
+            children: [
+              {
+                id: 'row-1',
+                type: 'table-row',
+                children: [
+                  {
+                    id: 'cell-1',
+                    type: 'table-cell',
+                    annotations: {
+                      tableCell: {
+                        padding: null,
+                        border: null,
+                        textAlign: null,
+                      },
+                    },
+                    children: [
+                      {
+                        id: 'para-1',
+                        annotations: {
+                          textStyle: 'paragraph',
+                          internalWrapper: true,
+                        },
+                        type: 'paragraph',
+                        nodes: [
+                          {
+                            id: 'text-1',
+                            annotations: {
+                              plainText: true,
+                            },
+                            type: 'text',
+                            text: 'Content',
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ] });
+      const tableBlock = RTETableBlock.from(tableWithNullCellAnnotations, {
+        autoMatchFormat: true,
+      });
+      const cellBlock = tableBlock.children[0].children[0]
+        .children[0];
+      const cellAnnotation = cellBlock.annotationMap.get(RTETableExtensionAnnotationTypeEnum.CELL);
+      expect(cellAnnotation).toBeDefined();
+      expect(cellAnnotation.padding).toBeNull();
+      expect(cellAnnotation.border).toBeNull();
+      expect(cellAnnotation.textAlign).toBeNull();
+      // verticalAlign should get default since it's undefined
+      expect(cellAnnotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+    });
+  });
+});