@heartlandone/vega 2.79.0 → 2.80.0

package/dist/collection/utils/e2e-utils.js

@@ -1,389 +0,0 @@
-import { newE2EPage } from '@stencil/core/testing';
-import * as axe from 'axe-core';
-import { TestIcons } from '../test-assets/test-icons';
-import { getViewportByDeviceType } from './test-utils';
-/**
- * NOTE: This method is only for **E2E** test cases.
- * Clear the input field and type the input
- *
- * @param {E2EElement} inputElement - E2EElement
- * @param {string} [typeInput] - The string that you want to type into the input field.
- */
-export const inputClearAndType = async (inputElement, typeInput = '') => {
-  await inputClear(inputElement);
-  await inputElement.type(typeInput);
-};
-/**
- * NOTE: This method is only for **E2E** test cases.
- * Click on the input element three times, then press backspace three times
- *
- * @param {E2EElement} inputElement - E2EElement
- */
-export const inputClear = async (inputElement) => {
-  await inputElement.click({ clickCount: 3 });
-  await inputElement.press('Backspace');
-};
-/**
- * `Disable animations for the page`
- *
- * @param {E2EPage} page - The E2EPage instance to disable animations on.
- */
-export const disableAnimationForPage = async (page) => {
-  await page.addStyleTag({
-    content: `
-    *,
-    *::after,
-    *::before {
-        transition-delay: 0s !important;
-        transition-duration: 0s !important;
-        animation-delay: -0.0001s !important;
-        animation-duration: 0s !important;
-        animation-play-state: paused !important;
-        caret-color: transparent !important;
-    }`,
-  });
-  await page.addScriptTag({
-    content: `const appendDisableAnimationScript = (el = document) => {
-            Array.from(el.querySelectorAll('*'))
-            .filter(item => item.tagName.includes('VEGA'))
-            .forEach(item => {
-                if (item.shadowRoot) {
-                    const style = document.createElement('style');
-                    style.innerHTML = \`*,
-					*::after,
-					*::before {
-						transition-delay: 0s !important;
-						transition-duration: 0s !important;
-						animation-delay: -0.0001s !important;
-						animation-duration: 0s !important;
-						animation-play-state: paused !important;
-						caret-color: transparent !important;
-					}\`;
-                    item.shadowRoot.append(style);
-                    appendDisableAnimationScript(item.shadowRoot);
-                }
-            });
-        }
-        appendDisableAnimationScript()`,
-  });
-};
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **E2E** test cases.
- * `Set dark mode for the page`
- *
- * @param {E2EPage} page - The E2EPage instance to set dark mode.
- */
-export const setDarkMode = async (page) => {
-  await page.evaluate(() => {
-    var _a;
-    // eslint-disable-next-line no-restricted-globals
-    (_a = document.querySelector('html')) === null || _a === void 0 ? void 0 : _a.setAttribute('style', 'background-color: rgba(4, 4, 28, 1);');
-    window['VegaThemeManager'].toggleDarkMode(true);
-  });
-  await page.waitForChanges();
-};
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **E2E** test cases.
- * `Set theme override for the page`
- *
- * @param {E2EPage} page - The E2EPage instance to set theme override.
- */
-export const themeOverride = async (page) => {
-  await page.evaluate(() => {
-    // eslint-disable-next-line @typescript-eslint/typedef
-    const customColors = { actionColor: '#f312e0', sidebarColor: '#0de3df' };
-    window['VegaThemeManager'].overrideColors(customColors);
-  });
-  await page.waitForChanges();
-};
-//add below for resolve evaluation failed issue: https://stackoverflow.com/questions/55272295/using-jest-with-puppeteer-evaluation-failed-referenceerror-cov-4kq3tptqc-is
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **E2E** test cases.
- * Send a touch event to the element specified by the selector
- *
- * @param {E2EPage} page - E2EPage
- * @param {{ touchX: number; touchY: number; touchEventType: string }[]} touches - An array of objects that represent the
- * touch events.
- * @param {string} selector - string to access document DOM. To access shadow dom, pass string with >>>. For example: vega-progress-tracker >>> vega-carousel >>> .carousel-inner
- */
-export const sendTouchEvent = async (page, touches, selector = null) => {
-  await page.evaluate((touches, selector) => {
-    const selectorParts = selector.split('>>>').map((item) => item.trim());
-    const hostSelector = selectorParts[0];
-    const nestedSelectors = selectorParts.slice(1);
-    // eslint-disable-next-line no-restricted-globals
-    let element = document.querySelector(hostSelector);
-    nestedSelectors.forEach((item) => {
-      var _a;
-      element = (_a = element === null || element === void 0 ? void 0 : element.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(item);
-    });
-    if (element) {
-      for (let i = 0; i < touches.length; i++) {
-        const x = touches[i].touchX;
-        const y = touches[i].touchY;
-        const eventType = touches[i].touchEventType;
-        const touchObj = new Touch({
-          identifier: Date.now(),
-          target: element,
-          screenX: x,
-          screenY: y,
-          radiusX: 2.5,
-          radiusY: 2.5,
-          rotationAngle: 10,
-          force: 0.5,
-        });
-        const touchEvent = new TouchEvent(eventType, {
-          cancelable: true,
-          bubbles: true,
-          touches: [touchObj],
-          targetTouches: [],
-          changedTouches: [touchObj],
-          shiftKey: true,
-        });
-        element.dispatchEvent(touchEvent);
-      }
-    }
-  }, touches, selector);
-};
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **E2E** test cases.
- * get axe Results
- *
- * @param {E2EPage} page - E2EPage
- * @param {string} content - string
- */
-export const getAxeResults = async (page, content) => {
-  await page.addScriptTag({
-    path: require.resolve('axe-core'),
-  });
-  const { violations, incomplete } = await page.evaluate((content) => axe.run(content, {
-    runOnly: ['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa'],
-  }), content);
-  return { violations, incomplete };
-};
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **E2E** test cases.
- * Rewrite Date to return fixed date
- *
- * @param {E2EPage} page - The E2EPage to mock date.
- * @param {string} date - The date want to mock.
- */
-export const mockDate = async (page, date) => {
-  await page.evaluateOnNewDocument((date) => {
-    /**
-     * Rewrite DateConstructor
-     */
-    // eslint-disable-next-line no-global-assign
-    Date = class extends Date {
-      /**
-       * @param {Date} args - The fixed date want to fixed
-       */
-      constructor(...args) {
-        if (args && args.length > 0) {
-          return super(...args);
-        }
-        date = date ? date : '2022-05-14';
-        return new Date(date);
-      }
-    };
-  }, date);
-};
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **E2E** test cases.
- * get ScreenshotDiff Results
- *
- * @param {E2EPage} page - E2EPage
- * @param {string} desc - the description about the screenshot
- * @param {string} selector - the element want to screenshot
- */
-export const getScreenshotDiffResults = async (page, desc, selector) => {
-  if (selector) {
-    // TODO: Replace with page.find when it support multiple layer shadow dom.
-    const boundingBox = await page.evaluate((selector) => {
-      const selectorParts = selector.split('>>>').map((item) => item.trim());
-      const rootSelector = selectorParts[0];
-      const nestedSelectors = selectorParts.slice(1);
-      // eslint-disable-next-line no-restricted-globals
-      let element = document.body.querySelector(rootSelector);
-      nestedSelectors.forEach((item) => {
-        var _a;
-        element = (_a = element === null || element === void 0 ? void 0 : element.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(item);
-      });
-      if (element) {
-        const { x, y, width, height } = element.getBoundingClientRect();
-        return { x, y, width, height };
-      }
-      else {
-        throw new Error(`Cannot find element by selector: ${selector}`);
-      }
-    }, selector);
-    return await page.compareScreenshot(desc, {
-      clip: boundingBox,
-    });
-  }
-  return await page.compareScreenshot(desc);
-};
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **E2E** test cases.
- * init page
- *
- * @param {string} content - the element content
- * @param {object} config - option parameters
- * @param {boolean} config.wrapped - set it to true when use visual test to catch the fixed area
- * @param {EventSemanticsConfig} config.eventSemanticsConfig - sets the event semantics configuration for the EventManager
- * @param {string} config.date --sets the date want to mock
- * @param {number} config.timeout --sets the content timeout
- * @param {InjectFeatureFlagsConfig} config.featureFlags -inject feature flags.
- * @param {string} config.timezone -sets the browser timezone (defaults to 'Asia/Shanghai' for consistent behavior across environments).
- * @param {boolean} config.isMobile - whether to set the viewport to a mobile device size (defaults to false).
- * @param {boolean} config.initSuggestionsDropdown - whether to inject the vega-input suggestionsDropdownSource initializer (defaults to true).
- */
-export const initVegaE2EPage = async (content, config) => {
-  var _a, _b, _c, _d;
-  const page = await newE2EPage();
-  if (config === null || config === void 0 ? void 0 : config.isMobile) {
-    await page.setUserAgent('Mobile');
-    await page.setViewport(getViewportByDeviceType('mobile'));
-  }
-  // Set timezone to ensure consistent behavior across different environments
-  const timezone = (_a = config === null || config === void 0 ? void 0 : config.timezone) !== null && _a !== void 0 ? _a : 'Asia/Shanghai';
-  const pageWithTimezone = page;
-  if (typeof pageWithTimezone.emulateTimezone === 'function') {
-    await pageWithTimezone.emulateTimezone(timezone);
-  }
-  await mockDate(page, config === null || config === void 0 ? void 0 : config.date);
-  const script = (config === null || config === void 0 ? void 0 : config.eventSemanticsConfig)
-    ? `<script type='module'>window.VegaEventManager.setSemantics(${JSON.stringify(config.eventSemanticsConfig)})</script>`
-    : '';
-  const injectTestIcons = `<script type='module'>
-    window.VegaIconManager.register(${JSON.stringify(TestIcons)});
-  </script>`;
-  const injectFeatureFlags = `<script>
-		window.VegaEnabledFeatureKeys = ${JSON.stringify(((_b = config === null || config === void 0 ? void 0 : config.featureFlags) === null || _b === void 0 ? void 0 : _b.enabled) || [])};
-		window.VegaDisabledFeatureKeys = ${JSON.stringify(((_c = config === null || config === void 0 ? void 0 : config.featureFlags) === null || _c === void 0 ? void 0 : _c.disabled) || [])};
-	</script>`;
-  const initSuggestionsDropdownScript = `<script>
-		// Initialize suggestionsDropdownSource to empty array after component loads
-		window.addEventListener('DOMContentLoaded', () => {
-			setTimeout(() => {
-				const vegaInputs = document.querySelectorAll('vega-input');
-				vegaInputs.forEach(input => {
-					if (!input.suggestionsDropdownSource) {
-						input.suggestionsDropdownSource = [];
-					}
-				});
-			}, 100);
-		});
-	</script>`;
-  const initSuggestionsDropdown = ((_d = config === null || config === void 0 ? void 0 : config.initSuggestionsDropdown) !== null && _d !== void 0 ? _d : true) ? initSuggestionsDropdownScript : '';
-  const contentHtml = (config === null || config === void 0 ? void 0 : config.wrapped)
-    ? `${injectTestIcons}${script}${injectFeatureFlags}${initSuggestionsDropdown}<div style="padding: 10px" id="visual-container">${content}</div>`
-    : injectTestIcons + script + injectFeatureFlags + initSuggestionsDropdown + content;
-  (config === null || config === void 0 ? void 0 : config.timeout)
-    ? await page.setContent(contentHtml, { timeout: config.timeout })
-    : await page.setContent(contentHtml);
-  await page.addStyleTag({ path: './src/test-assets/test-font-base64.css' });
-  await disableAnimationForPage(page);
-  await page.waitForChanges();
-  return page;
-};
-/**
- * NOTE: This method is only for **E2E** test cases.
- * When you want to find all element nested in multiple level shadowRoot
- *
- * @param {E2EPage} page - E2EPage
- * @param {string} selector - the element you want to find
- */
-export const findAll = async (page, selector) => {
-  const element = await page.$$(selector);
-  return element;
-};
-/**
- * NOTE: This method is only for **E2E** test cases.
- * When you want to find element nested in multiple level shadowRoot
- *
- * @param {E2EPage} page - E2EPage
- * @param {string} selector - the element you want to find
- */
-export const find = async (page, selector) => {
-  const element = await page.$(selector);
-  return element;
-};
-/**
- * NOTE: This method is only for **E2E** test cases.
- * When you want to get element prop nested in multiple level shadowRoot
- *
- * @param {ElementHandle<Element>} handler - The ElementHandle returned by call find method
- * @param {string} prop - the prop you want to get
- */
-export const getProperty = async (handler, prop) => {
-  const value = await (await handler.getProperty(prop)).jsonValue();
-  return value;
-};
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **E2E** test cases.
- * When you want to get element css nested in multiple level shadowRoot
- *
- * @param {E2EPage} page - E2EPage
- * @param {ElementHandle<Element>} handler - The ElementHandle returned by call find method
- */
-export const getComputedStyle = async (page, handler) => {
-  const styles = await page.evaluate((element) => {
-    return JSON.parse(JSON.stringify(window.getComputedStyle(element)));
-  }, handler);
-  return styles;
-};
-/**
- * Inject Font Awesome lib for e2e test
- *
- * @param {E2EPage} page - page host of e2e
- * @returns {Promise<void>} -
- */
-export const injectE2EFontAwesomeLib = async (page) => {
-  await page.addStyleTag({ path: './node_modules/@fortawesome/fontawesome-free/css/fontawesome.css' });
-  await page.addStyleTag({ path: './node_modules/@fortawesome/fontawesome-free/css/solid.css' });
-  await page.addStyleTag({ path: './src/test-assets/test-fontawesome-solid-font-base64.css' });
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  await new Promise((r) => setTimeout(r, 300)); // Note: Waiting for fontawesome.css loaded by addStyleTag
-};
-/* istanbul ignore next */
-/**
- * NOTE: This method is only for **E2E** test cases.
- * When you want to click an element nested in multiple level shadowRoot but the element is not clickable by normal click method, you can use this method to click the element by clicking the area off center of the element.
- *
- * @param {E2EPage} page - E2EPage
- * @param {string} selector - the element you want to click, it can be a nested selector with >>> to separate each level of shadow DOM, for example: vega-progress-tracker >>> vega-carousel >>> .carousel-inner
- */
-export const clickOffCenter = async (page, selector) => {
-  const box = await page.evaluate((selector) => {
-    const selectorParts = selector.split('>>>').map((item) => item.trim());
-    const rootSelector = selectorParts[0];
-    const nestedSelectors = selectorParts.slice(1);
-    // eslint-disable-next-line no-restricted-globals
-    let element = document.querySelector(rootSelector);
-    nestedSelectors.forEach((item) => {
-      var _a;
-      element = (_a = element === null || element === void 0 ? void 0 : element.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(item);
-    });
-    if (element) {
-      const rect = element.getBoundingClientRect();
-      return {
-        x: rect.x,
-        y: rect.y,
-      };
-    }
-    return null;
-  }, selector);
-  if (box) {
-    await page.mouse.click(box.x + 1, box.y);
-    await page.waitForChanges();
-  }
-};

package/dist/collection/utils/sanitize/test/empty-strategy.test.js

@@ -1,12 +0,0 @@
-import { HtmlSanitizer } from '../core/html-sanitizer';
-import { EmptySanitizeStrategy } from '../strategies/empty-sanitize-strategy';
-describe('EmptySanitizeStrategy', () => {
-  const sanitizer = new HtmlSanitizer();
-  const strategy = new EmptySanitizeStrategy();
-  it('should always return empty string', () => {
-    const inputs = ['Hello', '<b>Bold</b>', '<script>alert(1)</script>', '', '   '];
-    inputs.forEach((input) => {
-      expect(sanitizer.sanitize(input, strategy)).toBe('');
-    });
-  });
-});

package/dist/collection/utils/sanitize/test/html-sanitizer.test.js

@@ -1,57 +0,0 @@
-import { tryGetDocument } from '../../try-get-document';
-import { HtmlSanitizer } from '../core/html-sanitizer';
-import { labelSanitizeStrategy, styleSanitizeStrategy, emptySanitizeStrategy } from '../index';
-describe('HtmlSanitizer', () => {
-  const sanitizer = new HtmlSanitizer();
-  it('should return empty string for empty input', () => {
-    expect(sanitizer.sanitize('', labelSanitizeStrategy)).toBe('');
-    expect(sanitizer.sanitize('   ', labelSanitizeStrategy)).toBe('');
-  });
-  it('should sanitize label content correctly', () => {
-    const input = '<b>Bold</b> <i>Italic</i> <script>alert(1)</script>';
-    const result = sanitizer.sanitize(input, labelSanitizeStrategy);
-    expect(result).toBe('<b>Bold</b> <i>Italic</i> alert(1)');
-  });
-  it('should preserve text if no tags exist', () => {
-    const input = 'Hello world';
-    const result = sanitizer.sanitize(input, labelSanitizeStrategy);
-    expect(result).toBe('Hello world');
-  });
-  it('should unwrap disallowed elements', () => {
-    const input = '<div><span>Text</span></div>';
-    const result = sanitizer.sanitize(input, labelSanitizeStrategy);
-    expect(result).toBe('Text');
-  });
-  it('should remove unsupported node types (comment nodes)', () => {
-    const input = '<!-- comment -->Visible';
-    const result = sanitizer.sanitize(input, labelSanitizeStrategy);
-    expect(result).toBe('Visible');
-  });
-  it('should preserve safe CSS text in style strategy', () => {
-    const css = 'body { color: red; }';
-    const result = sanitizer.sanitize(css, styleSanitizeStrategy);
-    expect(result).toBe(css);
-  });
-  it('should remove dangerous CSS in style strategy', () => {
-    const css = 'body { background: url(javascript:alert(1)) }';
-    const result = sanitizer.sanitize(css, styleSanitizeStrategy);
-    expect(result).toBe('');
-  });
-  it('should always return empty string for empty strategy', () => {
-    const input = '<b>Bold</b> <i>Italic</i>';
-    const result = sanitizer.sanitize(input, emptySanitizeStrategy);
-    expect(result).toBe('');
-  });
-  it('sanitizeHtmlLabel should not return empty string if document is available', () => {
-    expect(typeof document).toBe('object');
-    expect(tryGetDocument()).toBe(document);
-    expect(sanitizer.sanitize('<b>Some</b> text', labelSanitizeStrategy)).toEqual('<b>Some</b> text');
-  });
-  it('sanitizeHtmlLabel should return empty string if document is not available', () => {
-    const originalDocument = globalThis.document;
-    delete globalThis.document;
-    expect(tryGetDocument()).toBeUndefined();
-    expect(sanitizer.sanitize('<b>Some</b> text', labelSanitizeStrategy)).toEqual('');
-    globalThis.document = originalDocument;
-  });
-});

package/dist/collection/utils/sanitize/test/label-strategy.test.js

@@ -1,56 +0,0 @@
-import { HtmlSanitizer } from '../core/html-sanitizer';
-import { LabelSanitizeStrategy } from '../strategies/label-sanitize-strategy';
-describe('LabelSanitizeStrategy', () => {
-  const sanitizer = new HtmlSanitizer();
-  const strategy = new LabelSanitizeStrategy();
-  it('should allow <b>, <i>, <strong>, <em>', () => {
-    const input = '<b>Bold</b><i>Italic</i><strong>Strong</strong><em>Em</em>';
-    const result = sanitizer.sanitize(input, strategy);
-    expect(result).toBe(input);
-  });
-  it('should unwrap disallowed tags but preserve text', () => {
-    const input = '<span>Span</span><div>Div</div>';
-    const result = sanitizer.sanitize(input, strategy);
-    expect(result).toBe('SpanDiv');
-  });
-  it('should strip attributes even on allowed tags', () => {
-    const input = '<b style="color:red">Bold</b>';
-    const result = sanitizer.sanitize(input, strategy);
-    expect(result).toBe('<b>Bold</b>');
-  });
-  it('should preserve plain text nodes', () => {
-    const input = 'Just some text';
-    const result = sanitizer.sanitize(input, strategy);
-    expect(result).toBe('Just some text');
-  });
-  it('should handle mixed allowed and disallowed tags', () => {
-    const input = '<b>Bold</b> <script>alert(1)</script>';
-    const result = sanitizer.sanitize(input, strategy);
-    expect(result).toBe('<b>Bold</b> alert(1)');
-  });
-  test('sanitizeHtmlLabel should return textContent if no HTML elements exist', () => {
-    expect(sanitizer.sanitize('>hello', strategy)).toEqual('>hello');
-    expect(sanitizer.sanitize('Me > You', strategy)).toEqual('Me > You');
-    expect(sanitizer.sanitize('Me <b>></b> You', strategy)).toEqual('Me <b>&gt;</b> You');
-  });
-  test('serializeFragment should return innerHTML when HTML elements exist', () => {
-    const result = sanitizer.sanitize('<b>Bold</b>', strategy);
-    expect(result).toBe('<b>Bold</b>');
-  });
-  test('serializeFragment falls back to empty string when textContent is null', () => {
-    const originalCreateElement = document.createElement;
-    jest.spyOn(document, 'createElement').mockImplementation((tagName) => {
-      const el = originalCreateElement.call(document, tagName);
-      if (tagName === 'div') {
-        Object.defineProperty(el, 'textContent', {
-          get: () => null,
-          configurable: true,
-        });
-      }
-      return el;
-    });
-    const result = sanitizer.sanitize('plain text', strategy);
-    expect(result).toBe('');
-    document.createElement.mockRestore();
-  });
-});

package/dist/collection/utils/sanitize/test/sanitize-strategy.test.js

@@ -1,85 +0,0 @@
-import { SanitizeStrategy } from '../core/sanitize-strategy';
-describe('SanitizeStrategy (base)', () => {
-  /**
-   * Concrete implementation for testing base class behavior.
-   * Allows only <b> tags.
-   */
-  class TestStrategy extends SanitizeStrategy {
-    constructor() {
-      super(...arguments);
-      this.allowedTags = new Set(['B']);
-      this.allowedAttributes = new Map([
-        ['B', new Set(['class', 'id'])],
-      ]);
-    }
-  }
-  class NoTextStrategy extends SanitizeStrategy {
-    constructor() {
-      super(...arguments);
-      this.allowedTags = new Set();
-      this.preserveTextContent = false;
-    }
-  }
-  let strategy;
-  let doc;
-  beforeEach(() => {
-    strategy = new TestStrategy();
-    doc = document;
-  });
-  it('should preserve text nodes', () => {
-    const textNode = doc.createTextNode('Hello');
-    const result = strategy.execute(textNode, doc);
-    expect(result).not.toBeNull();
-    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('Hello');
-  });
-  it('should allow allowed tags', () => {
-    const element = doc.createElement('b');
-    element.textContent = 'Bold';
-    const result = strategy.execute(element, doc);
-    expect(result).not.toBeNull();
-    expect(result.tagName).toBe('B');
-    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('Bold');
-  });
-  it('should unwrap disallowed tags but preserve children', () => {
-    const div = doc.createElement('div');
-    const span = doc.createElement('span');
-    span.textContent = 'Inner';
-    div.appendChild(span);
-    const result = strategy.execute(div, doc);
-    expect(result).not.toBeNull();
-    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('Inner');
-  });
-  it('should return null for unsupported node types (base implementation)', () => {
-    const comment = doc.createComment('test');
-    const result = strategy.execute(comment, doc);
-    expect(result).toBeNull();
-  });
-  it('should preserve only allowed attributes', () => {
-    const element = doc.createElement('b');
-    element.setAttribute('class', 'allowed');
-    element.setAttribute('id', 'also-allowed');
-    element.setAttribute('style', 'color:red'); // disallowed attribute
-    const result = strategy.execute(element, doc);
-    expect(result).not.toBeNull();
-    const cleanElement = result;
-    expect(cleanElement.getAttribute('class')).toBe('allowed');
-    expect(cleanElement.getAttribute('id')).toBe('also-allowed');
-    expect(cleanElement.hasAttribute('style')).toBe(false);
-  });
-  it('should fallback to empty string when textContent is null', () => {
-    const textNode = doc.createTextNode('test');
-    Object.defineProperty(textNode, 'textContent', {
-      value: null,
-      configurable: true,
-    });
-    const result = strategy.execute(textNode, doc);
-    expect(result).not.toBeNull();
-    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('');
-  });
-  it('should return null when preserveTextContent is false', () => {
-    const noTextStrategy = new NoTextStrategy();
-    const textNode = doc.createTextNode('Hidden');
-    const result = noTextStrategy.execute(textNode, doc);
-    expect(result).toBeNull();
-  });
-});

package/dist/collection/utils/sanitize/test/sanitize.test.js

@@ -1,22 +0,0 @@
-import { HtmlSanitizer, SanitizeStrategy, LabelSanitizeStrategy, StyleSanitizeStrategy, EmptySanitizeStrategy, htmlSanitizer, labelSanitizeStrategy, styleSanitizeStrategy, emptySanitizeStrategy, } from '../index';
-describe('utils/sanitize/index.ts exports', () => {
-  it('should export HtmlSanitizer class and instance', () => {
-    expect(typeof HtmlSanitizer).toBe('function');
-    expect(htmlSanitizer).toBeInstanceOf(HtmlSanitizer);
-  });
-  it('should export SanitizeStrategy class', () => {
-    expect(typeof SanitizeStrategy).toBe('function');
-  });
-  it('should export LabelSanitizeStrategy class and instance', () => {
-    expect(typeof LabelSanitizeStrategy).toBe('function');
-    expect(labelSanitizeStrategy).toBeInstanceOf(LabelSanitizeStrategy);
-  });
-  it('should export StyleSanitizeStrategy class and instance', () => {
-    expect(typeof StyleSanitizeStrategy).toBe('function');
-    expect(styleSanitizeStrategy).toBeInstanceOf(StyleSanitizeStrategy);
-  });
-  it('should export EmptySanitizeStrategy class and instance', () => {
-    expect(typeof EmptySanitizeStrategy).toBe('function');
-    expect(emptySanitizeStrategy).toBeInstanceOf(EmptySanitizeStrategy);
-  });
-});

package/dist/collection/utils/sanitize/test/serialize-fragment.test.js

@@ -1,25 +0,0 @@
-import { serializeFragment } from '../utils/serialize-fragment';
-describe('serializeFragment', () => {
-  it('should return textContent when there are no element children', () => {
-    const doc = document;
-    const fragment = doc.createDocumentFragment();
-    fragment.appendChild(doc.createTextNode('Hello World'));
-    const result = serializeFragment(fragment, doc);
-    expect(result).toBe('Hello World');
-  });
-  it('should return innerHTML when element children exist', () => {
-    const doc = document;
-    const fragment = doc.createDocumentFragment();
-    const div = doc.createElement('div');
-    div.textContent = 'Inside';
-    fragment.appendChild(div);
-    const result = serializeFragment(fragment, doc);
-    expect(result).toBe('<div>Inside</div>');
-  });
-  it('should return empty string when textContent is null', () => {
-    const doc = document;
-    const fragment = doc.createDocumentFragment();
-    const result = serializeFragment(fragment, doc);
-    expect(result).toBe('');
-  });
-});