@artsy/palette 45.13.1 → 45.14.0-canary.1497.33065.0

package/dist/esm/utils/useInterval.js

@@ -0,0 +1,26 @@
+import { useEffect, useRef } from "react";
+
+/** useInterval */
+export function useInterval(callback, delay) {
+  var savedCallback = useRef(null);
+
+  // Remember the latest callback.
+  useEffect(function () {
+    savedCallback.current = callback;
+  }, [callback]);
+
+  // Set up the interval.
+  useEffect(function () {
+    function tick() {
+      ;
+      savedCallback.current();
+    }
+    if (delay !== null) {
+      var id = setInterval(tick, delay);
+      return function () {
+        return clearInterval(id);
+      };
+    }
+  }, [delay]);
+}
+//# sourceMappingURL=useInterval.js.map

package/dist/esm/utils/useInterval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInterval.js","names":["useEffect","useRef","useInterval","callback","delay","savedCallback","current","tick","id","setInterval","clearInterval"],"sources":["../../../src/utils/useInterval.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\"\n\n/** useInterval */\nexport function useInterval(callback, delay) {\n  const savedCallback = useRef(null)\n\n  // Remember the latest callback.\n  useEffect(() => {\n    savedCallback.current = callback\n  }, [callback])\n\n  // Set up the interval.\n  useEffect(() => {\n    function tick() {\n      ;(savedCallback as any).current()\n    }\n    if (delay !== null) {\n      const id = setInterval(tick, delay)\n      return () => clearInterval(id)\n    }\n  }, [delay])\n}\n"],"mappings":"AAAA,SAASA,SAAS,EAAEC,MAAM,QAAQ,OAAO;;AAEzC;AACA,OAAO,SAASC,WAAWA,CAACC,QAAQ,EAAEC,KAAK,EAAE;EAC3C,IAAMC,aAAa,GAAGJ,MAAM,CAAC,IAAI,CAAC;;EAElC;EACAD,SAAS,CAAC,YAAM;IACdK,aAAa,CAACC,OAAO,GAAGH,QAAQ;EAClC,CAAC,EAAE,CAACA,QAAQ,CAAC,CAAC;;EAEd;EACAH,SAAS,CAAC,YAAM;IACd,SAASO,IAAIA,CAAA,EAAG;MACd;MAAEF,aAAa,CAASC,OAAO,EAAE;IACnC;IACA,IAAIF,KAAK,KAAK,IAAI,EAAE;MAClB,IAAMI,EAAE,GAAGC,WAAW,CAACF,IAAI,EAAEH,KAAK,CAAC;MACnC,OAAO;QAAA,OAAMM,aAAa,CAACF,EAAE,CAAC;MAAA;IAChC;EACF,CAAC,EAAE,CAACJ,KAAK,CAAC,CAAC;AACb"}

package/dist/esm/utils/useIsomorphicLayoutEffect.js

@@ -0,0 +1,7 @@
+import { useEffect, useLayoutEffect } from "react";
+
+/**
+ * Silences the "useLayoutEffect does nothing on the server" warning
+ */
+export var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+//# sourceMappingURL=useIsomorphicLayoutEffect.js.map

package/dist/esm/utils/useIsomorphicLayoutEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsomorphicLayoutEffect.js","names":["useEffect","useLayoutEffect","useIsomorphicLayoutEffect","window"],"sources":["../../../src/utils/useIsomorphicLayoutEffect.ts"],"sourcesContent":["import { useEffect, useLayoutEffect } from \"react\"\n\n/**\n * Silences the \"useLayoutEffect does nothing on the server\" warning\n */\nexport const useIsomorphicLayoutEffect =\n  typeof window !== \"undefined\" ? useLayoutEffect : useEffect\n"],"mappings":"AAAA,SAASA,SAAS,EAAEC,eAAe,QAAQ,OAAO;;AAElD;AACA;AACA;AACA,OAAO,IAAMC,yBAAyB,GACpC,OAAOC,MAAM,KAAK,WAAW,GAAGF,eAAe,GAAGD,SAAS"}

package/dist/esm/utils/useLatest.js

@@ -0,0 +1,9 @@
+import { useEffect, useRef } from "react";
+export var useLatest = function useLatest(current) {
+  var latest = useRef(current);
+  useEffect(function () {
+    latest.current = current;
+  });
+  return latest;
+};
+//# sourceMappingURL=useLatest.js.map

package/dist/esm/utils/useLatest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLatest.js","names":["useEffect","useRef","useLatest","current","latest"],"sources":["../../../src/utils/useLatest.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\"\n\nexport const useLatest = <T extends any>(current: T) => {\n  const latest = useRef(current)\n\n  useEffect(() => {\n    latest.current = current\n  })\n\n  return latest\n}\n"],"mappings":"AAAA,SAASA,SAAS,EAAEC,MAAM,QAAQ,OAAO;AAEzC,OAAO,IAAMC,SAAS,GAAG,SAAZA,SAASA,CAAmBC,OAAU,EAAK;EACtD,IAAMC,MAAM,GAAGH,MAAM,CAACE,OAAO,CAAC;EAE9BH,SAAS,CAAC,YAAM;IACdI,MAAM,CAACD,OAAO,GAAGA,OAAO;EAC1B,CAAC,CAAC;EAEF,OAAOC,MAAM;AACf,CAAC"}

package/dist/esm/utils/useMouseActivity.js

@@ -0,0 +1,22 @@
+import { useEffect, useRef } from "react";
+export var useMouseActivity = function useMouseActivity() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      active: true
+    },
+    active = _ref.active;
+  var lastMouseMoveTimestamp = useRef(0);
+  useEffect(function () {
+    if (!active) return;
+    var handleMouseMove = function handleMouseMove() {
+      lastMouseMoveTimestamp.current = performance.now();
+    };
+    window.addEventListener("mousemove", handleMouseMove);
+    return function () {
+      window.removeEventListener("mousemove", handleMouseMove);
+    };
+  }, [active]);
+  return {
+    lastMouseMoveTimestamp: lastMouseMoveTimestamp
+  };
+};
+//# sourceMappingURL=useMouseActivity.js.map

package/dist/esm/utils/useMouseActivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMouseActivity.js","names":["useEffect","useRef","useMouseActivity","_ref","arguments","length","undefined","active","lastMouseMoveTimestamp","handleMouseMove","current","performance","now","window","addEventListener","removeEventListener"],"sources":["../../../src/utils/useMouseActivity.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\"\n\ninterface UseMouseActivityProps {\n  /** Optionally disable for performance (default: `true`) */\n  active?: boolean\n}\n\nexport const useMouseActivity = (\n  { active }: UseMouseActivityProps = { active: true }\n) => {\n  const lastMouseMoveTimestamp = useRef<number>(0)\n\n  useEffect(() => {\n    if (!active) return\n\n    const handleMouseMove = () => {\n      lastMouseMoveTimestamp.current = performance.now()\n    }\n\n    window.addEventListener(\"mousemove\", handleMouseMove)\n\n    return () => {\n      window.removeEventListener(\"mousemove\", handleMouseMove)\n    }\n  }, [active])\n\n  return { lastMouseMoveTimestamp }\n}\n"],"mappings":"AAAA,SAASA,SAAS,EAAEC,MAAM,QAAQ,OAAO;AAOzC,OAAO,IAAMC,gBAAgB,GAAG,SAAnBA,gBAAgBA,CAAA,EAExB;EAAA,IAAAC,IAAA,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MADiC;MAAEG,MAAM,EAAE;IAAK,CAAC;IAAlDA,MAAM,GAAAJ,IAAA,CAANI,MAAM;EAER,IAAMC,sBAAsB,GAAGP,MAAM,CAAS,CAAC,CAAC;EAEhDD,SAAS,CAAC,YAAM;IACd,IAAI,CAACO,MAAM,EAAE;IAEb,IAAME,eAAe,GAAG,SAAlBA,eAAeA,CAAA,EAAS;MAC5BD,sBAAsB,CAACE,OAAO,GAAGC,WAAW,CAACC,GAAG,EAAE;IACpD,CAAC;IAEDC,MAAM,CAACC,gBAAgB,CAAC,WAAW,EAAEL,eAAe,CAAC;IAErD,OAAO,YAAM;MACXI,MAAM,CAACE,mBAAmB,CAAC,WAAW,EAAEN,eAAe,CAAC;IAC1D,CAAC;EACH,CAAC,EAAE,CAACF,MAAM,CAAC,CAAC;EAEZ,OAAO;IAAEC,sBAAsB,EAAtBA;EAAuB,CAAC;AACnC,CAAC"}

package/dist/esm/utils/useMutationObserver.js

@@ -0,0 +1,37 @@
+var _excluded = ["active", "onMutate", "options"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import { useEffect } from "react";
+/**
+ * Accepts a ref and calls the `onMutate` callback when mutations are observed.
+ */
+export var useMutationObserver = function useMutationObserver(_ref) {
+  var _ref$active = _ref.active,
+    active = _ref$active === void 0 ? true : _ref$active,
+    onMutate = _ref.onMutate,
+    _ref$options = _ref.options,
+    options = _ref$options === void 0 ? {
+      attributes: true,
+      characterData: true,
+      childList: true,
+      subtree: true
+    } : _ref$options,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  useEffect(function () {
+    if (!active || typeof MutationObserver === "undefined") {
+      return;
+    }
+    var el = "ref" in rest ? rest.ref.current : rest.element;
+    if (el) {
+      var observer = new MutationObserver(onMutate);
+
+      // Start observing the target node for configured mutations
+      observer.observe(el, options);
+      return function () {
+        observer.disconnect();
+      };
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [onMutate, options, active]);
+};
+//# sourceMappingURL=useMutationObserver.js.map

package/dist/esm/utils/useMutationObserver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMutationObserver.js","names":["useEffect","useMutationObserver","_ref","_ref$active","active","onMutate","_ref$options","options","attributes","characterData","childList","subtree","rest","_objectWithoutProperties","_excluded","MutationObserver","el","ref","current","element","observer","observe","disconnect"],"sources":["../../../src/utils/useMutationObserver.ts"],"sourcesContent":["import type { MutableRefObject } from \"react\"\nimport { useEffect } from \"react\"\n\ntype UseMutationObserver = {\n  active?: boolean\n  onMutate: MutationCallback\n  options?: MutationObserverInit\n} & (\n  | { ref: MutableRefObject<HTMLElement | null> }\n  | { element?: HTMLElement | null }\n)\n\n/**\n * Accepts a ref and calls the `onMutate` callback when mutations are observed.\n */\nexport const useMutationObserver = ({\n  active = true,\n  onMutate,\n  options = {\n    attributes: true,\n    characterData: true,\n    childList: true,\n    subtree: true,\n  },\n  ...rest\n}: UseMutationObserver) => {\n  useEffect(() => {\n    if (!active || typeof MutationObserver === \"undefined\") {\n      return\n    }\n\n    const el = \"ref\" in rest ? rest.ref.current : rest.element\n\n    if (el) {\n      const observer = new MutationObserver(onMutate)\n\n      // Start observing the target node for configured mutations\n      observer.observe(el, options)\n\n      return () => {\n        observer.disconnect()\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [onMutate, options, active])\n}\n"],"mappings":";;;AACA,SAASA,SAAS,QAAQ,OAAO;AAWjC;AACA;AACA;AACA,OAAO,IAAMC,mBAAmB,GAAG,SAAtBA,mBAAmBA,CAAAC,IAAA,EAUL;EAAA,IAAAC,WAAA,GAAAD,IAAA,CATzBE,MAAM;IAANA,MAAM,GAAAD,WAAA,cAAG,IAAI,GAAAA,WAAA;IACbE,QAAQ,GAAAH,IAAA,CAARG,QAAQ;IAAAC,YAAA,GAAAJ,IAAA,CACRK,OAAO;IAAPA,OAAO,GAAAD,YAAA,cAAG;MACRE,UAAU,EAAE,IAAI;MAChBC,aAAa,EAAE,IAAI;MACnBC,SAAS,EAAE,IAAI;MACfC,OAAO,EAAE;IACX,CAAC,GAAAL,YAAA;IACEM,IAAI,GAAAC,wBAAA,CAAAX,IAAA,EAAAY,SAAA;EAEPd,SAAS,CAAC,YAAM;IACd,IAAI,CAACI,MAAM,IAAI,OAAOW,gBAAgB,KAAK,WAAW,EAAE;MACtD;IACF;IAEA,IAAMC,EAAE,GAAG,KAAK,IAAIJ,IAAI,GAAGA,IAAI,CAACK,GAAG,CAACC,OAAO,GAAGN,IAAI,CAACO,OAAO;IAE1D,IAAIH,EAAE,EAAE;MACN,IAAMI,QAAQ,GAAG,IAAIL,gBAAgB,CAACV,QAAQ,CAAC;;MAE/C;MACAe,QAAQ,CAACC,OAAO,CAACL,EAAE,EAAET,OAAO,CAAC;MAE7B,OAAO,YAAM;QACXa,QAAQ,CAACE,UAAU,EAAE;MACvB,CAAC;IACH;IACA;EACF,CAAC,EAAE,CAACjB,QAAQ,EAAEE,OAAO,EAAEH,MAAM,CAAC,CAAC;AACjC,CAAC"}

package/dist/esm/utils/usePortal.js

@@ -0,0 +1,33 @@
+import { useEffect, useRef, useCallback } from "react";
+import { createPortal as __createPortal__ } from "react-dom";
+import { useDidMount } from "./useDidMount";
+export var usePortal = function usePortal() {
+  var isClient = useDidMount();
+  var appendEl = useRef(null);
+  useEffect(function () {
+    var _appendEl$current;
+    var el = (_appendEl$current = appendEl.current) !== null && _appendEl$current !== void 0 ? _appendEl$current : document.createElement("div");
+    appendEl.current = el;
+    document.body.appendChild(el);
+    return function () {
+      try {
+        document.body.removeChild(el);
+      } catch (e) {
+        // Ignore
+      }
+    };
+  }, []);
+  var createPortal = useCallback(function (children) {
+    var _appendEl$current2;
+    if (!isClient) return null;
+
+    // May execute before effect runs and appendEl is set
+    var el = (_appendEl$current2 = appendEl.current) !== null && _appendEl$current2 !== void 0 ? _appendEl$current2 : document.createElement("div");
+    appendEl.current = el;
+    return /*#__PURE__*/__createPortal__(children, el);
+  }, [isClient]);
+  return {
+    createPortal: createPortal
+  };
+};
+//# sourceMappingURL=usePortal.js.map

package/dist/esm/utils/usePortal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePortal.js","names":["useEffect","useRef","useCallback","createPortal","__createPortal__","useDidMount","usePortal","isClient","appendEl","_appendEl$current","el","current","document","createElement","body","appendChild","removeChild","e","children","_appendEl$current2"],"sources":["../../../src/utils/usePortal.ts"],"sourcesContent":["import React, { useEffect, useRef, useCallback } from \"react\"\nimport { createPortal as __createPortal__ } from \"react-dom\"\nimport { useDidMount } from \"./useDidMount\"\n\nexport const usePortal = () => {\n  const isClient = useDidMount()\n\n  const appendEl = useRef<HTMLDivElement | null>(null)\n\n  useEffect(() => {\n    const el = appendEl.current ?? document.createElement(\"div\")\n    appendEl.current = el\n\n    document.body.appendChild(el)\n\n    return () => {\n      try {\n        document.body.removeChild(el)\n      } catch (e) {\n        // Ignore\n      }\n    }\n  }, [])\n\n  const createPortal = useCallback(\n    (children: React.ReactNode): React.ReactPortal | null => {\n      if (!isClient) return null\n\n      // May execute before effect runs and appendEl is set\n      const el = appendEl.current ?? document.createElement(\"div\")\n      appendEl.current = el\n\n      return __createPortal__(children, el)\n    },\n    [isClient]\n  )\n\n  return { createPortal }\n}\n"],"mappings":"AAAA,SAAgBA,SAAS,EAAEC,MAAM,EAAEC,WAAW,QAAQ,OAAO;AAC7D,SAASC,YAAY,IAAIC,gBAAgB,QAAQ,WAAW;AAC5D,SAASC,WAAW;AAEpB,OAAO,IAAMC,SAAS,GAAG,SAAZA,SAASA,CAAA,EAAS;EAC7B,IAAMC,QAAQ,GAAGF,WAAW,EAAE;EAE9B,IAAMG,QAAQ,GAAGP,MAAM,CAAwB,IAAI,CAAC;EAEpDD,SAAS,CAAC,YAAM;IAAA,IAAAS,iBAAA;IACd,IAAMC,EAAE,IAAAD,iBAAA,GAAGD,QAAQ,CAACG,OAAO,cAAAF,iBAAA,cAAAA,iBAAA,GAAIG,QAAQ,CAACC,aAAa,CAAC,KAAK,CAAC;IAC5DL,QAAQ,CAACG,OAAO,GAAGD,EAAE;IAErBE,QAAQ,CAACE,IAAI,CAACC,WAAW,CAACL,EAAE,CAAC;IAE7B,OAAO,YAAM;MACX,IAAI;QACFE,QAAQ,CAACE,IAAI,CAACE,WAAW,CAACN,EAAE,CAAC;MAC/B,CAAC,CAAC,OAAOO,CAAC,EAAE;QACV;MAAA;IAEJ,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,IAAMd,YAAY,GAAGD,WAAW,CAC9B,UAACgB,QAAyB,EAA+B;IAAA,IAAAC,kBAAA;IACvD,IAAI,CAACZ,QAAQ,EAAE,OAAO,IAAI;;IAE1B;IACA,IAAMG,EAAE,IAAAS,kBAAA,GAAGX,QAAQ,CAACG,OAAO,cAAAQ,kBAAA,cAAAA,kBAAA,GAAIP,QAAQ,CAACC,aAAa,CAAC,KAAK,CAAC;IAC5DL,QAAQ,CAACG,OAAO,GAAGD,EAAE;IAErB,oBAAON,gBAAgB,CAACc,QAAQ,EAAER,EAAE,CAAC;EACvC,CAAC,EACD,CAACH,QAAQ,CAAC,CACX;EAED,OAAO;IAAEJ,YAAY,EAAZA;EAAa,CAAC;AACzB,CAAC"}

package/dist/esm/utils/usePosition.js

@@ -0,0 +1,428 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+/**
+ * Adapted from https://codesandbox.io/s/positioning-tooltip-rhplo
+ */
+import { useState } from "react";
+import { useRef } from "react";
+import { useMutationObserver } from "./useMutationObserver";
+import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect";
+import { useResizeObserver } from "./useResizeObserver";
+export var POSITION = {
+  "top-start": "top-start",
+  top: "top",
+  "top-end": "top-end",
+  "bottom-start": "bottom-start",
+  bottom: "bottom",
+  "bottom-end": "bottom-end",
+  "left-start": "left-start",
+  left: "left",
+  "left-end": "left-end",
+  "right-start": "right-start",
+  right: "right",
+  "right-end": "right-end"
+};
+/**
+ * Will position the floating element (tooltip) relative to the anchor element,
+ * using `position: fixed` and in such a way that it shouldn't ever appear
+ * partially offscreen and will move correctly when the parent is scrolled.
+ */
+export var usePosition = function usePosition(_ref) {
+  var key = _ref.key,
+    position = _ref.position,
+    _ref$offset = _ref.offset,
+    offset = _ref$offset === void 0 ? 0 : _ref$offset,
+    _ref$active = _ref.active,
+    active = _ref$active === void 0 ? true : _ref$active,
+    _ref$flip = _ref.flip,
+    flip = _ref$flip === void 0 ? true : _ref$flip,
+    _ref$clamp = _ref.clamp,
+    clamp = _ref$clamp === void 0 ? true : _ref$clamp,
+    _ref$padding = _ref.padding,
+    padding = _ref$padding === void 0 ? 0 : _ref$padding;
+  var _useState = useState({
+      isFlipped: false
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    state = _useState2[0],
+    setState = _useState2[1];
+  var tooltipRef = useRef(null);
+  var anchorRef = useRef(null);
+  var update = function update() {
+    if (!active || !tooltipRef.current || !anchorRef.current) return;
+    var tooltip = tooltipRef.current;
+    var anchor = anchorRef.current;
+    requestAnimationFrame(function () {
+      setState(placeTooltip({
+        anchor: anchor,
+        tooltip: tooltip,
+        position: position,
+        offset: offset,
+        flip: flip,
+        clamp: clamp,
+        padding: padding
+      }));
+    });
+  };
+
+  // Re-position when there's any change to the tooltip
+  useMutationObserver({
+    ref: tooltipRef,
+    onMutate: update,
+    active: active
+  });
+
+  // Re-position when there's any change to the anchor's size
+  useResizeObserver({
+    target: anchorRef,
+    onResize: update,
+    active: active
+  });
+
+  // Listen to changes on key
+  useIsomorphicLayoutEffect(update, [key]);
+  useIsomorphicLayoutEffect(function () {
+    if (!active || !tooltipRef.current || !anchorRef.current) return;
+    var tooltip = tooltipRef.current;
+    var anchor = anchorRef.current;
+    tooltip.style.position = "fixed";
+    tooltip.style.top = "0";
+    tooltip.style.left = "0";
+    var handleScroll = function handleScroll() {
+      requestAnimationFrame(function () {
+        setState(placeTooltip({
+          anchor: anchor,
+          tooltip: tooltip,
+          position: position,
+          offset: offset,
+          flip: flip,
+          clamp: clamp,
+          padding: padding
+        }));
+      });
+    };
+    document.addEventListener("scroll", handleScroll, {
+      passive: true
+    });
+    var handleResize = function handleResize() {
+      requestAnimationFrame(function () {
+        setState(placeTooltip({
+          anchor: anchor,
+          tooltip: tooltip,
+          position: position,
+          offset: offset,
+          flip: flip,
+          clamp: clamp,
+          padding: padding
+        }));
+      });
+    };
+    window.addEventListener("resize", handleResize, {
+      passive: true
+    });
+    requestAnimationFrame(function () {
+      setState(placeTooltip({
+        anchor: anchor,
+        tooltip: tooltip,
+        position: position,
+        offset: offset,
+        flip: flip,
+        clamp: clamp,
+        padding: padding
+      }));
+    });
+    return function () {
+      document.removeEventListener("scroll", handleScroll);
+      window.removeEventListener("resize", handleResize);
+    };
+  }, [active, tooltipRef, anchorRef, position]);
+  return {
+    // Element that floating element is anchored to
+    tooltipRef: tooltipRef,
+    // Element you want to position relative to the anchor
+    anchorRef: anchorRef,
+    state: state
+  };
+};
+export var placeTooltip = function placeTooltip(_ref2) {
+  var anchor = _ref2.anchor,
+    tooltip = _ref2.tooltip,
+    position = _ref2.position,
+    _ref2$offset = _ref2.offset,
+    offset = _ref2$offset === void 0 ? 0 : _ref2$offset,
+    _ref2$boundaryRect = _ref2.boundaryRect,
+    boundaryRect = _ref2$boundaryRect === void 0 ? getDocumentBoundingRect() : _ref2$boundaryRect,
+    _ref2$flip = _ref2.flip,
+    flip = _ref2$flip === void 0 ? true : _ref2$flip,
+    _ref2$clamp = _ref2.clamp,
+    clamp = _ref2$clamp === void 0 ? true : _ref2$clamp,
+    _ref2$padding = _ref2.padding,
+    padding = _ref2$padding === void 0 ? 0 : _ref2$padding;
+  var elementRect = anchor.getBoundingClientRect();
+  var tooltipRect = tooltip.getBoundingClientRect();
+  var targetPosition = getPosition({
+    elementRect: elementRect,
+    tooltipRect: tooltipRect,
+    position: position
+  });
+
+  // Flip to avoid edges
+  var isFlipped = flip && shouldFlip({
+    targetPosition: targetPosition,
+    position: position,
+    boundaryRect: boundaryRect,
+    tooltipRect: tooltipRect
+  });
+  if (isFlipped) {
+    position = getOppositePosition(position);
+    targetPosition = getPosition({
+      elementRect: elementRect,
+      tooltipRect: tooltipRect,
+      position: position
+    });
+  }
+
+  // Clamp position within boundary
+  if (clamp) {
+    targetPosition.x = Math.max(boundaryRect.left, targetPosition.x);
+    targetPosition.x = Math.min(boundaryRect.right - tooltipRect.width, targetPosition.x);
+    targetPosition.y = Math.max(boundaryRect.top, targetPosition.y);
+    targetPosition.y = Math.min(boundaryRect.bottom - tooltipRect.height, targetPosition.y);
+
+    // Apply padding to boundary
+    switch (position) {
+      case "top-start":
+      case "top":
+      case "top-end":
+      case "bottom-start":
+      case "bottom":
+      case "bottom-end":
+        targetPosition.x = targetPosition.x - padding;
+        break;
+      case "left-start":
+      case "left":
+      case "left-end":
+      case "right-start":
+      case "right":
+      case "right-end":
+        targetPosition.y = targetPosition.y + padding;
+        break;
+    }
+  }
+
+  // Should hide entirely if it scrolls out of view
+  var shouldHide = !isWithin(elementRect, boundaryRect);
+  tooltip.style.display = shouldHide ? "none" : "block";
+  tooltip.style.transform = translateWithOffset(targetPosition, position, offset);
+  return {
+    isFlipped: isFlipped
+  };
+};
+export var getPosition = function getPosition(_ref3) {
+  var elementRect = _ref3.elementRect,
+    tooltipRect = _ref3.tooltipRect,
+    position = _ref3.position;
+  var x;
+  var y;
+
+  // X position
+  switch (position) {
+    case "top-start":
+    case "bottom-start":
+      x = elementRect.left;
+      break;
+    case "top":
+    case "bottom":
+      x = elementRect.left + elementRect.width / 2 - tooltipRect.width / 2;
+      break;
+    case "top-end":
+    case "bottom-end":
+      x = elementRect.right - tooltipRect.width;
+      break;
+    case "left-start":
+    case "left":
+    case "left-end":
+      // [..] {XXX}
+      x = elementRect.left - tooltipRect.width;
+      break;
+    case "right-start":
+    case "right":
+    case "right-end":
+      // {XXX} [...]
+      x = elementRect.right;
+      break;
+  }
+
+  // Y position
+  switch (position) {
+    case "left-start":
+    case "right-start":
+      y = elementRect.top;
+      break;
+    case "left":
+    case "right":
+      y = elementRect.top + elementRect.height / 2 - tooltipRect.height / 2;
+      break;
+    case "left-end":
+    case "right-end":
+      y = elementRect.bottom - tooltipRect.height;
+      break;
+    case "top-start":
+    case "top":
+    case "top-end":
+      // [..]
+      // {XXX}
+      y = elementRect.top - tooltipRect.height;
+      break;
+    case "bottom-start":
+    case "bottom":
+    case "bottom-end":
+      // {XXX}
+      // [...]
+      y = elementRect.bottom;
+      break;
+  }
+  return {
+    x: x,
+    y: y
+  };
+};
+export var translateWithOffset = function translateWithOffset(targetPosition, position, offset) {
+  var _ref4 = function () {
+      switch (position) {
+        case "top-start":
+          return [targetPosition.x, targetPosition.y - offset];
+        case "top":
+          return [targetPosition.x, targetPosition.y - offset];
+        case "top-end":
+          return [targetPosition.x, targetPosition.y - offset];
+        case "bottom-start":
+          return [targetPosition.x, targetPosition.y + offset];
+        case "bottom":
+          return [targetPosition.x, targetPosition.y + offset];
+        case "bottom-end":
+          return [targetPosition.x, targetPosition.y + offset];
+        case "left-start":
+          return [targetPosition.x - offset, targetPosition.y];
+        case "left":
+          return [targetPosition.x - offset, targetPosition.y];
+        case "left-end":
+          return [targetPosition.x - offset, targetPosition.y];
+        case "right-start":
+          return [targetPosition.x + offset, targetPosition.y];
+        case "right":
+          return [targetPosition.x + offset, targetPosition.y];
+        case "right-end":
+          return [targetPosition.x + offset, targetPosition.y];
+      }
+    }(),
+    _ref5 = _slicedToArray(_ref4, 2),
+    x = _ref5[0],
+    y = _ref5[1];
+  return "translate(".concat(x, "px, ").concat(y, "px)");
+};
+var getOppositePosition = function getOppositePosition(position) {
+  switch (position) {
+    case "top-start":
+      return "bottom-start";
+    case "top":
+      return "bottom";
+    case "top-end":
+      return "bottom-end";
+    case "bottom-start":
+      return "top-start";
+    case "bottom":
+      return "top";
+    case "bottom-end":
+      return "top-end";
+    case "left-start":
+      return "right-start";
+    case "left":
+      return "right";
+    case "left-end":
+      return "right-end";
+    case "right-start":
+      return "left-start";
+    case "right":
+      return "left";
+    case "right-end":
+      return "left-end";
+  }
+};
+export var getDocumentBoundingRect = function getDocumentBoundingRect() {
+  var width = document.body.clientWidth;
+  var height = document.body.clientHeight;
+  return {
+    top: 0,
+    left: 0,
+    right: width,
+    bottom: height,
+    width: width,
+    height: height
+  };
+};
+export var shouldFlip = function shouldFlip(_ref6) {
+  var targetPosition = _ref6.targetPosition,
+    position = _ref6.position,
+    boundaryRect = _ref6.boundaryRect,
+    tooltipRect = _ref6.tooltipRect;
+  switch (position) {
+    case "top-start":
+    case "top":
+    case "top-end":
+      return targetPosition.y < boundaryRect.top;
+    case "bottom-start":
+    case "bottom":
+    case "bottom-end":
+      return targetPosition.y + tooltipRect.height > boundaryRect.bottom;
+    case "left-start":
+    case "left":
+    case "left-end":
+      return targetPosition.x < boundaryRect.left;
+    case "right-start":
+    case "right":
+    case "right-end":
+      return targetPosition.x + tooltipRect.width > boundaryRect.right;
+  }
+};
+var isWithin = function isWithin(elementRect, boundaryRect) {
+  return boundaryRect.top < elementRect.bottom && boundaryRect.left < elementRect.right && boundaryRect.bottom > elementRect.top && boundaryRect.right > elementRect.left;
+};
+
+/**
+ * Calculate the maximum height available for a tooltip based on its placement and viewport constraints.
+ */
+export var calculateMaxHeight = function calculateMaxHeight(_ref7) {
+  var anchorRect = _ref7.anchorRect,
+    position = _ref7.position,
+    _ref7$offset = _ref7.offset,
+    offset = _ref7$offset === void 0 ? 0 : _ref7$offset;
+  var viewportHeight = window.innerHeight;
+  switch (position) {
+    case "top-start":
+    case "top":
+    case "top-end":
+      // Space from top of anchor to top of viewport
+      return anchorRect.top - offset * 2;
+    case "bottom-start":
+    case "bottom":
+    case "bottom-end":
+      // Space from bottom of anchor to bottom of viewport
+      return viewportHeight - anchorRect.bottom - offset * 2;
+    case "left-start":
+    case "left":
+    case "left-end":
+    case "right-start":
+    case "right":
+    case "right-end":
+      // For side placements, use the entire viewport height
+      return viewportHeight - offset * 2;
+    default:
+      return viewportHeight;
+  }
+};
+//# sourceMappingURL=usePosition.js.map