@heartlandone/vega 2.78.0 → 2.80.0

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

@@ -1,341 +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).
- */
-export const initVegaE2EPage = async (content, config) => {
-  var _a, _b, _c;
-  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 contentHtml = (config === null || config === void 0 ? void 0 : config.wrapped)
-    ? `${injectTestIcons}${script}${injectFeatureFlags}<div style="padding: 10px" id="visual-container">${content}</div>`
-    : injectTestIcons + script + injectFeatureFlags + 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
-};

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('');
-  });
-});

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

@@ -1,45 +0,0 @@
-import { HtmlSanitizer } from '../core/html-sanitizer';
-import { StyleSanitizeStrategy } from '../strategies/style-sanitize-strategy';
-describe('StyleSanitizeStrategy', () => {
-  const sanitizer = new HtmlSanitizer();
-  const strategy = new StyleSanitizeStrategy();
-  it('should preserve safe CSS text', () => {
-    const css = 'body { color: red; }';
-    const result = sanitizer.sanitize(css, strategy);
-    expect(result).toBe(css);
-  });
-  it('should remove CSS with expression()', () => {
-    const css = 'body { width: expression(alert(1)); }';
-    const result = sanitizer.sanitize(css, strategy);
-    expect(result).toBe('');
-  });
-  it('should remove CSS with javascript: URL', () => {
-    const css = 'background: url(javascript:alert(1));';
-    const result = sanitizer.sanitize(css, strategy);
-    expect(result).toBe('');
-  });
-  it('should remove HTML tags entirely', () => {
-    const input = '<div>Some HTML</div>';
-    const result = sanitizer.sanitize(input, strategy);
-    expect(result).toBe('Some HTML');
-  });
-  it('should return null for unsupported node types', () => {
-    const doc = document;
-    const comment = doc.createComment('unsafe');
-    const result = strategy.execute(comment, doc);
-    expect(result).toBeNull();
-  });
-  it('should fallback to empty string when textContent is null', () => {
-    const doc = document;
-    const textNode = doc.createTextNode('test');
-    Object.defineProperty(textNode, 'textContent', {
-      value: null,
-      configurable: true,
-    });
-    const result = strategy.execute(textNode, doc);
-    // Since css becomes '', and empty string is safe,
-    // it should return an empty text node
-    expect(result).not.toBeNull();
-    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('');
-  });
-});