@dxos/react-ui 0.8.4-main.66e292d → 0.8.4-main.69d29f4

package/dist/lib/browser/chunk-CEKVHJ27.mjs

@@ -0,0 +1,774 @@
+// src/hooks/useElevationContext.ts
+import { useContext as useContext3 } from "react";
+
+// src/hooks/useThemeContext.ts
+import { useContext } from "react";
+import { raise } from "@dxos/debug";
+var useThemeContext = () => useContext(ThemeContext) ?? raise(new Error("Missing ThemeContext"));
+
+// src/hooks/useSafeArea.ts
+import { useCallback, useState } from "react";
+import { useViewportResize } from "@dxos/react-hooks";
+var initialSafeArea = {
+  top: NaN,
+  right: NaN,
+  bottom: NaN,
+  left: NaN
+};
+var useSafeArea = () => {
+  const [padding, setPadding] = useState(initialSafeArea);
+  const handleResize = useCallback(() => {
+    setPadding({
+      top: parseFloat(getComputedStyle(document.documentElement).getPropertyValue("--safe-area-top")),
+      right: parseFloat(getComputedStyle(document.documentElement).getPropertyValue("--safe-area-right")),
+      bottom: parseFloat(getComputedStyle(document.documentElement).getPropertyValue("--safe-area-bottom")),
+      left: parseFloat(getComputedStyle(document.documentElement).getPropertyValue("--safe-area-left"))
+    });
+  }, []);
+  useViewportResize(handleResize);
+  return padding;
+};
+
+// src/components/ThemeProvider/TranslationsProvider.tsx
+import { enUS as dtLocaleEnUs } from "date-fns/locale";
+import i18Next from "i18next";
+import React, { Suspense, createContext, useContext as useContext2, useEffect, useState as useState2 } from "react";
+import { initReactI18next, useTranslation as useI18NextTranslation } from "react-i18next";
+var initialLng = "en-US";
+var initialNs = "dxos-common";
+var initialDtLocale = dtLocaleEnUs;
+var resources = {
+  [initialLng]: {
+    [initialNs]: {
+      "loading translations": "Loading translations\u2026"
+    }
+  }
+};
+void i18Next.use(initReactI18next).init({
+  resources,
+  lng: initialLng,
+  defaultNS: initialNs,
+  interpolation: {
+    escapeValue: false
+  }
+});
+var TranslationsContext = /* @__PURE__ */ createContext({
+  appNs: initialNs,
+  dtLocale: initialDtLocale
+});
+var useTranslation = (...args) => {
+  const result = useI18NextTranslation(...args);
+  const { dtLocale } = useContext2(TranslationsContext);
+  return {
+    ...result,
+    dtLocale
+  };
+};
+var TranslationsProvider = ({ fallback, resourceExtensions, children, appNs, dtLocale }) => {
+  const [loaded, setLoaded] = useState2(false);
+  useEffect(() => {
+    setLoaded(false);
+    if (resourceExtensions && resourceExtensions.length) {
+      resourceExtensions.forEach((resource) => {
+        Object.keys(resource).forEach((language) => {
+          Object.keys(resource[language]).forEach((ns) => {
+            i18Next.addResourceBundle(language, ns, resource[language][ns]);
+          });
+        });
+      });
+    }
+    setLoaded(true);
+  }, [
+    resourceExtensions
+  ]);
+  return /* @__PURE__ */ React.createElement(TranslationsContext.Provider, {
+    value: {
+      appNs: appNs ?? initialNs,
+      dtLocale: dtLocale ?? initialDtLocale
+    }
+  }, /* @__PURE__ */ React.createElement(Suspense, {
+    fallback
+  }, loaded ? children : fallback));
+};
+
+// src/components/Tooltip/Tooltip.tsx
+import { composeEventHandlers } from "@radix-ui/primitive";
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import { createContextScope } from "@radix-ui/react-context";
+import { DismissableLayer } from "@radix-ui/react-dismissable-layer";
+import { useId } from "@radix-ui/react-id";
+import * as PopperPrimitive from "@radix-ui/react-popper";
+import { createPopperScope } from "@radix-ui/react-popper";
+import { Portal as PortalPrimitive } from "@radix-ui/react-portal";
+import { Presence } from "@radix-ui/react-presence";
+import { Primitive } from "@radix-ui/react-primitive";
+import { Slottable } from "@radix-ui/react-slot";
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import * as VisuallyHiddenPrimitive from "@radix-ui/react-visually-hidden";
+import React2, { forwardRef, useCallback as useCallback2, useEffect as useEffect2, useMemo, useRef, useState as useState3 } from "react";
+var [createTooltipContext, createTooltipScope] = createContextScope("Tooltip", [
+  createPopperScope
+]);
+var usePopperScope = createPopperScope();
+var DEFAULT_DELAY_DURATION = 700;
+var TOOLTIP_OPEN = "tooltip.open";
+var TOOLTIP_NAME = "Tooltip";
+var [TooltipContextProvider, useTooltipContext] = createTooltipContext(TOOLTIP_NAME);
+var TooltipProvider = (props) => {
+  const { __scopeTooltip, children, open: openProp, defaultOpen = false, onOpenChange, disableHoverableContent = false, delayDuration = DEFAULT_DELAY_DURATION, skipDelayDuration = 300 } = props;
+  const isOpenDelayedRef = useRef(true);
+  const isPointerInTransitRef = useRef(false);
+  const skipDelayTimerRef = useRef(0);
+  useEffect2(() => {
+    const skipDelayTimer = skipDelayTimerRef.current;
+    return () => window.clearTimeout(skipDelayTimer);
+  }, []);
+  const popperScope = usePopperScope(__scopeTooltip);
+  const [trigger, setTrigger] = useState3(null);
+  const [content, setContent] = useState3("");
+  const [side, setSide] = useState3(void 0);
+  const triggerRef = useRef(trigger);
+  const handleTriggerChange = useCallback2((nextTrigger) => {
+    setTrigger(nextTrigger);
+    triggerRef.current = nextTrigger;
+    setContent(nextTrigger?.getAttribute("data-tooltip-content") ?? "");
+    setSide(nextTrigger?.getAttribute("data-tooltip-side") ?? void 0);
+  }, []);
+  const contentId = useId();
+  const openTimerRef = useRef(0);
+  const wasOpenDelayedRef = useRef(false);
+  const handleOpenChange = useCallback2((open2) => {
+    if (open2) {
+      window.clearTimeout(skipDelayTimerRef.current);
+      isOpenDelayedRef.current = false;
+      document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
+    } else {
+      window.clearTimeout(skipDelayTimerRef.current);
+      skipDelayTimerRef.current = window.setTimeout(() => isOpenDelayedRef.current = true, skipDelayDuration);
+    }
+    onOpenChange?.(open2);
+  }, [
+    skipDelayDuration,
+    onOpenChange
+  ]);
+  const [open = false, setOpen] = useControllableState({
+    prop: openProp,
+    defaultProp: defaultOpen,
+    onChange: handleOpenChange
+  });
+  const stateAttribute = useMemo(() => {
+    return open ? wasOpenDelayedRef.current ? "delayed-open" : "instant-open" : "closed";
+  }, [
+    open
+  ]);
+  const handleOpen = useCallback2(() => {
+    window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = 0;
+    wasOpenDelayedRef.current = false;
+    setOpen(true);
+  }, [
+    setOpen
+  ]);
+  const handleClose = useCallback2(() => {
+    window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = 0;
+    setOpen(false);
+  }, [
+    setOpen
+  ]);
+  const handleDelayedOpen = useCallback2(() => {
+    window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = window.setTimeout(() => {
+      wasOpenDelayedRef.current = true;
+      setOpen(true);
+      openTimerRef.current = 0;
+    }, delayDuration);
+  }, [
+    delayDuration,
+    setOpen
+  ]);
+  useEffect2(() => {
+    return () => {
+      if (openTimerRef.current) {
+        window.clearTimeout(openTimerRef.current);
+        openTimerRef.current = 0;
+      }
+    };
+  }, []);
+  const { tx } = useThemeContext();
+  const elevation = useElevationContext();
+  return /* @__PURE__ */ React2.createElement(PopperPrimitive.Root, popperScope, /* @__PURE__ */ React2.createElement(TooltipContextProvider, {
+    scope: __scopeTooltip,
+    contentId,
+    open,
+    stateAttribute,
+    trigger,
+    onTriggerChange: handleTriggerChange,
+    onTriggerEnter: useCallback2(() => {
+      if (isOpenDelayedRef.current) {
+        handleDelayedOpen();
+      } else {
+        handleOpen();
+      }
+    }, [
+      isOpenDelayedRef,
+      handleDelayedOpen,
+      handleOpen
+    ]),
+    onTriggerLeave: useCallback2(() => {
+      if (disableHoverableContent) {
+        handleClose();
+      } else {
+        window.clearTimeout(openTimerRef.current);
+        openTimerRef.current = 0;
+      }
+    }, [
+      handleClose,
+      disableHoverableContent
+    ]),
+    onOpen: handleOpen,
+    onClose: handleClose,
+    disableHoverableContent,
+    isPointerInTransitRef,
+    onPointerInTransitChange: useCallback2((inTransit) => {
+      isPointerInTransitRef.current = inTransit;
+    }, [])
+  }, /* @__PURE__ */ React2.createElement(TooltipContent, {
+    side,
+    className: tx("tooltip.content", "tooltip", {
+      elevation
+    })
+  }, content, /* @__PURE__ */ React2.createElement(TooltipArrow, {
+    className: tx("tooltip.arrow", "tooltip__arrow")
+  })), /* @__PURE__ */ React2.createElement(TooltipVirtualTrigger, {
+    virtualRef: triggerRef
+  }), children));
+};
+TooltipProvider.displayName = TOOLTIP_NAME;
+var TooltipVirtualTrigger = ({ virtualRef, __scopeTooltip }) => {
+  const popperScope = usePopperScope(__scopeTooltip);
+  return /* @__PURE__ */ React2.createElement(PopperPrimitive.Anchor, {
+    asChild: true,
+    ...popperScope,
+    virtualRef
+  });
+};
+var TRIGGER_NAME = "TooltipTrigger";
+var TooltipTrigger = /* @__PURE__ */ forwardRef((props, forwardedRef) => {
+  const {
+    __scopeTooltip,
+    onInteract,
+    // TODO(thure): Pass `delayDuration` into the context.
+    delayDuration: _delayDuration,
+    side,
+    content,
+    ...triggerProps
+  } = props;
+  const context = useTooltipContext(TRIGGER_NAME, __scopeTooltip);
+  const ref = useRef(null);
+  const composedRefs = useComposedRefs(forwardedRef, ref);
+  const isPointerDownRef = useRef(false);
+  const hasPointerMoveOpenedRef = useRef(false);
+  const handlePointerUp = useCallback2(() => isPointerDownRef.current = false, []);
+  useEffect2(() => {
+    return () => document.removeEventListener("pointerup", handlePointerUp);
+  }, [
+    handlePointerUp
+  ]);
+  return /* @__PURE__ */ React2.createElement(Primitive.button, {
+    // We purposefully avoid adding `type=button` here because tooltip triggers are also
+    // commonly anchors and the anchor `type` attribute signifies MIME type.
+    "aria-describedby": context.open ? context.contentId : void 0,
+    "data-state": context.stateAttribute,
+    "data-tooltip-content": content,
+    "data-tooltip-side": side,
+    ...triggerProps,
+    ref: composedRefs,
+    onPointerMove: composeEventHandlers(props.onPointerMove, (event) => {
+      if (event.pointerType === "touch") {
+        return;
+      }
+      if (!hasPointerMoveOpenedRef.current && !context.isPointerInTransitRef.current) {
+        onInteract?.(event);
+        if (event.defaultPrevented) {
+          return;
+        }
+        context.onTriggerChange(ref.current);
+        context.onTriggerEnter();
+        hasPointerMoveOpenedRef.current = true;
+      }
+    }),
+    onPointerLeave: composeEventHandlers(props.onPointerLeave, () => {
+      context.onTriggerLeave();
+      hasPointerMoveOpenedRef.current = false;
+    }),
+    onPointerDown: composeEventHandlers(props.onPointerDown, () => {
+      if (context.open) {
+        context.onClose();
+      }
+      isPointerDownRef.current = true;
+      document.addEventListener("pointerup", handlePointerUp, {
+        once: true
+      });
+    }),
+    onFocus: props.onFocus,
+    onBlur: composeEventHandlers(props.onBlur, context.onClose),
+    onClick: composeEventHandlers(props.onClick, context.onClose)
+  });
+});
+TooltipTrigger.displayName = TRIGGER_NAME;
+var PORTAL_NAME = "TooltipPortal";
+var [PortalProvider, usePortalContext] = createTooltipContext(PORTAL_NAME, {
+  forceMount: void 0
+});
+var TooltipPortal = (props) => {
+  const { __scopeTooltip, forceMount, children, container } = props;
+  const context = useTooltipContext(PORTAL_NAME, __scopeTooltip);
+  return /* @__PURE__ */ React2.createElement(PortalProvider, {
+    scope: __scopeTooltip,
+    forceMount
+  }, /* @__PURE__ */ React2.createElement(Presence, {
+    present: forceMount || context.open
+  }, /* @__PURE__ */ React2.createElement(PortalPrimitive, {
+    asChild: true,
+    container
+  }, children)));
+};
+TooltipPortal.displayName = PORTAL_NAME;
+var CONTENT_NAME = "TooltipContent";
+var TooltipContent = /* @__PURE__ */ forwardRef((props, forwardedRef) => {
+  const portalContext = usePortalContext(CONTENT_NAME, props.__scopeTooltip);
+  const { forceMount = portalContext.forceMount, side = "top", ...contentProps } = props;
+  const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
+  return /* @__PURE__ */ React2.createElement(Presence, {
+    present: forceMount || context.open
+  }, context.disableHoverableContent ? /* @__PURE__ */ React2.createElement(TooltipContentImpl, {
+    side,
+    ...contentProps,
+    ref: forwardedRef
+  }) : /* @__PURE__ */ React2.createElement(TooltipContentHoverable, {
+    side,
+    ...contentProps,
+    ref: forwardedRef
+  }));
+});
+var TooltipContentHoverable = /* @__PURE__ */ forwardRef((props, forwardedRef) => {
+  const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
+  const ref = useRef(null);
+  const composedRefs = useComposedRefs(forwardedRef, ref);
+  const [pointerGraceArea, setPointerGraceArea] = useState3(null);
+  const { trigger, onClose } = context;
+  const content = ref.current;
+  const { onPointerInTransitChange } = context;
+  const handleRemoveGraceArea = useCallback2(() => {
+    setPointerGraceArea(null);
+    onPointerInTransitChange(false);
+  }, [
+    onPointerInTransitChange
+  ]);
+  const handleCreateGraceArea = useCallback2((event, hoverTarget) => {
+    const currentTarget = event.currentTarget;
+    const exitPoint = {
+      x: event.clientX,
+      y: event.clientY
+    };
+    const exitSide = getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());
+    const paddedExitPoints = getPaddedExitPoints(exitPoint, exitSide);
+    const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
+    const graceArea = getHull([
+      ...paddedExitPoints,
+      ...hoverTargetPoints
+    ]);
+    setPointerGraceArea(graceArea);
+    onPointerInTransitChange(true);
+  }, [
+    onPointerInTransitChange
+  ]);
+  useEffect2(() => {
+    return () => handleRemoveGraceArea();
+  }, [
+    handleRemoveGraceArea
+  ]);
+  useEffect2(() => {
+    if (trigger && content) {
+      const handleTriggerLeave = (event) => handleCreateGraceArea(event, content);
+      const handleContentLeave = (event) => handleCreateGraceArea(event, trigger);
+      trigger.addEventListener("pointerleave", handleTriggerLeave);
+      content.addEventListener("pointerleave", handleContentLeave);
+      return () => {
+        trigger.removeEventListener("pointerleave", handleTriggerLeave);
+        content.removeEventListener("pointerleave", handleContentLeave);
+      };
+    }
+  }, [
+    trigger,
+    content,
+    handleCreateGraceArea,
+    handleRemoveGraceArea
+  ]);
+  useEffect2(() => {
+    if (pointerGraceArea) {
+      const handleTrackPointerGrace = (event) => {
+        const target = event.target;
+        const pointerPosition = {
+          x: event.clientX,
+          y: event.clientY
+        };
+        const hasEnteredTarget = trigger?.contains(target) || content?.contains(target);
+        const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea);
+        if (hasEnteredTarget) {
+          handleRemoveGraceArea();
+        } else if (isPointerOutsideGraceArea) {
+          handleRemoveGraceArea();
+          onClose();
+        }
+      };
+      document.addEventListener("pointermove", handleTrackPointerGrace);
+      return () => document.removeEventListener("pointermove", handleTrackPointerGrace);
+    }
+  }, [
+    trigger,
+    content,
+    pointerGraceArea,
+    onClose,
+    handleRemoveGraceArea
+  ]);
+  return /* @__PURE__ */ React2.createElement(TooltipContentImpl, {
+    ...props,
+    ref: composedRefs
+  });
+});
+var [VisuallyHiddenContentContextProvider, useVisuallyHiddenContentContext] = createTooltipContext(TOOLTIP_NAME, {
+  isInside: false
+});
+var TooltipContentImpl = /* @__PURE__ */ forwardRef((props, forwardedRef) => {
+  const { __scopeTooltip, children, "aria-label": ariaLabel, onEscapeKeyDown, onPointerDownOutside, ...contentProps } = props;
+  const context = useTooltipContext(CONTENT_NAME, __scopeTooltip);
+  const popperScope = usePopperScope(__scopeTooltip);
+  const { onClose } = context;
+  useEffect2(() => {
+    document.addEventListener(TOOLTIP_OPEN, onClose);
+    return () => document.removeEventListener(TOOLTIP_OPEN, onClose);
+  }, [
+    onClose
+  ]);
+  useEffect2(() => {
+    if (context.trigger) {
+      const handleScroll = (event) => {
+        const target = event.target;
+        if (target?.contains(context.trigger)) {
+          onClose();
+        }
+      };
+      window.addEventListener("scroll", handleScroll, {
+        capture: true
+      });
+      return () => window.removeEventListener("scroll", handleScroll, {
+        capture: true
+      });
+    }
+  }, [
+    context.trigger,
+    onClose
+  ]);
+  return /* @__PURE__ */ React2.createElement(DismissableLayer, {
+    asChild: true,
+    disableOutsidePointerEvents: false,
+    onEscapeKeyDown,
+    onPointerDownOutside,
+    onFocusOutside: (event) => event.preventDefault(),
+    onDismiss: onClose
+  }, /* @__PURE__ */ React2.createElement(PopperPrimitive.Content, {
+    "data-state": context.stateAttribute,
+    ...popperScope,
+    ...contentProps,
+    ref: forwardedRef,
+    style: {
+      ...contentProps.style,
+      // re-namespace exposed content custom properties
+      ...{
+        "--radix-tooltip-content-transform-origin": "var(--radix-popper-transform-origin)",
+        "--radix-tooltip-content-available-width": "var(--radix-popper-available-width)",
+        "--radix-tooltip-content-available-height": "var(--radix-popper-available-height)",
+        "--radix-tooltip-trigger-width": "var(--radix-popper-anchor-width)",
+        "--radix-tooltip-trigger-height": "var(--radix-popper-anchor-height)"
+      }
+    }
+  }, /* @__PURE__ */ React2.createElement(Slottable, null, children), /* @__PURE__ */ React2.createElement(VisuallyHiddenContentContextProvider, {
+    scope: __scopeTooltip,
+    isInside: true
+  }, /* @__PURE__ */ React2.createElement(VisuallyHiddenPrimitive.Root, {
+    id: context.contentId,
+    role: "tooltip"
+  }, ariaLabel || children))));
+});
+TooltipContent.displayName = CONTENT_NAME;
+var ARROW_NAME = "TooltipArrow";
+var TooltipArrow = /* @__PURE__ */ forwardRef((props, forwardedRef) => {
+  const { __scopeTooltip, ...arrowProps } = props;
+  const popperScope = usePopperScope(__scopeTooltip);
+  const visuallyHiddenContentContext = useVisuallyHiddenContentContext(ARROW_NAME, __scopeTooltip);
+  return visuallyHiddenContentContext.isInside ? null : /* @__PURE__ */ React2.createElement(PopperPrimitive.Arrow, {
+    ...popperScope,
+    ...arrowProps,
+    ref: forwardedRef
+  });
+});
+TooltipArrow.displayName = ARROW_NAME;
+var getExitSideFromRect = (point, rect) => {
+  const top = Math.abs(rect.top - point.y);
+  const bottom = Math.abs(rect.bottom - point.y);
+  const right = Math.abs(rect.right - point.x);
+  const left = Math.abs(rect.left - point.x);
+  switch (Math.min(top, bottom, right, left)) {
+    case left:
+      return "left";
+    case right:
+      return "right";
+    case top:
+      return "top";
+    case bottom:
+      return "bottom";
+    default:
+      throw new Error("unreachable");
+  }
+};
+var getPaddedExitPoints = (exitPoint, exitSide, padding = 5) => {
+  const paddedExitPoints = [];
+  switch (exitSide) {
+    case "top":
+      paddedExitPoints.push({
+        x: exitPoint.x - padding,
+        y: exitPoint.y + padding
+      }, {
+        x: exitPoint.x + padding,
+        y: exitPoint.y + padding
+      });
+      break;
+    case "bottom":
+      paddedExitPoints.push({
+        x: exitPoint.x - padding,
+        y: exitPoint.y - padding
+      }, {
+        x: exitPoint.x + padding,
+        y: exitPoint.y - padding
+      });
+      break;
+    case "left":
+      paddedExitPoints.push({
+        x: exitPoint.x + padding,
+        y: exitPoint.y - padding
+      }, {
+        x: exitPoint.x + padding,
+        y: exitPoint.y + padding
+      });
+      break;
+    case "right":
+      paddedExitPoints.push({
+        x: exitPoint.x - padding,
+        y: exitPoint.y - padding
+      }, {
+        x: exitPoint.x - padding,
+        y: exitPoint.y + padding
+      });
+      break;
+  }
+  return paddedExitPoints;
+};
+var getPointsFromRect = (rect) => {
+  const { top, right, bottom, left } = rect;
+  return [
+    {
+      x: left,
+      y: top
+    },
+    {
+      x: right,
+      y: top
+    },
+    {
+      x: right,
+      y: bottom
+    },
+    {
+      x: left,
+      y: bottom
+    }
+  ];
+};
+var isPointInPolygon = (point, polygon) => {
+  const { x, y } = point;
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const xi = polygon[i].x;
+    const yi = polygon[i].y;
+    const xj = polygon[j].x;
+    const yj = polygon[j].y;
+    const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
+    if (intersect) {
+      inside = !inside;
+    }
+  }
+  return inside;
+};
+var getHull = (points) => {
+  const newPoints = points.slice();
+  newPoints.sort((a, b) => {
+    if (a.x < b.x) {
+      return -1;
+    } else if (a.x > b.x) {
+      return 1;
+    } else if (a.y < b.y) {
+      return -1;
+    } else if (a.y > b.y) {
+      return 1;
+    } else {
+      return 0;
+    }
+  });
+  return getHullPresorted(newPoints);
+};
+var getHullPresorted = (points) => {
+  if (points.length <= 1) {
+    return points.slice();
+  }
+  const upperHull = [];
+  for (let i = 0; i < points.length; i++) {
+    const p = points[i];
+    while (upperHull.length >= 2) {
+      const q = upperHull[upperHull.length - 1];
+      const r = upperHull[upperHull.length - 2];
+      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) {
+        upperHull.pop();
+      } else {
+        break;
+      }
+    }
+    upperHull.push(p);
+  }
+  upperHull.pop();
+  const lowerHull = [];
+  for (let i = points.length - 1; i >= 0; i--) {
+    const p = points[i];
+    while (lowerHull.length >= 2) {
+      const q = lowerHull[lowerHull.length - 1];
+      const r = lowerHull[lowerHull.length - 2];
+      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) {
+        lowerHull.pop();
+      } else {
+        break;
+      }
+    }
+    lowerHull.push(p);
+  }
+  lowerHull.pop();
+  if (upperHull.length === 1 && lowerHull.length === 1 && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y) {
+    return upperHull;
+  } else {
+    return upperHull.concat(lowerHull);
+  }
+};
+var Tooltip = {
+  Provider: TooltipProvider,
+  Trigger: TooltipTrigger
+};
+
+// src/components/ThemeProvider/ThemeProvider.tsx
+import { createKeyborg } from "keyborg";
+import React5, { createContext as createContext4, useEffect as useEffect3, useMemo as useMemo2 } from "react";
+
+// src/util/hasIosKeyboard.ts
+var hasIosKeyboard = () => {
+  return !!navigator.userAgent.match(/iP(ad|od|hone).+Safari/);
+};
+
+// src/components/DensityProvider/DensityProvider.tsx
+import React3, { createContext as createContext2 } from "react";
+var DensityContext = /* @__PURE__ */ createContext2({
+  density: "fine"
+});
+var DensityProvider = ({ density, children }) => /* @__PURE__ */ React3.createElement(DensityContext.Provider, {
+  value: {
+    density
+  }
+}, children);
+
+// src/components/ElevationProvider/ElevationProvider.tsx
+import React4, { createContext as createContext3 } from "react";
+var ElevationContext = /* @__PURE__ */ createContext3({
+  elevation: "base"
+});
+var ElevationProvider = ({ elevation, children }) => /* @__PURE__ */ React4.createElement(ElevationContext.Provider, {
+  value: {
+    elevation
+  }
+}, children);
+
+// src/components/ThemeProvider/ThemeProvider.tsx
+var ThemeContext = /* @__PURE__ */ createContext4(void 0);
+var ThemeProvider = ({ children, fallback = null, resourceExtensions, appNs, tx = (_path, defaultClassName, _styleProps, ..._options) => defaultClassName, themeMode = "dark", rootDensity = "fine", ...rest }) => {
+  useEffect3(() => {
+    if (document.defaultView) {
+      const kb = createKeyborg(document.defaultView);
+      kb.subscribe(handleInputModalityChange);
+      return () => kb.unsubscribe(handleInputModalityChange);
+    }
+  }, []);
+  const safeAreaPadding = useSafeArea();
+  const contextValue = useMemo2(() => ({
+    tx,
+    themeMode,
+    hasIosKeyboard: hasIosKeyboard(),
+    safeAreaPadding,
+    ...rest
+  }), [
+    tx,
+    themeMode,
+    safeAreaPadding,
+    rest
+  ]);
+  return /* @__PURE__ */ React5.createElement(ThemeContext.Provider, {
+    value: contextValue
+  }, /* @__PURE__ */ React5.createElement(TranslationsProvider, {
+    fallback,
+    resourceExtensions,
+    appNs
+  }, /* @__PURE__ */ React5.createElement(ElevationProvider, {
+    elevation: "base"
+  }, /* @__PURE__ */ React5.createElement(DensityProvider, {
+    density: rootDensity
+  }, children))));
+};
+var handleInputModalityChange = (isUsingKeyboard) => {
+  if (isUsingKeyboard) {
+    document.body.setAttribute("data-is-keyboard", "true");
+  } else {
+    document.body.removeAttribute("data-is-keyboard");
+  }
+};
+
+// src/hooks/useElevationContext.ts
+var useElevationContext = (propsElevation) => {
+  const { elevation } = useContext3(ElevationContext);
+  return propsElevation ?? elevation;
+};
+
+export {
+  useElevationContext,
+  useThemeContext,
+  initialSafeArea,
+  useSafeArea,
+  TranslationsContext,
+  useTranslation,
+  createTooltipScope,
+  useTooltipContext,
+  Tooltip,
+  hasIosKeyboard,
+  DensityContext,
+  DensityProvider,
+  ElevationContext,
+  ElevationProvider,
+  ThemeContext,
+  ThemeProvider
+};
+//# sourceMappingURL=chunk-CEKVHJ27.mjs.map