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

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

@@ -7,6 +7,9 @@ import { RTETableHeadCellBlock } from '../../../extensions/table/dto/table-head-
 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',
@@ -14,6 +17,7 @@ describe('dto', () => {
     annotations: {
       table: {
         alignment: 'center',
+        borderCollapse: 'collapse',
       },
     },
     children: [
@@ -38,6 +42,8 @@ describe('dto', () => {
                     padding: '12px',
                     textAlign: 'left',
                     verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
                   },
                 },
                 children: [
@@ -74,6 +80,8 @@ describe('dto', () => {
                     padding: '12px',
                     textAlign: 'left',
                     verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
                   },
                 },
                 children: [
@@ -122,6 +130,8 @@ describe('dto', () => {
                     padding: '12px',
                     textAlign: 'left',
                     verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
                   },
                 },
                 children: [
@@ -158,6 +168,8 @@ describe('dto', () => {
                     padding: '12px',
                     textAlign: 'left',
                     verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
                   },
                 },
                 children: [
@@ -200,6 +212,8 @@ describe('dto', () => {
                     padding: '12px',
                     textAlign: 'left',
                     verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
                   },
                 },
                 children: [
@@ -236,6 +250,8 @@ describe('dto', () => {
                     padding: '12px',
                     textAlign: 'left',
                     verticalAlign: 'middle',
+                    minWidth: '55px',
+                    boxSizing: 'border-box',
                   },
                 },
                 children: [
@@ -290,28 +306,28 @@ describe('dto', () => {
 		<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: 30px; background-color: #f2f2f2;">
+			  <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: 30px; background-color: #f2f2f2;">
+			  <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: 30px;">
+			  <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: 30px;">
+			  <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: 30px;">
+			  <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: 30px;">
+			  <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>
@@ -418,6 +434,116 @@ describe('dto', () => {
         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;
@@ -448,6 +574,198 @@ describe('dto', () => {
         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', () => {
@@ -514,4 +832,263 @@ describe('dto', () => {
 			`);
     });
   });
+  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);
+    });
+  });
 });