@heartlandone/vega 2.75.1 → 2.76.0

package/dist/collection/polyfill/tinycolor/tinycolor-polyfill.test.js

@@ -0,0 +1,361 @@
+import { tinycolor } from './tinycolor-polyfill';
+describe('TinyColorPolyfill', () => {
+  describe('Color Parsing', () => {
+    describe('Hex colors', () => {
+      it('should parse 6-digit hex color', () => {
+        const color = tinycolor('#ff5500');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 255, g: 85, b: 0, a: 1 });
+      });
+      it('should parse 3-digit shorthand hex color', () => {
+        const color = tinycolor('#f50');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 255, g: 85, b: 0, a: 1 });
+      });
+      it('should parse 8-digit hex color with alpha', () => {
+        const color = tinycolor('#ff550080');
+        const rgb = color.toRgb();
+        expect(rgb.r).toBe(255);
+        expect(rgb.g).toBe(85);
+        expect(rgb.b).toBe(0);
+        expect(rgb.a).toBeCloseTo(0.502, 2);
+      });
+      it('should parse uppercase hex color', () => {
+        const color = tinycolor('#FF5500');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 255, g: 85, b: 0, a: 1 });
+      });
+      // eslint-disable-next-line spellcheck/spell-checker
+      it('should handle hex with leading/trailing whitespace', () => {
+        const color = tinycolor('  #ff5500  ');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 255, g: 85, b: 0, a: 1 });
+      });
+    });
+    describe('RGB/RGBA strings', () => {
+      it('should parse rgb() format', () => {
+        const color = tinycolor('rgb(255, 128, 64)');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 255, g: 128, b: 64, a: 1 });
+      });
+      it('should parse rgba() format', () => {
+        const color = tinycolor('rgba(255, 128, 64, 0.5)');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 255, g: 128, b: 64, a: 0.5 });
+      });
+      it('should handle rgb() with extra spaces', () => {
+        const color = tinycolor('rgb(  255 ,  128 ,  64  )');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 255, g: 128, b: 64, a: 1 });
+      });
+    });
+    describe('RGBA objects', () => {
+      it('should parse RGBA object with alpha', () => {
+        const color = tinycolor({ r: 200, g: 100, b: 50, a: 0.8 });
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 200, g: 100, b: 50, a: 0.8 });
+      });
+      it('should default alpha to 1 when not provided', () => {
+        const color = tinycolor({ r: 200, g: 100, b: 50 });
+        const rgb = color.toRgb();
+        expect(rgb.a).toBe(1);
+      });
+      it('should clamp RGB values to 0-255', () => {
+        const color = tinycolor({ r: 300, g: -10, b: 128, a: 1 });
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 255, g: 0, b: 128, a: 1 });
+      });
+      it('should clamp alpha to 0-1', () => {
+        const color = tinycolor({ r: 128, g: 128, b: 128, a: 2 });
+        const rgb = color.toRgb();
+        expect(rgb.a).toBe(1);
+      });
+    });
+    describe('Hex with 4-digit shorthand (#RGBA)', () => {
+      it('should parse 4-digit hex color with alpha', () => {
+        // #f508 expands to #ff550088
+        const color = tinycolor('#f508');
+        const rgb = color.toRgb();
+        expect(rgb.r).toBe(255);
+        expect(rgb.g).toBe(85);
+        expect(rgb.b).toBe(0);
+        expect(rgb.a).toBeCloseTo(0.533, 2);
+      });
+    });
+    describe('Invalid inputs', () => {
+      it('should return black for unsupported format', () => {
+        // eslint-disable-next-line spellcheck/spell-checker
+        const color = tinycolor('hsl(120, 50%, 50%)');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 0, g: 0, b: 0, a: 1 });
+      });
+      it('should return black for invalid hex', () => {
+        // eslint-disable-next-line spellcheck/spell-checker
+        const color = tinycolor('#xyz');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 0, g: 0, b: 0, a: 1 });
+      });
+      it('should return black for non-string non-object input', () => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const color = tinycolor(12345);
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 0, g: 0, b: 0, a: 1 });
+      });
+      it('should return black for malformed rgb string', () => {
+        // eslint-disable-next-line spellcheck/spell-checker
+        const color = tinycolor('rgb(abc)');
+        const rgb = color.toRgb();
+        expect(rgb).toEqual({ r: 0, g: 0, b: 0, a: 1 });
+      });
+      it('should default alpha to 1 when hex alpha characters are invalid', () => {
+        // eslint-disable-next-line spellcheck/spell-checker
+        const color = tinycolor('#ff5500zz');
+        const rgb = color.toRgb();
+        expect(rgb.a).toBe(1);
+      });
+    });
+  });
+  describe('isDark() / isLight()', () => {
+    it('should identify black as dark', () => {
+      const color = tinycolor('#000000');
+      expect(color.isDark()).toBe(true);
+      expect(color.isLight()).toBe(false);
+    });
+    it('should identify white as light', () => {
+      const color = tinycolor('#ffffff');
+      expect(color.isDark()).toBe(false);
+      expect(color.isLight()).toBe(true);
+    });
+    it('should identify dark blue as dark', () => {
+      const color = tinycolor('#000080');
+      expect(color.isDark()).toBe(true);
+    });
+    it('should identify yellow as light', () => {
+      const color = tinycolor('#ffff00');
+      expect(color.isLight()).toBe(true);
+    });
+    it('should correctly identify mid-gray threshold', () => {
+      // Brightness at 128 threshold
+      // Using YIQ formula: (r * 299 + g * 587 + b * 114) / 1000
+      // For gray: (128 * 299 + 128 * 587 + 128 * 114) / 1000 = 128
+      const darkGray = tinycolor('#7f7f7f'); // brightness ~127
+      const lightGray = tinycolor('#808080'); // brightness = 128
+      expect(darkGray.isDark()).toBe(true);
+      expect(lightGray.isLight()).toBe(true);
+    });
+  });
+  describe('clone()', () => {
+    it('should create an independent copy', () => {
+      const original = tinycolor('#ff5500');
+      const cloned = original.clone();
+      // Modify the clone
+      cloned.lighten(20);
+      // Original should be unchanged
+      const originalRgb = original.toRgb();
+      expect(originalRgb).toEqual({ r: 255, g: 85, b: 0, a: 1 });
+    });
+    it('should preserve alpha when cloning', () => {
+      const original = tinycolor('#ff550080');
+      const cloned = original.clone();
+      const clonedRgb = cloned.toRgb();
+      expect(clonedRgb.a).toBeCloseTo(0.502, 2);
+    });
+  });
+  describe('lighten()', () => {
+    it('should lighten a color', () => {
+      const color = tinycolor('#336699');
+      const originalRgb = color.toRgb();
+      color.lighten(20);
+      const lightenedRgb = color.toRgb();
+      // The lightened color should have higher RGB values
+      expect(lightenedRgb.r).toBeGreaterThan(originalRgb.r);
+      expect(lightenedRgb.g).toBeGreaterThan(originalRgb.g);
+      expect(lightenedRgb.b).toBeGreaterThan(originalRgb.b);
+    });
+    it('should lighten using default amount when no argument is provided', () => {
+      const color1 = tinycolor('#336699');
+      const color2 = tinycolor('#336699');
+      color1.lighten();
+      color2.lighten(10);
+      expect(color1.toRgb()).toEqual(color2.toRgb());
+    });
+    it('should darken a color with negative amount', () => {
+      const color = tinycolor('#668899');
+      const originalRgb = color.toRgb();
+      color.lighten(-20);
+      const darkenedRgb = color.toRgb();
+      // The darkened color should have lower RGB values
+      expect(darkenedRgb.r).toBeLessThan(originalRgb.r);
+      expect(darkenedRgb.g).toBeLessThan(originalRgb.g);
+      expect(darkenedRgb.b).toBeLessThan(originalRgb.b);
+    });
+    it('should not exceed white when over-lightening', () => {
+      const color = tinycolor('#cccccc');
+      color.lighten(100);
+      const rgb = color.toRgb();
+      expect(rgb.r).toBeLessThanOrEqual(255);
+      expect(rgb.g).toBeLessThanOrEqual(255);
+      expect(rgb.b).toBeLessThanOrEqual(255);
+    });
+    it('should be chainable', () => {
+      const color = tinycolor('#336699');
+      const result = color.lighten(10);
+      expect(result).toBe(color);
+    });
+  });
+  describe('darken()', () => {
+    it('should darken a color', () => {
+      const color = tinycolor('#668899');
+      const originalRgb = color.toRgb();
+      color.darken(20);
+      const darkenedRgb = color.toRgb();
+      expect(darkenedRgb.r).toBeLessThan(originalRgb.r);
+      expect(darkenedRgb.g).toBeLessThan(originalRgb.g);
+      expect(darkenedRgb.b).toBeLessThan(originalRgb.b);
+    });
+    it('should darken using default amount when no argument is provided', () => {
+      const color1 = tinycolor('#668899');
+      const color2 = tinycolor('#668899');
+      color1.darken();
+      color2.darken(10);
+      expect(color1.toRgb()).toEqual(color2.toRgb());
+    });
+    it('should not go below black when over-darkening', () => {
+      const color = tinycolor('#333333');
+      color.darken(100);
+      const rgb = color.toRgb();
+      expect(rgb.r).toBeGreaterThanOrEqual(0);
+      expect(rgb.g).toBeGreaterThanOrEqual(0);
+      expect(rgb.b).toBeGreaterThanOrEqual(0);
+    });
+  });
+  describe('setAlpha()', () => {
+    it('should set the alpha value', () => {
+      const color = tinycolor('#ff5500');
+      color.setAlpha(0.5);
+      const rgb = color.toRgb();
+      expect(rgb.a).toBe(0.5);
+    });
+    it('should clamp alpha to 0-1 range', () => {
+      const color = tinycolor('#ff5500');
+      color.setAlpha(-0.5);
+      expect(color.toRgb().a).toBe(0);
+      color.setAlpha(1.5);
+      expect(color.toRgb().a).toBe(1);
+    });
+    it('should be chainable', () => {
+      const color = tinycolor('#ff5500');
+      const result = color.setAlpha(0.5);
+      expect(result).toBe(color);
+    });
+    it('should work with lighten in a chain', () => {
+      const color = tinycolor('#ff5500');
+      color.lighten(10).setAlpha(0.25);
+      const rgb = color.toRgb();
+      expect(rgb.a).toBe(0.25);
+    });
+  });
+  describe('toRgb()', () => {
+    it('should return RGBA object', () => {
+      const color = tinycolor('#ff5500');
+      const rgb = color.toRgb();
+      expect(rgb).toHaveProperty('r');
+      expect(rgb).toHaveProperty('g');
+      expect(rgb).toHaveProperty('b');
+      expect(rgb).toHaveProperty('a');
+    });
+    it('should return integer RGB values', () => {
+      const color = tinycolor('#ff5500');
+      color.lighten(15);
+      const rgb = color.toRgb();
+      expect(Number.isInteger(rgb.r)).toBe(true);
+      expect(Number.isInteger(rgb.g)).toBe(true);
+      expect(Number.isInteger(rgb.b)).toBe(true);
+    });
+  });
+  describe('Theme override use cases', () => {
+    /**
+     * These tests simulate the actual usage patterns from overridable-color-tokens.ts
+     */
+    describe('rgbToHsl branch coverage via lighten/darken', () => {
+      it('should handle color where green is the max component', () => {
+        // Green-dominant color: r=50, g=200, b=100 => max is green
+        const color = tinycolor({ r: 50, g: 200, b: 100, a: 1 });
+        const original = color.toRgb();
+        color.lighten(10);
+        const lightened = color.toRgb();
+        // Lightening should increase at least one channel
+        expect(lightened.r + lightened.g + lightened.b).toBeGreaterThan(original.r + original.g + original.b);
+      });
+      it('should handle color where red is max and green < blue', () => {
+        // Red-dominant with g < b: r=200, g=50, b=100 => max is red, g < b
+        const color = tinycolor({ r: 200, g: 50, b: 100, a: 1 });
+        const original = color.toRgb();
+        color.lighten(10);
+        const lightened = color.toRgb();
+        expect(lightened.r + lightened.g + lightened.b).toBeGreaterThan(original.r + original.g + original.b);
+      });
+      it('should handle pure gray (saturation = 0) in hslToRgb', () => {
+        // Pure gray: r=g=b, saturation is 0
+        const color = tinycolor('#808080');
+        color.lighten(10);
+        const rgb = color.toRgb();
+        // After lightening gray, all channels should still be equal (still gray)
+        expect(rgb.r).toBe(rgb.g);
+        expect(rgb.g).toBe(rgb.b);
+        // And should be lighter
+        expect(rgb.r).toBeGreaterThan(128);
+      });
+    });
+    it('should handle action color hover (dark color)', () => {
+      const actionColor = '#1a237e'; // Dark blue
+      const color = tinycolor(actionColor);
+      const cloned = color.clone();
+      if (color.isDark()) {
+        cloned.lighten(10);
+      }
+      else {
+        cloned.lighten(-10);
+      }
+      const rgb = cloned.toRgb();
+      // Should be lightened since the original is dark
+      expect(rgb.r).toBeGreaterThan(26);
+    });
+    it('should handle action color hover (light color)', () => {
+      const actionColor = '#e3f2fd'; // Light blue
+      const color = tinycolor(actionColor);
+      const cloned = color.clone();
+      if (color.isDark()) {
+        cloned.lighten(10);
+      }
+      else {
+        cloned.lighten(-10);
+      }
+      const rgb = cloned.toRgb();
+      // Should be darkened since the original is light
+      expect(rgb.r).toBeLessThan(227);
+    });
+    it('should handle secondary action with alpha', () => {
+      const actionColor = '#1976d2';
+      const color = tinycolor(actionColor);
+      const cloned = color.clone();
+      if (color.isDark()) {
+        cloned.lighten(10);
+      }
+      else {
+        cloned.lighten(-10);
+      }
+      cloned.setAlpha(0.15);
+      const rgb = cloned.toRgb();
+      expect(rgb.a).toBe(0.15);
+    });
+    it('should format value correctly for CSS variable', () => {
+      const actionColor = '#1976d2';
+      const color = tinycolor(actionColor);
+      const rgb = color.toRgb();
+      // This matches the formatValue function in the generated tokens
+      const cssValue = `${rgb.r} ${rgb.g} ${rgb.b} / ${rgb.a}`;
+      expect(cssValue).toMatch(/^\d+ \d+ \d+ \/ [\d.]+$/);
+    });
+  });
+});

package/dist/collection/types/ui.type.js

@@ -1,6 +1,18 @@
+/**
+ * Device type enumeration for responsive design breakpoints.
+ */
 export var DeviceType;
 (function (DeviceType) {
+  /**
+   * Tablet device type.
+   */
   DeviceType["TABLET"] = "tablet";
+  /**
+   * Mobile device type.
+   */
   DeviceType["MOBILE"] = "mobile";
+  /**
+   * Desktop device type.
+   */
   DeviceType["DESKTOP"] = "desktop";
 })(DeviceType || (DeviceType = {}));

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

@@ -240,10 +240,17 @@ export const getScreenshotDiffResults = async (page, desc, selector) => {
  * @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).
  */
 export const initVegaE2EPage = async (content, config) => {
-  var _a, _b;
+  var _a, _b, _c;
   const page = await newE2EPage();
+  // 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>`
@@ -252,8 +259,8 @@ export const initVegaE2EPage = async (content, config) => {
     window.VegaIconManager.register(${JSON.stringify(TestIcons)});
   </script>`;
   const injectFeatureFlags = `<script>
-		window.VegaEnabledFeatureKeys = ${JSON.stringify(((_a = config === null || config === void 0 ? void 0 : config.featureFlags) === null || _a === void 0 ? void 0 : _a.enabled) || [])};
-		window.VegaDisabledFeatureKeys = ${JSON.stringify(((_b = config === null || config === void 0 ? void 0 : config.featureFlags) === null || _b === void 0 ? void 0 : _b.disabled) || [])};
+		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>`

package/dist/collection/utils/sanitize/constants/tag-sets.js

@@ -0,0 +1,5 @@
+/**
+ * Set of allowed HTML tags for label rendering.
+ * Tags must be uppercase to match DOMParser element.tagName output.
+ */
+export const LABEL_ALLOWED_TAGS = new Set(['B', 'I', 'STRONG', 'EM']);

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

@@ -0,0 +1,39 @@
+import { tryGetDocument } from '../../try-get-document';
+import { serializeFragment } from '../utils/serialize-fragment';
+/**
+ * Main sanitization engine.
+ *
+ * Responsible for:
+ * - Parsing HTML
+ * - Delegating sanitization to strategy
+ * - Serializing safe output
+ */
+export class HtmlSanitizer {
+  /**
+   * Sanitizes the given string using the provided sanitization strategy.
+   *
+   * This is the single entry point for HTML sanitization.
+   * Always returns a safe string for DOM insertion.
+   *
+   * @param {string} input - Raw string input to be sanitized.
+   * @param {SanitizeStrategy} strategy - Sanitization strategy to apply.
+   * @returns { string } Sanitized string safe for rendering.
+   */
+  sanitize(input, strategy) {
+    if (!input || input.trim() === '') {
+      return '';
+    }
+    const doc = tryGetDocument();
+    if (!doc)
+      return '';
+    const parser = new DOMParser();
+    const parsed = parser.parseFromString(input, 'text/html');
+    const fragment = doc.createDocumentFragment();
+    parsed.body.childNodes.forEach((node) => {
+      const clean = strategy.execute(node, doc);
+      if (clean)
+        fragment.appendChild(clean);
+    });
+    return serializeFragment(fragment, doc);
+  }
+}

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

@@ -0,0 +1,62 @@
+/**
+ * Base class for all sanitization strategies.
+ *
+ * Strategy defines:
+ * - Allowed tags
+ * - Allowed attributes per tag
+ * - Text preservation behavior
+ */
+export class SanitizeStrategy {
+  constructor() {
+    this.preserveTextContent = true;
+  }
+  /**
+   * @param {Node} node - Node to sanitize.
+   * @param {Document} doc - document reference.
+   * @returns {Nullable<Node>} - Sanitized node
+   */
+  execute(node, doc) {
+    var _a;
+    switch (node.nodeType) {
+      case Node.TEXT_NODE:
+        return this.preserveTextContent ? doc.createTextNode((_a = node.textContent) !== null && _a !== void 0 ? _a : '') : null;
+      case Node.ELEMENT_NODE:
+        return this.sanitizeElement(node, doc);
+      default:
+        return null;
+    }
+  }
+  /**
+   * @param {HTMLElement} element - HTMLElement to sanitize.
+   * @param {Document} doc - document reference.
+   * @returns {Nullable<Node>} - Sanitized node
+   */
+  sanitizeElement(element, doc) {
+    var _a;
+    const tagName = element.tagName;
+    if (!this.allowedTags.has(tagName)) {
+      const fragment = doc.createDocumentFragment();
+      element.childNodes.forEach((child) => {
+        const clean = this.execute(child, doc);
+        if (clean)
+          fragment.appendChild(clean);
+      });
+      return fragment;
+    }
+    const cleanElement = doc.createElement(tagName.toLowerCase());
+    const allowedAttrs = (_a = this.allowedAttributes) === null || _a === void 0 ? void 0 : _a.get(tagName);
+    if (allowedAttrs) {
+      Array.from(element.attributes).forEach((attr) => {
+        if (allowedAttrs.has(attr.name)) {
+          cleanElement.setAttribute(attr.name, attr.value);
+        }
+      });
+    }
+    element.childNodes.forEach((child) => {
+      const clean = this.execute(child, doc);
+      if (clean)
+        cleanElement.appendChild(clean);
+    });
+    return cleanElement;
+  }
+}

package/dist/collection/utils/sanitize/core/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared sanitization types.
+ */
+export {};

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

@@ -0,0 +1,12 @@
+/**
+ * Public Sanitization API
+ */
+export { HtmlSanitizer } from './core/html-sanitizer';
+export { SanitizeStrategy } from './core/sanitize-strategy';
+export { LabelSanitizeStrategy, StyleSanitizeStrategy, EmptySanitizeStrategy } from './strategies';
+import { HtmlSanitizer } from './core/html-sanitizer';
+import { LabelSanitizeStrategy, StyleSanitizeStrategy, EmptySanitizeStrategy } from './strategies';
+export const htmlSanitizer = new HtmlSanitizer();
+export const labelSanitizeStrategy = new LabelSanitizeStrategy();
+export const styleSanitizeStrategy = new StyleSanitizeStrategy();
+export const emptySanitizeStrategy = new EmptySanitizeStrategy();

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

@@ -0,0 +1,17 @@
+import { SanitizeStrategy } from '../core/sanitize-strategy';
+/**
+ * Strategy that always returns empty output.
+ */
+export class EmptySanitizeStrategy extends SanitizeStrategy {
+  constructor() {
+    super(...arguments);
+    this.allowedTags = new Set();
+    this.preserveTextContent = false;
+  }
+  /**
+   * @returns {Nullable<Node>} - Sanitized node
+   */
+  execute() {
+    return null;
+  }
+}

package/dist/collection/utils/sanitize/strategies/index.js

@@ -0,0 +1,3 @@
+export { LabelSanitizeStrategy } from './label-sanitize-strategy';
+export { StyleSanitizeStrategy } from './style-sanitize-strategy';
+export { EmptySanitizeStrategy } from './empty-sanitize-strategy';

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

@@ -0,0 +1,13 @@
+import { SanitizeStrategy } from '../core/sanitize-strategy';
+import { LABEL_ALLOWED_TAGS } from '../constants/tag-sets';
+/**
+ * Label HTML sanitization strategy.
+ *
+ * Allows minimal formatting tags only.
+ */
+export class LabelSanitizeStrategy extends SanitizeStrategy {
+  constructor() {
+    super(...arguments);
+    this.allowedTags = LABEL_ALLOWED_TAGS;
+  }
+}

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

@@ -0,0 +1,50 @@
+import { SanitizeStrategy } from '../core/sanitize-strategy';
+/**
+ * CSS / style sanitization strategy.
+ *
+ * - Strips all HTML elements
+ * - Preserves text nodes
+ * - Blocks dangerous CSS patterns (expression(), javascript:)
+ */
+export class StyleSanitizeStrategy extends SanitizeStrategy {
+  constructor() {
+    super(...arguments);
+    this.allowedTags = new Set();
+    this.preserveTextContent = true;
+  }
+  /**
+   * @param {Node} node - Node to sanitize.
+   * @param {Document} doc - document reference.
+   * @returns {Nullable<Node>} - Sanitized node
+   */
+  execute(node, doc) {
+    var _a;
+    switch (node.nodeType) {
+      case Node.TEXT_NODE: {
+        const css = (_a = node.textContent) !== null && _a !== void 0 ? _a : '';
+        // Strip dangerous CSS patterns
+        return this.isSafeCss(css) ? doc.createTextNode(css) : null;
+      }
+      case Node.ELEMENT_NODE: {
+        // Recurse into children but discard the element itself
+        const fragment = doc.createDocumentFragment();
+        node.childNodes.forEach((child) => {
+          const clean = this.execute(child, doc);
+          if (clean)
+            fragment.appendChild(clean);
+        });
+        return fragment;
+      }
+      default:
+        return null;
+    }
+  }
+  /**
+   * @param {string} css - CSS string.
+   * @returns {boolean} - True or false
+   */
+  isSafeCss(css) {
+    // Block known XSS patterns
+    return !/expression\s*\(|javascript:|url\s*\(/i.test(css);
+  }
+}

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

@@ -0,0 +1,12 @@
+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('');
+    });
+  });
+});