@heartlandone/vega 2.77.1 → 2.79.0

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

@@ -0,0 +1,172 @@
+import { generateUUID } from '../../../../../utils/misc';
+/**
+ * Generate mock table data for testing purposes.
+ *
+ * @param {{ withHeader?: boolean }} options - Options for generating the table data.
+ * @param {boolean} options.withHeader - Whether to include a table header.
+ * @returns {VegaRTETableBlock} The generated mock table block data.
+ */
+export const mockRTETableData = ({ withHeader } = {}) => {
+  const tableHead = {
+    id: generateUUID(),
+    type: 'table-head',
+    children: [
+      {
+        id: generateUUID(),
+        type: 'table-row',
+        children: [
+          {
+            id: generateUUID(),
+            type: 'table-head-cell',
+            children: [
+              {
+                id: generateUUID(),
+                annotations: {
+                  textStyle: 'paragraph',
+                },
+                type: 'paragraph',
+                nodes: [
+                  {
+                    id: generateUUID(),
+                    type: 'text',
+                    text: 'H-A',
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            id: generateUUID(),
+            type: 'table-head-cell',
+            children: [
+              {
+                id: generateUUID(),
+                annotations: {
+                  textStyle: 'paragraph',
+                },
+                type: 'paragraph',
+                nodes: [
+                  {
+                    id: generateUUID(),
+                    type: 'text',
+                    text: 'H-B',
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+  const tableBody = {
+    id: generateUUID(),
+    type: 'table-body',
+    children: [
+      {
+        id: generateUUID(),
+        type: 'table-row',
+        children: [
+          {
+            id: generateUUID(),
+            type: 'table-cell',
+            children: [
+              {
+                id: generateUUID(),
+                annotations: {
+                  textStyle: 'paragraph',
+                },
+                type: 'paragraph',
+                nodes: [
+                  {
+                    id: generateUUID(),
+                    type: 'text',
+                    text: 'A',
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            id: generateUUID(),
+            type: 'table-cell',
+            children: [
+              {
+                id: generateUUID(),
+                annotations: {
+                  textStyle: 'paragraph',
+                },
+                type: 'paragraph',
+                nodes: [
+                  {
+                    id: generateUUID(),
+                    type: 'text',
+                    text: 'B',
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: generateUUID(),
+        type: 'table-row',
+        children: [
+          {
+            id: generateUUID(),
+            type: 'table-cell',
+            children: [
+              {
+                id: generateUUID(),
+                annotations: {
+                  textStyle: 'paragraph',
+                },
+                type: 'paragraph',
+                nodes: [
+                  {
+                    id: generateUUID(),
+                    type: 'text',
+                    text: 'C',
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            id: generateUUID(),
+            type: 'table-cell',
+            children: [
+              {
+                id: generateUUID(),
+                annotations: {
+                  textStyle: 'paragraph',
+                },
+                type: 'paragraph',
+                nodes: [
+                  {
+                    id: generateUUID(),
+                    type: 'text',
+                    text: 'D',
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+  const children = [];
+  if (withHeader) {
+    children.push(tableHead, tableBody);
+  }
+  else {
+    children.push(tableBody);
+  }
+  return {
+    id: generateUUID(),
+    type: 'table-block',
+    children: children,
+  };
+};

package/dist/collection/components/vega-rich-text-editor/test/filter-styles-strategies/filter-styles-strategy.test.js

@@ -0,0 +1,129 @@
+import { RTEFilterStylesStrategy, } from '../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+import { RTEFilterStylesStrategyRegistry } from '../../dto/filter-styles-strategies/filter-styles-strategy-registry';
+// ---------------------------------------------------------------------------
+// Concrete stub for testing the abstract class
+// ---------------------------------------------------------------------------
+class StubFilterStylesStrategy extends RTEFilterStylesStrategy {
+  constructor(styles) {
+    super();
+    this.stylesToBeFiltered = styles;
+  }
+  /** Expose the protected method for testing */
+  testExtract(styles) {
+    return this.extractAndDeleteMatchedStyles(styles);
+  }
+}
+// ---------------------------------------------------------------------------
+// RTEFilterStylesStrategy – extractAndDeleteMatchedStyles
+// ---------------------------------------------------------------------------
+describe('RTEFilterStylesStrategy.extractAndDeleteMatchedStyles', () => {
+  it('should remove properties whose value matches the configured default', () => {
+    const strategy = new StubFilterStylesStrategy({
+      fontFamily: 'Inter',
+      fontSize: '16px',
+    });
+    const styles = { fontFamily: 'Inter', fontSize: '16px', color: 'red' };
+    const result = strategy.testExtract(styles);
+    expect(result).toBe(true);
+    expect(styles).toEqual({ color: 'red' });
+  });
+  it('should return true even when only a subset of defaults are present', () => {
+    const strategy = new StubFilterStylesStrategy({
+      fontFamily: 'Inter',
+      fontSize: '16px',
+    });
+    const styles = { fontFamily: 'Inter' };
+    const result = strategy.testExtract(styles);
+    expect(result).toBe(true);
+    expect(styles).toEqual({});
+  });
+  it('should return false when no property matches', () => {
+    const strategy = new StubFilterStylesStrategy({
+      fontFamily: 'Inter',
+    });
+    const styles = { fontFamily: 'Roboto' };
+    const result = strategy.testExtract(styles);
+    expect(result).toBe(false);
+    expect(styles).toEqual({ fontFamily: 'Roboto' });
+  });
+  it('should not remove a property whose value differs from the default', () => {
+    const strategy = new StubFilterStylesStrategy({
+      marginTop: '0px',
+    });
+    const styles = { marginTop: '10px' };
+    strategy.testExtract(styles);
+    expect(styles).toEqual({ marginTop: '10px' });
+  });
+  it('should return false and not throw when styles is null', () => {
+    const strategy = new StubFilterStylesStrategy({ fontSize: '16px' });
+    expect(strategy.testExtract(null)).toBe(false);
+  });
+  it('should return false and leave styles unchanged when stylesToBeFiltered is empty', () => {
+    const strategy = new StubFilterStylesStrategy({});
+    const styles = { color: 'blue' };
+    const result = strategy.testExtract(styles);
+    expect(result).toBe(false);
+    expect(styles).toEqual({ color: 'blue' });
+  });
+  it('should remove all properties when styles exactly matches defaults', () => {
+    const defaults = { fontFamily: 'Inter', fontWeight: '500', fontSize: '16px' };
+    const strategy = new StubFilterStylesStrategy(defaults);
+    const styles = Object.assign({}, defaults);
+    strategy.testExtract(styles);
+    expect(styles).toEqual({});
+  });
+});
+// ---------------------------------------------------------------------------
+// RTEFilterStylesStrategyRegistry – register / getStrategies
+// ---------------------------------------------------------------------------
+describe('RTEFilterStylesStrategyRegistry', () => {
+  // Use a unique class name per describe to avoid state leakage between tests.
+  const DTO_CLASS_A = '__TestDtoClassA__';
+  const DTO_CLASS_B = '__TestDtoClassB__';
+  it('should return an empty array for an unregistered DTO class name', () => {
+    expect(RTEFilterStylesStrategyRegistry.getStrategies('__NotRegistered__')).toEqual([]);
+  });
+  it('should register a strategy and return it via getStrategies', () => {
+    const strategy = new StubFilterStylesStrategy({ color: 'red' });
+    RTEFilterStylesStrategyRegistry.register(DTO_CLASS_A, strategy);
+    const result = RTEFilterStylesStrategyRegistry.getStrategies(DTO_CLASS_A);
+    expect(result).toContain(strategy);
+  });
+  it('should ignore duplicate registrations of the same instance', () => {
+    const strategy = new StubFilterStylesStrategy({ color: 'blue' });
+    RTEFilterStylesStrategyRegistry.register(DTO_CLASS_B, strategy);
+    RTEFilterStylesStrategyRegistry.register(DTO_CLASS_B, strategy);
+    RTEFilterStylesStrategyRegistry.register(DTO_CLASS_B, strategy);
+    const result = RTEFilterStylesStrategyRegistry.getStrategies(DTO_CLASS_B);
+    expect(result.filter((s) => s === strategy).length).toBe(1);
+  });
+  it('should allow multiple distinct strategy instances for the same DTO class', () => {
+    const dtoClass = '__TestDtoClassMulti__';
+    const s1 = new StubFilterStylesStrategy({ fontSize: '16px' });
+    const s2 = new StubFilterStylesStrategy({ fontWeight: '500' });
+    RTEFilterStylesStrategyRegistry.register(dtoClass, s1);
+    RTEFilterStylesStrategyRegistry.register(dtoClass, s2);
+    const result = RTEFilterStylesStrategyRegistry.getStrategies(dtoClass);
+    expect(result).toContain(s1);
+    expect(result).toContain(s2);
+  });
+  it('should keep strategies for different DTO class names independent', () => {
+    const classX = '__TestDtoClassX__';
+    const classY = '__TestDtoClassY__';
+    const strategyX = new StubFilterStylesStrategy({ color: 'green' });
+    const strategyY = new StubFilterStylesStrategy({ color: 'yellow' });
+    RTEFilterStylesStrategyRegistry.register(classX, strategyX);
+    RTEFilterStylesStrategyRegistry.register(classY, strategyY);
+    expect(RTEFilterStylesStrategyRegistry.getStrategies(classX)).not.toContain(strategyY);
+    expect(RTEFilterStylesStrategyRegistry.getStrategies(classY)).not.toContain(strategyX);
+  });
+  it('getStrategies should return a new array snapshot each call', () => {
+    const dtoClass = '__TestDtoClassSnapshot__';
+    const strategy = new StubFilterStylesStrategy({ opacity: '1' });
+    RTEFilterStylesStrategyRegistry.register(dtoClass, strategy);
+    const first = RTEFilterStylesStrategyRegistry.getStrategies(dtoClass);
+    const second = RTEFilterStylesStrategyRegistry.getStrategies(dtoClass);
+    expect(first).not.toBe(second);
+    expect(first).toEqual(second);
+  });
+});

package/dist/collection/components/vega-rich-text-editor/test/spec-utils.js

@@ -6,19 +6,22 @@ import { tryGetDocument } from '../../../utils/try-get-document';
  * @param {SpecPage} page - The SpecPage instance.
  * @param {{ textEl: HTMLElement; startOffset: number; endOffset: number }} options - Options for text selection.
  * @param {HTMLElement} options.textEl - The text element to select within.
+ * @param {HTMLElement} [options.endContainer] - The end container element of the selection.
+ * @param {HTMLElement} [options.commonAncestorContainer] - The common ancestor container of the selection.
  * @param {number} options.startOffset - The start offset of the selection.
  * @param {number} options.endOffset - The end offset of the selection.
  */
 export const mockTextSelection = async (page, options) => {
   const richTextEditorContent = find(page.body, 'vega-rich-text-editor >>> vega-rich-text-content');
   richTextEditorContent.shadowRoot['getSelection'] = jest.fn(() => {
+    var _a;
     return {
       rangeCount: 1,
       removeAllRanges: jest.fn(),
       getRangeAt: jest.fn().mockReturnValue({
         startContainer: options.textEl.firstChild,
-        endContainer: options.textEl.firstChild,
-        commonAncestorContainer: options.textEl,
+        endContainer: ((_a = options.endContainer) === null || _a === void 0 ? void 0 : _a.firstChild) || options.textEl.firstChild,
+        commonAncestorContainer: options.commonAncestorContainer || options.textEl,
         startOffset: options.startOffset,
         endOffset: options.endOffset,
         intersectsNode: jest.fn().mockReturnValue(true),

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-editor.css

@@ -78,6 +78,10 @@
   background-color: rgba(var(--v-bg-secondary, 245, 247, 247, 1));
   border: 1px solid rgba(var(--v-border-input-field-disabled, 222, 225, 227, 1));
   cursor: not-allowed;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
 }
 :host .rich-text-editor-container.disabled:hover, :host .rich-text-editor-container.disabled:focus-within {
   border: 1px solid rgba(var(--v-border-input-field-disabled, 222, 225, 227, 1));

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-editor.js

@@ -23,7 +23,7 @@ import { LessIndentToolbarButtonSlimmer } from './slimmers/renderers/tools/less-
 import { ImageToolbarButtonSlimmer } from './slimmers/renderers/tools/image-toolbar-button-slimmer';
 import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
 import { createEventEmitSlimmer, } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
-import { VegaChange, VegaImageInserted } from '../../helpers/event-manager/event-id/vega-event-id';
+import { VegaChange, VegaImageInserted, VegaSourceCodeChange, } from '../../helpers/event-manager/event-id/vega-event-id';
 import { TextColorToolbarButtonSlimmer } from './slimmers/renderers/tools/text-color-toolbar-button-slimmer';
 import { createSubStateNotifySlimmer } from '../../helpers/slimmers/sub-state/sub-state-notify-slimmer';
 import { BulletsNumbersToolbarButtonSlimmer } from './slimmers/renderers/tools/bullets-numbers/bullets-numbers-toolbar-button-slimmer';
@@ -38,7 +38,6 @@ import { RichTextEditorRequiredRule } from '../../helpers/validator/rules/rich-t
 import { InsertImageController } from './slimmers/controllers/insert-image-controller';
 import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { FocusController } from './slimmers/controllers/focus-controller';
-import { TextNodeColorController } from './slimmers/controllers/text-node-color-controller';
 import { InsertCompositionTextController } from './slimmers/controllers/insert-composition-text-controller';
 import { DeleteSelectedNodesController } from './slimmers/controllers/delete-selected-nodes-controller';
 import { TranslationSlimmer } from '../../helpers/slimmers/translation';
@@ -49,6 +48,7 @@ import { InternalCodeBlockSelectionController } from './slimmers/controllers/int
 import { SourceEditToolbarButtonSlimmer } from './slimmers/renderers/tools/source-edit-toolbar-button-slimmer';
 import { RTEExtensionController } from './slimmers/controllers/extension-controller';
 import { VegaRTEPresetToolbarItems } from './constants/constant';
+import { VegaRichTextEditorSourceViewRenderer } from './slimmers/renderers/vega-rich-text-editor-source-view-renderer';
 /**
  * @vegaVersion 2.34.0
  */
@@ -101,11 +101,12 @@ export class VegaRichTextEditor {
     this.insertCompositionTextController = new InsertCompositionTextController();
     this.imageInsertedEventEmitter = createEventEmitSlimmer(VegaRichTextEditor, VegaImageInserted);
     this.changeEventPreventSlimmer = new ChildNodesEventPreventSlimmer([VegaChange], () => this.vegaRichTextEditorRenderer.getRichTextWrapperRef());
-    this.textNodeColorController = new TextNodeColorController();
     this.deleteSelectedNodesController = new DeleteSelectedNodesController();
     this.historyController = new HistoryController();
     this.internalCodeBlockSelectionController = new InternalCodeBlockSelectionController();
     this.rteExtensionController = new RTEExtensionController();
+    this.sourceCodeChangeEventEmitter = createEventEmitSlimmer(VegaRichTextEditor, VegaSourceCodeChange);
+    this.richTextEditorSourceViewRenderer = new VegaRichTextEditorSourceViewRenderer();
     this.richTextContentEditable = true;
     this.selectionMap = new Map();
     this.isInDarkMode = VegaInternalThemeManager.isDarkMode();
@@ -660,6 +661,45 @@ export class VegaRichTextEditor {
           }
         }
       }
+    }, {
+      "method": "vegaSourceCodeChange",
+      "name": "vegaSourceCodeChange",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [{
+            "name": "vegaVersion",
+            "text": "2.78.0"
+          }],
+        "text": "An event emitter notifying a source code change event. It triggers when the editor loses focus in source edit mode."
+      },
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      }
+    }, {
+      "method": "sourceCodeChange",
+      "name": "sourceCodeChange",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [{
+            "name": "eventSemantics",
+            "text": "namespace:native"
+          }, {
+            "name": "vegaVersion",
+            "text": "2.78.0"
+          }],
+        "text": "An event emitter notifying a source code change event. It triggers when the editor loses focus in source edit mode."
+      },
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      }
     }]; }
   static get elementRef() { return "host"; }
   static get watchers() { return [{
@@ -787,9 +827,6 @@ __decorate([
 __decorate([
   InjectVegaSlimmer()
 ], VegaRichTextEditor.prototype, "changeEventPreventSlimmer", void 0);
-__decorate([
-  InjectVegaSlimmer()
-], VegaRichTextEditor.prototype, "textNodeColorController", void 0);
 __decorate([
   InjectVegaSlimmer()
 ], VegaRichTextEditor.prototype, "deleteSelectedNodesController", void 0);
@@ -802,3 +839,9 @@ __decorate([
 __decorate([
   InjectVegaSlimmer()
 ], VegaRichTextEditor.prototype, "rteExtensionController", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaRichTextEditor.prototype, "sourceCodeChangeEventEmitter", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaRichTextEditor.prototype, "richTextEditorSourceViewRenderer", void 0);

package/dist/collection/components/vega-stepper/vega-stepper.js

@@ -188,7 +188,7 @@ export class VegaStepper {
             DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, VegaBlur, (input) => this.handleInputBlur(input));
             DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, VegaChange, (input) => this.onChildInputChange(input));
             return (this.inputRef = el);
-          } }),
+          }, "data-aria-label": this.label || 'stepper' }),
         h("vega-button-circle", { label: "Increase", showTooltip: false, ref: (ref) => {
             DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaClick, () => this.onIncrease());
           }, icon: "plus-sign", disabled: this.value >= this.max || this.disabled, size: "small", variant: this.buttonVariant == 'secondary' ? 'secondary' : 'primary' }))), this.host);