@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/annotation-handler/table-head-cell-annotation-handler.test.js

@@ -1,5 +1,6 @@
 import { TableHeadCellAnnotationHandler } from '../../../../extensions/table/annotation-handler/table-head-cell-annotation-handler';
 import { RTETableHeadCellBlock } from '../../../../extensions/table/dto/table-head-cell-block';
+import { setBorder } from './table-cell-annotation-handler.test';
 describe('TableHeadCellAnnotationHandler', () => {
   let handler;
   beforeEach(() => {
@@ -22,11 +23,11 @@ describe('TableHeadCellAnnotationHandler', () => {
     });
     it('should extract background color from inline style', () => {
       const element = document.createElement('th');
-      element.style.backgroundColor = '#e0e0e0';
+      element.style.backgroundColor = 'rgb(252, 252, 252)';
       const result = handler.handle(element);
       expect(result).toEqual({
         tableCell: {
-          backgroundColor: '#e0e0e0',
+          backgroundColor: 'white',
         },
       });
     });
@@ -40,32 +41,18 @@ describe('TableHeadCellAnnotationHandler', () => {
         },
       });
     });
-    it('should extract border from inline style', () => {
-      const element = document.createElement('th');
-      element.style.border = 'solid 1px #000';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          border: {
-            style: 'solid',
-            width: '1px',
-            color: '#000',
-          },
-        },
-      });
-    });
     it('should extract border from individual properties', () => {
       const element = document.createElement('th');
       element.style.borderStyle = 'double';
       element.style.borderWidth = '4px';
-      element.style.borderColor = '#333';
+      element.style.borderColor = 'rgb(4, 4, 28)';
       const result = handler.handle(element);
       expect(result).toEqual({
         tableCell: {
           border: {
             style: 'double',
             width: '4px',
-            color: '#333',
+            color: 'black',
           },
         },
       });
@@ -165,9 +152,9 @@ describe('TableHeadCellAnnotationHandler', () => {
     });
     it('should extract multiple annotations', () => {
       const element = document.createElement('th');
-      element.style.backgroundColor = '#d0d0d0';
+      element.style.backgroundColor = 'rgb(252, 252, 252)';
       element.style.padding = '10px';
-      element.style.border = 'solid 2px #555';
+      setBorder(element, 'solid 2px rgb(4, 4, 28)');
       element.style.width = '200px';
       element.style.height = '40px';
       element.style.textAlign = 'center';
@@ -175,12 +162,12 @@ describe('TableHeadCellAnnotationHandler', () => {
       const result = handler.handle(element);
       expect(result).toEqual({
         tableCell: {
-          backgroundColor: '#d0d0d0',
+          backgroundColor: 'white',
           padding: '10px',
           border: {
             style: 'solid',
             width: '2px',
-            color: '#555',
+            color: 'black',
           },
           width: '200px',
           height: '40px',
@@ -191,14 +178,14 @@ describe('TableHeadCellAnnotationHandler', () => {
     });
     it('should handle border with rgba color', () => {
       const element = document.createElement('th');
-      element.style.border = 'solid 1px rgba(0, 0, 0, 0.5)';
+      setBorder(element, 'solid 1px rgb(4, 4, 28)');
       const result = handler.handle(element);
       expect(result).toEqual({
         tableCell: {
           border: {
             style: 'solid',
             width: '1px',
-            color: 'rgba(0, 0, 0, 0.5)',
+            color: 'black',
           },
         },
       });
@@ -279,12 +266,12 @@ describe('TableHeadCellAnnotationHandler', () => {
     it('should inherit all extraction methods from TableCellAnnotationHandler', () => {
       const element = document.createElement('th');
       element.style.padding = '10px';
-      element.style.border = 'solid 1px #ddd';
+      setBorder(element, 'solid 1px #ddd');
       element.style.width = '150px';
       element.style.height = '50px';
       element.style.textAlign = 'left';
       element.style.verticalAlign = 'top';
-      element.style.backgroundColor = '#f5f5f5';
+      element.style.backgroundColor = 'rgb(252, 252, 252)';
       const result = handler.handle(element);
       // Should extract all cell properties using inherited methods
       expect(result).toEqual({
@@ -293,13 +280,13 @@ describe('TableHeadCellAnnotationHandler', () => {
           border: {
             style: 'solid',
             width: '1px',
-            color: '#ddd',
+            color: '',
           },
           width: '150px',
           height: '50px',
           textAlign: 'left',
           verticalAlign: 'top',
-          backgroundColor: '#f5f5f5',
+          backgroundColor: 'white',
         },
       });
     });
@@ -323,13 +310,13 @@ describe('TableHeadCellAnnotationHandler', () => {
       // Test that protected methods are accessible and working
       const element = document.createElement('th');
       // Test border extraction (inherited protected method)
-      element.style.border = 'dashed 2px rgba(0, 0, 0, 0.5)';
+      setBorder(element, 'dashed 2px rgb(4, 4, 28)');
       const borderResult = handler.handle(element);
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       expect((_a = borderResult.tableCell) === null || _a === void 0 ? void 0 : _a.border).toEqual({
         style: 'dashed',
         width: '2px',
-        color: 'rgba(0, 0, 0, 0.5)',
+        color: 'black',
       });
     });
     it('should handle all text alignment values like parent class', () => {
@@ -363,50 +350,59 @@ describe('TableHeadCellAnnotationHandler', () => {
         });
       });
     });
-    it('should extract border from borderTop properties when general properties are not set', () => {
-      const element = document.createElement('th');
-      element.style.borderTopStyle = 'groove';
-      element.style.borderTopWidth = '4px';
-      element.style.borderTopColor = '#aaa';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          border: {
-            style: 'groove',
-            width: '4px',
-            color: '#aaa',
-          },
-        },
-      });
-    });
     describe('border edge cases inherited from parent', () => {
       it('should handle invalid border string gracefully', () => {
         const element = document.createElement('th');
-        element.style.border = 'invalid';
+        setBorder(element, 'invalid');
         const result = handler.handle(element);
-        expect(result).toEqual({});
+        expect(result).toEqual({
+          tableCell: {
+            border: {
+              style: 'invalid',
+              width: '',
+              color: '',
+            },
+          },
+        });
       });
       it('should handle border with only 2 parts', () => {
         const element = document.createElement('th');
-        element.style.border = 'double 3px';
+        setBorder(element, 'double 3px');
         const result = handler.handle(element);
-        expect(result).toEqual({});
+        expect(result).toEqual({
+          tableCell: {
+            border: {
+              style: 'double',
+              width: '3px',
+              color: '',
+            },
+          },
+        });
       });
       it('should handle border with only spaces', () => {
         const element = document.createElement('th');
-        element.style.border = '   ';
+        setBorder(element, '   ');
         const result = handler.handle(element);
         expect(result).toEqual({});
       });
       it('should handle border with single word', () => {
         const element = document.createElement('th');
-        element.style.border = 'ridge';
+        setBorder(element, 'ridge');
         const result = handler.handle(element);
-        expect(result).toEqual({});
+        expect(result).toEqual({
+          tableCell: {
+            border: {
+              style: 'ridge',
+              width: '',
+              color: '',
+            },
+          },
+        });
+        // Should not fail even if border string is incomplete
       });
       it('should handle empty border string', () => {
         const element = document.createElement('th');
-        element.style.border = '';
+        setBorder(element, '');
         const result = handler.handle(element);
         expect(result).toEqual({});
       });

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

@@ -1,6 +1,7 @@
 import { RTETableExtensionAnnotationTypeEnum, RTETableAnnotation, } from '../../../extensions/table/annotations/table-annotation';
 import { RTETableBlock } from '../../../extensions/table/dto/table-block';
 import { RTETableAnnotationsAction } from '../../../extensions/table/actions/table-annotations-action';
+import { VegaInternalThemeManager } from '../../../../../helpers/theme/internal-theme-manager';
 describe('RTETableAnnotation', () => {
   test('defaults width to 100% and includes border collapse in style', () => {
     const annotation = new RTETableAnnotation();
@@ -17,15 +18,15 @@ describe('RTETableAnnotation', () => {
   });
   test('renderStyle merges provided values', () => {
     const annotation = new RTETableAnnotation({
-      backgroundColor: '#fafafa',
-      border: { style: 'solid', width: '2px', color: '#123' },
+      backgroundColor: 'orange',
+      border: { style: 'solid', width: '2px', color: 'orange' },
       height: '200px',
       alignment: 'center',
     });
     expect(annotation.renderStyle()).toEqual({
       borderCollapse: 'collapse',
-      backgroundColor: '#fafafa',
-      border: 'solid 2px #123',
+      backgroundColor: '#FDAB68',
+      border: 'solid 2px #FDAB68',
       height: '200px',
       margin: '0 auto',
     });
@@ -33,13 +34,13 @@ describe('RTETableAnnotation', () => {
   test('borderStr handles missing and provided borders', () => {
     expect(new RTETableAnnotation({ border: undefined }).borderStr).toBeNull();
     expect(new RTETableAnnotation({
-      border: { style: 'dotted', width: '3px', color: '#222' },
-    }).borderStr).toBe('dotted 3px #222');
+      border: { style: 'dotted', width: '3px', color: 'orange' },
+    }).borderStr).toBe('dotted 3px #FDAB68');
   });
   test('clone duplicates all values', () => {
     const original = new RTETableAnnotation({
-      backgroundColor: '#0f0',
-      border: { style: 'dashed', width: '1px', color: '#000' },
+      backgroundColor: 'orange',
+      border: { style: 'dashed', width: '1px', color: 'orange' },
       height: '50px',
       alignment: 'right',
     });
@@ -49,23 +50,24 @@ describe('RTETableAnnotation', () => {
   });
   test('from returns tuple with type constant', () => {
     const [type, annotation] = RTETableAnnotation.from({
-      backgroundColor: '#abc',
+      backgroundColor: 'orange',
     });
     expect(type).toBe(RTETableExtensionAnnotationTypeEnum.TABLE);
     expect(annotation).toBeInstanceOf(RTETableAnnotation);
-    expect(annotation.backgroundColor).toBe('#abc');
+    expect(annotation.backgroundColor).toBe('orange');
   });
   test('toJSON filters undefined values', () => {
     const annotation = new RTETableAnnotation({
-      backgroundColor: '#f00',
+      backgroundColor: 'orange',
       height: '20px',
       border: undefined,
     });
     expect(annotation.toJSON()).toEqual({
       table: {
-        backgroundColor: '#f00',
+        backgroundColor: 'orange',
         height: '20px',
         alignment: 'center',
+        borderCollapse: 'collapse',
       },
     });
   });
@@ -75,15 +77,105 @@ describe('RTETableAnnotation', () => {
   test('should apply annotation correctly', () => {
     const tableBlock = new RTETableBlock('table-id');
     tableBlock.apply(new RTETableAnnotationsAction({
-      backgroundColor: '#3c3ffa',
+      backgroundColor: 'orange',
     }));
     expect(tableBlock.toJSON()).toEqual({
       id: 'table-id',
       type: 'table-block',
       annotations: {
-        table: { backgroundColor: '#3c3ffa', alignment: 'center' },
+        table: { backgroundColor: 'orange', alignment: 'center', borderCollapse: 'collapse' },
       },
       children: [],
     });
   });
+  test('should initial table color annotation correct', () => {
+    VegaInternalThemeManager.toggleDarkMode(false);
+    const annotation = new RTETableAnnotation({
+      backgroundColor: 'orange',
+      border: { color: 'orange', style: 'none', width: '1px' },
+    });
+    expect(annotation.toJSON()).toEqual({
+      table: {
+        backgroundColor: 'orange',
+        alignment: 'center',
+        borderCollapse: 'collapse',
+        border: { color: 'orange', style: 'none', width: '1px' },
+      },
+    });
+    expect(annotation.renderStyle().backgroundColor).toEqual('#FDAB68');
+    expect(annotation.borderStr).toEqual('none 1px #FDAB68');
+    VegaInternalThemeManager.toggleDarkMode(true);
+    expect(annotation.renderStyle().backgroundColor).toEqual('#974502');
+    expect(annotation.borderStr).toEqual('none 1px #974502');
+    VegaInternalThemeManager.toggleDarkMode(false);
+  });
+  describe('useInternalStyle parameter', () => {
+    test('applies default values when useInternalStyle is true and values are undefined', () => {
+      const annotation = new RTETableAnnotation({}, true);
+      expect(annotation.alignment).toBe(RTETableAnnotation.DEFAULT_ALIGNMENT);
+      expect(annotation.borderCollapse).toBe(RTETableAnnotation.DEFAULT_BORDER_COLLAPSE);
+      expect(annotation.useInternalStyle).toBe(true);
+    });
+    test('does not apply default values when useInternalStyle is false', () => {
+      const annotation = new RTETableAnnotation({}, false);
+      expect(annotation.alignment).toBeUndefined();
+      expect(annotation.borderCollapse).toBeUndefined();
+      expect(annotation.useInternalStyle).toBe(false);
+    });
+    test('preserves explicit null values when useInternalStyle is true', () => {
+      const annotation = new RTETableAnnotation({
+        alignment: null,
+        borderCollapse: null,
+      }, true);
+      expect(annotation.alignment).toBeNull();
+      expect(annotation.borderCollapse).toBeNull();
+    });
+    test('preserves explicit null values when useInternalStyle is false', () => {
+      const annotation = new RTETableAnnotation({
+        alignment: null,
+        borderCollapse: null,
+      }, false);
+      expect(annotation.alignment).toBeNull();
+      expect(annotation.borderCollapse).toBeNull();
+    });
+    test('uses provided custom values regardless of useInternalStyle', () => {
+      const customValues = {
+        alignment: 'left',
+        borderCollapse: 'separate',
+      };
+      const annotationWithInternal = new RTETableAnnotation(customValues, true);
+      const annotationWithoutInternal = new RTETableAnnotation(customValues, false);
+      expect(annotationWithInternal.alignment).toBe('left');
+      expect(annotationWithInternal.borderCollapse).toBe('separate');
+      expect(annotationWithoutInternal.alignment).toBe('left');
+      expect(annotationWithoutInternal.borderCollapse).toBe('separate');
+    });
+    test('defaults to useInternalStyle true when not specified', () => {
+      const annotation = new RTETableAnnotation({});
+      expect(annotation.alignment).toBe(RTETableAnnotation.DEFAULT_ALIGNMENT);
+      expect(annotation.borderCollapse).toBe(RTETableAnnotation.DEFAULT_BORDER_COLLAPSE);
+      expect(annotation.useInternalStyle).toBe(true);
+    });
+    test('applies defaults only for undefined values when useInternalStyle is true', () => {
+      const annotation = new RTETableAnnotation({
+        alignment: 'right',
+        borderCollapse: undefined,
+      }, true);
+      expect(annotation.alignment).toBe('right');
+      expect(annotation.borderCollapse).toBe(RTETableAnnotation.DEFAULT_BORDER_COLLAPSE);
+    });
+    test('clone preserves useInternalStyle flag', () => {
+      const original = new RTETableAnnotation({
+        alignment: 'left',
+      }, false);
+      const cloned = original.clone();
+      expect(cloned.useInternalStyle).toBe(false);
+      expect(cloned.alignment).toBe('left');
+    });
+    test('from method passes useInternalStyle to constructor', () => {
+      const [, annotation] = RTETableAnnotation.from({ alignment: undefined }, false);
+      expect(annotation.useInternalStyle).toBe(false);
+      expect(annotation.alignment).toBeUndefined();
+    });
+  });
 });

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

@@ -1,13 +1,13 @@
-import { RTETableCellAnnotation } from '../../../extensions/table/annotations/table-cell-annotation';
+import { RTETableCellAnnotation, } from '../../../extensions/table/annotations/table-cell-annotation';
 import { RTETableExtensionAnnotationTypeEnum } from '../../../extensions/table/annotations/table-annotation';
 import { RTETableCellBlock } from '../../../extensions/table/dto/table-cell-block';
 import { RTETableCellAnnotationsAction } from '../../../extensions/table/actions/table-cell-annotations-action';
 import { RTETableHeadCellAnnotation } from '../../../extensions/table/annotations/table-head-cell-annotation';
 describe('RTETableCellAnnotation', () => {
   const customOptions = {
-    backgroundColor: '#fff',
+    backgroundColor: 'white',
     padding: '8px',
-    border: { style: 'dashed', width: '2px', color: '#000' },
+    border: { style: 'dashed', width: '2px', color: 'black' },
     width: '100px',
     height: '80px',
     textAlign: 'right',
@@ -36,9 +36,9 @@ describe('RTETableCellAnnotation', () => {
   test('renderStyle preserves custom values when not standalone', () => {
     const annotation = new RTETableCellAnnotation(customOptions);
     expect(annotation.renderStyle({ standalone: false })).toEqual({
-      backgroundColor: '#fff',
+      backgroundColor: '#FCFCFC',
       padding: '8px',
-      border: 'dashed 2px #000',
+      border: 'dashed 2px #04041C',
       width: '100px',
       height: '80px',
       textAlign: 'right',
@@ -48,9 +48,9 @@ describe('RTETableCellAnnotation', () => {
   test('renderStyle preserves custom values when not standalone for RTETableHeadCellAnnotation', () => {
     const annotation = new RTETableHeadCellAnnotation(customOptions);
     expect(annotation.renderStyle({ standalone: false })).toEqual({
-      backgroundColor: '#fff',
+      backgroundColor: '#FCFCFC',
       padding: '8px',
-      border: 'dashed 2px #000',
+      border: 'dashed 2px #04041C',
       width: '100px',
       height: '80px',
       textAlign: 'right',
@@ -61,9 +61,9 @@ describe('RTETableCellAnnotation', () => {
     const withoutBorder = new RTETableCellAnnotation({ border: null });
     expect(withoutBorder.borderStr).toBeNull();
     const withBorder = new RTETableCellAnnotation({
-      border: { style: 'dotted', width: '3px', color: '#123' },
+      border: { style: 'dotted', width: '3px', color: 'white' },
     });
-    expect(withBorder.borderStr).toBe('dotted 3px #123');
+    expect(withBorder.borderStr).toBe('dotted 3px #FCFCFC');
   });
   test('clone duplicates instance but keeps values', () => {
     const original = new RTETableCellAnnotation({
@@ -80,6 +80,34 @@ describe('RTETableCellAnnotation', () => {
     expect(annotation).toBeInstanceOf(RTETableCellAnnotation);
     expect(annotation.backgroundColor).toBe('#abc');
   });
+  test('from applies default minWidth and boxSizing when useInternalStyle is true', () => {
+    const [, annotation] = RTETableCellAnnotation.from({ backgroundColor: '#abc' }, true);
+    expect(annotation.minWidth).toBe(RTETableCellAnnotation.DEFAULT_CELL_MIN_WIDTH);
+    expect(annotation.boxSizing).toBe(RTETableCellAnnotation.DEFAULT_BOX_SIZING);
+  });
+  test('from does not apply default minWidth and boxSizing when useInternalStyle is false', () => {
+    const [, annotation] = RTETableCellAnnotation.from({ backgroundColor: '#abc' }, false);
+    expect(annotation.minWidth).toBeUndefined();
+    expect(annotation.boxSizing).toBeUndefined();
+  });
+  test('from preserves explicit minWidth and boxSizing values', () => {
+    const [, annotation] = RTETableCellAnnotation.from({
+      backgroundColor: '#abc',
+      minWidth: '100px',
+      boxSizing: 'content-box',
+    }, true);
+    expect(annotation.minWidth).toBe('100px');
+    expect(annotation.boxSizing).toBe('content-box');
+  });
+  test('from preserves null minWidth and boxSizing values when useInternalStyle is true', () => {
+    const [, annotation] = RTETableCellAnnotation.from({
+      backgroundColor: '#abc',
+      minWidth: null,
+      boxSizing: null,
+    }, true);
+    expect(annotation.minWidth).toBeNull();
+    expect(annotation.boxSizing).toBeNull();
+  });
   test('from returns type constant and annotation instance', () => {
     const [type, annotation] = RTETableHeadCellAnnotation.from({ backgroundColor: '#abc' });
     expect(type).toBe(RTETableExtensionAnnotationTypeEnum.CELL);
@@ -99,9 +127,71 @@ describe('RTETableCellAnnotation', () => {
         padding: '12px',
         textAlign: 'left',
         verticalAlign: 'middle',
+        minWidth: '55px',
+        boxSizing: 'border-box',
+      },
+    });
+  });
+  test('toJSON includes custom minWidth and boxSizing values', () => {
+    const annotation = new RTETableCellAnnotation({
+      backgroundColor: '#f00',
+      minWidth: '100px',
+      boxSizing: 'content-box',
+    });
+    expect(annotation.toJSON()).toEqual({
+      tableCell: {
+        backgroundColor: '#f00',
+        padding: '12px',
+        border: { style: 'solid', width: '1px', color: '#ddd' },
+        textAlign: 'left',
+        verticalAlign: 'middle',
+        minWidth: '100px',
+        boxSizing: 'content-box',
+      },
+    });
+  });
+  test('toJSON excludes minWidth and boxSizing when they are null', () => {
+    const annotation = new RTETableCellAnnotation({
+      backgroundColor: '#f00',
+      minWidth: null,
+      boxSizing: null,
+    });
+    expect(annotation.toJSON()).toEqual({
+      tableCell: {
+        backgroundColor: '#f00',
+        padding: '12px',
+        border: { style: 'solid', width: '1px', color: '#ddd' },
+        textAlign: 'left',
+        verticalAlign: 'middle',
+      },
+    });
+  });
+  test('toJSON excludes minWidth and boxSizing when useInternalStyle is false', () => {
+    const annotation = new RTETableCellAnnotation({
+      backgroundColor: '#f00',
+    }, false);
+    expect(annotation.toJSON()).toEqual({
+      tableCell: {
+        backgroundColor: '#f00',
       },
     });
   });
+  test('toJSON includes only non-default minWidth when specified', () => {
+    const annotation = new RTETableCellAnnotation({
+      backgroundColor: '#f00',
+      minWidth: '200px',
+    });
+    const json = annotation.toJSON();
+    expect(json.tableCell.minWidth).toBe('200px');
+  });
+  test('toJSON includes only non-default boxSizing when specified', () => {
+    const annotation = new RTETableCellAnnotation({
+      backgroundColor: '#f00',
+      boxSizing: 'content-box',
+    });
+    const json = annotation.toJSON();
+    expect(json.tableCell.boxSizing).toBe('content-box');
+  });
   test('renderClass always returns null', () => {
     expect(new RTETableCellAnnotation().renderClass()).toBeNull();
   });
@@ -121,8 +211,113 @@ describe('RTETableCellAnnotation', () => {
           padding: '12px',
           textAlign: 'left',
           verticalAlign: 'middle',
+          minWidth: '55px',
+          boxSizing: 'border-box',
         },
       },
     });
   });
+  describe('useInternalStyle parameter', () => {
+    test('applies default values when useInternalStyle is true and values are undefined', () => {
+      const annotation = new RTETableCellAnnotation({}, true);
+      expect(annotation.padding).toBe(RTETableCellAnnotation.DEFAULT_PADDING);
+      expect(annotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+      expect(annotation.textAlign).toBe(RTETableCellAnnotation.DEFAULT_HORIZONTAL_TEXT_ALIGN);
+      expect(annotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+      expect(annotation.minWidth).toBe(RTETableCellAnnotation.DEFAULT_CELL_MIN_WIDTH);
+      expect(annotation.boxSizing).toBe(RTETableCellAnnotation.DEFAULT_BOX_SIZING);
+    });
+    test('does not apply default values when useInternalStyle is false', () => {
+      const annotation = new RTETableCellAnnotation({}, false);
+      expect(annotation.padding).toBeUndefined();
+      expect(annotation.border).toBeUndefined();
+      expect(annotation.textAlign).toBeUndefined();
+      expect(annotation.verticalAlign).toBeUndefined();
+      expect(annotation.minWidth).toBeUndefined();
+      expect(annotation.boxSizing).toBeUndefined();
+    });
+    test('preserves explicit null values when useInternalStyle is true', () => {
+      const annotation = new RTETableCellAnnotation({
+        padding: null,
+        border: null,
+        textAlign: null,
+        verticalAlign: null,
+        minWidth: null,
+        boxSizing: null,
+      }, true);
+      expect(annotation.padding).toBeNull();
+      expect(annotation.border).toBeNull();
+      expect(annotation.textAlign).toBeNull();
+      expect(annotation.verticalAlign).toBeNull();
+      expect(annotation.minWidth).toBeNull();
+      expect(annotation.boxSizing).toBeNull();
+    });
+    test('preserves explicit null values when useInternalStyle is false', () => {
+      const annotation = new RTETableCellAnnotation({
+        padding: null,
+        border: null,
+        textAlign: null,
+        verticalAlign: null,
+        minWidth: null,
+        boxSizing: null,
+      }, false);
+      expect(annotation.padding).toBeNull();
+      expect(annotation.border).toBeNull();
+      expect(annotation.textAlign).toBeNull();
+      expect(annotation.verticalAlign).toBeNull();
+      expect(annotation.minWidth).toBeNull();
+      expect(annotation.boxSizing).toBeNull();
+    });
+    test('uses provided custom values regardless of useInternalStyle', () => {
+      const customValues = {
+        padding: '20px',
+        border: { style: 'dotted', width: '3px', color: 'blue' },
+        textAlign: 'center',
+        verticalAlign: 'top',
+        minWidth: '100px',
+        boxSizing: 'content-box',
+      };
+      const annotationWithInternal = new RTETableCellAnnotation(customValues, true);
+      const annotationWithoutInternal = new RTETableCellAnnotation(customValues, false);
+      expect(annotationWithInternal.padding).toBe('20px');
+      expect(annotationWithInternal.border).toEqual({
+        style: 'dotted',
+        width: '3px',
+        color: 'blue',
+      });
+      expect(annotationWithInternal.textAlign).toBe('center');
+      expect(annotationWithInternal.verticalAlign).toBe('top');
+      expect(annotationWithInternal.minWidth).toBe('100px');
+      expect(annotationWithInternal.boxSizing).toBe('content-box');
+      expect(annotationWithoutInternal.padding).toBe('20px');
+      expect(annotationWithoutInternal.border).toEqual({
+        style: 'dotted',
+        width: '3px',
+        color: 'blue',
+      });
+      expect(annotationWithoutInternal.textAlign).toBe('center');
+      expect(annotationWithoutInternal.verticalAlign).toBe('top');
+      expect(annotationWithoutInternal.minWidth).toBe('100px');
+      expect(annotationWithoutInternal.boxSizing).toBe('content-box');
+    });
+    test('defaults to useInternalStyle true when not specified', () => {
+      const annotation = new RTETableCellAnnotation({});
+      expect(annotation.padding).toBe(RTETableCellAnnotation.DEFAULT_PADDING);
+      expect(annotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+      expect(annotation.textAlign).toBe(RTETableCellAnnotation.DEFAULT_HORIZONTAL_TEXT_ALIGN);
+      expect(annotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+    });
+    test('applies defaults only for undefined values when useInternalStyle is true', () => {
+      const annotation = new RTETableCellAnnotation({
+        padding: '15px',
+        border: undefined,
+        textAlign: null,
+        verticalAlign: undefined,
+      }, true);
+      expect(annotation.padding).toBe('15px');
+      expect(annotation.border).toEqual(RTETableCellAnnotation.DEFAULT_BORDER);
+      expect(annotation.textAlign).toBeNull();
+      expect(annotation.verticalAlign).toBe(RTETableCellAnnotation.DEFAULT_VERTICAL_TEXT_ALIGN);
+    });
+  });
 });