@swisspost/design-system-components 9.0.0-next.9 → 10.0.0-next.37

package/dist/esm/{post-tooltip-b298039a.js → post-tooltip-trigger-7d6f234b.js}

@@ -1,7 +1,7 @@
-import { r as registerInstance, h, H as Host, g as getElement } from './index-fb8d6be7.js';
-import { v as version$1 } from './package-4d81f3c2.js';
-import { g as getAttributeObserver } from './attribute-observer-37fa950a.js';
-import { d as checkEmptyOrType } from './index-b49c9904.js';
+import { r as registerInstance, h, H as Host, g as getElement } from './index-f4d19816.js';
+import { I as IS_BROWSER } from './breakpoints-7812702e.js';
+import { c as checkType } from './check-type-37d5d307.js';
+import { v as version$1 } from './package-d9237b44.js';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -4507,492 +4507,179 @@ module.exports = exports['default'];
 
 const isFocusable = /*@__PURE__*/getDefaultExportFromCjs(focusable.exports);
 
-/*!
- * long-press-event - v@version@
- * Pure JavaScript long-press-event
- * https://github.com/john-doherty/long-press-event
- * @author John Doherty <www.johndoherty.info>
- * @license MIT
- */
-(function (window, document) {
-
-    // local timer object based on rAF
-    var timer = null;
-
-    // check if we're using a touch screen
-    var hasPointerEvents = (('PointerEvent' in window) || (window.navigator && 'msPointerEnabled' in window.navigator));
-    var isTouch = (('ontouchstart' in window) || (navigator.MaxTouchPoints > 0) || (navigator.msMaxTouchPoints > 0));
-
-    // switch to pointer events or touch events if using a touch screen
-    var mouseDown = hasPointerEvents ? 'pointerdown' : isTouch ? 'touchstart' : 'mousedown';
-    var mouseUp = hasPointerEvents ? 'pointerup' : isTouch ? 'touchend' : 'mouseup';
-    var mouseMove = hasPointerEvents ? 'pointermove' : isTouch ? 'touchmove' : 'mousemove';
-    var mouseLeave = hasPointerEvents ? 'pointerleave' : isTouch ? 'touchleave' : 'mouseleave';
-
-    // track number of pixels the mouse moves during long press
-    var startX = 0; // mouse x position when timer started
-    var startY = 0; // mouse y position when timer started
-    var maxDiffX = 10; // max number of X pixels the mouse can move during long press before it is canceled
-    var maxDiffY = 10; // max number of Y pixels the mouse can move during long press before it is canceled
-
-    // patch CustomEvent to allow constructor creation (IE/Chrome)
-    if (typeof window.CustomEvent !== 'function') {
-
-        window.CustomEvent = function (event, params) {
-
-            params = params || { bubbles: false, cancelable: false, detail: undefined };
-
-            var evt = document.createEvent('CustomEvent');
-            evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
-            return evt;
-        };
-
-        window.CustomEvent.prototype = window.Event.prototype;
-    }
+const postTooltipTriggerCss = "post-tooltip-trigger{vertical-align:top}";
+const PostTooltipTriggerStyle0 = postTooltipTriggerCss;
 
-    // requestAnimationFrame() shim by Paul Irish
-    window.requestAnimFrame = (function () {
-        return window.requestAnimationFrame ||
-            window.webkitRequestAnimationFrame ||
-            window.mozRequestAnimationFrame ||
-            window.oRequestAnimationFrame ||
-            window.msRequestAnimationFrame || function (callback) {
-                window.setTimeout(callback, 1000 / 60);
-            };
+const TRIGGER_EVENTS = ['pointerenter', 'pointerleave', 'focusin', 'focusout', 'long-press'];
+if (IS_BROWSER) {
+    (async () => {
+        await import('./long-press-event-04d24397.js');
     })();
-
-    /**
-     * Behaves the same as setTimeout except uses requestAnimationFrame() where possible for better performance
-     * @param {function} fn The callback function
-     * @param {int} delay The delay in milliseconds
-     * @returns {object} handle to the timeout object
-     */
-    function requestTimeout(fn, delay) {
-
-        if (!window.requestAnimationFrame && !window.webkitRequestAnimationFrame &&
-            !(window.mozRequestAnimationFrame && window.mozCancelRequestAnimationFrame) && // Firefox 5 ships without cancel support
-            !window.oRequestAnimationFrame && !window.msRequestAnimationFrame) return window.setTimeout(fn, delay);
-
-        var start = new Date().getTime();
-        var handle = {};
-
-        var loop = function () {
-            var current = new Date().getTime();
-            var delta = current - start;
-
-            if (delta >= delay) {
-                fn.call();
-            }
-            else {
-                handle.value = requestAnimFrame(loop);
-            }
-        };
-
-        handle.value = requestAnimFrame(loop);
-
-        return handle;
-    }
-
-    /**
-     * Behaves the same as clearTimeout except uses cancelRequestAnimationFrame() where possible for better performance
-     * @param {object} handle The callback function
-     * @returns {void}
-     */
-    function clearRequestTimeout(handle) {
-        if (handle) {
-            window.cancelAnimationFrame ? window.cancelAnimationFrame(handle.value) :
-                window.webkitCancelAnimationFrame ? window.webkitCancelAnimationFrame(handle.value) :
-                    window.webkitCancelRequestAnimationFrame ? window.webkitCancelRequestAnimationFrame(handle.value) : /* Support for legacy API */
-                        window.mozCancelRequestAnimationFrame ? window.mozCancelRequestAnimationFrame(handle.value) :
-                            window.oCancelRequestAnimationFrame ? window.oCancelRequestAnimationFrame(handle.value) :
-                                window.msCancelRequestAnimationFrame ? window.msCancelRequestAnimationFrame(handle.value) :
-                                    clearTimeout(handle);
-        }
+}
+const PostTooltipTrigger = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        /**
+         * Reference to the element inside the host that will act as the trigger.
+         */
+        this.trigger = null;
+        /**
+         * Timeout ID for the delay.
+         */
+        this.delayTimeout = null;
+        this.for = undefined;
+        this.delay = 0;
+        this.boundTriggerHandler = this.handleTriggerEvent.bind(this);
+        this.boundTooltipHandler = this.handleTooltipEvent.bind(this);
     }
-
-    /**
-     * Fires the 'long-press' event on element
-     * @param {MouseEvent|PointerEvent|TouchEvent} originalEvent The original event being fired
-     * @returns {void}
-     */
-    function fireLongPressEvent(originalEvent) {
-
-        clearLongPressTimer();
-
-        originalEvent = unifyEvent(originalEvent);
-
-        // fire the long-press event
-        var allowClickEvent = this.dispatchEvent(new CustomEvent('long-press', {
-            bubbles: true,
-            cancelable: true,
-
-            // custom event data (legacy)
-            detail: {
-                clientX: originalEvent.clientX,
-                clientY: originalEvent.clientY,
-                offsetX: originalEvent.offsetX,
-                offsetY: originalEvent.offsetY,
-                pageX: originalEvent.pageX,
-                pageY: originalEvent.pageY
-            },
-
-            // add coordinate data that would typically acompany a touch/click event
-            clientX: originalEvent.clientX,
-            clientY: originalEvent.clientY,
-            offsetX: originalEvent.offsetX,
-            offsetY: originalEvent.offsetY,
-            pageX: originalEvent.pageX,
-            pageY: originalEvent.pageY,
-            screenX: originalEvent.screenX,
-            screenY: originalEvent.screenY
-        }));
-
-        if (!allowClickEvent) {
-            // suppress the next click event if e.preventDefault() was called in long-press handler
-            document.addEventListener('click', function suppressEvent(e) {
-                document.removeEventListener('click', suppressEvent, true);
-                cancelEvent(e);
-            }, true);
-        }
+    validateControlFor() {
+        checkType(this, 'for', 'string');
     }
-
-    /**
-     * consolidates mouse, touch, and Pointer events
-     * @param {MouseEvent|PointerEvent|TouchEvent} e The original event being fired
-     * @returns {MouseEvent|PointerEvent|Touch}
-     */
-    function unifyEvent(e) {
-        if (e.changedTouches !== undefined) {
-            return e.changedTouches[0];
-        }
-        return e;
+    get tooltip() {
+        if (!IS_BROWSER)
+            return null;
+        const ref = document.getElementById(this.for);
+        return ref?.localName === 'post-tooltip'
+            ? ref
+            : null;
     }
-
-    /**
-     * method responsible for starting the long press timer
-     * @param {event} e - event object
-     * @returns {void}
-     */
-    function startLongPressTimer(e) {
-
-        clearLongPressTimer();
-
-        var el = e.target;
-
-        // get delay from html attribute if it exists, otherwise default to 1500
-        var longPressDelayInMs = parseInt(getNearestAttribute(el, 'data-long-press-delay', '1500'), 10); // default 1500
-
-        // start the timer
-        timer = requestTimeout(fireLongPressEvent.bind(el, e), longPressDelayInMs);
-    }
-
-    /**
-     * method responsible for clearing a pending long press timer
-     * @param {event} e - event object
-     * @returns {void}
-     */
-    function clearLongPressTimer(e) {
-        clearRequestTimeout(timer);
-        timer = null;
+    componentDidLoad() {
+        this.setupTrigger();
+        this.attachListeners();
+        this.attachTooltipListeners();
     }
-
-    /**
-    * Cancels the current event
-    * @param {object} e - browser event object
-    * @returns {void}
-    */
-    function cancelEvent(e) {
-        e.stopImmediatePropagation();
-        e.preventDefault();
-        e.stopPropagation();
+    disconnectedCallback() {
+        this.removeListeners();
+        this.removeTooltipListeners();
+        this.cleanupTrigger();
+        if (this.delayTimeout) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
+        }
     }
-
-    /**
-     * Starts the timer on mouse down and logs current position
-     * @param {object} e - browser event object
-     * @returns {void}
-     */
-    function mouseDownHandler(e) {
-        startX = e.clientX;
-        startY = e.clientY;
-        startLongPressTimer(e);
+    handleSlotChange() {
+        this.cleanupTrigger();
+        this.setupTrigger();
     }
-
-    /**
-     * If the mouse moves n pixels during long-press, cancel the timer
-     * @param {object} e - browser event object
-     * @returns {void}
-     */
-    function mouseMoveHandler(e) {
-
-        // calculate total number of pixels the pointer has moved
-        var diffX = Math.abs(startX - e.clientX);
-        var diffY = Math.abs(startY - e.clientY);
-
-        // if pointer has moved more than allowed, cancel the long-press timer and therefore the event
-        if (diffX >= maxDiffX || diffY >= maxDiffY) {
-            clearLongPressTimer();
+    cleanupTrigger() {
+        if (this.trigger) {
+            const describedBy = this.trigger.getAttribute('aria-describedby') || '';
+            if (describedBy.includes(this.for)) {
+                const newDescribedBy = describedBy
+                    .split(' ')
+                    .filter(id => id !== this.for)
+                    .join(' ');
+                if (newDescribedBy) {
+                    this.trigger.setAttribute('aria-describedby', newDescribedBy);
+                }
+                else {
+                    this.trigger.removeAttribute('aria-describedby');
+                }
+            }
+            this.trigger = null;
         }
     }
-
-    /**
-     * Gets attribute off HTML element or nearest parent
-     * @param {object} el - HTML element to retrieve attribute from
-     * @param {string} attributeName - name of the attribute
-     * @param {any} defaultValue - default value to return if no match found
-     * @returns {any} attribute value or defaultValue
-     */
-    function getNearestAttribute(el, attributeName, defaultValue) {
-
-        // walk up the dom tree looking for data-action and data-trigger
-        while (el && el !== document.documentElement) {
-
-            var attributeValue = el.getAttribute(attributeName);
-
-            if (attributeValue) {
-                return attributeValue;
+    setupTrigger() {
+        this.trigger = this.host.querySelector('*');
+        if (this.trigger) {
+            if (!isFocusable(this.trigger)) {
+                this.trigger.setAttribute('tabindex', '0');
+            }
+            const describedBy = this.trigger.getAttribute('aria-describedby') || '';
+            if (!describedBy.includes(this.for)) {
+                this.trigger.setAttribute('aria-describedby', `${describedBy} ${this.for}`.trim());
             }
-
-            el = el.parentNode;
         }
-
-        return defaultValue;
-    }
-
-    // hook events that clear a pending long press event
-    document.addEventListener(mouseUp, clearLongPressTimer, true);
-    document.addEventListener(mouseLeave, clearLongPressTimer, true);
-    document.addEventListener(mouseMove, mouseMoveHandler, true);
-    document.addEventListener('wheel', clearLongPressTimer, true);
-    document.addEventListener('scroll', clearLongPressTimer, true);
-    document.addEventListener('contextmenu', clearLongPressTimer, true);
-
-    // hook events that can trigger a long press event
-    document.addEventListener(mouseDown, mouseDownHandler, true); // <- start
-
-}(window, document));
-
-const postTooltipCss = ":host{--post-contrast-color:#fff;--post-bg-rgb:51, 51, 51}post-popovercontainer{padding:.25rem .5rem;max-width:13.5rem;min-height:1rem}post-popovercontainer[arrow]::after{position:absolute;content:\"\";inset:-13px;z-index:-1}";
-const PostTooltipStyle0 = postTooltipCss;
-
-const OPEN_DELAY = 650; // matches HTML title delay
-/**
- * @slot default - Slot for the content of the tooltip.
- */
-/**
- * Track how many instances remain on the page. Used for removing global event listeners
- */
-let tooltipInstances = 0;
-let hideTooltipTimeout = null;
-const tooltipTargetAttribute = 'data-tooltip-target';
-const tooltipTargetAttributeSelector = `[${tooltipTargetAttribute}]`;
-let globalCurrentTarget;
-let tooltipTimeout = null;
-/**
- * Global event listener to show tooltips. This is globalized so that triggers that are rendered
- * async will still work without the need to set listeners on the element itself
- *
- * This handler manages both pointer and focus events to properly trigger tooltips.
- * If the event is a focus event (e.g., keyboard navigation), pointer events are ignored to avoid
- * interference with tooltip behavior.
- * @param e Event
- * @returns
- */
-const globalInterestHandler = (e) => {
-    const targetElement = e.target.closest(tooltipTargetAttributeSelector);
-    globalCurrentTarget = targetElement;
-    if (!targetElement || !('getAttribute' in targetElement)) {
-        clearTimeout(tooltipTimeout);
-        return;
-    }
-    const tooltipTarget = targetElement.getAttribute(tooltipTargetAttribute);
-    if (!tooltipTarget || tooltipTarget === '')
-        return;
-    const tooltip = document.getElementById(tooltipTarget);
-    // Determine if the tooltip was triggered by a focus event
-    const triggeredByFocus = e.type === 'focusin';
-    void (tooltip === null || tooltip === void 0 ? void 0 : tooltip.show(targetElement, triggeredByFocus));
-    if (hideTooltipTimeout) {
-        window.clearTimeout(hideTooltipTimeout);
-        hideTooltipTimeout = null;
+        else {
+            console.warn('No content found in the post-tooltip-trigger slot. Please insert a focusable element or content that can receive focus.');
+        }
     }
-};
-/**
- * Global event listener to hide tooltips. This is globalized so that triggers that are rendered
- * async will still work without the need to set listeners on the element itself
- * @param e Event
- * @returns
- */
-const globalInterestLostHandler = (e) => {
-    const targetElement = e.target.closest(tooltipTargetAttributeSelector);
-    if (!targetElement || !('getAttribute' in targetElement))
-        return;
-    const tooltipTarget = targetElement.getAttribute(tooltipTargetAttribute);
-    if (!tooltipTarget || tooltipTarget === '')
-        return;
-    const tooltip = document.getElementById(tooltipTarget);
-    globalHideTooltip(tooltip);
-};
-/**
- * Start the hiding process through a timeout to give other interest events a chance to
- * intervene and cancel the hide event.
- * @param {HTMLPostTooltipElement} tooltip
- */
-const globalHideTooltip = (tooltip) => {
-    hideTooltipTimeout = window.setTimeout(() => {
-        tooltip.hide();
-        hideTooltipTimeout = null;
-    }, 42);
-};
-/**
- * Patch some accessibility features that are hard to remember or understand
- * @param {HTMLElement} trigger
- */
-const patchAccessibilityFeatures = (trigger) => {
-    const describedBy = trigger.getAttribute('aria-describedby');
-    const id = trigger.getAttribute(tooltipTargetAttribute);
-    // Add tooltip to aria-describedby
-    if (!(describedBy === null || describedBy === void 0 ? void 0 : describedBy.includes(id))) {
-        const newDescribedBy = describedBy ? `${describedBy} ${id}` : id;
-        trigger.setAttribute('aria-describedby', newDescribedBy);
+    attachListeners() {
+        TRIGGER_EVENTS.forEach(event => {
+            this.host.addEventListener(event, this.boundTriggerHandler);
+        });
     }
-    // Make element focusable
-    if (!isFocusable(trigger)) {
-        trigger.setAttribute('tabindex', '0');
+    removeListeners() {
+        TRIGGER_EVENTS.forEach(event => {
+            this.host.removeEventListener(event, this.boundTriggerHandler);
+        });
     }
-};
-// Initialize a mutation observer for patching accessibility features
-const triggerObserver = getAttributeObserver(tooltipTargetAttribute, patchAccessibilityFeatures);
-const PostTooltip = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.wasOpenedByFocus = false;
-        this.placement = 'top';
-        this.arrow = true;
-        this.delayed = false;
+    attachTooltipListeners() {
+        if (this.tooltip) {
+            this.tooltip.addEventListener('pointerenter', this.boundTooltipHandler);
+            this.tooltip.addEventListener('pointerleave', this.boundTooltipHandler);
+        }
     }
-    validateDelayed() {
-        checkEmptyOrType(this.delayed, 'boolean', 'The post-tooltip "delayed" property should be a boolean.');
+    removeTooltipListeners() {
+        if (this.tooltip) {
+            this.tooltip.removeEventListener('pointerenter', this.boundTooltipHandler);
+            this.tooltip.removeEventListener('pointerleave', this.boundTooltipHandler);
+        }
     }
-    connectedCallback() {
-        this.validateDelayed();
+    handleTriggerEvent(event) {
+        switch (event.type) {
+            case 'pointerenter':
+            case 'focusin':
+            case 'long-press':
+                this.handleEnter();
+                break;
+            case 'pointerleave':
+            case 'focusout':
+                this.handleLeave(event);
+                break;
+        }
     }
-    componentDidLoad() {
-        if (!this.host.id) {
-            throw new Error(
-            /*prettier-ignore*/
-            'No id set: <post-tooltip> must have an id, linking it to it\'s target element using the data-tooltip-target attribute.');
+    handleTooltipEvent(event) {
+        switch (event.type) {
+            case 'pointerenter':
+                this.handleEnter();
+                break;
+            case 'pointerleave':
+                this.handleLeave(event);
+                break;
         }
     }
-    /**
-     * Add interest event listeners, but only once, and start
-     * the accessibility patcher
-     */
-    componentWillLoad() {
-        if (tooltipInstances === 0) {
-            // This is the first tooltip on the page, add event listeners
-            document.addEventListener('pointerover', globalInterestHandler);
-            document.addEventListener('pointerout', globalInterestLostHandler);
-            document.addEventListener('focusin', globalInterestHandler);
-            document.addEventListener('focusout', globalInterestLostHandler);
-            document.addEventListener('long-press', globalInterestHandler);
-            // Initially run the accessibility patcher on all triggers
-            document.querySelectorAll('[data-tooltip-target]').forEach(patchAccessibilityFeatures);
-            // Start watching for future triggers
-            triggerObserver.observe(document.body, {
-                subtree: true,
-                childList: true,
-                attributeFilter: [tooltipTargetAttribute],
-            });
+    handleEnter() {
+        if (this.delayTimeout) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
         }
-        tooltipInstances++;
+        this.interestHandler();
     }
-    /**
-     * Remove a bunch of event listeners if the tooltip gets removed from the DOM
-     * and disconnect the accessibility patcher
-     */
-    disconnectedCallback() {
-        tooltipInstances--;
-        if (tooltipInstances <= 0) {
-            // The last tooltip has been removed, stop listening for these kind of events
-            document.removeEventListener('pointerover', globalInterestHandler);
-            document.removeEventListener('pointerout', globalInterestLostHandler);
-            document.removeEventListener('focusin', globalInterestHandler);
-            document.removeEventListener('focusout', globalInterestLostHandler);
-            document.removeEventListener('long-press', globalInterestHandler);
-            triggerObserver.disconnect();
+    handleLeave(event) {
+        const newTarget = event.relatedTarget;
+        if ((this.tooltip && newTarget && this.tooltip.contains(newTarget)) ||
+            (newTarget === this.trigger)) {
+            return;
         }
+        this.interestLostHandler();
     }
-    /**
-     * Programmatically display the tooltip
-     * @param target An element with [data-tooltip-target="id"] where the tooltip should be shown
-     * @param triggeredByFocus A boolean indicating if the tooltip was triggered by a focus event.
-     */
-    async show(target, triggeredByFocus = false) {
-        const showTooltip = () => {
-            // If focus or pointer event is not on the button anymore, don't show the tooltip
-            if (globalCurrentTarget !== target)
-                return;
-            // Determine if the tooltip was opened by a focus event
-            this.wasOpenedByFocus = triggeredByFocus;
-            // Disable pointer events if triggered by focus, otherwise enable them
-            if (this.wasOpenedByFocus) {
-                this.host.style.pointerEvents = 'none';
-            }
-            else {
-                this.host.style.pointerEvents = 'auto';
-            }
-            this.popoverRef.show(target);
-        };
-        if (this.delayed) {
-            tooltipTimeout = setTimeout(() => {
-                showTooltip();
-            }, OPEN_DELAY);
+    interestHandler() {
+        if (this.delay > 0) {
+            this.delayTimeout = window.setTimeout(() => {
+                this.tooltip?.show(this.trigger);
+                this.delayTimeout = null;
+            }, this.delay);
         }
         else {
-            showTooltip();
+            this.tooltip?.show(this.trigger);
         }
     }
-    /**
-     * Programmatically hide this tooltip
-     */
-    async hide() {
-        this.popoverRef.hide();
-    }
-    /**
-     * Toggle tooltip display
-     * @param target An element with [data-tooltip-target="id"] where the tooltip should be shown
-     * @param force Pass true to always show or false to always hide
-     */
-    async toggle(target, force) {
-        this.popoverRef.toggle(target, force);
-    }
-    /**
-     * Pointer or focus is on the tooltip, stop the tooltip from disappearing
-     */
-    handleInterest() {
-        if (hideTooltipTimeout) {
-            window.clearTimeout(hideTooltipTimeout);
-            hideTooltipTimeout = null;
+    interestLostHandler() {
+        if (this.delayTimeout) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
         }
-    }
-    /**
-     * Pointer or focus left the tooltip, initiate the hiding process
-     * Re-enable pointer events when the tooltip is no longer in focus or hovered
-     */
-    handleInterestLost() {
-        globalHideTooltip(this);
-        this.host.style.pointerEvents = 'auto';
+        this.tooltip?.hide();
     }
     render() {
-        const popoverClass = `${this.arrow ? ' has-arrow' : ''}`;
-        return (h(Host, { key: '71db1ccf3cf929d76550b08e69c8594479eaa84f', "data-version": version$1, role: "tooltip", onPointerOver: this.handleInterest, onPointerOut: this.handleInterestLost, onFocusIn: this.handleInterest, onFocusOut: this.handleInterestLost }, h("post-popovercontainer", { key: 'b9a38cabbfc2cf2eb9b257bca32022b5d97aac7c', class: popoverClass, arrow: this.arrow, placement: this.placement, ref: (el) => (this.popoverRef = el) }, h("slot", { key: '316b55f5fc55d9607205496a87f02a0a5fa197cf' }))));
+        return (h(Host, { key: '4e4b53e85570d6dbba4ee7833a1d3de00e53dbc6', "data-version": version$1 }, h("slot", { key: 'f8f5ea2e2ce848d654e233617455bbbbdc6ba5b1', onSlotchange: () => this.handleSlotChange() })));
     }
     get host() { return getElement(this); }
     static get watchers() { return {
-        "delayed": ["validateDelayed"]
+        "for": ["validateControlFor"]
     }; }
 };
-PostTooltip.style = PostTooltipStyle0;
+PostTooltipTrigger.style = PostTooltipTriggerStyle0;
 
-export { PostTooltip as P };
+export { PostTooltipTrigger as P };

package/dist/esm/post-tooltip-trigger.entry.js

@@ -0,0 +1,5 @@
+export { P as post_tooltip_trigger } from './post-tooltip-trigger-7d6f234b.js';
+import './index-f4d19816.js';
+import './breakpoints-7812702e.js';
+import './check-type-37d5d307.js';
+import './package-d9237b44.js';

package/dist/esm/post-tooltip.entry.js

@@ -1,9 +1,5 @@
-export { P as post_tooltip } from './post-tooltip-b298039a.js';
-import './index-fb8d6be7.js';
-import './package-4d81f3c2.js';
-import './attribute-observer-37fa950a.js';
-import './index-b49c9904.js';
-import './constants-8d548297.js';
-import './check-one-of-6b3ef8eb.js';
-import './check-type-8828dbe4.js';
-import './check-url-a974431e.js';
+export { P as post_tooltip } from './post-tooltip-9a195d47.js';
+import './index-f4d19816.js';
+import './package-d9237b44.js';
+import './check-type-37d5d307.js';
+import './breakpoints-7812702e.js';