@heartlandone/vega 2.75.1 → 2.77.0

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

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

package/dist/collection/helpers/common/test/wait-for-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/common/test/wait-for-vega-handler.test.js

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

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

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

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

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

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

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

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

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

package/dist/collection/helpers/public-api.js

@@ -14,6 +14,4 @@ export { ValidCreditCardNumberRule } from './validator/rules/valid-credit-card-n
 export { waitForVega } from './common';
 export { VegaSkeletonLoader } from './skeleton-loader/vega-skeleton-loader-controller';
 export { VegaTranslation, en as VegaTranslationResourceEN } from './translation';
-export { VegaRTEContent } from '../components/vega-rich-text-editor/dto/content-state';
 export { setVegaNonce } from './csp/vega-nonce-manager';
-export * from '../components/vega-rich-text-editor/public-api';

package/dist/collection/helpers/slimmers/component-global-style-slimmer.js

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
 import { vegaNonceManager } from '../csp/vega-nonce-manager';
+import { htmlSanitizer, styleSanitizeStrategy } from '../../utils/sanitize';
 /**
  * Component global style slimmer
  */
@@ -58,7 +59,7 @@ export class ComponentGlobalStyleSlimmer extends VegaSlimmer {
       // eslint-disable-next-line no-restricted-globals
       styleElement = document.createElement('style');
       styleElement.id = this.id;
-      styleElement.innerHTML = this.style;
+      styleElement.innerHTML = htmlSanitizer.sanitize(this.style, styleSanitizeStrategy);
       if (vegaNonceManager.nonce) {
         styleElement.setAttribute('nonce', vegaNonceManager.nonce);
       }

package/dist/collection/helpers/slimmers/field-error-ui-controller-slimmer.js

@@ -14,6 +14,7 @@ import { SiblingContainerErrorLabelContainerRetrievalStrategy } from './field-er
 import { Observer } from '../change-manager/observer/observer';
 import { UPDATE_TRANSLATION } from '../change-manager/subject/static-subject/static-subject-title';
 import { FormFieldMessageTranslatorSlimmer } from './form-field-message-translator';
+import { htmlSanitizer, labelSanitizeStrategy } from '../../utils/sanitize';
 /** The `FieldErrorUIControllerSlimmer` class is responsible for displaying error messages and managing the invalid UI state of a form field. */
 export class FieldErrorUIControllerSlimmer extends VegaSlimmer {
   constructor() {
@@ -44,8 +45,7 @@ export class FieldErrorUIControllerSlimmer extends VegaSlimmer {
       if (errorMessage) {
         this.errorMessage = errorMessage;
         const errorContainer = this.getErrorContainer(inputContainer);
-        errorContainer.innerHTML =
-          this.formFieldMessageTranslatorSlimmer.getTranslatedMessage(errorMessage);
+        errorContainer.innerHTML = htmlSanitizer.sanitize(this.formFieldMessageTranslatorSlimmer.getTranslatedMessage(errorMessage), labelSanitizeStrategy);
         errorContainer.classList.remove('vega-hidden');
       }
     }
@@ -101,8 +101,7 @@ export class FieldErrorUIControllerSlimmer extends VegaSlimmer {
       if (inputContainer) {
         const errorContainer = this.getErrorContainer(inputContainer);
         if (errorContainer) {
-          errorContainer.innerHTML =
-            this.formFieldMessageTranslatorSlimmer.getTranslatedMessage(this.errorMessage);
+          errorContainer.innerHTML = htmlSanitizer.sanitize(this.formFieldMessageTranslatorSlimmer.getTranslatedMessage(this.errorMessage), labelSanitizeStrategy);
         }
       }
     });

package/dist/collection/helpers/slimmers/form-field-message-translator.js

@@ -1,5 +1,5 @@
 import { VegaSlimmer } from 'vega-slimmer/core';
-import { VegaInternalTranslation } from '../translation';
+import { VegaInternalTranslation } from '../translation/internal-translation-controller';
 /** The `FormFieldMessageTranslatorSlimmer` class is to get translated message */
 export class FormFieldMessageTranslatorSlimmer extends VegaSlimmer {
   /**

package/dist/collection/helpers/slimmers/global/vega-translate-observer-slimmer.js

@@ -9,7 +9,7 @@ import { UPDATE_TRANSLATION } from '../../change-manager/subject/static-subject/
 import ChangeManager from '../../change-manager/change-manager';
 import { Observer } from '../../change-manager/observer/observer';
 import { forceUpdate } from '@stencil/core';
-import { VegaInternalTranslation } from '../../translation';
+import { VegaInternalTranslation } from '../../translation/internal-translation-controller';
 /**
  * Class responsible for observing translation updates and triggering re-renders.
  */

package/dist/collection/helpers/slimmers/global/vega-watch-method-cancel-slimmer.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
-import { FeatureFlag } from '../../public-api';
+import { FeatureFlag } from '../../feature-control/feature-flag-controller';
 /**
  * The `VegaWatchMethodCancelSlimmer` class is a TypeScript class that removes
  * the body of watch methods when a component is not fully instantiated and

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

@@ -0,0 +1,132 @@
+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';
+import { LogUtility } from '../../../utils/log';
+/**
+ * Maps component attributes/properties to aria-XXX attributes on an inner native element.
+ * Observes attribute changes on host and updates the target element accordingly.
+ */
+export class AriaAttributesValueMapper extends MutationObserverSlimmer {
+  /**
+   * The constructor initializes a class instance with a targetGetter function and an ariaMap.
+   *
+   * @param {() => HTMLElement} targetGetter - a function that returns the target element to set aria attributes on
+   * @param {AriaAttributesMap} ariaMap - a map where the key is the aria attribute to set on the target element, and the value is an object that defines the dependencies (attributes/properties on host to check for value) and an optional default value
+   */
+  constructor(targetGetter, ariaMap) {
+    // Build attributeFilter from dependencies
+    const attrs = Array.from(new Set(Object.values(ariaMap).reduce((acc, cur) => acc.concat(cur.dependency), [])));
+    // create entry for MutationObserverSlimmer to observe host attributes (omit target so host is observed)
+    super({
+      options: { attributes: true, attributeFilter: attrs },
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      callback: (mutations) => {
+        this.handleMutations(mutations);
+      },
+    });
+    this.targetGetter = targetGetter;
+    this.ariaMap = ariaMap;
+  }
+  /**
+   * Component lifecycle - [componentDidLoad]
+   */
+  componentDidLoad() {
+    this.performMapping();
+    super.componentDidLoad && super.componentDidLoad();
+  }
+  /**
+   * Run mapping after each component render to ensure refs assigned and
+   * attributes/properties are up-to-date. This guarantees the mapper runs
+   * even when attribute changes are observed before the inner target ref
+   * is available.
+   */
+  componentDidRender() {
+    this.performMapping();
+  }
+  /**
+   * The `handleMutations` function processes an array of `MutationRecord` objects to determine which attributes have changed and then calls the `performMapping` function to update the corresponding aria attributes on the target element. It collects the names of the changed attributes into a set and passes it to the `performMapping` function, which uses this information to decide which aria attributes need to be updated based on their defined dependencies.
+   *
+   * @param {MutationRecord[]} mutations - an array of MutationRecord objects that represent the changes observed by the MutationObserver. Each MutationRecord contains information about the type of mutation, the target element that was mutated, and any relevant attribute names if the mutation was an attribute change.
+   */
+  handleMutations(mutations) {
+    const changedAttrs = new Set();
+    if (mutations && mutations.length) {
+      for (const m of mutations) {
+        if (m.attributeName)
+          changedAttrs.add(m.attributeName);
+      }
+    }
+    this.performMapping(changedAttrs.size ? changedAttrs : undefined);
+  }
+  /**
+   * The `performMapping` function updates the aria attributes on the target element based on the defined dependencies in the `ariaMap`. It checks which attributes have changed (if provided) and only updates the aria attributes that depend on those changed attributes. For each aria attribute defined in the `ariaMap`, it looks for the first non-empty value among its dependencies (checking both attributes and properties on the host element) and sets that as the value of the aria attribute on the target element. If all dependencies are empty or undefined, it uses the default value specified in the `ariaMap`. The function also includes error handling when setting attributes on the target element.
+   *
+   * @param {Set<string>} changedAttrs - a set of attribute names that have changed on the host element
+   */
+  performMapping(changedAttrs) {
+    const target = this.targetGetter ? this.targetGetter() : null;
+    if (!target)
+      return;
+    const host = this.host;
+    Object.keys(this.ariaMap).forEach((ariaAttr) => {
+      const { dependency, defaultValue } = this.ariaMap[ariaAttr];
+      // If no relevant dependency changed, skip updating this ariaAttr
+      if (changedAttrs && !dependency.some((item) => changedAttrs.has(item))) {
+        return;
+      }
+      let finalValue = null;
+      for (const item of dependency) {
+        // Try attribute first
+        let val = host.getAttribute(item);
+        if (val === null || val === undefined || val === '') {
+          // Try property on host if attribute not present or empty
+          // support dashed-name -> camelCase property (e.g. data-aria-label -> dataAriaLabel)
+          const camel = item.replace(/-([a-z])/g, (_m, p1) => p1.toUpperCase());
+          const p1 = host[item];
+          const p2 = host[camel];
+          if (p1 !== undefined && p1 !== null) {
+            val = String(p1);
+          }
+          else if (p2 !== undefined && p2 !== null) {
+            val = String(p2);
+          }
+        }
+        if (val !== null && val !== undefined && String(val).trim() !== '') {
+          finalValue = val;
+          break;
+        }
+      }
+      if (finalValue === null || finalValue === undefined || String(finalValue).trim() === '') {
+        finalValue = defaultValue !== null && defaultValue !== void 0 ? defaultValue : '';
+      }
+      try {
+        if (String(finalValue).trim() === '') {
+          target.removeAttribute(ariaAttr);
+          return;
+        }
+        const existing = target.getAttribute(ariaAttr);
+        if (existing !== finalValue) {
+          target.setAttribute(ariaAttr, finalValue);
+        }
+      }
+      catch (e) {
+        LogUtility.warn('Errors occurred when setting aria attribute:', {
+          ariaAttr,
+          finalValue,
+          error: e,
+        });
+      }
+    });
+  }
+}
+__decorate([
+  MapToComponentMethod('componentDidLoad')
+], AriaAttributesValueMapper.prototype, "componentDidLoad", null);
+__decorate([
+  MapToComponentMethod('componentDidRender')
+], AriaAttributesValueMapper.prototype, "componentDidRender", null);

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

@@ -0,0 +1,196 @@
+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 { AriaAttributesValueMapper } from '../aria-attributes-value-mapper';
+import { MockedMutationObserver } from '../../../../utils/spec-utils';
+import { LogUtility } from '../../../../utils/log';
+describe('AriaAttributesValueMapper', () => {
+  const mockedConnectedCallback = jest.fn();
+  const mockedDisconnectedCallback = jest.fn();
+  const mockedComponentDidLoad = jest.fn();
+  beforeEach(() => {
+    // ensure MutationObserver is mocked
+    global.MutationObserver = MockedMutationObserver;
+    MockedMutationObserver.mockClear();
+  });
+  class MockedComponent {
+    constructor() {
+      this.host = new MockHTMLElement('body', 'mocked-component');
+    }
+    connectedCallback() {
+      mockedConnectedCallback();
+    }
+    disconnectedCallback() {
+      mockedDisconnectedCallback();
+    }
+    componentDidLoad() {
+      mockedComponentDidLoad();
+    }
+    setMapper(mapper) {
+      this.ariaAttributesValueMapper = mapper;
+    }
+  }
+  __decorate([
+    InjectVegaSlimmer()
+  ], MockedComponent.prototype, "ariaAttributesValueMapper", void 0);
+  it('should map initial attribute value to target aria attribute', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    comp.host.setAttribute('data-aria-label', 'test');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    }));
+    // simulate lifecycle
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(button.getAttribute('aria-label')).toBe('test');
+  });
+  it('should update aria attribute when observed attribute changes', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    comp.host.setAttribute('data-aria-label', 'apple');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    // change attribute and trigger mutation
+    comp.host.setAttribute('data-aria-label', 'banana');
+    MockedMutationObserver.mock.instances[0].trigger([
+      { attributeName: 'data-aria-label', oldValue: 'apple' },
+    ]);
+    expect(button.getAttribute('aria-label')).toBe('banana');
+  });
+  it('should respect dependency priority and not overwrite when higher-priority exists', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    // higher priority present
+    comp.host.setAttribute('data-aria-label', 'test');
+    comp.host.setAttribute('label', 'initial');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(button.getAttribute('aria-label')).toBe('test');
+    // lower-priority 'label' changes
+    comp.host.setAttribute('label', 'apple');
+    MockedMutationObserver.mock.instances[0].trigger([{ attributeName: 'label', oldValue: 'initial' }]);
+    // should remain the higher-priority value
+    expect(button.getAttribute('aria-label')).toBe('test');
+  });
+  it('should read camelCase host property when dashed attribute not present', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    // set property instead of attribute
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    comp.host.dataAriaLabel = 'propVal';
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(button.getAttribute('aria-label')).toBe('propVal');
+  });
+  it('should use default value when dependencies are empty', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(button.getAttribute('aria-label')).toBe('No label');
+  });
+  it('should ignore unrelated attribute mutations', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    comp.host.setAttribute('data-aria-label', 'test');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    // unrelated attribute changes should not affect mapping
+    comp.host.setAttribute('some-other-attr', 'val');
+    MockedMutationObserver.mock.instances[0].trigger([
+      { attributeName: 'some-other-attr', oldValue: null },
+    ]);
+    expect(button.getAttribute('aria-label')).toBe('test');
+  });
+  it('should warn when setting aria attribute throws', () => {
+    const comp = new MockedComponent();
+    // create a target that throws when setAttribute is called
+    const target = {
+      getAttribute: () => null,
+      setAttribute: () => {
+        throw new Error('boom');
+      },
+    };
+    const warnSpy = jest.spyOn(LogUtility, 'warn').mockImplementation(() => {
+      return 'warn mock';
+    });
+    comp.host.setAttribute('data-aria-label', 'test');
+    comp.setMapper(new AriaAttributesValueMapper(() => target, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    expect(warnSpy).toBeCalled();
+    warnSpy.mockRestore();
+  });
+  it('should be no-op when targetGetter returns null or targetGetter is null', () => {
+    const comp = new MockedComponent();
+    // Case 1: constructor targetGetter returns null
+    comp.setMapper(new AriaAttributesValueMapper(() => null, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    }));
+    expect(() => {
+      comp.connectedCallback();
+      comp.componentDidLoad();
+    }).not.toThrow();
+    // Case 2: targetGetter property explicitly set to null after construction
+    const button = document.createElement('button');
+    const mapper = new AriaAttributesValueMapper(() => button, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    });
+    // force targetGetter to null
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mapper.targetGetter = null;
+    comp.setMapper(mapper);
+    expect(() => {
+      comp.connectedCallback();
+      comp.componentDidLoad();
+    }).not.toThrow();
+  });
+  it('should set empty string when no defaultValue provided', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    // no dependencies present on host and no defaultValue in map
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': { dependency: ['data-aria-label', 'label'] },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    // should set attribute to empty string when no defaultValue provided
+    expect(button.getAttribute('aria-label')).toBe(null);
+  });
+  it('should handle empty mutations array (pass undefined to performMapping)', () => {
+    const comp = new MockedComponent();
+    const button = document.createElement('button');
+    comp.host.setAttribute('data-aria-label', 'test');
+    comp.setMapper(new AriaAttributesValueMapper(() => button, {
+      'aria-label': { dependency: ['data-aria-label', 'label'], defaultValue: 'No label' },
+    }));
+    comp.connectedCallback();
+    comp.componentDidLoad();
+    // trigger with empty mutations array -> changedAttrs.size === 0 -> undefined passed
+    MockedMutationObserver.mock.instances[0].trigger([]);
+    expect(button.getAttribute('aria-label')).toBe('test');
+  });
+});