@cypress-design/react-tooltip 0.6.2 → 0.7.0

package/dist/index.umd.js

@@ -60,6 +60,16 @@ function __rest(s, e) {
                 t[p[i]] = s[p[i]];
         }
     return t;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 }
 
 function getSide(placement) {
@@ -650,6 +660,88 @@ const offset = function (value) {
   };
 };
 
+function getCrossAxis(axis) {
+  return axis === 'x' ? 'y' : 'x';
+}
+
+/**
+ * Shifts the floating element in order to keep it in view when it will overflow
+ * a clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+const shift = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return {
+    name: 'shift',
+    options,
+
+    async fn(middlewareArguments) {
+      const {
+        x,
+        y,
+        placement
+      } = middlewareArguments;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: _ref => {
+            let {
+              x,
+              y
+            } = _ref;
+            return {
+              x,
+              y
+            };
+          }
+        },
+        ...detectOverflowOptions
+      } = options;
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+      const mainAxis = getMainAxisFromPlacement(getSide(placement));
+      const crossAxis = getCrossAxis(mainAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+
+      if (checkMainAxis) {
+        const minSide = mainAxis === 'y' ? 'top' : 'left';
+        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
+        const min = mainAxisCoord + overflow[minSide];
+        const max = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = within(min, mainAxisCoord, max);
+      }
+
+      if (checkCrossAxis) {
+        const minSide = crossAxis === 'y' ? 'top' : 'left';
+        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
+        const min = crossAxisCoord + overflow[minSide];
+        const max = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = within(min, crossAxisCoord, max);
+      }
+
+      const limitedCoords = limiter.fn({ ...middlewareArguments,
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      });
+      return { ...limitedCoords,
+        data: {
+          x: limitedCoords.x - x,
+          y: limitedCoords.y - y
+        }
+      };
+    }
+
+  };
+};
+
 function isWindow(value) {
   return value && value.document && value.location && value.alert && value.setInterval;
 }
@@ -33455,21 +33547,15 @@ var ROTATE_MAP = {
 };
 var Tooltip = function (_a) {
     var _b;
-    var placement = _a.placement, _c = _a.color, color = _c === void 0 ? 'light' : _c, className = _a.className, children = _a.children, popper = _a.popper, disabled = _a.disabled, interactive = _a.interactive, forcePlacement = _a.forcePlacement, rest = __rest(_a, ["placement", "color", "className", "children", "popper", "disabled", "interactive", "forcePlacement"]);
+    var placement = _a.placement, _c = _a.color, color = _c === void 0 ? 'light' : _c, className = _a.className, children = _a.children, popper = _a.popper, disabled = _a.disabled, interactive = _a.interactive, forcePlacement = _a.forcePlacement, _d = _a.forceOpen, forceOpen = _d === void 0 ? false : _d, rest = __rest(_a, ["placement", "color", "className", "children", "popper", "disabled", "interactive", "forcePlacement", "forceOpen"]);
     var arrowRef = React__namespace.useRef(null);
-    var _d = React__namespace.useState(false), open = _d[0], setOpen = _d[1];
-    var container = React__namespace.useState(function () {
-        // This will be executed only on the initial render
-        // https://reactjs.org/docs/hooks-reference.html#lazy-initial-state
-        return document.createElement('div');
-    })[0];
+    var _e = React__namespace.useState(false), open = _e[0], setOpen = _e[1];
     React__namespace.useEffect(function () {
-        document.body.appendChild(container);
-        return function () {
-            document.body.removeChild(container);
-        };
-    }, []);
-    var _e = useFloating({
+        if (forceOpen) {
+            setOpen(true);
+        }
+    }, [forceOpen]);
+    var _f = useFloating({
         placement: placement,
         open: open,
         onOpenChange: setOpen,
@@ -33482,20 +33568,20 @@ var Tooltip = function (_a) {
                 : flip(),
             offset(interactive ? 0 : 16),
             arrow({ element: arrowRef, padding: 24 }),
+            shift({ padding: 16 }),
         ],
         whileElementsMounted: autoUpdate,
-    }), x = _e.x, y = _e.y, reference = _e.reference, floating = _e.floating, strategy = _e.strategy, calculatedPlacement = _e.placement, context = _e.context, _f = _e.middlewareData.arrow, _g = _f === void 0 ? {} : _f, arrowX = _g.x, arrowY = _g.y;
-    var _h = useInteractions([
+    }), x = _f.x, y = _f.y, reference = _f.reference, floating = _f.floating, strategy = _f.strategy, calculatedPlacement = _f.placement, context = _f.context, _g = _f.middlewareData.arrow, _h = _g === void 0 ? {} : _g, arrowX = _h.x, arrowY = _h.y;
+    var _j = useInteractions(__spreadArray([
         useHover(context, {
             handleClose: interactive ? safePolygon() : undefined,
-            enabled: !disabled,
+            enabled: !disabled && !forceOpen,
         }),
         useFocus(context, {
-            enabled: !disabled,
+            enabled: !disabled && !forceOpen,
         }),
-        useRole(context, { role: 'tooltip' }),
-        useDismiss(context),
-    ]), getReferenceProps = _h.getReferenceProps, getFloatingProps = _h.getFloatingProps;
+        useRole(context, { role: 'tooltip' })
+    ], (!forceOpen ? [useDismiss(context)] : []), true)), getReferenceProps = _j.getReferenceProps, getFloatingProps = _j.getFloatingProps;
     var placementSide = calculatedPlacement.split('-')[0];
     var arrowRotate = ROTATE_MAP[placementSide];
     var arrowXRule = 'left', arrowYRule = 'top';
@@ -33558,4 +33644,4 @@ var Tooltip = function (_a) {
 module.exports = Tooltip;
 //# sourceMappingURL=index.umd.js.map
 
-/* <wind-keep class="container stroke-none fill-white block text-gray-900 shadow-gray-100 border-transparent bg-white fill-gray-900 text-white shadow-gray-800 bg-gray-900 rounded shadow border invisible absolute z-10 transform filter text-[16px] leading-[24px] min-w-[160px] text-center p-[8px] relative z-20 drop-shadow"> */
+/* <wind-keep class="stroke-none fill-white block text-gray-900 shadow-gray-100 border-transparent bg-white fill-gray-900 text-white shadow-gray-800 bg-gray-900 rounded shadow border invisible absolute z-10 transform filter text-[16px] leading-[24px] min-w-[160px] text-center p-[8px] relative z-20 drop-shadow"> */