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

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

@@ -0,0 +1,79 @@
+import { RTETableCaptionAnnotation } from '../../../extensions/table/annotations/table-caption-annotation';
+import { RTETableExtensionAnnotationTypeEnum } from '../../../extensions/table/annotations/table-annotation';
+describe('RTETableCaptionAnnotation', () => {
+  it('should have CAPTION type', () => {
+    const annotation = new RTETableCaptionAnnotation();
+    expect(annotation.type).toBe(RTETableExtensionAnnotationTypeEnum.CAPTION);
+  });
+  it('clone should return a new instance with same type', () => {
+    const annotation = new RTETableCaptionAnnotation();
+    const cloned = annotation.clone();
+    expect(cloned).toBeInstanceOf(RTETableCaptionAnnotation);
+    expect(cloned).not.toBe(annotation);
+    expect(cloned.type).toBe(annotation.type);
+  });
+  describe('renderClass', () => {
+    it('should return CSS class when not standalone', () => {
+      const annotation = new RTETableCaptionAnnotation();
+      const context = { standalone: false };
+      const className = annotation.renderClass(context);
+      expect(className).toBe('v-rte--extension-table-caption');
+    });
+    it('should return CSS class when context is undefined', () => {
+      const annotation = new RTETableCaptionAnnotation();
+      const className = annotation.renderClass();
+      expect(className).toBe('v-rte--extension-table-caption');
+    });
+    it('should return null when standalone', () => {
+      const annotation = new RTETableCaptionAnnotation();
+      const context = { standalone: true };
+      const className = annotation.renderClass(context);
+      expect(className).toBeNull();
+    });
+  });
+  describe('renderStyle', () => {
+    it('should return null when not standalone', () => {
+      const annotation = new RTETableCaptionAnnotation();
+      const context = { standalone: false };
+      const style = annotation.renderStyle(context);
+      expect(style).toBeNull();
+    });
+    it('should return null when context is undefined', () => {
+      const annotation = new RTETableCaptionAnnotation();
+      const style = annotation.renderStyle();
+      expect(style).toBeNull();
+    });
+    it('should return correct style when standalone', () => {
+      const annotation = new RTETableCaptionAnnotation();
+      const context = { standalone: true };
+      const style = annotation.renderStyle(context);
+      expect(style).toEqual({
+        padding: '8px',
+        border: '1px solid #ddd',
+        borderBottom: 'none',
+        backgroundColor: '#f7f7f7',
+        position: 'relative',
+        textAlign: 'center',
+        minHeight: '22px',
+      });
+    });
+  });
+  describe('toJSON', () => {
+    it('should return caption style JSON', () => {
+      const annotation = new RTETableCaptionAnnotation();
+      const json = annotation.toJSON();
+      expect(json).not.toBeNull();
+      expect(json).toEqual({
+        caption: {
+          padding: '8px 12px',
+          border: '1px solid #ddd',
+          borderBottom: 'none',
+          backgroundColor: '#f7f7f7',
+          position: 'relative',
+          textAlign: 'center',
+          minHeight: '22px',
+        },
+      });
+    });
+  });
+});

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

@@ -0,0 +1,323 @@
+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: 'white',
+    padding: '8px',
+    border: { style: 'dashed', width: '2px', color: 'black' },
+    width: '100px',
+    height: '80px',
+    textAlign: 'right',
+    verticalAlign: 'bottom',
+  };
+  test('exposes a default padding constant', () => {
+    expect(RTETableCellAnnotation.DEFAULT_PADDING).toBe('12px');
+  });
+  test('renderStyle removes defaults without options', () => {
+    expect(new RTETableCellAnnotation().renderStyle()).toEqual({});
+  });
+  test('renderStyle includes defaults when standalone true', () => {
+    const style = new RTETableCellAnnotation().renderStyle({ standalone: true });
+    expect(style).toMatchObject({
+      padding: RTETableCellAnnotation.DEFAULT_PADDING,
+      border: 'solid 1px #ddd',
+      textAlign: 'left',
+      verticalAlign: 'middle',
+    });
+  });
+  test('renderStyle omits defaults when not standalone', () => {
+    const annotation = new RTETableCellAnnotation();
+    const style = annotation.renderStyle({ standalone: false });
+    expect(style).toEqual({});
+  });
+  test('renderStyle preserves custom values when not standalone', () => {
+    const annotation = new RTETableCellAnnotation(customOptions);
+    expect(annotation.renderStyle({ standalone: false })).toEqual({
+      backgroundColor: '#FCFCFC',
+      padding: '8px',
+      border: 'dashed 2px #04041C',
+      width: '100px',
+      height: '80px',
+      textAlign: 'right',
+      verticalAlign: 'bottom',
+    });
+  });
+  test('renderStyle preserves custom values when not standalone for RTETableHeadCellAnnotation', () => {
+    const annotation = new RTETableHeadCellAnnotation(customOptions);
+    expect(annotation.renderStyle({ standalone: false })).toEqual({
+      backgroundColor: '#FCFCFC',
+      padding: '8px',
+      border: 'dashed 2px #04041C',
+      width: '100px',
+      height: '80px',
+      textAlign: 'right',
+      verticalAlign: 'bottom',
+    });
+  });
+  test('borderStr handles absent and custom borders', () => {
+    const withoutBorder = new RTETableCellAnnotation({ border: null });
+    expect(withoutBorder.borderStr).toBeNull();
+    const withBorder = new RTETableCellAnnotation({
+      border: { style: 'dotted', width: '3px', color: 'white' },
+    });
+    expect(withBorder.borderStr).toBe('dotted 3px #FCFCFC');
+  });
+  test('clone duplicates instance but keeps values', () => {
+    const original = new RTETableCellAnnotation({
+      backgroundColor: '#abc',
+      textAlign: 'center',
+    });
+    const copy = original.clone();
+    expect(copy).not.toBe(original);
+    expect(copy).toEqual(original);
+  });
+  test('from returns type constant and annotation instance', () => {
+    const [type, annotation] = RTETableCellAnnotation.from({ backgroundColor: '#abc' });
+    expect(type).toBe(RTETableExtensionAnnotationTypeEnum.CELL);
+    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);
+    expect(annotation).toBeInstanceOf(RTETableCellAnnotation);
+    expect(annotation.backgroundColor).toBe('#abc');
+  });
+  test('toJSON removes undefined entries', () => {
+    const annotation = new RTETableCellAnnotation({
+      backgroundColor: '#f00',
+      height: '120px',
+      border: null,
+    });
+    expect(annotation.toJSON()).toEqual({
+      tableCell: {
+        backgroundColor: '#f00',
+        height: '120px',
+        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();
+  });
+  test('should apply the annotation correctly', () => {
+    const cellBlock = new RTETableCellBlock('cell-1');
+    cellBlock.apply(new RTETableCellAnnotationsAction({
+      backgroundColor: '#03852d',
+    }));
+    expect(cellBlock.toJSON()).toEqual({
+      id: 'cell-1',
+      type: 'table-cell',
+      children: [],
+      annotations: {
+        tableCell: {
+          backgroundColor: '#03852d',
+          border: { color: '#ddd', style: 'solid', width: '1px' },
+          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);
+    });
+  });
+});

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

@@ -0,0 +1,32 @@
+import { VegaInternalThemeManager } from '../../../../../helpers/theme/internal-theme-manager';
+import { RTETableColorAnnotation } from '../../../extensions/table/annotations/table-color-annotation';
+import { RTETableColorManager } from '../../../extensions/table/utils/table-color-manager';
+describe('RTETableColorAnnotation', () => {
+  it('should create instance successfully', () => {
+    const colorAnnotation = new RTETableColorAnnotation();
+    expect(colorAnnotation.toJSON()).toEqual({ color: '' });
+  });
+  it('should table color annotation method work properly', () => {
+    const colorAnnotation = new RTETableColorAnnotation('white');
+    expect(colorAnnotation.renderStyle()).toEqual({ color: '#FCFCFC' });
+    expect(colorAnnotation.renderClass()).toBeNull();
+    expect(colorAnnotation.toJSON()).toEqual({ color: 'white' });
+    const clonedAnnotation = colorAnnotation.clone();
+    expect(clonedAnnotation.renderStyle()).toEqual({ color: '#FCFCFC' });
+    expect(clonedAnnotation.toJSON()).toEqual({ color: 'white' });
+    function test() {
+      new RTETableColorAnnotation().clone();
+    }
+    expect(test).not.toThrowError();
+  });
+});
+describe('RTETableColorManager getColorKey', () => {
+  it('should getColorKey work properly', () => {
+    expect(RTETableColorManager.getColorKey('rgb(252, 252, 252)')).toBe('white');
+    expect(RTETableColorManager.getColorKey('#333')).toBe('');
+    VegaInternalThemeManager.toggleDarkMode(true);
+    expect(RTETableColorManager.getColorKey('rgb(252, 252, 252)')).toBe('black');
+    VegaInternalThemeManager.toggleDarkMode(false);
+    expect(RTETableColorManager.getColorKey('orange')).toBe('orange');
+  });
+});