@seeqdev/qomponents 0.0.108 → 0.0.109

package/dist/Tooltip/Qtip.js

@@ -1,155 +1,155 @@
-import DOMPurify from 'dompurify';
-import React, { useEffect, useRef, useState } from 'react';
-import { arrow, computePosition, offset } from '@floating-ui/dom';
-import { useIntervalWhen } from 'rooks';
-import { DEFAULT_TOOL_TIP_DELAY } from './Tooltip.types';
-const getArrowStyle = (position, x, arrowWidth, tooltipHeight, tooltipWidth) => {
-    switch (position) {
-        case 'bottom':
-            return {
-                left: `${x}px`,
-                top: `${-arrowWidth}px`,
-            };
-        case 'left':
-            return {
-                left: `${tooltipWidth - arrowWidth}px`,
-                top: `${tooltipHeight / 2 - arrowWidth}px`,
-            };
-        case 'right':
-            return {
-                left: `${-arrowWidth}px`,
-                top: `${tooltipHeight / 2 - arrowWidth}px`,
-            };
-        default: // 'top':
-            return {
-                left: `${x}px`,
-                top: `${tooltipHeight - 10 + arrowWidth}px`,
-            };
-    }
-};
-const HTMLTip = ({ text }) => {
-    return React.createElement('div', {
-        dangerouslySetInnerHTML: { __html: DOMPurify.sanitize(text) },
-    });
-};
-/** Tooltips can cause SystemTests to be flaky, so we suppress them in Playwright and Protractor */
-const suppressTooltip = () => {
-    return window.navigator.userAgent === 'Playwright' || window.navigator.userAgent.includes('Protractor');
-};
-/**
- * QTip
- *
- * QTip is a Singleton Tooltip component that guarantees high-performance and reduces component wrappers!
- *
- * QTip is used by all qomponents that support the display of tooltips.
- * If you want to add a Tooltip to your application you can do so by adding the following html data-attributes:
- *
- *    'data-qtip-text': the tooltip text to display; this can also be a string containing valid HTML
- *    'data-qtip-placement': one of TooltipPosition (top, bottom, right, or left)
- *    'data-qtip-is-html': set this to true if you provided a text that contains HTML,
- *    'data-qtip-delay': this can be used to delay the showing of the tooltip. this should be a number representing
- *    the # of milliseconds you want to delay the tooltip for. If no delay is provided the DEFAULT_TOOL_TIP_DELAY is
- *    applied!
- *    'data-qtip-testid': use this attribute to provide a value for a data-testid of your tooltip; this is useful
- *    for tests
- *
- * In order for QTip to be able to display Tooltips you must add the QTip component to your top-most component
- * (often that's App or Application) - simply add:
- *
- *    <QTip />
- *
- * and enjoy beautiful & performant tooltips!
- */
-export const QTip = () => {
-    const tooltipRef = useRef(null);
-    const tooltipTarget = useRef(null);
-    const tooltipArrowRef = useRef(null);
-    const [tooltipText, setTooltipText] = useState('');
-    const [tooltipTargetOriginalPosition, setTooltipTargetOriginalPosition] = useState(null);
-    const [show, setShow] = useState(false);
-    const [html, setHtml] = useState(false);
-    const [tooltipTestId, setTooltipTestId] = useState('');
-    const [overTooltip, setOverTooltip] = useState(false);
-    // Check every 300ms if the tooltip target position has changed and hide the tooltip if this happens.
-    useIntervalWhen(() => {
-        const currentPosition = tooltipTarget?.current?.getBoundingClientRect();
-        if (overTooltip) {
-            return;
-        }
-        if (tooltipTargetOriginalPosition?.y !== currentPosition?.y ||
-            tooltipTargetOriginalPosition?.x !== currentPosition?.x) {
-            setShow(false);
-        }
-    }, 300, show);
-    useEffect(() => {
-        !suppressTooltip() && document.body.addEventListener('mousemove', onMouseMove);
-        return () => {
-            !suppressTooltip() && document.removeEventListener('mousemove', onMouseMove);
-        };
-    }, []);
-    const ttTimeout = useRef();
-    const onMouseMove = (e) => {
-        clearTimeout(ttTimeout.current);
-        tooltipTarget.current = e.target;
-        let dataset = e.target?.dataset;
-        let text = dataset?.qtipText;
-        // Buttons support React.Nodes as children, the tooltip however is applied to the actual button component.
-        // we only check two levels up - alternatively the tooltip can also be provided on the React.Node
-        if (!text || text === '') {
-            let currentTooltipTarget = e.target?.parentElement;
-            dataset = currentTooltipTarget?.dataset;
-            text = dataset?.qtipText;
-            if (!text || text === '') {
-                currentTooltipTarget = e.target?.parentElement?.parentElement || null;
-                dataset = currentTooltipTarget?.dataset;
-                text = dataset?.qtipText;
-            }
-            tooltipTarget.current = currentTooltipTarget;
-        }
-        if (text) {
-            const delay = parseInt(dataset?.qtipDelay ?? DEFAULT_TOOL_TIP_DELAY + '');
-            ttTimeout.current = setTimeout(() => makeTooltip(text, dataset?.qtipPlacement, dataset?.qtipIsHtml === 'true', dataset?.qtipTestid, delay), delay);
-        }
-    };
-    const makeTooltip = (tooltipText, position = 'top', isHtml, dataTestId, delay) => {
-        if (tooltipText && tooltipTarget.current) {
-            setHtml(isHtml);
-            setTooltipText(tooltipText);
-            setTooltipTestId(dataTestId);
-            setTooltipTargetOriginalPosition(tooltipTarget.current.getBoundingClientRect());
-            const positionTooltip = () => {
-                if (tooltipRef.current && tooltipTarget.current) {
-                    computePosition(tooltipTarget.current, tooltipRef.current, {
-                        placement: position,
-                        middleware: [offset(10), arrow({ element: tooltipArrowRef.current })],
-                    }).then(({ x, y, middlewareData }) => {
-                        Object.assign(tooltipRef.current?.style, {
-                            left: `${x}px`,
-                            top: `${y}px`,
-                        });
-                        if (middlewareData.arrow) {
-                            const { x, y } = middlewareData.arrow;
-                            const arrowWidth = tooltipArrowRef.current?.offsetHeight / 2;
-                            const tooltipHeight = tooltipRef.current?.offsetHeight;
-                            const tooltipWidth = tooltipRef.current?.offsetWidth;
-                            const style = getArrowStyle(position, x || y, arrowWidth, tooltipHeight, tooltipWidth);
-                            Object.assign(tooltipArrowRef.current.style, style);
-                        }
-                        setShow(true);
-                    });
-                }
-            };
-            delay > 0
-                ? requestAnimationFrame(() => {
-                    positionTooltip();
-                })
-                : positionTooltip();
-        }
-    };
-    return (React.createElement(React.Fragment, null,
-        React.createElement("div", { onMouseEnter: () => setOverTooltip(true), onMouseLeave: () => setOverTooltip(false), "data-testid": tooltipTestId, ref: tooltipRef, className: 'tw-absolute tw-rounded tw-bg-black tw-p-2 tw-text-xs tw-text-white tw-z-[9999] fade-in ' +
-                (show ? 'tw-visible' : 'tw-invisible tw-pointer-events-none') },
-            html ? React.createElement(HTMLTip, { text: tooltipText }) : tooltipText,
-            React.createElement("div", { className: "tw-absolute tw-w-[10px] tw-h-[10px] tw-rotate-45 tw-bg-black", ref: tooltipArrowRef }))));
-};
+import DOMPurify from 'dompurify';
+import React, { useEffect, useRef, useState } from 'react';
+import { arrow, computePosition, offset } from '@floating-ui/dom';
+import { useIntervalWhen } from 'rooks';
+import { DEFAULT_TOOL_TIP_DELAY } from './Tooltip.types';
+const getArrowStyle = (position, x, arrowWidth, tooltipHeight, tooltipWidth) => {
+    switch (position) {
+        case 'bottom':
+            return {
+                left: `${x}px`,
+                top: `${-arrowWidth}px`,
+            };
+        case 'left':
+            return {
+                left: `${tooltipWidth - arrowWidth}px`,
+                top: `${tooltipHeight / 2 - arrowWidth}px`,
+            };
+        case 'right':
+            return {
+                left: `${-arrowWidth}px`,
+                top: `${tooltipHeight / 2 - arrowWidth}px`,
+            };
+        default: // 'top':
+            return {
+                left: `${x}px`,
+                top: `${tooltipHeight - 10 + arrowWidth}px`,
+            };
+    }
+};
+const HTMLTip = ({ text }) => {
+    return React.createElement('div', {
+        dangerouslySetInnerHTML: { __html: DOMPurify.sanitize(text) },
+    });
+};
+/** Tooltips can cause SystemTests to be flaky, so we suppress them in Playwright and Protractor */
+const suppressTooltip = () => {
+    return window.navigator.userAgent === 'Playwright' || window.navigator.userAgent.includes('Protractor');
+};
+/**
+ * QTip
+ *
+ * QTip is a Singleton Tooltip component that guarantees high-performance and reduces component wrappers!
+ *
+ * QTip is used by all qomponents that support the display of tooltips.
+ * If you want to add a Tooltip to your application you can do so by adding the following html data-attributes:
+ *
+ *    'data-qtip-text': the tooltip text to display; this can also be a string containing valid HTML
+ *    'data-qtip-placement': one of TooltipPosition (top, bottom, right, or left)
+ *    'data-qtip-is-html': set this to true if you provided a text that contains HTML,
+ *    'data-qtip-delay': this can be used to delay the showing of the tooltip. this should be a number representing
+ *    the # of milliseconds you want to delay the tooltip for. If no delay is provided the DEFAULT_TOOL_TIP_DELAY is
+ *    applied!
+ *    'data-qtip-testid': use this attribute to provide a value for a data-testid of your tooltip; this is useful
+ *    for tests
+ *
+ * In order for QTip to be able to display Tooltips you must add the QTip component to your top-most component
+ * (often that's App or Application) - simply add:
+ *
+ *    <QTip />
+ *
+ * and enjoy beautiful & performant tooltips!
+ */
+export const QTip = () => {
+    const tooltipRef = useRef(null);
+    const tooltipTarget = useRef(null);
+    const tooltipArrowRef = useRef(null);
+    const [tooltipText, setTooltipText] = useState('');
+    const [tooltipTargetOriginalPosition, setTooltipTargetOriginalPosition] = useState(null);
+    const [show, setShow] = useState(false);
+    const [html, setHtml] = useState(false);
+    const [tooltipTestId, setTooltipTestId] = useState('');
+    const [overTooltip, setOverTooltip] = useState(false);
+    // Check every 300ms if the tooltip target position has changed and hide the tooltip if this happens.
+    useIntervalWhen(() => {
+        const currentPosition = tooltipTarget?.current?.getBoundingClientRect();
+        if (overTooltip) {
+            return;
+        }
+        if (tooltipTargetOriginalPosition?.y !== currentPosition?.y ||
+            tooltipTargetOriginalPosition?.x !== currentPosition?.x) {
+            setShow(false);
+        }
+    }, 300, show);
+    useEffect(() => {
+        !suppressTooltip() && document.body.addEventListener('mousemove', onMouseMove);
+        return () => {
+            !suppressTooltip() && document.removeEventListener('mousemove', onMouseMove);
+        };
+    }, []);
+    const ttTimeout = useRef();
+    const onMouseMove = (e) => {
+        clearTimeout(ttTimeout.current);
+        tooltipTarget.current = e.target;
+        let dataset = e.target?.dataset;
+        let text = dataset?.qtipText;
+        // Buttons support React.Nodes as children, the tooltip however is applied to the actual button component.
+        // we only check two levels up - alternatively the tooltip can also be provided on the React.Node
+        if (!text || text === '') {
+            let currentTooltipTarget = e.target?.parentElement;
+            dataset = currentTooltipTarget?.dataset;
+            text = dataset?.qtipText;
+            if (!text || text === '') {
+                currentTooltipTarget = e.target?.parentElement?.parentElement || null;
+                dataset = currentTooltipTarget?.dataset;
+                text = dataset?.qtipText;
+            }
+            tooltipTarget.current = currentTooltipTarget;
+        }
+        if (text) {
+            const delay = parseInt(dataset?.qtipDelay ?? DEFAULT_TOOL_TIP_DELAY + '');
+            ttTimeout.current = setTimeout(() => makeTooltip(text, dataset?.qtipPlacement, dataset?.qtipIsHtml === 'true', dataset?.qtipTestid, delay), delay);
+        }
+    };
+    const makeTooltip = (tooltipText, position = 'top', isHtml, dataTestId, delay) => {
+        if (tooltipText && tooltipTarget.current) {
+            setHtml(isHtml);
+            setTooltipText(tooltipText);
+            setTooltipTestId(dataTestId);
+            setTooltipTargetOriginalPosition(tooltipTarget.current.getBoundingClientRect());
+            const positionTooltip = () => {
+                if (tooltipRef.current && tooltipTarget.current) {
+                    computePosition(tooltipTarget.current, tooltipRef.current, {
+                        placement: position,
+                        middleware: [offset(10), arrow({ element: tooltipArrowRef.current })],
+                    }).then(({ x, y, middlewareData }) => {
+                        Object.assign(tooltipRef.current?.style, {
+                            left: `${x}px`,
+                            top: `${y}px`,
+                        });
+                        if (middlewareData.arrow) {
+                            const { x, y } = middlewareData.arrow;
+                            const arrowWidth = tooltipArrowRef.current?.offsetHeight / 2;
+                            const tooltipHeight = tooltipRef.current?.offsetHeight;
+                            const tooltipWidth = tooltipRef.current?.offsetWidth;
+                            const style = getArrowStyle(position, x || y, arrowWidth, tooltipHeight, tooltipWidth);
+                            Object.assign(tooltipArrowRef.current.style, style);
+                        }
+                        setShow(true);
+                    });
+                }
+            };
+            delay > 0
+                ? requestAnimationFrame(() => {
+                    positionTooltip();
+                })
+                : positionTooltip();
+        }
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", { onMouseEnter: () => setOverTooltip(true), onMouseLeave: () => setOverTooltip(false), "data-testid": tooltipTestId, ref: tooltipRef, className: 'tw-absolute tw-rounded tw-bg-black tw-p-2 tw-text-xs tw-text-white tw-z-[9999] fade-in ' +
+                (show ? 'tw-visible' : 'tw-invisible tw-pointer-events-none') },
+            html ? React.createElement(HTMLTip, { text: tooltipText }) : tooltipText,
+            React.createElement("div", { className: "tw-absolute tw-w-[10px] tw-h-[10px] tw-rotate-45 tw-bg-black", ref: tooltipArrowRef }))));
+};
 //# sourceMappingURL=Qtip.js.map

package/dist/Tooltip/Tooltip.js

@@ -1,36 +1,36 @@
-import React from 'react';
-import '../styles.css';
-import { DEFAULT_TOOL_TIP_DELAY } from './Tooltip.types';
-/**
- * @deprecated
- * Note: Tooltip has been replaced by QTip - a singleton JS tooltip that behaves well even with overflow settings :)
- * See @QTip for more info!
- *
- * This component displays a Tooltip for the provided children. It is a CSS only tooltip that will not display
- * correctly if a parent element has an overflow CSS property assigned. Please use QTip to ensure your tooltips
- * display correctly.
- */
-export const Tooltip = ({ position = 'bottom', children, text, delay = DEFAULT_TOOL_TIP_DELAY, }) => {
-    const arrowBaseClasses = 'before:tw-content-[\'\'] before:tw-absolute before:tw-border-8';
-    const centerArrowVertically = 'before:tw-top-1/2 before:-tw-translate-y-1/2';
-    const centerArrowHorizontally = 'before:tw-left-1/2 before:-tw-translate-x-1/2';
+import React from 'react';
+import '../styles.css';
+import { DEFAULT_TOOL_TIP_DELAY } from './Tooltip.types';
+/**
+ * @deprecated
+ * Note: Tooltip has been replaced by QTip - a singleton JS tooltip that behaves well even with overflow settings :)
+ * See @QTip for more info!
+ *
+ * This component displays a Tooltip for the provided children. It is a CSS only tooltip that will not display
+ * correctly if a parent element has an overflow CSS property assigned. Please use QTip to ensure your tooltips
+ * display correctly.
+ */
+export const Tooltip = ({ position = 'bottom', children, text, delay = DEFAULT_TOOL_TIP_DELAY, }) => {
+    const arrowBaseClasses = 'before:tw-content-[\'\'] before:tw-absolute before:tw-border-8';
+    const centerArrowVertically = 'before:tw-top-1/2 before:-tw-translate-y-1/2';
+    const centerArrowHorizontally = 'before:tw-left-1/2 before:-tw-translate-x-1/2';
     const arrowRight = `${arrowBaseClasses} ${centerArrowVertically} before:tw-right-[100%] before:tw-border-y-transparent 
-  before:tw-border-l-transparent before:tw-border-r-black`;
+  before:tw-border-l-transparent before:tw-border-r-black`;
     const arrowLeft = `${arrowBaseClasses} ${centerArrowVertically} before:tw-left-[100%] before:tw-border-y-transparent
-   before:tw-border-l-black before:tw-border-r-transparent`;
+   before:tw-border-l-black before:tw-border-r-transparent`;
     const arrowBottom = `${arrowBaseClasses} ${centerArrowHorizontally} before:-tw-top-4 before:tw-border-b-black 
-  before:tw-border-r-transparent before:tw-border-l-transparent before:tw-border-t-transparent`;
+  before:tw-border-r-transparent before:tw-border-l-transparent before:tw-border-t-transparent`;
     const arrowTop = `${arrowBaseClasses} ${centerArrowHorizontally} before:-tw-bottom-4 before:tw-border-b-transparent 
-  before:tw-border-t-black before:tw-border-l-transparent before:tw-border-r-transparent`;
-    const placements = {
-        top: `-tw-top-2 -tw-translate-y-full tw-left-1/2 -tw-translate-x-1/2 ${arrowTop}`,
-        left: `-tw-translate-x-full -tw-left-3 -tw-translate-y-1/2 tw-top-1/2 ${arrowLeft}`,
-        right: `tw-translate-x-full -tw-right-3 -tw-translate-y-1/2 tw-top-1/2 ${arrowRight}`,
-        bottom: `-tw-bottom-2 tw-translate-y-full tw-left-1/2 -tw-translate-x-1/2 ${arrowBottom}`,
-    };
-    return (React.createElement("div", { className: "tw-group tw-relative tw-inline-block" },
-        children,
+  before:tw-border-t-black before:tw-border-l-transparent before:tw-border-r-transparent`;
+    const placements = {
+        top: `-tw-top-2 -tw-translate-y-full tw-left-1/2 -tw-translate-x-1/2 ${arrowTop}`,
+        left: `-tw-translate-x-full -tw-left-3 -tw-translate-y-1/2 tw-top-1/2 ${arrowLeft}`,
+        right: `tw-translate-x-full -tw-right-3 -tw-translate-y-1/2 tw-top-1/2 ${arrowRight}`,
+        bottom: `-tw-bottom-2 tw-translate-y-full tw-left-1/2 -tw-translate-x-1/2 ${arrowBottom}`,
+    };
+    return (React.createElement("div", { className: "tw-group tw-relative tw-inline-block" },
+        children,
         React.createElement("div", { className: `tw-z-50 tw-whitespace-nowrap tw-hidden group-hover:tw-inline-block group-hover:tw-delay-[${delay}ms] 
-        tw-absolute tw-opacity-0 group-hover:tw-opacity-100 tw-rounded tw-bg-black tw-p-2 tw-text-xs tw-text-white ${placements[position]}` }, text)));
-};
+        tw-absolute tw-opacity-0 group-hover:tw-opacity-100 tw-rounded tw-bg-black tw-p-2 tw-text-xs tw-text-white ${placements[position]}` }, text)));
+};
 //# sourceMappingURL=Tooltip.js.map

package/dist/Tooltip/Tooltip.stories.js

@@ -1,32 +1,32 @@
-import React from 'react';
-import { Tooltip } from './Tooltip';
-import Icon from '../Icon';
-import Button from '../Button';
-import { tooltipPositions } from './Tooltip.types';
-export default {
-    title: 'Tooltip',
-};
-export const AllTooltips = () => {
-    const renderButtonsWithTooltip = () => tooltipPositions.map((position) => (React.createElement("div", { key: `${position}_button` },
-        React.createElement(Tooltip, { text: `Tooltip on the ${position}`, position: position },
-            React.createElement(Button, { label: position })))));
-    const renderIconsWithHtmlTooltip = () => tooltipPositions.map((position) => (React.createElement("div", { key: `${position}_icon` },
-        React.createElement(Tooltip, { text: React.createElement("div", null,
-                React.createElement("h2", null, "Fancy Tooltip"),
-                " This is a special tooltip. Why?",
-                React.createElement("br", null),
-                "Because it supports ",
-                React.createElement("b", null, "HTML!")), position: position },
-            React.createElement(Icon, { icon: "fc-sun" })))));
-    const renderTextTooltipOnText = () => tooltipPositions.map((position) => (React.createElement("div", { key: `${position}_text` },
-        React.createElement(Tooltip, { text: "Helpful information provided here", position: position },
-            React.createElement("span", null,
-                "Hover for Tooltip (on the ",
-                position,
-                ")")))));
-    return (React.createElement("div", { className: "tw-grid tw-grid-cols-4 tw-gap-4 tw-text-center" },
-        renderButtonsWithTooltip(),
-        renderIconsWithHtmlTooltip(),
-        renderTextTooltipOnText()));
-};
+import React from 'react';
+import { Tooltip } from './Tooltip';
+import Icon from '../Icon';
+import Button from '../Button';
+import { tooltipPositions } from './Tooltip.types';
+export default {
+    title: 'Tooltip',
+};
+export const AllTooltips = () => {
+    const renderButtonsWithTooltip = () => tooltipPositions.map((position) => (React.createElement("div", { key: `${position}_button` },
+        React.createElement(Tooltip, { text: `Tooltip on the ${position}`, position: position },
+            React.createElement(Button, { label: position })))));
+    const renderIconsWithHtmlTooltip = () => tooltipPositions.map((position) => (React.createElement("div", { key: `${position}_icon` },
+        React.createElement(Tooltip, { text: React.createElement("div", null,
+                React.createElement("h2", null, "Fancy Tooltip"),
+                " This is a special tooltip. Why?",
+                React.createElement("br", null),
+                "Because it supports ",
+                React.createElement("b", null, "HTML!")), position: position },
+            React.createElement(Icon, { icon: "fc-sun" })))));
+    const renderTextTooltipOnText = () => tooltipPositions.map((position) => (React.createElement("div", { key: `${position}_text` },
+        React.createElement(Tooltip, { text: "Helpful information provided here", position: position },
+            React.createElement("span", null,
+                "Hover for Tooltip (on the ",
+                position,
+                ")")))));
+    return (React.createElement("div", { className: "tw-grid tw-grid-cols-4 tw-gap-4 tw-text-center" },
+        renderButtonsWithTooltip(),
+        renderIconsWithHtmlTooltip(),
+        renderTextTooltipOnText()));
+};
 //# sourceMappingURL=Tooltip.stories.js.map

package/dist/Tooltip/Tooltip.types.js

@@ -1,3 +1,3 @@
-export const DEFAULT_TOOL_TIP_DELAY = 500;
-export const tooltipPositions = ['top', 'left', 'right', 'bottom'];
+export const DEFAULT_TOOL_TIP_DELAY = 500;
+export const tooltipPositions = ['top', 'left', 'right', 'bottom'];
 //# sourceMappingURL=Tooltip.types.js.map

package/dist/Tooltip/TooltipPerformance.stories.js

@@ -1,30 +1,30 @@
-import React from 'react';
-import { Tooltip } from './Tooltip';
-import Icon from '../Icon';
-export default {
-    title: 'Tooltip',
-};
-const renderManyTooltips = () => {
-    const colsCount = 100;
-    const rowCount = 100;
-    const rows = [];
-    const getCols = (rowId) => {
-        const cols = [];
-        for (let i = 0; i < colsCount; i++) {
-            cols.push(React.createElement("td", { key: 'col_' + i + '_row_' + rowId },
-                React.createElement(Tooltip, { text: `hello there ${i}` },
-                    React.createElement(Icon, { icon: "fc-sun" }))));
-        }
-        return cols;
-    };
-    for (let i = 0; i < rowCount; i++) {
-        rows.push(React.createElement("tr", { key: 'row_' + i }, ...getCols(i)));
-    }
-    return (React.createElement("table", null,
-        React.createElement("tbody", null, rows.map((row) => row))));
-};
-export const TooltipPerformance = () => {
-    return (React.createElement(React.Fragment, null,
-        React.createElement("div", { className: "tw-grid tw-grid-cols-4 tw-gap-4 tw-text-center" }, renderManyTooltips())));
-};
+import React from 'react';
+import { Tooltip } from './Tooltip';
+import Icon from '../Icon';
+export default {
+    title: 'Tooltip',
+};
+const renderManyTooltips = () => {
+    const colsCount = 100;
+    const rowCount = 100;
+    const rows = [];
+    const getCols = (rowId) => {
+        const cols = [];
+        for (let i = 0; i < colsCount; i++) {
+            cols.push(React.createElement("td", { key: 'col_' + i + '_row_' + rowId },
+                React.createElement(Tooltip, { text: `hello there ${i}` },
+                    React.createElement(Icon, { icon: "fc-sun" }))));
+        }
+        return cols;
+    };
+    for (let i = 0; i < rowCount; i++) {
+        rows.push(React.createElement("tr", { key: 'row_' + i }, ...getCols(i)));
+    }
+    return (React.createElement("table", null,
+        React.createElement("tbody", null, rows.map((row) => row))));
+};
+export const TooltipPerformance = () => {
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", { className: "tw-grid tw-grid-cols-4 tw-gap-4 tw-text-center" }, renderManyTooltips())));
+};
 //# sourceMappingURL=TooltipPerformance.stories.js.map

package/dist/Tooltip/index.js

@@ -1,3 +1,3 @@
-export { Tooltip } from './Tooltip';
-export { QTip } from './Qtip';
+export { Tooltip } from './Tooltip';
+export { QTip } from './Qtip';
 //# sourceMappingURL=index.js.map

package/dist/Tooltip/qTip.utilities.js

@@ -1,11 +1,11 @@
-import { DEFAULT_TOOL_TIP_DELAY } from './Tooltip.types';
-export const getQTipData = ({ tooltip, tooltipPlacement, isHtmlTooltip, tooltipTestId, tooltipDelay = DEFAULT_TOOL_TIP_DELAY, }) => tooltip
-    ? {
-        'data-qtip-text': tooltip,
-        'data-qtip-placement': tooltipPlacement,
-        'data-qtip-is-html': isHtmlTooltip,
-        'data-qtip-testid': tooltipTestId,
-        'data-qtip-delay': tooltipDelay,
-    }
-    : undefined;
+import { DEFAULT_TOOL_TIP_DELAY } from './Tooltip.types';
+export const getQTipData = ({ tooltip, tooltipPlacement, isHtmlTooltip, tooltipTestId, tooltipDelay = DEFAULT_TOOL_TIP_DELAY, }) => tooltip
+    ? {
+        'data-qtip-text': tooltip,
+        'data-qtip-placement': tooltipPlacement,
+        'data-qtip-is-html': isHtmlTooltip,
+        'data-qtip-testid': tooltipTestId,
+        'data-qtip-delay': tooltipDelay,
+    }
+    : undefined;
 //# sourceMappingURL=qTip.utilities.js.map

package/dist/index.esm.js

@@ -6584,27 +6584,40 @@ const QTip = () => {
         };
     }, []);
     const ttTimeout = useRef();
+    const findTooltipData = (element) => {
+        // Traverse up to 8 levels to find the tooltip data
+        for (let i = 0; i < 8 && element; i++) {
+            if (!element) {
+                return null;
+            }
+            if (element?.dataset?.qtipText) {
+                return element.dataset;
+            }
+            element = element?.parentElement;
+        }
+        return null;
+    };
     const onMouseMove = (e) => {
         clearTimeout(ttTimeout.current);
-        tooltipTarget.current = e.target;
-        let dataset = e.target?.dataset;
-        let text = dataset?.qtipText;
-        // Buttons support React.Nodes as children, the tooltip however is applied to the actual button component.
-        // we only check two levels up - alternatively the tooltip can also be provided on the React.Node
-        if (!text || text === '') {
-            let currentTooltipTarget = e.target?.parentElement;
-            dataset = currentTooltipTarget?.dataset;
-            text = dataset?.qtipText;
-            if (!text || text === '') {
-                currentTooltipTarget = e.target?.parentElement?.parentElement || null;
-                dataset = currentTooltipTarget?.dataset;
-                text = dataset?.qtipText;
-            }
-            tooltipTarget.current = currentTooltipTarget;
+        // Find tooltip data on the current or parent elements
+        const target = e.target;
+        const dataset = findTooltipData(target);
+        if (!dataset) {
+            // No tooltip data found
+            tooltipTarget.current = null;
+            return;
         }
+        tooltipTarget.current = target;
+        const text = dataset.qtipText;
         if (text) {
-            const delay = parseInt(dataset?.qtipDelay ?? DEFAULT_TOOL_TIP_DELAY + '');
-            ttTimeout.current = setTimeout(() => makeTooltip(text, dataset?.qtipPlacement, dataset?.qtipIsHtml === 'true', dataset?.qtipTestid, delay), delay);
+            const delay = parseInt(dataset.qtipDelay || `${DEFAULT_TOOL_TIP_DELAY}`, 10);
+            const placement = dataset.qtipPlacement || 'top';
+            const isHtml = dataset.qtipIsHtml === 'true';
+            const testId = dataset.qtipTestid;
+            // Debounced tooltip display
+            ttTimeout.current = setTimeout(() => {
+                makeTooltip(text, placement, isHtml, testId, delay);
+            }, delay);
         }
     };
     const makeTooltip = (tooltipText, position = 'top', isHtml, dataTestId, delay) => {