@elliemae/ds-hooks-headless-tooltip 3.37.0-rc.5

package/dist/cjs/DSHooksHeadlessTooltip.js

@@ -0,0 +1,136 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DSHooksHeadlessTooltip_exports = {};
+__export(DSHooksHeadlessTooltip_exports, {
+  useHeadlessTooltip: () => useHeadlessTooltip
+});
+module.exports = __toCommonJS(DSHooksHeadlessTooltip_exports);
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+const useGlobalKeyboardListener = (func) => {
+  import_react.default.useEffect(() => {
+    document.addEventListener("keydown", func);
+    return () => document.removeEventListener("keydown", func);
+  }, [func]);
+};
+const useControlledState = (controlledValue, defaultVal) => {
+  const [internalValue, setInternalValue] = import_react.default.useState(defaultVal ?? null);
+  const val = import_react.default.useMemo(() => {
+    if (controlledValue !== void 0) return controlledValue;
+    return internalValue;
+  }, [controlledValue, internalValue]);
+  return [val, setInternalValue];
+};
+const useHeadlessTooltip = (config) => {
+  const { hasFocus, isHovering, latestOpenInteraction, onOpen = () => {
+  }, onClose = () => {
+  } } = config ?? {};
+  const [finalHasFocus, setInternalHasFocus] = useControlledState(hasFocus, false);
+  const [finalIsHovering, setInternalIsHovering] = useControlledState(isHovering, false);
+  const [finalLatestOpenInteraction, setLatestOpenInteraction] = useControlledState(latestOpenInteraction, "");
+  const [referenceElement, setReferenceElement] = import_react.default.useState(null);
+  const [shouldShowPopover, setShouldShowPopover] = import_react.default.useState(false);
+  const showTooltip = import_react.default.useCallback(() => {
+    setShouldShowPopover(true);
+    onOpen();
+  }, [onOpen]);
+  const hideTooltip = import_react.default.useCallback(() => {
+    setShouldShowPopover(false);
+    onClose();
+  }, [onClose]);
+  const trackLatestKeyboardInteraction = import_react.default.useCallback(() => {
+    if (!shouldShowPopover) {
+      setLatestOpenInteraction("onFocus");
+    }
+  }, [setLatestOpenInteraction, shouldShowPopover]);
+  const trackLatestMouseInteraction = import_react.default.useCallback(() => {
+    if (!shouldShowPopover) {
+      setLatestOpenInteraction("onMouseEnter");
+    }
+  }, [setLatestOpenInteraction, shouldShowPopover]);
+  const onFocus = import_react.default.useCallback(() => {
+    setInternalHasFocus(true);
+    trackLatestKeyboardInteraction();
+    if (!shouldShowPopover) {
+      showTooltip();
+    }
+  }, [setInternalHasFocus, shouldShowPopover, showTooltip, trackLatestKeyboardInteraction]);
+  const onBlur = import_react.default.useCallback(() => {
+    setInternalHasFocus(false);
+    if (!finalIsHovering || finalLatestOpenInteraction === "onFocus") hideTooltip();
+  }, [setInternalHasFocus, finalIsHovering, finalLatestOpenInteraction, hideTooltip]);
+  const onMouseEnter = import_react.default.useCallback(() => {
+    setInternalIsHovering(true);
+    trackLatestMouseInteraction();
+    if (!shouldShowPopover) {
+      showTooltip();
+    }
+  }, [setInternalIsHovering, shouldShowPopover, showTooltip, trackLatestMouseInteraction]);
+  const onMouseLeave = import_react.default.useCallback(() => {
+    setInternalIsHovering(false);
+    if (!finalHasFocus || finalLatestOpenInteraction === "onMouseEnter") hideTooltip();
+  }, [setInternalIsHovering, finalHasFocus, finalLatestOpenInteraction, hideTooltip]);
+  const handleEscKey = import_react.default.useCallback(
+    ({ key }) => {
+      if (key === "Escape") hideTooltip();
+    },
+    [hideTooltip]
+  );
+  useGlobalKeyboardListener(handleEscKey);
+  return import_react.default.useMemo(
+    () => ({
+      hasFocus: finalHasFocus,
+      isHovering: finalIsHovering,
+      latestOpenInteraction: finalLatestOpenInteraction,
+      referenceElement,
+      setReferenceElement,
+      shouldShowPopover,
+      showTooltip,
+      hideTooltip,
+      onFocus,
+      onBlur,
+      onMouseEnter,
+      onMouseLeave
+    }),
+    [
+      finalHasFocus,
+      finalIsHovering,
+      finalLatestOpenInteraction,
+      referenceElement,
+      shouldShowPopover,
+      showTooltip,
+      hideTooltip,
+      onFocus,
+      onBlur,
+      onMouseEnter,
+      onMouseLeave
+    ]
+  );
+};
+//# sourceMappingURL=DSHooksHeadlessTooltip.js.map

package/dist/cjs/DSHooksHeadlessTooltip.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSHooksHeadlessTooltip.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React from 'react';\n\n// This function is a custom hook that adds a keyboard event listener to the document\n//   calls the specified function when a key is pressed.\nconst useGlobalKeyboardListener = (func: ({ key }: { key: string }) => void) => {\n  React.useEffect(() => {\n    document.addEventListener('keydown', func);\n    return () => document.removeEventListener('keydown', func);\n  }, [func]);\n};\n\nexport type LatestOpenInteraction = '' | 'onFocus' | 'onMouseEnter';\nexport type UseHeadlessTooltipConfig = {\n  hasFocus?: boolean;\n  isHovering?: boolean;\n  latestOpenInteraction?: LatestOpenInteraction;\n  onOpen?: () => void;\n  onClose?: () => void;\n};\n\nconst useControlledState = <T,>(controlledValue?: T, defaultVal?: T) => {\n  const [internalValue, setInternalValue] = React.useState<T | null>(defaultVal ?? null);\n  const val = React.useMemo(() => {\n    if (controlledValue !== undefined) return controlledValue;\n    return internalValue;\n  }, [controlledValue, internalValue]);\n  return [val, setInternalValue] as const;\n};\n\n/**\n * A custom hook that provides logic for a headless tooltip. This hook can be used in a controlled or uncontrolled way.\n * @param {UseHeadlessTooltipConfig} config - The configuration object for the hook.\n * @param {boolean} config.hasFocus - Whether or not the trigger element has focus. If this is not provided, the hook will track focus internally.\n * @param {boolean} config.isHovering - Whether or not the mouse is hovering over the trigger element. If this is not provided, the hook will track hover internally.\n * @param {LatestOpenInteraction} config.latestOpenInteraction - Whether or not the mouse is hovering over the trigger element. If this is not provided, the hook will track hover internally.\n * @param {Function} config.onOpen - A callback that will be invoked when the tooltip is opened.\n * @param {Function} config.onClose - A callback that will be invoked when the tooltip is closed.\n * @returns {object} - An object containing the following properties:\n *\n * {boolean} hasFocus - Whether or not the trigger element has focus.\n *\n * {boolean} isHovering - Whether or not the mouse is hovering over the trigger element.\n *\n * {'' | 'onFocus' | 'onMouseEnter'} latestOpenInteraction - which was the last operation that is used to control if the tooltip should show or not.\n *\n * {string} finalLatestOpenInteraction - The most recent interaction that caused the tooltip to open.\n *\n * {HTMLDivElement} referenceElement - The trigger element.\n *\n * {function} setReferenceElement - A function that sets the trigger element.\n *\n * {boolean} shouldShowPopover - Whether or not the tooltip is visible.\n *\n * {function} showTooltip - A function that opens the tooltip.\n *\n * {function} hideTooltip - A function that closes the tooltip.\n *\n * {function} onFocus - A function that should be invoked when the trigger element receives focus.\n *\n * {function} onBlur - A function that should be invoked when the trigger element loses focus.\n *\n * {function} onMouseEnter - A function that should be invoked when the mouse enters the trigger element.\n *\n * {function} onMouseLeave - A function that should be invoked when the mouse leaves the trigger element.\n * @example\n * const tooltipHelpers = useHeadlessTooltip({\n *    hasFocus: true,\n *    isHovering: false,\n *    onOpen: () => console.log('tooltip opened'),\n *    onClose: () => console.log('tooltip closed'),\n * });\n * ...\n *   <div>\n *     <button\n *        ref={tooltipHelpers.setReferenceElement}\n *        onMouseEnter={tooltipHelpers.onMouseEnter}\n *        onMouseLeave={tooltipHelpers.onMouseLeave}\n *        onPointerEnter={tooltipHelpers.onMouseEnter}\n *        onPointerLeave={tooltipHelpers.onMouseLeave}\n *        onFocus={tooltipHelpers.onFocus}\n *        onBlur={tooltipHelpers.onBlur}\n *     >hello</button>\n *     <DSPopperJS\n *       referenceElement={tooltipHelpers.referenceElement}\n *       shouldShowPopover={tooltipHelpers.shouldShowPopover}\n *     >\n *        <div>Tooltip content</div>\n *     </DSPopperJS>\n *   </div>\n */\nexport const useHeadlessTooltip = (config?: UseHeadlessTooltipConfig) => {\n  // Extract the configuration values or set default values if they are not provided.\n  const { hasFocus, isHovering, latestOpenInteraction, onOpen = () => {}, onClose = () => {} } = config ?? {};\n\n  // this pattern is basically a way to allow usage of the hook in a controlled or uncontrolled way.\n  const [finalHasFocus, setInternalHasFocus] = useControlledState<boolean>(hasFocus, false);\n  const [finalIsHovering, setInternalIsHovering] = useControlledState<boolean>(isHovering, false);\n  const [finalLatestOpenInteraction, setLatestOpenInteraction] = useControlledState<string>(latestOpenInteraction, '');\n\n  // end of controlled/uncontrolled pattern\n\n  // Set up state variables for the tooltip's visibility and the most recent interaction that caused it to open.\n  //  The most recent interaction is used to determine whether or not to close the tooltip when the user\n  //  moves the mouse away from the trigger element.\n  const [referenceElement, setReferenceElement] = React.useState<HTMLDivElement | null>(null);\n  const [shouldShowPopover, setShouldShowPopover] = React.useState<boolean>(false);\n\n  // memoized versions of the show and hide functions\n  //  those include the callbacks to allow \"controlled\" usage of the hook\n  const showTooltip = React.useCallback(() => {\n    setShouldShowPopover(true);\n    onOpen();\n  }, [onOpen]);\n\n  const hideTooltip = React.useCallback(() => {\n    setShouldShowPopover(false);\n    onClose();\n  }, [onClose]);\n\n  const trackLatestKeyboardInteraction = React.useCallback(() => {\n    if (!shouldShowPopover) {\n      setLatestOpenInteraction('onFocus');\n    }\n  }, [setLatestOpenInteraction, shouldShowPopover]);\n\n  const trackLatestMouseInteraction = React.useCallback(() => {\n    if (!shouldShowPopover) {\n      setLatestOpenInteraction('onMouseEnter');\n    }\n  }, [setLatestOpenInteraction, shouldShowPopover]);\n\n  // following here are the event handlers that are used to control the tooltip's visibility logic\n  const onFocus = React.useCallback(() => {\n    setInternalHasFocus(true); // uncontrolled usage tracking\n    trackLatestKeyboardInteraction();\n    if (!shouldShowPopover) {\n      showTooltip();\n    }\n  }, [setInternalHasFocus, shouldShowPopover, showTooltip, trackLatestKeyboardInteraction]);\n\n  const onBlur = React.useCallback(() => {\n    setInternalHasFocus(false); // uncontrolled usage tracking\n    // blur may triggered via keyboard navigation or mouse interaction\n    // every time the mouse is hovering, we want to keep the tooltip open\n    // but if the mouse is not hovering, we want to close the tooltip only if the last interaction was via keyboard\n    // e.g if the user keyboard navigates to the trigger element and then moves the mouse away, we want to keep the tooltip open\n    if (!finalIsHovering || finalLatestOpenInteraction === 'onFocus') hideTooltip();\n  }, [setInternalHasFocus, finalIsHovering, finalLatestOpenInteraction, hideTooltip]);\n\n  const onMouseEnter = React.useCallback(() => {\n    setInternalIsHovering(true); // uncontrolled usage tracking\n    // kind of debouncing the mouse enter event to reduce the avarge O() notation of the function\n    // even if this is continually invoked, it will be O(1) and controlled callbacks will be invoked only once\n    trackLatestMouseInteraction();\n    if (!shouldShowPopover) {\n      showTooltip();\n    }\n  }, [setInternalIsHovering, shouldShowPopover, showTooltip, trackLatestMouseInteraction]);\n\n  const onMouseLeave = React.useCallback(() => {\n    setInternalIsHovering(false); // uncontrolled usage tracking\n    // mouse leave may be triggered via keyboard navigation or mouse interaction\n    // every time the trigger element has focus, we want to keep the tooltip open\n    // but if the trigger element does not have focus, we want to close the tooltip only if the last interaction was via mouse\n    // e.g if the user keyboard navigates to the trigger element and then moves the mouse away, we want to keep the tooltip open\n    if (!finalHasFocus || finalLatestOpenInteraction === 'onMouseEnter') hideTooltip();\n  }, [setInternalIsHovering, finalHasFocus, finalLatestOpenInteraction, hideTooltip]);\n\n  const handleEscKey = React.useCallback(\n    ({ key }: { key: string }) => {\n      // accessibility standard: pressing escape should close the tooltip\n      if (key === 'Escape') hideTooltip();\n    },\n    [hideTooltip],\n  );\n\n  // accessibilty standard: pressing escape should close the tooltip no matter where the focus is\n  useGlobalKeyboardListener(handleEscKey);\n\n  return React.useMemo(\n    () => ({\n      hasFocus: finalHasFocus,\n      isHovering: finalIsHovering,\n      latestOpenInteraction: finalLatestOpenInteraction,\n      referenceElement,\n      setReferenceElement,\n      shouldShowPopover,\n      showTooltip,\n      hideTooltip,\n      onFocus,\n      onBlur,\n      onMouseEnter,\n      onMouseLeave,\n    }),\n    [\n      finalHasFocus,\n      finalIsHovering,\n      finalLatestOpenInteraction,\n      referenceElement,\n      shouldShowPopover,\n      showTooltip,\n      hideTooltip,\n      onFocus,\n      onBlur,\n      onMouseEnter,\n      onMouseLeave,\n    ],\n  );\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": ["React"]
+}

package/dist/cjs/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  useHeadlessTooltip: () => import_DSHooksHeadlessTooltip.useHeadlessTooltip
+});
+module.exports = __toCommonJS(src_exports);
+var React = __toESM(require("react"));
+var import_DSHooksHeadlessTooltip = require("./DSHooksHeadlessTooltip.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export {\n  type LatestOpenInteraction,\n  type UseHeadlessTooltipConfig,\n  useHeadlessTooltip,\n} from './DSHooksHeadlessTooltip.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,oCAIO;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "commonjs",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ]
+}

package/dist/esm/DSHooksHeadlessTooltip.js

@@ -0,0 +1,106 @@
+import * as React from "react";
+import React2 from "react";
+const useGlobalKeyboardListener = (func) => {
+  React2.useEffect(() => {
+    document.addEventListener("keydown", func);
+    return () => document.removeEventListener("keydown", func);
+  }, [func]);
+};
+const useControlledState = (controlledValue, defaultVal) => {
+  const [internalValue, setInternalValue] = React2.useState(defaultVal ?? null);
+  const val = React2.useMemo(() => {
+    if (controlledValue !== void 0) return controlledValue;
+    return internalValue;
+  }, [controlledValue, internalValue]);
+  return [val, setInternalValue];
+};
+const useHeadlessTooltip = (config) => {
+  const { hasFocus, isHovering, latestOpenInteraction, onOpen = () => {
+  }, onClose = () => {
+  } } = config ?? {};
+  const [finalHasFocus, setInternalHasFocus] = useControlledState(hasFocus, false);
+  const [finalIsHovering, setInternalIsHovering] = useControlledState(isHovering, false);
+  const [finalLatestOpenInteraction, setLatestOpenInteraction] = useControlledState(latestOpenInteraction, "");
+  const [referenceElement, setReferenceElement] = React2.useState(null);
+  const [shouldShowPopover, setShouldShowPopover] = React2.useState(false);
+  const showTooltip = React2.useCallback(() => {
+    setShouldShowPopover(true);
+    onOpen();
+  }, [onOpen]);
+  const hideTooltip = React2.useCallback(() => {
+    setShouldShowPopover(false);
+    onClose();
+  }, [onClose]);
+  const trackLatestKeyboardInteraction = React2.useCallback(() => {
+    if (!shouldShowPopover) {
+      setLatestOpenInteraction("onFocus");
+    }
+  }, [setLatestOpenInteraction, shouldShowPopover]);
+  const trackLatestMouseInteraction = React2.useCallback(() => {
+    if (!shouldShowPopover) {
+      setLatestOpenInteraction("onMouseEnter");
+    }
+  }, [setLatestOpenInteraction, shouldShowPopover]);
+  const onFocus = React2.useCallback(() => {
+    setInternalHasFocus(true);
+    trackLatestKeyboardInteraction();
+    if (!shouldShowPopover) {
+      showTooltip();
+    }
+  }, [setInternalHasFocus, shouldShowPopover, showTooltip, trackLatestKeyboardInteraction]);
+  const onBlur = React2.useCallback(() => {
+    setInternalHasFocus(false);
+    if (!finalIsHovering || finalLatestOpenInteraction === "onFocus") hideTooltip();
+  }, [setInternalHasFocus, finalIsHovering, finalLatestOpenInteraction, hideTooltip]);
+  const onMouseEnter = React2.useCallback(() => {
+    setInternalIsHovering(true);
+    trackLatestMouseInteraction();
+    if (!shouldShowPopover) {
+      showTooltip();
+    }
+  }, [setInternalIsHovering, shouldShowPopover, showTooltip, trackLatestMouseInteraction]);
+  const onMouseLeave = React2.useCallback(() => {
+    setInternalIsHovering(false);
+    if (!finalHasFocus || finalLatestOpenInteraction === "onMouseEnter") hideTooltip();
+  }, [setInternalIsHovering, finalHasFocus, finalLatestOpenInteraction, hideTooltip]);
+  const handleEscKey = React2.useCallback(
+    ({ key }) => {
+      if (key === "Escape") hideTooltip();
+    },
+    [hideTooltip]
+  );
+  useGlobalKeyboardListener(handleEscKey);
+  return React2.useMemo(
+    () => ({
+      hasFocus: finalHasFocus,
+      isHovering: finalIsHovering,
+      latestOpenInteraction: finalLatestOpenInteraction,
+      referenceElement,
+      setReferenceElement,
+      shouldShowPopover,
+      showTooltip,
+      hideTooltip,
+      onFocus,
+      onBlur,
+      onMouseEnter,
+      onMouseLeave
+    }),
+    [
+      finalHasFocus,
+      finalIsHovering,
+      finalLatestOpenInteraction,
+      referenceElement,
+      shouldShowPopover,
+      showTooltip,
+      hideTooltip,
+      onFocus,
+      onBlur,
+      onMouseEnter,
+      onMouseLeave
+    ]
+  );
+};
+export {
+  useHeadlessTooltip
+};
+//# sourceMappingURL=DSHooksHeadlessTooltip.js.map

package/dist/esm/DSHooksHeadlessTooltip.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/DSHooksHeadlessTooltip.tsx"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import React from 'react';\n\n// This function is a custom hook that adds a keyboard event listener to the document\n//   calls the specified function when a key is pressed.\nconst useGlobalKeyboardListener = (func: ({ key }: { key: string }) => void) => {\n  React.useEffect(() => {\n    document.addEventListener('keydown', func);\n    return () => document.removeEventListener('keydown', func);\n  }, [func]);\n};\n\nexport type LatestOpenInteraction = '' | 'onFocus' | 'onMouseEnter';\nexport type UseHeadlessTooltipConfig = {\n  hasFocus?: boolean;\n  isHovering?: boolean;\n  latestOpenInteraction?: LatestOpenInteraction;\n  onOpen?: () => void;\n  onClose?: () => void;\n};\n\nconst useControlledState = <T,>(controlledValue?: T, defaultVal?: T) => {\n  const [internalValue, setInternalValue] = React.useState<T | null>(defaultVal ?? null);\n  const val = React.useMemo(() => {\n    if (controlledValue !== undefined) return controlledValue;\n    return internalValue;\n  }, [controlledValue, internalValue]);\n  return [val, setInternalValue] as const;\n};\n\n/**\n * A custom hook that provides logic for a headless tooltip. This hook can be used in a controlled or uncontrolled way.\n * @param {UseHeadlessTooltipConfig} config - The configuration object for the hook.\n * @param {boolean} config.hasFocus - Whether or not the trigger element has focus. If this is not provided, the hook will track focus internally.\n * @param {boolean} config.isHovering - Whether or not the mouse is hovering over the trigger element. If this is not provided, the hook will track hover internally.\n * @param {LatestOpenInteraction} config.latestOpenInteraction - Whether or not the mouse is hovering over the trigger element. If this is not provided, the hook will track hover internally.\n * @param {Function} config.onOpen - A callback that will be invoked when the tooltip is opened.\n * @param {Function} config.onClose - A callback that will be invoked when the tooltip is closed.\n * @returns {object} - An object containing the following properties:\n *\n * {boolean} hasFocus - Whether or not the trigger element has focus.\n *\n * {boolean} isHovering - Whether or not the mouse is hovering over the trigger element.\n *\n * {'' | 'onFocus' | 'onMouseEnter'} latestOpenInteraction - which was the last operation that is used to control if the tooltip should show or not.\n *\n * {string} finalLatestOpenInteraction - The most recent interaction that caused the tooltip to open.\n *\n * {HTMLDivElement} referenceElement - The trigger element.\n *\n * {function} setReferenceElement - A function that sets the trigger element.\n *\n * {boolean} shouldShowPopover - Whether or not the tooltip is visible.\n *\n * {function} showTooltip - A function that opens the tooltip.\n *\n * {function} hideTooltip - A function that closes the tooltip.\n *\n * {function} onFocus - A function that should be invoked when the trigger element receives focus.\n *\n * {function} onBlur - A function that should be invoked when the trigger element loses focus.\n *\n * {function} onMouseEnter - A function that should be invoked when the mouse enters the trigger element.\n *\n * {function} onMouseLeave - A function that should be invoked when the mouse leaves the trigger element.\n * @example\n * const tooltipHelpers = useHeadlessTooltip({\n *    hasFocus: true,\n *    isHovering: false,\n *    onOpen: () => console.log('tooltip opened'),\n *    onClose: () => console.log('tooltip closed'),\n * });\n * ...\n *   <div>\n *     <button\n *        ref={tooltipHelpers.setReferenceElement}\n *        onMouseEnter={tooltipHelpers.onMouseEnter}\n *        onMouseLeave={tooltipHelpers.onMouseLeave}\n *        onPointerEnter={tooltipHelpers.onMouseEnter}\n *        onPointerLeave={tooltipHelpers.onMouseLeave}\n *        onFocus={tooltipHelpers.onFocus}\n *        onBlur={tooltipHelpers.onBlur}\n *     >hello</button>\n *     <DSPopperJS\n *       referenceElement={tooltipHelpers.referenceElement}\n *       shouldShowPopover={tooltipHelpers.shouldShowPopover}\n *     >\n *        <div>Tooltip content</div>\n *     </DSPopperJS>\n *   </div>\n */\nexport const useHeadlessTooltip = (config?: UseHeadlessTooltipConfig) => {\n  // Extract the configuration values or set default values if they are not provided.\n  const { hasFocus, isHovering, latestOpenInteraction, onOpen = () => {}, onClose = () => {} } = config ?? {};\n\n  // this pattern is basically a way to allow usage of the hook in a controlled or uncontrolled way.\n  const [finalHasFocus, setInternalHasFocus] = useControlledState<boolean>(hasFocus, false);\n  const [finalIsHovering, setInternalIsHovering] = useControlledState<boolean>(isHovering, false);\n  const [finalLatestOpenInteraction, setLatestOpenInteraction] = useControlledState<string>(latestOpenInteraction, '');\n\n  // end of controlled/uncontrolled pattern\n\n  // Set up state variables for the tooltip's visibility and the most recent interaction that caused it to open.\n  //  The most recent interaction is used to determine whether or not to close the tooltip when the user\n  //  moves the mouse away from the trigger element.\n  const [referenceElement, setReferenceElement] = React.useState<HTMLDivElement | null>(null);\n  const [shouldShowPopover, setShouldShowPopover] = React.useState<boolean>(false);\n\n  // memoized versions of the show and hide functions\n  //  those include the callbacks to allow \"controlled\" usage of the hook\n  const showTooltip = React.useCallback(() => {\n    setShouldShowPopover(true);\n    onOpen();\n  }, [onOpen]);\n\n  const hideTooltip = React.useCallback(() => {\n    setShouldShowPopover(false);\n    onClose();\n  }, [onClose]);\n\n  const trackLatestKeyboardInteraction = React.useCallback(() => {\n    if (!shouldShowPopover) {\n      setLatestOpenInteraction('onFocus');\n    }\n  }, [setLatestOpenInteraction, shouldShowPopover]);\n\n  const trackLatestMouseInteraction = React.useCallback(() => {\n    if (!shouldShowPopover) {\n      setLatestOpenInteraction('onMouseEnter');\n    }\n  }, [setLatestOpenInteraction, shouldShowPopover]);\n\n  // following here are the event handlers that are used to control the tooltip's visibility logic\n  const onFocus = React.useCallback(() => {\n    setInternalHasFocus(true); // uncontrolled usage tracking\n    trackLatestKeyboardInteraction();\n    if (!shouldShowPopover) {\n      showTooltip();\n    }\n  }, [setInternalHasFocus, shouldShowPopover, showTooltip, trackLatestKeyboardInteraction]);\n\n  const onBlur = React.useCallback(() => {\n    setInternalHasFocus(false); // uncontrolled usage tracking\n    // blur may triggered via keyboard navigation or mouse interaction\n    // every time the mouse is hovering, we want to keep the tooltip open\n    // but if the mouse is not hovering, we want to close the tooltip only if the last interaction was via keyboard\n    // e.g if the user keyboard navigates to the trigger element and then moves the mouse away, we want to keep the tooltip open\n    if (!finalIsHovering || finalLatestOpenInteraction === 'onFocus') hideTooltip();\n  }, [setInternalHasFocus, finalIsHovering, finalLatestOpenInteraction, hideTooltip]);\n\n  const onMouseEnter = React.useCallback(() => {\n    setInternalIsHovering(true); // uncontrolled usage tracking\n    // kind of debouncing the mouse enter event to reduce the avarge O() notation of the function\n    // even if this is continually invoked, it will be O(1) and controlled callbacks will be invoked only once\n    trackLatestMouseInteraction();\n    if (!shouldShowPopover) {\n      showTooltip();\n    }\n  }, [setInternalIsHovering, shouldShowPopover, showTooltip, trackLatestMouseInteraction]);\n\n  const onMouseLeave = React.useCallback(() => {\n    setInternalIsHovering(false); // uncontrolled usage tracking\n    // mouse leave may be triggered via keyboard navigation or mouse interaction\n    // every time the trigger element has focus, we want to keep the tooltip open\n    // but if the trigger element does not have focus, we want to close the tooltip only if the last interaction was via mouse\n    // e.g if the user keyboard navigates to the trigger element and then moves the mouse away, we want to keep the tooltip open\n    if (!finalHasFocus || finalLatestOpenInteraction === 'onMouseEnter') hideTooltip();\n  }, [setInternalIsHovering, finalHasFocus, finalLatestOpenInteraction, hideTooltip]);\n\n  const handleEscKey = React.useCallback(\n    ({ key }: { key: string }) => {\n      // accessibility standard: pressing escape should close the tooltip\n      if (key === 'Escape') hideTooltip();\n    },\n    [hideTooltip],\n  );\n\n  // accessibilty standard: pressing escape should close the tooltip no matter where the focus is\n  useGlobalKeyboardListener(handleEscKey);\n\n  return React.useMemo(\n    () => ({\n      hasFocus: finalHasFocus,\n      isHovering: finalIsHovering,\n      latestOpenInteraction: finalLatestOpenInteraction,\n      referenceElement,\n      setReferenceElement,\n      shouldShowPopover,\n      showTooltip,\n      hideTooltip,\n      onFocus,\n      onBlur,\n      onMouseEnter,\n      onMouseLeave,\n    }),\n    [\n      finalHasFocus,\n      finalIsHovering,\n      finalLatestOpenInteraction,\n      referenceElement,\n      shouldShowPopover,\n      showTooltip,\n      hideTooltip,\n      onFocus,\n      onBlur,\n      onMouseEnter,\n      onMouseLeave,\n    ],\n  );\n};\n"],
+  "mappings": "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",
+  "names": ["React"]
+}

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+import {
+  useHeadlessTooltip
+} from "./DSHooksHeadlessTooltip.js";
+export {
+  useHeadlessTooltip
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../src/index.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "export {\n  type LatestOpenInteraction,\n  type UseHeadlessTooltipConfig,\n  useHeadlessTooltip,\n} from './DSHooksHeadlessTooltip.js';\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB;AAAA,EAGE;AAAA,OACK;",
+  "names": []
+}

package/dist/esm/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "module",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ]
+}

package/dist/types/DSHooksHeadlessTooltip.d.ts

@@ -0,0 +1,84 @@
+import React from 'react';
+export type LatestOpenInteraction = '' | 'onFocus' | 'onMouseEnter';
+export type UseHeadlessTooltipConfig = {
+    hasFocus?: boolean;
+    isHovering?: boolean;
+    latestOpenInteraction?: LatestOpenInteraction;
+    onOpen?: () => void;
+    onClose?: () => void;
+};
+/**
+ * A custom hook that provides logic for a headless tooltip. This hook can be used in a controlled or uncontrolled way.
+ * @param {UseHeadlessTooltipConfig} config - The configuration object for the hook.
+ * @param {boolean} config.hasFocus - Whether or not the trigger element has focus. If this is not provided, the hook will track focus internally.
+ * @param {boolean} config.isHovering - Whether or not the mouse is hovering over the trigger element. If this is not provided, the hook will track hover internally.
+ * @param {LatestOpenInteraction} config.latestOpenInteraction - Whether or not the mouse is hovering over the trigger element. If this is not provided, the hook will track hover internally.
+ * @param {Function} config.onOpen - A callback that will be invoked when the tooltip is opened.
+ * @param {Function} config.onClose - A callback that will be invoked when the tooltip is closed.
+ * @returns {object} - An object containing the following properties:
+ *
+ * {boolean} hasFocus - Whether or not the trigger element has focus.
+ *
+ * {boolean} isHovering - Whether or not the mouse is hovering over the trigger element.
+ *
+ * {'' | 'onFocus' | 'onMouseEnter'} latestOpenInteraction - which was the last operation that is used to control if the tooltip should show or not.
+ *
+ * {string} finalLatestOpenInteraction - The most recent interaction that caused the tooltip to open.
+ *
+ * {HTMLDivElement} referenceElement - The trigger element.
+ *
+ * {function} setReferenceElement - A function that sets the trigger element.
+ *
+ * {boolean} shouldShowPopover - Whether or not the tooltip is visible.
+ *
+ * {function} showTooltip - A function that opens the tooltip.
+ *
+ * {function} hideTooltip - A function that closes the tooltip.
+ *
+ * {function} onFocus - A function that should be invoked when the trigger element receives focus.
+ *
+ * {function} onBlur - A function that should be invoked when the trigger element loses focus.
+ *
+ * {function} onMouseEnter - A function that should be invoked when the mouse enters the trigger element.
+ *
+ * {function} onMouseLeave - A function that should be invoked when the mouse leaves the trigger element.
+ * @example
+ * const tooltipHelpers = useHeadlessTooltip({
+ *    hasFocus: true,
+ *    isHovering: false,
+ *    onOpen: () => console.log('tooltip opened'),
+ *    onClose: () => console.log('tooltip closed'),
+ * });
+ * ...
+ *   <div>
+ *     <button
+ *        ref={tooltipHelpers.setReferenceElement}
+ *        onMouseEnter={tooltipHelpers.onMouseEnter}
+ *        onMouseLeave={tooltipHelpers.onMouseLeave}
+ *        onPointerEnter={tooltipHelpers.onMouseEnter}
+ *        onPointerLeave={tooltipHelpers.onMouseLeave}
+ *        onFocus={tooltipHelpers.onFocus}
+ *        onBlur={tooltipHelpers.onBlur}
+ *     >hello</button>
+ *     <DSPopperJS
+ *       referenceElement={tooltipHelpers.referenceElement}
+ *       shouldShowPopover={tooltipHelpers.shouldShowPopover}
+ *     >
+ *        <div>Tooltip content</div>
+ *     </DSPopperJS>
+ *   </div>
+ */
+export declare const useHeadlessTooltip: (config?: UseHeadlessTooltipConfig) => {
+    hasFocus: boolean | null;
+    isHovering: boolean | null;
+    latestOpenInteraction: string | null;
+    referenceElement: HTMLDivElement | null;
+    setReferenceElement: React.Dispatch<React.SetStateAction<HTMLDivElement | null>>;
+    shouldShowPopover: boolean;
+    showTooltip: () => void;
+    hideTooltip: () => void;
+    onFocus: () => void;
+    onBlur: () => void;
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+};

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { type LatestOpenInteraction, type UseHeadlessTooltipConfig, useHeadlessTooltip, } from './DSHooksHeadlessTooltip.js';

package/dist/types/tests/useHeadlessTooltip.func.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/useHeadlessTooltip.render.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@elliemae/ds-hooks-headless-tooltip",
+  "version": "3.37.0-rc.5",
+  "license": "MIT",
+  "description": "ICE MT - Dimsum - Headless tooltip Hook",
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/esm/index.js",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://git.elliemae.io/platform-ui/dimsum.git"
+  },
+  "engines": {
+    "pnpm": ">=6",
+    "node": ">=16"
+  },
+  "author": "ICE MT",
+  "jestSonar": {
+    "sonar56x": true,
+    "reportPath": "reports",
+    "reportFile": "tests.xml",
+    "indent": 4
+  },
+  "devDependencies": {
+    "@elliemae/pui-cli": "~9.0.0-next.31",
+    "@elliemae/ds-monorepo-devops": "3.37.0-rc.5"
+  },
+  "peerDependencies": {
+    "lodash": "^4.17.21",
+    "react": "~17.0.2",
+    "react-dom": "^17.0.2",
+    "styled-components": "~5.3.9",
+    "styled-system": "^5.1.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "typeSafety": false
+  },
+  "scripts": {
+    "dev": "cross-env NODE_ENV=development node ../../../scripts/build/build.mjs --watch",
+    "test": "pui-cli test --passWithNoTests --coverage=\"false\"",
+    "lint": "node ../../../scripts/lint.mjs --fix",
+    "dts": "node ../../../scripts/dts.mjs",
+    "build": "cross-env NODE_ENV=production node ../../../scripts/build/build.mjs",
+    "checkDeps": "npm exec ../../util/ds-codemods -- check-missing-packages --projectFolderPath=\"./\" --ignorePackagesGlobPattern=\"\" --ignoreFilesGlobPattern=\"**/test-ables/*,**/tests/*\""
+  }
+}