@heartlandone/vega 2.75.0 → 2.76.0

package/dist/collection/components/vega-rich-text-editor/test/html-cleaner/html-content-cleaner.test.js

@@ -0,0 +1,186 @@
+import { HTMLContentCleaner } from '../../slimmers/controllers/html-cleaner';
+describe('HTMLContentCleaner', () => {
+  let cleaner;
+  beforeEach(() => {
+    cleaner = new HTMLContentCleaner();
+  });
+  it('should handle empty string', () => {
+    expect(cleaner.clean('')).toBe('');
+  });
+  it('should handle whitespace-only string', () => {
+    expect(cleaner.clean('   ')).toBe('   ');
+  });
+  it('should remove \\n\\t after opening tag and before closing tag', () => {
+    const input = '<div><p>\n\t <span>test</span>\n\t </p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p><span>test</span></p></div>');
+  });
+  it('should remove all \\n and \\t characters between tags', () => {
+    const input = '<div><p>\n\ttest\n</p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p>test</p></div>');
+  });
+  it('should preserve space between matching tags', () => {
+    const input = '<div><span> </span></div>';
+    expect(cleaner.clean(input)).toBe('<div><span> </span></div>');
+  });
+  it('should preserve space with text between matching tags', () => {
+    const input = '<div><span> test </span></div>';
+    expect(cleaner.clean(input)).toBe('<div><span> test </span></div>');
+  });
+  it('should preserve multiple spaces between matching tags', () => {
+    const input = '<div><span>  </span></div>';
+    expect(cleaner.clean(input)).toBe('<div><span>  </span></div>');
+  });
+  it('should remove whitespace between opening tags', () => {
+    const input = '<div>\n\t<p></p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p></p></div>');
+  });
+  it('should remove \\n\\t after opening tag but preserve regular spaces', () => {
+    const input = '<p>\n\t  Hello</p>';
+    expect(cleaner.clean(input)).toBe('<p>  Hello</p>');
+  });
+  it('should remove whitespace between multiple closing tags', () => {
+    const input = '<table><tbody><tr></tr> </tbody> </table>';
+    expect(cleaner.clean(input)).toBe('<table><tbody><tr></tr></tbody></table>');
+  });
+  it('should remove whitespace between multiple opening tags', () => {
+    const input = '<div> <span></span></div>';
+    expect(cleaner.clean(input)).toBe('<div><span></span></div>');
+  });
+  it('should handle complex nested structure', () => {
+    const input = '<div>\n\t<p>\n\t\t<span>Hello</span>\n\t</p>\n</div>';
+    expect(cleaner.clean(input)).toBe('<div><p><span>Hello</span></p></div>');
+  });
+  it('should preserve regular spaces within text content', () => {
+    const input = '<div><p>Hello World</p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p>Hello World</p></div>');
+  });
+  it('should preserve multiple spaces in text content', () => {
+    const input = '<div><p>Hello  World</p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p>Hello  World</p></div>');
+  });
+  it('should not remove \\n between words in text content', () => {
+    const input = '<div><p>Hello\nWorld</p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p>Hello\nWorld</p></div>');
+  });
+  it('should not remove \\n between words with space in text content', () => {
+    const input = '<div><p>Hello\n World</p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p>Hello\n World</p></div>');
+  });
+  it('should remove multiple consecutive \\n characters', () => {
+    const input = '<div><p>\n\n\n\nHello</p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p>Hello</p></div>');
+  });
+  it('should remove multiple consecutive \\t characters', () => {
+    const input = '<div><p>\t\t\tHello</p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p>Hello</p></div>');
+  });
+  it('should preserve empty matching tags', () => {
+    const input = '<div><span></span></div>';
+    expect(cleaner.clean(input)).toBe('<div><span></span></div>');
+  });
+  it('should handle mixed spaces, tabs, and newlines', () => {
+    const input = '<div> \n\t <p>Text</p> \n\t </div>';
+    expect(cleaner.clean(input)).toBe('<div><p>Text</p></div>');
+  });
+  it('should remove \\t\\n combination', () => {
+    const input = '<div><p>\t\nHello</p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p>Hello</p></div>');
+  });
+  it('should remove complex \\n\\t\\n patterns', () => {
+    const input = '<div><p>\n\t\n\t\nHello</p></div>';
+    expect(cleaner.clean(input)).toBe('<div><p>Hello</p></div>');
+  });
+  it('should handle 4-level deep nesting', () => {
+    const input = '<div>\n\t<section>\n\t\t<article>\n\t\t\t<p>Text</p>\n\t\t</article>\n\t</section>\n</div>';
+    expect(cleaner.clean(input)).toBe('<div><section><article><p>Text</p></article></section></div>');
+  });
+  it('should handle 5-level deep nesting', () => {
+    const input = '<div>\n\t<section>\n\t\t<article>\n\t\t\t<main>\n\t\t\t\t<p>Text</p>\n\t\t\t</main>\n\t\t</article>\n\t</section>\n</div>';
+    expect(cleaner.clean(input)).toBe('<div><section><article><main><p>Text</p></main></article></section></div>');
+  });
+  it('should handle 6-level deep nesting', () => {
+    const input = '<div>\n\t<section>\n\t\t<article>\n\t\t\t<main>\n\t\t\t\t<aside>\n\t\t\t\t\t<p>Text</p>\n\t\t\t\t</aside>\n\t\t\t</main>\n\t\t</article>\n\t</section>\n</div>';
+    expect(cleaner.clean(input)).toBe('<div><section><article><main><aside><p>Text</p></aside></main></article></section></div>');
+  });
+  it('should remove whitespace after br and hr tags', () => {
+    const input1 = '<div><br>\n</div>';
+    expect(cleaner.clean(input1)).toBe('<div><br></div>');
+    const input2 = '<div><hr>\n\t</div>';
+    expect(cleaner.clean(input2)).toBe('<div><hr></div>');
+    const input3 = '<div><input type="text">\n</div>';
+    expect(cleaner.clean(input3)).toBe('<div><input type="text"></div>');
+  });
+  it('should remove newlines after br tags', () => {
+    const input = '<p>Line 1<br>\nLine 2</p>';
+    expect(cleaner.clean(input)).toBe('<p>Line 1<br>Line 2</p>');
+  });
+  it('should preserve spaces in code blocks between matching tags', () => {
+    const input = '<code>  const x = 1;  </code>';
+    expect(cleaner.clean(input)).toBe('<code>  const x = 1;  </code>');
+  });
+  it('should preserve plain text without tags', () => {
+    const input = 'Hello World';
+    expect(cleaner.clean(input)).toBe('Hello World');
+  });
+  it('should remove whitespace between different inline elements', () => {
+    const input = '<span>text</span>\n\t<strong>bold</strong>';
+    expect(cleaner.clean(input)).toBe('<span>text</span><strong>bold</strong>');
+  });
+  it('should inline a table by removing all whitespace between tags', () => {
+    const input = `<table style="width: 400px; border-collapse: collapse;">   <thead>     <tr>       ` +
+      `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 1</th>       ` +
+      `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 2</th>       ` +
+      `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 3</th>     ` +
+      `</tr>   </thead>   <tbody>     <tr>       <td style="padding: 12px;">Cell 1-1</td>       ` +
+      `<td style="padding: 12px;">Cell 1-2</td>       <td style="padding: 12px;">Cell 1-3</td>     ` +
+      `</tr>     <tr>       <td style="padding: 12px;">Cell 2-1</td>       <td style="padding: 12px;">Cell 2-2</td>       ` +
+      `<td style="padding: 12px;">Cell 2-3</td>     </tr>     <tr>       <td style="padding: 12px;">Cell 3-1</td>       ` +
+      `<td style="padding: 12px;">Cell 3-2</td>       <td style="padding: 12px;">Cell 3-3</td>     ` +
+      `</tr>   </tbody> </table>`;
+    const expected = `<table style="width: 400px; border-collapse: collapse;"><thead><tr>` +
+      `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 1</th>` +
+      `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 2</th>` +
+      `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 3</th>` +
+      `</tr></thead><tbody><tr>` +
+      `<td style="padding: 12px;">Cell 1-1</td>` +
+      `<td style="padding: 12px;">Cell 1-2</td>` +
+      `<td style="padding: 12px;">Cell 1-3</td>` +
+      `</tr><tr>` +
+      `<td style="padding: 12px;">Cell 2-1</td>` +
+      `<td style="padding: 12px;">Cell 2-2</td>` +
+      `<td style="padding: 12px;">Cell 2-3</td>` +
+      `</tr><tr>` +
+      `<td style="padding: 12px;">Cell 3-1</td>` +
+      `<td style="padding: 12px;">Cell 3-2</td>` +
+      `<td style="padding: 12px;">Cell 3-3</td>` +
+      `</tr></tbody></table>`;
+    expect(cleaner.clean(input)).toBe(expected);
+  });
+  it('should remove newline after img tag', () => {
+    const input = '<div><img id="image-id" class="img-class" style="vertical-align: bottom; width: 25%; padding: 20px" alt="test alt" src="data:image/svg+xml;base64,xxx=" data-size="sm">\n</div>';
+    const expected = '<div><img id="image-id" class="img-class" style="vertical-align: bottom; width: 25%; padding: 20px" alt="test alt" src="data:image/svg+xml;base64,xxx=" data-size="sm"></div>';
+    expect(cleaner.clean(input)).toBe(expected);
+  });
+  it('should preserve spaces in attribute values', () => {
+    const input = '<p class="my custom class">Text</p>';
+    expect(cleaner.clean(input)).toBe('<p class="my custom class">Text</p>');
+  });
+  describe('Edge cases', () => {
+    it('should handle self-closing tags', () => {
+      expect(cleaner.clean('<br/>\n<hr/>')).toBe('<br/><hr/>');
+      expect(cleaner.clean('<img src="test.jpg"/>\n<input/>')).toBe('<img src="test.jpg"/><input/>');
+    });
+    it('should handle nested matching tags', () => {
+      expect(cleaner.clean('<div> <div> </div> </div>')).toBe('<div><div> </div></div>');
+    });
+    it('should handle tags with special characters in attributes', () => {
+      expect(cleaner.clean('<a href="http://example.com?a=1&b=2">\nLink</a>')).toBe('<a href="http://example.com?a=1&b=2">Link</a>');
+    });
+    it('should handle HTML entities', () => {
+      expect(cleaner.clean('<div><p>\n&nbsp;&lt;&gt;</p></div>')).toBe('<div><p>&nbsp;&lt;&gt;</p></div>');
+    });
+    it('should handle comments', () => {
+      expect(cleaner.clean('<div>\n<!-- comment -->\n<p>Text</p></div>')).toBe('<div><!-- comment --><p>Text</p></div>');
+    });
+  });
+});

package/dist/collection/components/vega-rich-text-editor/test/html-cleaner/remove-whitespace-after-opening-tag-processor.test.js

@@ -0,0 +1,22 @@
+import { RemoveWhitespaceAfterOpeningTagProcessor } from '../../slimmers/controllers/html-cleaner';
+describe('RemoveWhitespaceAfterOpeningTagProcessor', () => {
+  let processor;
+  beforeEach(() => {
+    processor = new RemoveWhitespaceAfterOpeningTagProcessor();
+  });
+  it('should remove \\n and \\t after opening tag', () => {
+    expect(processor.process('<div><p>\n\tHello</p></div>')).toBe('<div><p>Hello</p></div>');
+    expect(processor.process('<div><div>\n\n\tWorld</div></div>')).toBe('<div><div>World</div></div>');
+    expect(processor.process('<div><span>\tTest</span></div>')).toBe('<div><span>Test</span></div>');
+  });
+  it('should preserve regular spaces', () => {
+    expect(processor.process('<div><p>  Hello</p></div>')).toBe('<div><p>  Hello</p></div>');
+    expect(processor.process('<div><p> World</p></div>')).toBe('<div><p> World</p></div>');
+  });
+  it('should not affect text without opening tags', () => {
+    expect(processor.process('<div>Hello World</div>')).toBe('<div>Hello World</div>');
+  });
+  it('should handle multiple occurrences', () => {
+    expect(processor.process('<div><p>\nHello</p><div>\tWorld</div></div>')).toBe('<div><p>Hello</p><div>World</div></div>');
+  });
+});

package/dist/collection/components/vega-rich-text-editor/test/html-cleaner/remove-whitespace-before-closing-tag-processor.test.js

@@ -0,0 +1,22 @@
+import { RemoveWhitespaceBeforeClosingTagProcessor } from '../../slimmers/controllers/html-cleaner';
+describe('RemoveWhitespaceBeforeClosingTagProcessor', () => {
+  let processor;
+  beforeEach(() => {
+    processor = new RemoveWhitespaceBeforeClosingTagProcessor();
+  });
+  it('should remove \\n and \\t before closing tag', () => {
+    expect(processor.process('<div><p>World\n\t</p></div>')).toBe('<div><p>World</p></div>');
+    expect(processor.process('<div><div>Hello\n</div></div>')).toBe('<div><div>Hello</div></div>');
+    expect(processor.process('<div><span>Test\t</span></div>')).toBe('<div><span>Test</span></div>');
+  });
+  it('should preserve regular spaces', () => {
+    expect(processor.process('<div><p>Hello  </p></div>')).toBe('<div><p>Hello  </p></div>');
+    expect(processor.process('<div><p>World </p></div>')).toBe('<div><p>World </p></div>');
+  });
+  it('should not affect text without closing tags', () => {
+    expect(processor.process('<div>Hello World</div>')).toBe('<div>Hello World</div>');
+  });
+  it('should handle multiple occurrences', () => {
+    expect(processor.process('<div><p>Hello\n</p><div>World\t</div></div>')).toBe('<div><p>Hello</p><div>World</div></div>');
+  });
+});

package/dist/collection/components/vega-rich-text-editor/test/html-cleaner/remove-whitespace-between-tags-processor.test.js

@@ -0,0 +1,26 @@
+import { RemoveWhitespaceBetweenTagsProcessor } from '../../slimmers/controllers/html-cleaner';
+describe('RemoveWhitespaceBetweenTagsProcessor', () => {
+  let processor;
+  beforeEach(() => {
+    processor = new RemoveWhitespaceBetweenTagsProcessor();
+  });
+  it('should remove whitespace between different tags', () => {
+    expect(processor.process('<div><p></p>\n\t<div></div></div>')).toBe('<div><p></p><div></div></div>');
+    expect(processor.process('<div><div>\n\t<span></span></div></div>')).toBe('<div><div><span></span></div></div>');
+    expect(processor.process('<div><div></div> <p></p></div>')).toBe('<div><div></div><p></p></div>');
+  });
+  it('should preserve whitespace between matching tags', () => {
+    expect(processor.process('<div><span> </span></div>')).toBe('<div><span> </span></div>');
+    expect(processor.process('<div><span>  </span></div>')).toBe('<div><span>  </span></div>');
+    expect(processor.process('<div><span>\n\t</span></div>')).toBe('<div><span>\n\t</span></div>');
+    expect(processor.process('<div><code> </code></div>')).toBe('<div><code> </code></div>');
+  });
+  it('should handle custom elements with hyphens', () => {
+    expect(processor.process('<div><my-component> </my-component></div>')).toBe('<div><my-component> </my-component></div>');
+    expect(processor.process('<div><my-component></my-component>\n<other-component></other-component></div>')).toBe('<div><my-component></my-component><other-component></other-component></div>');
+  });
+  it('should handle tags with attributes', () => {
+    expect(processor.process('<div><div class="test">\n<span></span></div></div>')).toBe('<div><div class="test"><span></span></div></div>');
+    expect(processor.process('<div><span id="test"> </span></div>')).toBe('<div><span id="test"> </span></div>');
+  });
+});

package/dist/collection/components/vega-signature-capture/slimmers/written-mode/controllers/written-mode-svg-controller.js

@@ -8,6 +8,7 @@ import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-sli
 import { FORM_ELEMENT_VALUE_CHANGE } from '../../../../../helpers/change-manager/subject/static-subject/static-subject-title';
 import ChangeManager from '../../../../../helpers/change-manager/change-manager';
 import { deepEqual } from '../../../../../utils/object';
+import { emptySanitizeStrategy, htmlSanitizer } from '../../../../../utils/sanitize';
 /**
  * Signature written mode controller
  */
@@ -19,7 +20,7 @@ export class WrittenModeSvgController extends VegaSlimmer {
      * Clear the signature
      */
     this.clear = () => {
-      this.signatureContainerRef.innerHTML = '';
+      this.signatureContainerRef.innerHTML = htmlSanitizer.sanitize('', emptySanitizeStrategy);
       this.value = null;
     };
     /*

package/dist/collection/components/vega-table/interface.js

@@ -1,3 +1,6 @@
+/**
+ * List of supported form field types for editable table cells.
+ */
 export const VegaTableEditableFieldTypes = [
   'input',
   'input-select',

package/dist/collection/components/vega-table/vega-table-foot-cell/slimmers/renderers/vega-table-foot-cell-renderer.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { MapToComponentField, VegaSlimmer } from 'vega-slimmer/core';
 import { h } from '@stencil/core';
-import { FeatureFlag } from '../../../../../helpers/public-api';
+import { FeatureFlag } from '../../../../../helpers/feature-control/feature-flag-controller';
 import { generateResponsiveClass } from '../../../utils';
 import { arrayToClassString } from '../../../../../utils/ui';
 export class VegaTableFootCellRenderer extends VegaSlimmer {

package/dist/collection/global/scripts/before-vega-load.js

@@ -8,13 +8,14 @@ import { GlobalSlimmersRegistry } from 'vega-slimmer/core';
 import { VegaWatchMethodCancelSlimmer } from '../../helpers/slimmers/global/vega-watch-method-cancel-slimmer';
 import VegaEventManager from '../../helpers/event-manager/vega-event-manager';
 import { TypographyUrls } from '../../constants/tokens/typography';
-import { VegaIconManager, VegaTranslationResourceEN } from '../../helpers/public-api';
+import { VegaIconManager } from '../../helpers/icon/icon-manager';
+import { default as VegaTranslationResourceEN } from '../../helpers/translation/locales/en';
 import VegaZIndexManager from '../../helpers/zindex/vega-z-index-manager';
 import { ValidCreditCardNumberRule } from '../../helpers/validator/rules/valid-credit-card-number-rule';
 import vegaEnvManager from '../../helpers/vega-telemetry-helper/vega-env-manager';
-import { waitForVega } from '../../helpers/common';
+import { waitForVega } from '../../helpers/common/wait-for-vega-handler';
 import { VegaSkeletonLoader } from '../../helpers/skeleton-loader/vega-skeleton-loader-controller';
-import { VegaTranslation } from '../../helpers/translation';
+import { VegaTranslation } from '../../helpers/translation/translation';
 import { VegaTranslateObserverSlimmer } from '../../helpers/slimmers/global/vega-translate-observer-slimmer';
 import { VegaRTEContent } from '../../components/vega-rich-text-editor/dto/content-state';
 import { setVegaNonce, vegaNonceManager } from '../../helpers/csp/vega-nonce-manager';

package/dist/collection/helpers/calendar/calendar-date.js

@@ -1,4 +1,4 @@
-import { VegaInternalTranslation } from '../translation';
+import { VegaInternalTranslation } from '../translation/internal-translation-controller';
 import { CalendarDateTime } from './calendar-date-time';
 import { getSystemTimezone } from './utils';
 import { DateFormatParserRegex } from '../../constants/regex';

package/dist/collection/helpers/calendar/calendar-event.js

@@ -1,6 +1,6 @@
 import calendarEventRepeatPatternFactory from '../../components/vega-calendar/slimmers/common/helpers/repeat-pattern/calendar-event-repeat-pattern-factory';
 import { generateUUID } from '../../utils/misc';
-import { VegaInternalTranslation } from '../translation';
+import { VegaInternalTranslation } from '../translation/internal-translation-controller';
 import { CalendarDate } from './calendar-date';
 import { CalendarTime } from './calendar-time';
 import { CalendarDateTime } from './calendar-date-time';

package/dist/collection/helpers/calendar/calendar-time.js

@@ -1,4 +1,4 @@
-import { VegaInternalTranslation } from '../translation';
+import { VegaInternalTranslation } from '../translation/internal-translation-controller';
 /**
  * CalendarTime represents hours/minutes in 24-hour format and centralizes parsing/formatting logic.
  */

package/dist/collection/helpers/code-format/code-formatter.js

@@ -5,6 +5,7 @@ class CodeFormatter {
   constructor() {
     /**
      * Formats a given HTML source string by applying indentation and cleaning up styles.
+     * Content inside preserve tags (pre) is preserved as-is without formatting.
      *
      * @param {string} source - The HTML source string to format.
      * @param {CodeFormatOptions} options - Formatting options.
@@ -19,9 +20,25 @@ class CodeFormatter {
       const tokens = source.split(tagRegex).filter((t) => t.length > 0);
       let indentLevel = 0;
       let output = '';
+      let preserveDepth = 0;
       for (let i = 0; i < tokens.length; i++) {
         let token = tokens[i];
-        // Decrease indentation for closing tags
+        const tagName = CodeFormatter.getTagName(token);
+        // Track if we're entering or exiting preserve tags
+        if (CodeFormatter.PRESERVE_CONTENT_TAGS.has(tagName)) {
+          if (token.startsWith('</')) {
+            preserveDepth = Math.max(0, preserveDepth - 1);
+          }
+          else if (token.startsWith('<')) {
+            preserveDepth++;
+          }
+        }
+        // If inside preserve tag, output as-is without formatting
+        if (preserveDepth > 0) {
+          output += token;
+          continue;
+        }
+        // Decrease indentation for closing tags (after exiting preserve tags)
         if (token.startsWith('</')) {
           indentLevel = Math.max(0, indentLevel - 1);
         }
@@ -31,15 +48,20 @@ class CodeFormatter {
           token = token.replace(/style\s*=\s*"([^"]*)"/g, (_, styleContent) => {
             return `style="${this.formatStyle(styleContent)}"`;
           });
-          const tagName = CodeFormatter.getTagName(token);
           const isInline = CodeFormatter.INLINE_TAGS.has(tagName);
-          // Inline tag grouping: e.g., <strong>Text</strong> stays on one line
-          if (isInline && i + 2 < tokens.length && tokens[i + 2] === `</${tagName}>`) {
-            // Group consecutive inline tags
+          // Inline tag grouping: e.g., <strong>Text</strong> or <span></span> stays on one line
+          // Check for empty tags: <tag></tag> (closing tag immediately follows opening tag)
+          if (isInline && i + 1 < tokens.length && tokens[i + 1] === `</${tagName}>`) {
+            // Empty inline tag: <span></span>
+            output += `${indent}${token}${tokens[i + 1]}\n`;
+            i += 1;
+          }
+          else if (isInline && i + 2 < tokens.length && tokens[i + 2] === `</${tagName}>`) {
+            // Group consecutive inline tags with content
             let inlineGroup = `${token}${tokens[i + 1]}${tokens[i + 2]}`;
             i += 2;
             // Keep merging consecutive inline tag pairs
-            while (i + 2 < tokens.length &&
+            while (i + 3 < tokens.length &&
               tokens[i + 1].startsWith('<') &&
               CodeFormatter.INLINE_TAGS.has(CodeFormatter.getTagName(tokens[i + 1])) &&
               tokens[i + 3] === `</${CodeFormatter.getTagName(tokens[i + 1])}>`) {
@@ -53,7 +75,7 @@ class CodeFormatter {
             // Increase indentation for non-void opening tags
             if (!token.startsWith('</') &&
               !token.endsWith('/>') &&
-              !/^<br|^<img|^<meta|^<input|^<hr/i.test(token)) {
+              !CodeFormatter.VOID_TAGS.has(tagName)) {
               indentLevel++;
             }
           }
@@ -94,6 +116,10 @@ class CodeFormatter {
       .join('; ');
   }
 }
+/**
+ * Inline/phrasing elements that should be kept on a single line with their content.
+ * These tags are formatted as: <tag>content</tag> on one line.
+ */
 CodeFormatter.INLINE_TAGS = new Set([
   'span',
   'strong',
@@ -113,4 +139,28 @@ CodeFormatter.INLINE_TAGS = new Set([
   'del',
   'ins',
 ]);
+/**
+ * Void/self-closing elements that don't have closing tags.
+ * Used to avoid increasing indentation for these elements.
+ */
+CodeFormatter.VOID_TAGS = new Set([
+  'area',
+  'base',
+  'br',
+  'col',
+  'embed',
+  'hr',
+  'img',
+  'input',
+  'link',
+  'meta',
+  'param',
+  'source',
+  'track',
+  'wbr',
+]);
+/**
+ * Tags whose content should be preserved as-is without formatting.
+ */
+CodeFormatter.PRESERVE_CONTENT_TAGS = new Set(['pre']);
 export default new CodeFormatter();

package/dist/collection/helpers/code-format/test/code-formatter.test.js

@@ -1,5 +1,5 @@
 import CodeFormatter from '../code-formatter';
-import { VegaRTEContent } from '../../public-api';
+import { VegaRTEContent } from '../../../components/vega-rich-text-editor/dto/content-state';
 describe('Code formatter', () => {
   it('should format simple HTML with option useTabs', () => {
     const input = `<p><span>Text</span></p>`;
@@ -359,4 +359,52 @@ describe('Code formatter', () => {
     ]).toHtml();
     expect(CodeFormatter.format(input)).toMatchSnapshot();
   });
+  it('should preserve pre content without formatting', () => {
+    const input = `<pre>
+             S
+             A
+            LUT
+             M
+            O N
+            D  E
+            DONT
+          JE SUIS
+          LA  LAN
+          G U E  É
+         L O Q U E N
+        TE      QUESA
+       B  O  U  C  H  E
+      O        P A R I S
+     T I R E   ET   TIRERA
+    T O U             JOURS
+   AUX                  A  L
+ LEM                      ANDS   - Apollinaire
+</pre>
+`;
+    expect(CodeFormatter.format(input)).toMatchSnapshot();
+  });
+  it('should format empty inline tags on a single line', () => {
+    const input = `<p><span></span></p>`;
+    const output = CodeFormatter.format(input);
+    expect(output).toMatchSnapshot();
+    // Verify empty span stays inline
+    expect(output).toContain('<span></span>');
+    expect(output).not.toContain('<span>\n');
+  });
+  it('should format multiple empty inline tags', () => {
+    const input = `<p><span></span><strong></strong><em></em></p>`;
+    const output = CodeFormatter.format(input);
+    expect(output).toMatchSnapshot();
+    // Verify all empty inline tags stay inline
+    expect(output).toContain('<span></span>');
+    expect(output).toContain('<strong></strong>');
+    expect(output).toContain('<em></em>');
+  });
+  it('should format mixed empty and non-empty inline tags', () => {
+    const input = `<p><span></span><strong>Text</strong><em></em></p>`;
+    const output = CodeFormatter.format(input);
+    expect(output).toMatchSnapshot();
+    expect(output).toContain('<span></span>');
+    expect(output).toContain('<em></em>');
+  });
 });

package/dist/collection/helpers/common/index.js

@@ -1,37 +1,2 @@
-import { WaitForVega } from './wait-for-vega-handler';
-import { Observer } from '../change-manager/observer/observer';
-import ChangeManager from '../change-manager/change-manager';
-import domNodeSubjectFactory from '../change-manager/subject/dom-node-subject/dom-node-subject-factory';
-import { VegaInternalComponentDidRender } from '../event-manager/event-id/vega-internal-event-id';
-/* istanbul ignore next */
-/**
- * Wait for all vega elements to be ready.
- *
- * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
- */
-export const waitForVega = async () => {
-  return WaitForVega.handle();
-};
-/**
- * Wait for the component has been rendered.
- *
- * @param {HTMLStencilElement} componentRef - The reference to the component that needs to be rendered.
- * @returns {Promise<unknown>} A promise that resolves when the component has been rendered.
- */
-export const waitForComponentDidRender = async (componentRef) => {
-  return new Promise((resolve) => {
-    const observer = new Observer(isAcceptableComponentDidRender.bind(null), () => {
-      ChangeManager.unregister(domNodeSubjectFactory.getSubject(componentRef, VegaInternalComponentDidRender), observer);
-      resolve(null);
-    });
-    ChangeManager.register(domNodeSubjectFactory.getSubject(componentRef, VegaInternalComponentDidRender), observer);
-  });
-};
-/**
- * Determines whether the observer should accept changes.
- *
- * @returns {boolean} Always returns true in the current implementation.
- */
-const isAcceptableComponentDidRender = () => {
-  return true;
-};
+export { waitForVega } from './wait-for-vega-handler';
+export { waitForComponentDidRender } from './wait-for-component-did-render';

package/dist/collection/helpers/common/test/wait-for-vega-handler.test.js

@@ -1,10 +1,10 @@
 import VegaTelemetryRuntimeMetricsManager from '@heartlandone/vega-telemetry-runtime-metrics/index';
 import { sleep } from '../../../utils/test-utils';
-import { WaitForVega } from '../wait-for-vega-handler';
+import { waitForVega } from '../wait-for-vega-handler';
 describe('WaitForVegaHandler', () => {
   it('should call the emit method of VegaTelemetryRuntimeMetricsManager when call handle', async () => {
     jest.spyOn(VegaTelemetryRuntimeMetricsManager, 'emit');
-    await WaitForVega.handle();
+    await waitForVega();
     void Promise.resolve(sleep(100)).then(async () => {
       expect(VegaTelemetryRuntimeMetricsManager.emit).toHaveBeenCalledWith('publicAPIMetrics', {
         publicAPIName: 'WaitForVegaHandler',

package/dist/collection/helpers/common/wait-for-component-did-render.js

@@ -0,0 +1,27 @@
+import { Observer } from '../change-manager/observer/observer';
+import ChangeManager from '../change-manager/change-manager';
+import domNodeSubjectFactory from '../change-manager/subject/dom-node-subject/dom-node-subject-factory';
+import { VegaInternalComponentDidRender } from '../event-manager/event-id/vega-internal-event-id';
+/**
+ * Wait for the component has been rendered.
+ *
+ * @param {HTMLStencilElement} componentRef - The reference to the component that needs to be rendered.
+ * @returns {Promise<unknown>} A promise that resolves when the component has been rendered.
+ */
+export const waitForComponentDidRender = async (componentRef) => {
+  return new Promise((resolve) => {
+    const observer = new Observer(isAcceptableComponentDidRender.bind(null), () => {
+      ChangeManager.unregister(domNodeSubjectFactory.getSubject(componentRef, VegaInternalComponentDidRender), observer);
+      resolve(null);
+    });
+    ChangeManager.register(domNodeSubjectFactory.getSubject(componentRef, VegaInternalComponentDidRender), observer);
+  });
+};
+/**
+ * Determines whether the observer should accept changes.
+ *
+ * @returns {boolean} Always returns true in the current implementation.
+ */
+const isAcceptableComponentDidRender = () => {
+  return true;
+};

package/dist/collection/helpers/common/wait-for-vega-handler.js

@@ -33,4 +33,15 @@ class WaitForVegaHandler {
 __decorate([
   InjectVegaTelemetrySlimmer()
 ], WaitForVegaHandler.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
-export const WaitForVega = new WaitForVegaHandler();
+const WaitForVega = new WaitForVegaHandler();
+/* istanbul ignore next */
+/**
+ * Wait for all vega elements to be ready.
+ *
+ * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
+ *
+ * @returns {Promise} A promise that resolves when all vega elements are ready.
+ */
+export const waitForVega = async () => {
+  return WaitForVega.handle();
+};

package/dist/collection/helpers/feature-control/feature-flags-map.js

@@ -209,5 +209,11 @@ const FeatureFlagsMap = {
     createdAtVersion: '2.48.1',
     disabledByDefault: true,
   },
+  'VEGA_ELEMENT_APPENDER.AUTO_PLACEMENT': {
+    description: `A feature flag to automatic placement for appendable pop-ups when isScreenPosition is enabled.`,
+    createdTimestamp: 1770940800000,
+    createdAtVersion: '2.76.0',
+    disabledByDefault: false,
+  },
 };
 export default Object.freeze(FeatureFlagsMap);

package/dist/collection/helpers/formatter/responsive-map-formatter/responsive-border-radius-style-formatter.js

@@ -3,7 +3,7 @@ import { LogUtility } from '../../../utils/log';
 import { BorderRadius } from '../../../constants/public-api';
 import { ResponsiveCSSTextFormatter } from './responsive-css-text-formatter';
 import { sortAsExistArray } from '../../../utils/array';
-import { FeatureFlag } from '../../public-api';
+import { FeatureFlag } from '../../feature-control/feature-flag-controller';
 const BORDER_RADIUS_DIRECTION_STYLE_MAP = {
   'top': ['border-top-left-radius', 'border-top-right-radius'],
   'right': ['border-top-right-radius', 'border-bottom-right-radius'],