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

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

@@ -1,1094 +0,0 @@
-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);
-    });
-  });
-});