@heartlandone/vega 2.76.0 → 2.77.1

package/dist/collection/helpers/chart/test/input-processors/x-axis-label-formatter-input-processor.test.js

@@ -1,5 +1,5 @@
 import { XAxisLabelFormatterInputProcessor } from '../../input-processors/x-axis-label-formatter-input-processor';
-import { scaleTime } from 'd3';
+import { scaleTime } from '../../../../polyfill/d3';
 describe('xAxisLabelFormatterInputProcessor', () => {
   const xAxisLabelFormatterInputProcessor = new XAxisLabelFormatterInputProcessor();
   it('should not override the default scale formatter function when the type is not time or labelFormatter is not empty', () => {
@@ -41,22 +41,69 @@ describe('xAxisLabelFormatterInputProcessor', () => {
   });
   it('should call the expect function when call the time formatter function', () => {
     const mockXAxisLabelFormatterInputProcessor = new XAxisLabelFormatterInputProcessor();
-    const mockSecond = jest.fn();
-    const mockMinute = jest.fn();
-    const mockHour = jest.fn();
-    const mockDay = jest.fn();
-    mockXAxisLabelFormatterInputProcessor['formatMillisecond'] = mockSecond;
-    mockXAxisLabelFormatterInputProcessor['formatSecond'] = mockMinute;
-    mockXAxisLabelFormatterInputProcessor['formatMinute'] = mockHour;
-    mockXAxisLabelFormatterInputProcessor['formatHour'] = mockDay;
-    const testDate = new Date('2023-03-02');
-    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date(testDate.valueOf() - 100));
+    const mockMillisecond = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockSecond = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockMinute = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockHour = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockDay = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockWeek = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockMonth = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockYear = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    mockXAxisLabelFormatterInputProcessor['formatMillisecond'] = mockMillisecond;
+    mockXAxisLabelFormatterInputProcessor['formatSecond'] = mockSecond;
+    mockXAxisLabelFormatterInputProcessor['formatMinute'] = mockMinute;
+    mockXAxisLabelFormatterInputProcessor['formatHour'] = mockHour;
+    mockXAxisLabelFormatterInputProcessor['formatDay'] = mockDay;
+    mockXAxisLabelFormatterInputProcessor['formatWeek'] = mockWeek;
+    mockXAxisLabelFormatterInputProcessor['formatMonth'] = mockMonth;
+    mockXAxisLabelFormatterInputProcessor['formatYear'] = mockYear;
+    // millisecond: has ms
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T00:00:00.100Z'));
+    expect(mockMillisecond).toBeCalledTimes(1);
+    // second: at second boundary but within a minute
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T00:00:01.000Z'));
     expect(mockSecond).toBeCalledTimes(1);
-    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date(testDate.valueOf() + 59 * 1000));
+    // minute: at minute boundary but within an hour
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T00:01:00.000Z'));
     expect(mockMinute).toBeCalledTimes(1);
-    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date(testDate.valueOf() + 2 * 60 * 1000));
+    // hour: at hour boundary but within a day
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T01:00:00.000Z'));
     expect(mockHour).toBeCalledTimes(1);
-    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date(testDate.valueOf() + 60 * 60 * 1000));
+    // day: at day boundary but not week boundary (Thu)
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T00:00:00.000Z'));
     expect(mockDay).toBeCalledTimes(1);
+    // week: at week boundary (Sun) but not month boundary
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-05T00:00:00.000Z'));
+    expect(mockWeek).toBeCalledTimes(1);
+    // month: at month boundary but not year boundary
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-02-01T00:00:00.000Z'));
+    expect(mockMonth).toBeCalledTimes(1);
+    // year: at year boundary
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-01-01T00:00:00.000Z'));
+    expect(mockYear).toBeCalledTimes(1);
   });
 });

package/dist/collection/helpers/chart/test/input-processors/y-axis-input-processor.coverage.test.js

@@ -0,0 +1,39 @@
+describe('YAxisInputProcessor - coverage-only branches', () => {
+  it('should fall back when polyfill returns undefined/empty', () => {
+    jest.isolateModules(() => {
+      const createdScales = [];
+      jest.doMock('../../../../polyfill/d3', () => {
+        const scaleLinear = jest.fn(() => {
+          const scale = {
+            domain: jest.fn(function () {
+              return this;
+            }),
+            range: jest.fn(function () {
+              return this;
+            }),
+            // intentionally no ticks()
+          };
+          createdScales.push(scale);
+          return scale;
+        });
+        return {
+          scaleLinear,
+          max: jest.fn(() => undefined),
+          min: jest.fn(() => undefined),
+          extent: jest.fn(() => [undefined, undefined]),
+        };
+      });
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const requiredModule = require('../../input-processors/y-axis-input-processor');
+      const processor = new requiredModule.YAxisInputProcessor();
+      const data = [{ x: 1, y: 0 }];
+      const result = processor['getScale'](data, [200, 0], 4);
+      expect(result.ticks).toBe(4);
+      expect(createdScales.length).toBe(2);
+      expect(createdScales[0].domain).toHaveBeenCalledWith([0, 0]);
+      expect(createdScales[1].domain).toHaveBeenCalledWith([0, 0]);
+      expect(createdScales[1].range).toHaveBeenCalledWith([200, 0]);
+    });
+  });
+});
+export {};

package/dist/collection/helpers/chart/test/input-processors/y-axis-input-processor.test.js

@@ -14,6 +14,20 @@ describe('scaleGenerator', () => {
     ]);
     expect(yAxisInputProcessor['getScale'](numberData, [height, 0], 4).scale.domain()[0]).toEqual(0);
   });
+  it('should expand domain/ticks when tick rounding excludes min/max', () => {
+    // Use values where the generated tick start/stop (based on a rounded step)
+    // does not include the data min/max, forcing both min and max adjustments.
+    const numberData = [
+      { x: 1, y: -125 },
+      { x: 2, y: 210 },
+    ];
+    const height = 200;
+    const result = yAxisInputProcessor['getScale'](numberData, [height, 0], 4);
+    const domain = result.scale.domain();
+    expect(domain[0]).toBeLessThanOrEqual(-125);
+    expect(domain[1]).toBeGreaterThanOrEqual(210);
+    expect(result.ticks).toBeGreaterThan(4);
+  });
   // VD-992
   it('should return the correct min data when call the getScale function', () => {
     const numberData = [

package/dist/collection/helpers/chart/test/renderers/svg-renderer.test.js

@@ -1,5 +1,5 @@
 import { SVGRenderer } from '../../renderers/svg-renderer';
-import { scaleLinear } from 'd3';
+import { scaleLinear } from '../../../../polyfill/d3';
 describe('svg renderer', () => {
   it('should set context layout when run the set layout function', () => {
     const context = document.createElementNS('http://www.w3.org/2000/svg', 'svg');

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

@@ -0,0 +1,67 @@
+import { waitForComponentDidRender } from '../index';
+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';
+/**
+ * Creates a minimal HTMLStencilElement-compatible HTMLElement for testing.
+ */
+function createComponentRef() {
+  return document.createElement('div');
+}
+describe('waitForComponentDidRender', () => {
+  it('resolves the promise when ChangeManager notifies the subject', async () => {
+    const componentRef = createComponentRef();
+    // Start waiting — do NOT await yet; we need to trigger the notify first.
+    const waitPromise = waitForComponentDidRender(componentRef);
+    // Grab the subject that the function just registered an observer on.
+    const subject = domNodeSubjectFactory.getSubject(componentRef, VegaInternalComponentDidRender);
+    // Simulate the component firing its "componentDidRender" internal event.
+    ChangeManager.notify(subject, null);
+    // The promise should now be resolved.
+    await expect(waitPromise).resolves.toBeNull();
+  });
+  it('un registers the observer from ChangeManager after the promise resolves', async () => {
+    var _a, _b;
+    const componentRef = createComponentRef();
+    const waitPromise = waitForComponentDidRender(componentRef);
+    const subject = domNodeSubjectFactory.getSubject(componentRef, VegaInternalComponentDidRender);
+    // Capture the observer count before notification.
+    const observersBefore = ((_a = ChangeManager['pubSubMap'].get(subject)) !== null && _a !== void 0 ? _a : []).length;
+    // Notify once — this should resolve the promise AND unregister the observer.
+    ChangeManager.notify(subject, null);
+    await waitPromise;
+    // After resolving, the observer must have been removed.
+    const observersAfter = ((_b = ChangeManager['pubSubMap'].get(subject)) !== null && _b !== void 0 ? _b : []).length;
+    expect(observersAfter).toBe(observersBefore - 1);
+  });
+  it('resolves with null', async () => {
+    const componentRef = createComponentRef();
+    const waitPromise = waitForComponentDidRender(componentRef);
+    const subject = domNodeSubjectFactory.getSubject(componentRef, VegaInternalComponentDidRender);
+    ChangeManager.notify(subject, null);
+    const result = await waitPromise;
+    expect(result).toBeNull();
+  });
+  it('registers an observer with ChangeManager before the event fires', async () => {
+    const componentRef = createComponentRef();
+    // Spy on register BEFORE calling the function under test.
+    const registerSpy = jest.spyOn(ChangeManager, 'register');
+    const waitPromise = waitForComponentDidRender(componentRef);
+    expect(registerSpy).toHaveBeenCalledTimes(1);
+    // Clean up — trigger resolve so the promise does not leak.
+    const subject = domNodeSubjectFactory.getSubject(componentRef, VegaInternalComponentDidRender);
+    ChangeManager.notify(subject, null);
+    await waitPromise;
+    registerSpy.mockRestore();
+  });
+  it('calls ChangeManager.unregister when the observer is notified', async () => {
+    const componentRef = createComponentRef();
+    const unregisterSpy = jest.spyOn(ChangeManager, 'unregister');
+    const waitPromise = waitForComponentDidRender(componentRef);
+    const subject = domNodeSubjectFactory.getSubject(componentRef, VegaInternalComponentDidRender);
+    ChangeManager.notify(subject, null);
+    await waitPromise;
+    expect(unregisterSpy).toHaveBeenCalledTimes(1);
+    unregisterSpy.mockRestore();
+  });
+});

package/dist/collection/helpers/slimmers/element-appender/element-appender-slimmer.js

@@ -173,6 +173,7 @@ export class ElementAppenderSlimmer extends VegaSlimmer {
   show() {
     this.elementAppender && this.elementAppender.show();
     this[this.isDropdownShowName] = true;
+    this.setAriaOwns();
   }
   hide() {
     this.elementAppender && this.elementAppender.hide();
@@ -182,6 +183,7 @@ export class ElementAppenderSlimmer extends VegaSlimmer {
     });
   }
   destroy() {
+    this.removeAriaOwns();
     this.destroyElementAppender();
     this[this.isDropdownShowName] = false;
   }
@@ -264,6 +266,31 @@ export class ElementAppenderSlimmer extends VegaSlimmer {
       return new NoneTriggerStrategy();
     }
   }
+  /**
+   * Sets `ariaOwnsElements` on the target element to reference the appendable element directly.
+   * Uses the Element Reflection API which works across shadow DOM boundaries by using
+   * direct element references instead of IDREF strings.
+   * This ensures screen readers (e.g. VoiceOver) can navigate to the portal-appended
+   * content immediately after the trigger, rather than at the end of the document.
+   */
+  setAriaOwns() {
+    if (this.showConfig) {
+      const target = this.showConfig.target;
+      const appendableElement = this.showConfig.appendableElement;
+      if (target && appendableElement) {
+        target.ariaOwnsElements = [appendableElement];
+      }
+    }
+  }
+  /**
+   * Removes `ariaOwnsElements` from the target element when the popup is hidden or destroyed.
+   */
+  removeAriaOwns() {
+    var _a;
+    if ((_a = this.showConfig) === null || _a === void 0 ? void 0 : _a.target) {
+      this.showConfig.target.ariaOwnsElements = [];
+    }
+  }
 }
 ElementAppenderSlimmer.DELAY_HIDE_TIME = 100;
 __decorate([

package/dist/collection/helpers/slimmers/element-appender/test/element-appender-slimmer.test.js

@@ -568,4 +568,54 @@ describe('ElementAppender slimmer test suite', () => {
       expect(child2.appendableElement).toHaveClass('vega-force-hidden');
     });
   });
+  describe('AriaOwns management', () => {
+    test('should set ariaOwnsElements on target when show is called', () => {
+      const mockedComponent = new MockedComponent();
+      const target = new MockHTMLElement('body', 'div');
+      const appendableElement = new MockHTMLElement('body', 'div');
+      appendableElement.classList.add('vega-force-hidden');
+      mockedComponent.target = target;
+      mockedComponent.appendableElement = appendableElement;
+      mockedComponent.componentDidLoad();
+      mockedComponent.show();
+      expect(target.ariaOwnsElements).toEqual([
+        appendableElement,
+      ]);
+    });
+    test('should remove ariaOwnsElements from target when destroy is called', () => {
+      const mockedComponent = new MockedComponent();
+      const target = new MockHTMLElement('body', 'div');
+      const appendableElement = new MockHTMLElement('body', 'div');
+      appendableElement.classList.add('vega-force-hidden');
+      mockedComponent.target = target;
+      mockedComponent.appendableElement = appendableElement;
+      mockedComponent.componentDidLoad();
+      mockedComponent.show();
+      expect(target.ariaOwnsElements).toEqual([
+        appendableElement,
+      ]);
+      mockedComponent.destroy();
+      expect(target.ariaOwnsElements).toEqual([]);
+    });
+    test('should not throw when show is called without showConfig', () => {
+      const mockedComponent = new MockedComponent();
+      mockedComponent.target = null;
+      mockedComponent.appendableElement = null;
+      spyOn(LogUtility, 'error');
+      mockedComponent.componentDidLoad();
+      expect(() => mockedComponent.show()).not.toThrow();
+    });
+    test('should not throw when destroy is called without target', () => {
+      const mockedComponent = new MockedComponent();
+      mockedComponent.target = null;
+      mockedComponent.appendableElement = null;
+      spyOn(LogUtility, 'error');
+      mockedComponent.componentDidLoad();
+      expect(() => mockedComponent.destroy()).not.toThrow();
+    });
+    test('should not throw when destroy is called before componentDidLoad', () => {
+      const mockedComponent = new MockedComponent();
+      expect(() => mockedComponent.destroy()).not.toThrow();
+    });
+  });
 });

package/dist/collection/helpers/slimmers/mutation-observer/aria-attributes-value-mapper.js

@@ -102,12 +102,23 @@ export class AriaAttributesValueMapper extends MutationObserverSlimmer {
         }
       }
       if (finalValue === null || finalValue === undefined || String(finalValue).trim() === '') {
-        finalValue = defaultValue !== null && defaultValue !== void 0 ? defaultValue : '';
+        finalValue = defaultValue;
       }
       try {
+        if (String(finalValue).trim() === '') {
+          target.removeAttribute(ariaAttr);
+          return;
+        }
         const existing = target.getAttribute(ariaAttr);
-        if (existing !== finalValue) {
-          target.setAttribute(ariaAttr, finalValue);
+        if (finalValue === null || finalValue === undefined) {
+          if (existing !== null) {
+            target.removeAttribute(ariaAttr);
+          }
+          return;
+        }
+        const stringValue = String(finalValue);
+        if (existing !== stringValue) {
+          target.setAttribute(ariaAttr, stringValue);
         }
       }
       catch (e) {

package/dist/collection/helpers/slimmers/mutation-observer/data-tab-index-value-mapper.js

@@ -0,0 +1,80 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MapToComponentMethod } from 'vega-slimmer/core';
+import { MutationObserverSlimmer } from './mutation-observer-slimmer';
+/**
+ * Maps host data-tabindex to inner native input tabindex.
+ */
+export class DataTabIndexValueMapper extends MutationObserverSlimmer {
+  /**
+   * Constructor for DataTabIndexValueMapper
+   *
+   * @param {() => HTMLElement} targetGetter - Function to get the target HTMLElement
+   */
+  constructor(targetGetter) {
+    super({
+      options: { attributes: true, attributeFilter: [DataTabIndexValueMapper.OBSERVED_ATTRIBUTE] },
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      callback: () => {
+        this.performMapping();
+      },
+    });
+    this.targetGetter = targetGetter;
+  }
+  /**
+   * Component lifecycle - [componentDidLoad]
+   */
+  componentDidLoad() {
+    this.performMapping();
+    super.componentDidLoad && super.componentDidLoad();
+  }
+  /**
+   * Component lifecycle - [componentDidRender]
+   */
+  componentDidRender() {
+    this.performMapping();
+  }
+  /**
+   * Performs the mapping of host data-tabindex to target element's tabindex.
+   * If the host attribute value is null, undefined, or empty string, it removes the tabindex attribute from the target.
+   * Otherwise, it sets the target's tabindex to the host attribute value.
+   */
+  performMapping() {
+    const target = this.targetGetter ? this.targetGetter() : null;
+    if (!target)
+      return;
+    const hostValue = this.host.getAttribute(DataTabIndexValueMapper.OBSERVED_ATTRIBUTE);
+    if (this.shouldRemoveTabIndex(hostValue)) {
+      target.removeAttribute('tabindex');
+      return;
+    }
+    const tabIndexValue = String(hostValue);
+    if (target.getAttribute('tabindex') !== tabIndexValue) {
+      target.setAttribute('tabindex', tabIndexValue);
+    }
+  }
+  /**
+   * Determines whether the tabindex attribute should be removed from the target element.
+   *
+   * @param {string | null} hostValue - The value of the host element's data-tabindex attribute
+   * @returns {boolean} True if the tabindex should be removed, false otherwise
+   */
+  shouldRemoveTabIndex(hostValue) {
+    if (hostValue === null || hostValue === undefined) {
+      return true;
+    }
+    const normalizedValue = String(hostValue).trim().toLowerCase();
+    return normalizedValue === '' || normalizedValue === 'null' || normalizedValue === 'undefined';
+  }
+}
+DataTabIndexValueMapper.OBSERVED_ATTRIBUTE = 'data-tabindex';
+__decorate([
+  MapToComponentMethod('componentDidLoad')
+], DataTabIndexValueMapper.prototype, "componentDidLoad", null);
+__decorate([
+  MapToComponentMethod('componentDidRender')
+], DataTabIndexValueMapper.prototype, "componentDidRender", null);

package/dist/collection/helpers/slimmers/mutation-observer/test/aria-attributes-value-mapper.test.js

@@ -168,7 +168,7 @@ describe('AriaAttributesValueMapper', () => {
       comp.componentDidLoad();
     }).not.toThrow();
   });
-  it('should set empty string when no defaultValue provided', () => {
+  it('should omit aria attribute when no defaultValue provided', () => {
     const comp = new MockedComponent();
     const button = document.createElement('button');
     // no dependencies present on host and no defaultValue in map
@@ -177,8 +177,47 @@ describe('AriaAttributesValueMapper', () => {
     }));
     comp.connectedCallback();
     comp.componentDidLoad();
-    // should set attribute to empty string when no defaultValue provided
-    expect(button.getAttribute('aria-label')).toBe('');
+    expect(button.hasAttribute('aria-label')).toBeFalsy();
+  });
+  it('should omit aria attribute when defaultValue is null', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': {
+        dependency: ['data-aria-label', 'label'],
+        defaultValue: null,
+      },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(button.hasAttribute('aria-label')).toBeFalsy();
+  });
+  it('should omit aria attribute when defaultValue is undefined', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': {
+        dependency: ['data-aria-label', 'label'],
+        defaultValue: undefined,
+      },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(button.hasAttribute('aria-label')).toBeFalsy();
+  });
+  it('should remove existing aria attribute when resolved value is undefined', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    button.setAttribute('aria-label', 'legacy-value');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': {
+        dependency: ['data-aria-label', 'label'],
+        defaultValue: undefined,
+      },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(button.hasAttribute('aria-label')).toBeFalsy();
   });
   it('should handle empty mutations array (pass undefined to performMapping)', () => {
     const comp = new MockedComponent();
@@ -193,4 +232,17 @@ describe('AriaAttributesValueMapper', () => {
     MockedMutationObserver.mock.instances[0].trigger([]);
     expect(button.getAttribute('aria-label')).toBe('test');
   });
+  it('should be null for aria attribute when defaultValue is empty string', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': {
+        dependency: ['data-aria-label', 'label'],
+        defaultValue: '',
+      },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(button.getAttribute('aria-label')).toBe(null);
+  });
 });

package/dist/collection/helpers/slimmers/mutation-observer/test/data-tab-index-value-mapper.test.js

@@ -0,0 +1,120 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MockHTMLElement } from '@stencil/core/mock-doc';
+import { InjectVegaSlimmer } from 'vega-slimmer/core';
+import { MockedMutationObserver } from '../../../../utils/spec-utils';
+import { DataTabIndexValueMapper } from '../data-tab-index-value-mapper';
+describe('DataTabIndexValueMapper', () => {
+  beforeEach(() => {
+    global.MutationObserver = MockedMutationObserver;
+    MockedMutationObserver.mockClear();
+  });
+  class MockedComponent {
+    constructor() {
+      this.host = new MockHTMLElement('body', 'mocked-component');
+    }
+    connectedCallback() {
+      return;
+    }
+    componentDidLoad() {
+      return;
+    }
+    setMapper(mapper) {
+      this.dataTabIndexValueMapper = mapper;
+    }
+  }
+  __decorate([
+    InjectVegaSlimmer()
+  ], MockedComponent.prototype, "dataTabIndexValueMapper", void 0);
+  it('should map host data-tabindex to native input tabindex on load', () => {
+    const comp = new MockedComponent();
+    const input = document.createElement('input');
+    comp.host.setAttribute('data-tabindex', '-1');
+    comp.setMapper(new DataTabIndexValueMapper(() => input));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(input.getAttribute('tabindex')).toBe('-1');
+    expect(MockedMutationObserver.mock.instances[0].observe).toHaveBeenCalledWith(comp.host, {
+      attributes: true,
+      attributeFilter: ['data-tabindex'],
+    });
+  });
+  it('should update native input tabindex when host data-tabindex changes', () => {
+    const comp = new MockedComponent();
+    const input = document.createElement('input');
+    comp.host.setAttribute('data-tabindex', '0');
+    comp.setMapper(new DataTabIndexValueMapper(() => input));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(input.getAttribute('tabindex')).toBe('0');
+    comp.host.setAttribute('data-tabindex', '-1');
+    MockedMutationObserver.mock.instances[0].trigger([{ attributeName: 'data-tabindex', oldValue: '0' }]);
+    expect(input.getAttribute('tabindex')).toBe('-1');
+  });
+  it('should remove native input tabindex when host data-tabindex is empty or missing', () => {
+    const comp = new MockedComponent();
+    const input = document.createElement('input');
+    comp.host.setAttribute('data-tabindex', '0');
+    comp.setMapper(new DataTabIndexValueMapper(() => input));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(input.getAttribute('tabindex')).toBe('0');
+    comp.host.setAttribute('data-tabindex', '');
+    MockedMutationObserver.mock.instances[0].trigger([{ attributeName: 'data-tabindex', oldValue: '0' }]);
+    expect(input.hasAttribute('tabindex')).toBeFalsy();
+    comp.host.removeAttribute('data-tabindex');
+    MockedMutationObserver.mock.instances[0].trigger([{ attributeName: 'data-tabindex', oldValue: '' }]);
+    expect(input.hasAttribute('tabindex')).toBeFalsy();
+  });
+  it('should remove native input tabindex when host data-tabindex is "null" or "undefined" string', () => {
+    const comp = new MockedComponent();
+    const input = document.createElement('input');
+    comp.host.setAttribute('data-tabindex', '0');
+    comp.setMapper(new DataTabIndexValueMapper(() => input));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(input.getAttribute('tabindex')).toBe('0');
+    comp.host.setAttribute('data-tabindex', 'null');
+    MockedMutationObserver.mock.instances[0].trigger([{ attributeName: 'data-tabindex', oldValue: '0' }]);
+    expect(input.hasAttribute('tabindex')).toBeFalsy();
+    comp.host.setAttribute('data-tabindex', 'undefined');
+    MockedMutationObserver.mock.instances[0].trigger([
+      { attributeName: 'data-tabindex', oldValue: 'null' },
+    ]);
+    expect(input.hasAttribute('tabindex')).toBeFalsy();
+  });
+  it('should return early when targetGetter returns null', () => {
+    const comp = new MockedComponent();
+    comp.host.setAttribute('data-tabindex', '0');
+    comp.setMapper(new DataTabIndexValueMapper(() => null));
+    expect(() => {
+      comp.connectedCallback();
+      comp.componentDidLoad();
+      MockedMutationObserver.mock.instances[0].trigger([
+        { attributeName: 'data-tabindex', oldValue: null },
+      ]);
+    }).not.toThrow();
+  });
+  it('should return early when targetGetter field is null', () => {
+    const comp = new MockedComponent();
+    const input = document.createElement('input');
+    comp.host.setAttribute('data-tabindex', '1');
+    const mapper = new DataTabIndexValueMapper(() => input);
+    // force the private readonly field to null so ternary fallback branch is executed
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mapper.targetGetter = null;
+    comp.setMapper(mapper);
+    expect(() => {
+      comp.connectedCallback();
+      comp.componentDidLoad();
+      MockedMutationObserver.mock.instances[0].trigger([
+        { attributeName: 'data-tabindex', oldValue: null },
+      ]);
+    }).not.toThrow();
+    expect(input.hasAttribute('tabindex')).toBeFalsy();
+  });
+});