@choice-ui/react 1.9.7 → 1.9.9

package/dist/components/picture-preview/dist/index.js

@@ -1,8 +1,7 @@
 import { Dropdown as Dropdown2 } from "../../dropdown/dist/index.js";
 import { IconButton } from "../../icon-button/dist/index.js";
 import { LoaderCircle, ImageRemove, Delete, Add } from "@choiceform/icons-react";
-import { forwardRef, useState, useMemo, useRef, useEffect, useCallback } from "react";
-import { useEventCallback } from "usehooks-ts";
+import { forwardRef, useState, useRef, useCallback, useEffect, useMemo } from "react";
 import isHotkey from "is-hotkey";
 import { jsxs, jsx } from "react/jsx-runtime";
 import { tcv, tcx } from "../../../shared/utils/tcx/tcx.js";
@@ -92,7 +91,7 @@ function useDraggable(initialPosition = { x: 0, y: 0 }, options = {}) {
   };
 }
 function useWheelHandler(targetRef, zoomRef, positionRef, options = {}) {
-  const { minZoom = 0.01, maxZoom = 10, zoomStep = 0.1, onZoom, onPan, onZoomAtPoint } = options;
+  const { minZoom = 0.01, maxZoom = 10, zoomStep = 0.1, onZoom, onPan } = options;
   const isMac = useRef(
     typeof navigator !== "undefined" && navigator.platform.toUpperCase().indexOf("MAC") >= 0
   );
@@ -101,32 +100,14 @@ function useWheelHandler(targetRef, zoomRef, positionRef, options = {}) {
     (event) => {
       event.preventDefault();
       event.stopPropagation();
-      if (zoomRef.current === void 0 || zoomRef.current === null || !positionRef.current) return;
+      if (!zoomRef.current || !positionRef.current) return;
       const isPreciseEvent = event.deltaMode === 0;
       const hasDeltaX = Math.abs(event.deltaX) > 0;
       const isZoomModifier = isMac.current && event.metaKey || !isMac.current && event.ctrlKey;
-      const isPinchZoom = event.ctrlKey && isPreciseEvent && !event.metaKey;
-      if (isZoomModifier || isPinchZoom) {
-        const oldZoom = zoomRef.current;
-        let newZoom;
-        const sensitivity = isPinchZoom ? 8e-3 : 3e-3;
-        const delta = event.deltaY;
-        newZoom = oldZoom * Math.exp(-delta * sensitivity);
-        newZoom = Math.max(minZoom, Math.min(maxZoom, newZoom));
-        const target = targetRef.current;
-        if (onZoomAtPoint && target) {
-          const rect = target.getBoundingClientRect();
-          const mouseX = event.clientX - rect.left - rect.width / 2;
-          const mouseY = event.clientY - rect.top - rect.height / 2;
-          const zoomRatio = newZoom / oldZoom;
-          const currentX = positionRef.current.x;
-          const currentY = positionRef.current.y;
-          const newPosition = {
-            x: mouseX - (mouseX - currentX) * zoomRatio,
-            y: mouseY - (mouseY - currentY) * zoomRatio
-          };
-          onZoomAtPoint({ newZoom, newPosition });
-        } else if (onZoom) {
+      if (isZoomModifier) {
+        const delta = -Math.sign(event.deltaY) * zoomStep;
+        const newZoom = Math.max(minZoom, Math.min(maxZoom, zoomRef.current + delta));
+        if (onZoom) {
           onZoom(newZoom);
         }
       } else if (isPreciseEvent && hasDeltaX) {
@@ -158,7 +139,7 @@ function useWheelHandler(targetRef, zoomRef, positionRef, options = {}) {
         }
       }
     },
-    [minZoom, maxZoom, onZoom, onPan, onZoomAtPoint, targetRef]
+    [minZoom, maxZoom, zoomStep, onZoom, onPan]
   );
   const handleKeyDown = useCallback((e) => {
     if (isMac.current && e.metaKey || !isMac.current && e.ctrlKey) {
@@ -219,30 +200,24 @@ var HOTKEYS = {
 };
 var PicturePreviewTv = tcv({
   slots: {
-    root: [
-      "group/picture-preview relative flex flex-col overflow-hidden",
-      "h-full w-full",
-      "touch-none select-none"
-    ],
+    root: ["relative flex flex-col overflow-hidden", "h-full w-full", "touch-none select-none"],
     loading: [
       "text-secondary-foreground absolute inset-0 z-10 flex flex-col items-center justify-center gap-4"
     ],
     content: [
       "relative flex-1 overflow-hidden",
       "flex items-center justify-center",
-      "bg-gray-100 dark:bg-gray-900",
-      "[contain:layout_paint]"
+      "bg-gray-100 dark:bg-gray-900"
     ],
     canvas: [
+      "relative h-full w-full",
       "transform-gpu will-change-transform",
-      "cursor-grab active:cursor-grabbing",
-      "origin-center",
-      "flex items-center justify-center"
+      "cursor-grab active:cursor-grabbing"
     ],
-    image: ["pointer-events-none", "block w-auto h-auto"],
+    image: ["pointer-events-none", "h-full w-full object-contain"],
     controlGroup: [
       "overflow-hidden",
-      "absolute flex items-center",
+      "absolute right-2 bottom-2 flex items-center",
       "bg-default-background",
       "rounded-md",
       "shadow-md"
@@ -251,58 +226,26 @@ var PicturePreviewTv = tcv({
   variants: {
     isLoading: {
       true: {
-        image: "opacity-0 scale-105 blur-sm transition-all duration-500 ease-out"
-      },
-      false: {
-        image: "opacity-100 scale-100 blur-0 transition-all duration-500 ease-out"
-      }
-    },
-    isError: {
-      true: {
-        image: "opacity-0"
+        image: "opacity-0 transition-opacity duration-300"
       },
       false: {}
     },
-    isMenuOpen: {
+    isError: {
       true: {
-        controlGroup: "opacity-100"
+        image: "opacity-0 transition-opacity duration-300"
       },
       false: {}
-    },
-    controlPosition: {
-      "top-left": {
-        controlGroup: "top-2 left-2"
-      },
-      "top-right": {
-        controlGroup: "top-2 right-2"
-      },
-      "bottom-left": {
-        controlGroup: "bottom-2 left-2"
-      },
-      "bottom-right": {
-        controlGroup: "bottom-2 right-2"
-      }
-    },
-    controlShow: {
-      always: {
-        controlGroup: ""
-      },
-      hover: {
-        controlGroup: "group-hover/picture-preview:opacity-100 opacity-0 transition-opacity duration-200"
-      }
     }
   },
   defaultVariants: {
     isLoading: false,
-    isError: false,
-    isMenuOpen: false,
-    controlPosition: "bottom-right"
+    isError: false
   }
 });
+var MIN_ZOOM = 0.01;
+var MAX_ZOOM = 10;
 var ZOOM_STEP = 0.1;
 var INITIAL_ZOOM = 1;
-var MIN_ACTUAL_PERCENT = 2;
-var MAX_ACTUAL_PERCENT = 1e3;
 var PicturePreview = forwardRef(
   function PicturePreview2(props, ref) {
     const {
@@ -320,32 +263,16 @@ var PicturePreview = forwardRef(
         zoomTo200: "Zoom to 200%",
         error: "Image loading failed, please try again."
       },
-      control = {
-        enable: true,
-        position: "bottom-right",
-        show: "hover"
-      },
       ...rest
     } = props;
     const [zoom, setZoom] = useState(INITIAL_ZOOM);
     const [isLoading, setIsLoading] = useState(true);
     const [isError, setIsError] = useState(false);
-    const [naturalSize, setNaturalSize] = useState(null);
-    const [baseScale, setBaseScale] = useState(1);
-    const [menuIsOpen, setMenuIsOpen] = useState(false);
-    const minZoom = useMemo(
-      () => baseScale > 0 ? MIN_ACTUAL_PERCENT / 100 / baseScale : 0.01,
-      [baseScale]
-    );
-    const maxZoom = useMemo(
-      () => baseScale > 0 ? MAX_ACTUAL_PERCENT / 100 / baseScale : 100,
-      [baseScale]
-    );
     const internalRef = useRef(null);
     const canvasRef = useRef(null);
     const zoomRef = useRef(zoom);
     const rafId = useRef(null);
-    const scheduleUpdate = useEventCallback(() => {
+    const scheduleUpdate = useCallback(() => {
       if (rafId.current !== null) {
         return;
       }
@@ -353,7 +280,7 @@ var PicturePreview = forwardRef(
         setZoom(zoomRef.current);
         rafId.current = null;
       });
-    });
+    }, []);
     useEffect(() => {
       return () => {
         if (rafId.current !== null) {
@@ -365,52 +292,43 @@ var PicturePreview = forwardRef(
       zoomRef.current = zoom;
     }, [zoom]);
     const { position, isDragging, handleMouseDown, updatePosition, positionRef } = useDraggable();
-    const handlePositionChange = useEventCallback((newPosition) => {
-      updatePosition(newPosition);
-    });
-    const handleZoomAtPoint = useEventCallback(
-      (params) => {
-        zoomRef.current = params.newZoom;
-        updatePosition(params.newPosition);
+    const handleZoomChange = useCallback(
+      (newZoom) => {
+        zoomRef.current = newZoom;
         scheduleUpdate();
-      }
+      },
+      [scheduleUpdate]
+    );
+    const handlePositionChange = useCallback(
+      (newPosition) => {
+        updatePosition(newPosition);
+      },
+      [updatePosition]
     );
     useWheelHandler(internalRef, zoomRef, positionRef, {
-      minZoom,
-      maxZoom,
+      minZoom: MIN_ZOOM,
+      maxZoom: MAX_ZOOM,
       zoomStep: ZOOM_STEP,
-      onPan: handlePositionChange,
-      onZoomAtPoint: handleZoomAtPoint
-    });
-    const zoomIn = useEventCallback(() => {
-      zoomRef.current = Math.min(maxZoom, zoomRef.current + ZOOM_STEP);
-      scheduleUpdate();
+      onZoom: handleZoomChange,
+      onPan: handlePositionChange
     });
-    const zoomOut = useEventCallback(() => {
-      zoomRef.current = Math.max(minZoom, zoomRef.current - ZOOM_STEP);
-      scheduleUpdate();
-    });
-    const resetView = useEventCallback(() => {
+    const zoomIn = useCallback(() => {
+      handleZoomChange(Math.min(MAX_ZOOM, zoomRef.current + ZOOM_STEP));
+    }, [handleZoomChange]);
+    const zoomOut = useCallback(() => {
+      handleZoomChange(Math.max(MIN_ZOOM, zoomRef.current - ZOOM_STEP));
+    }, [handleZoomChange]);
+    const resetView = useCallback(() => {
       zoomRef.current = INITIAL_ZOOM;
       updatePosition({ x: 0, y: 0 });
       scheduleUpdate();
-    });
-    const fitToView = useEventCallback(() => {
-      if (!canvasRef.current || !naturalSize || !internalRef.current || baseScale <= 0) return;
-      const containerRect = internalRef.current.getBoundingClientRect();
-      const containerWidth = containerRect.width;
-      const containerHeight = containerRect.height;
-      if (naturalSize.width <= 0 || naturalSize.height <= 0) return;
-      const scaleX = containerWidth / naturalSize.width;
-      const scaleY = containerHeight / naturalSize.height;
-      const fitScale = Math.min(scaleX, scaleY);
-      zoomRef.current = fitScale / baseScale;
+    }, [updatePosition, scheduleUpdate]);
+    const fitToView = useCallback(() => {
+      if (!canvasRef.current) return;
+      zoomRef.current = 1;
       updatePosition({ x: 0, y: 0 });
       scheduleUpdate();
-    });
-    const handleDoubleClick = useEventCallback(() => {
-      fitToView();
-    });
+    }, [updatePosition, scheduleUpdate]);
     useHotkeys([
       {
         hotkey: HOTKEYS.ZOOM_IN,
@@ -429,16 +347,13 @@ var PicturePreview = forwardRef(
         handler: () => fitToView()
       }
     ]);
-    const handleZoomMenuItemClick = useEventCallback((zoomLevel) => {
-      zoomRef.current = zoomLevel;
-      scheduleUpdate();
-    });
-    const setActualZoomPercent = useEventCallback((percent) => {
-      if (baseScale === 0) return;
-      const newZoom = percent / 100 / baseScale;
-      zoomRef.current = Math.max(minZoom, Math.min(maxZoom, newZoom));
-      scheduleUpdate();
-    });
+    const handleZoomMenuItemClick = useCallback(
+      (zoomLevel) => {
+        zoomRef.current = zoomLevel;
+        scheduleUpdate();
+      },
+      [scheduleUpdate]
+    );
     useEffect(() => {
       if (!internalRef.current) return;
       if (typeof ref === "function") {
@@ -458,75 +373,26 @@ var PicturePreview = forwardRef(
         backfaceVisibility: "hidden"
       };
     }, [position.x, position.y, zoom, isDragging]);
-    const calculateBaseScale = useCallback(() => {
-      if (!naturalSize || !internalRef.current) return 1;
-      const containerRect = internalRef.current.getBoundingClientRect();
-      const containerWidth = containerRect.width;
-      const containerHeight = containerRect.height;
-      if (naturalSize.width <= 0 || naturalSize.height <= 0 || containerWidth <= 0 || containerHeight <= 0) {
-        return 1;
-      }
-      const scaleX = containerWidth / naturalSize.width;
-      const scaleY = containerHeight / naturalSize.height;
-      return Math.min(scaleX, scaleY);
-    }, [naturalSize]);
-    useEffect(() => {
-      if (!naturalSize || !internalRef.current) return;
-      const updateBaseScale = () => {
-        const scale = calculateBaseScale();
-        setBaseScale(scale);
-      };
-      updateBaseScale();
-      const resizeObserver = new ResizeObserver(() => {
-        updateBaseScale();
-      });
-      resizeObserver.observe(internalRef.current);
-      return () => {
-        resizeObserver.disconnect();
-      };
-    }, [naturalSize, calculateBaseScale]);
     useEffect(() => {
       setIsLoading(true);
-      setIsError(false);
-      setNaturalSize(null);
       const img = new Image();
-      let isCancelled = false;
+      img.src = src;
       img.onload = () => {
-        if (isCancelled) return;
-        setNaturalSize({ width: img.naturalWidth, height: img.naturalHeight });
         setIsLoading(false);
       };
       img.onerror = () => {
-        if (isCancelled) return;
-        setIsError(true);
         setIsLoading(false);
       };
-      img.src = src;
-      return () => {
-        isCancelled = true;
-        img.onload = null;
-        img.onerror = null;
-        img.src = "";
-      };
     }, [src]);
-    const actualZoomPercent = useMemo(() => {
-      return Math.round(zoom * baseScale * 100);
-    }, [zoom, baseScale]);
-    const tv = PicturePreviewTv({
-      isLoading,
-      isError,
-      isMenuOpen: menuIsOpen,
-      controlPosition: control.position,
-      controlShow: control.show
-    });
+    const styles = PicturePreviewTv({ isLoading, isError });
     return /* @__PURE__ */ jsxs(
       "div",
       {
         ref: internalRef,
-        className: tcx(tv.root(), className),
+        className: tcx(styles.root(), className),
         ...rest,
         children: [
-          isLoading && /* @__PURE__ */ jsx("div", { className: tv.loading(), children: /* @__PURE__ */ jsx(
+          isLoading && /* @__PURE__ */ jsx("div", { className: styles.loading(), children: /* @__PURE__ */ jsx(
             LoaderCircle,
             {
               className: "animate-spin",
@@ -534,7 +400,7 @@ var PicturePreview = forwardRef(
               height: 32
             }
           ) }),
-          isError && /* @__PURE__ */ jsxs("div", { className: tv.loading(), children: [
+          isError && /* @__PURE__ */ jsxs("div", { className: styles.loading(), children: [
             /* @__PURE__ */ jsx(
               ImageRemove,
               {
@@ -544,24 +410,19 @@ var PicturePreview = forwardRef(
             ),
             /* @__PURE__ */ jsx("span", { children: defaultText.error })
           ] }),
-          !isError && /* @__PURE__ */ jsx("div", { className: tv.content(), children: /* @__PURE__ */ jsx(
+          /* @__PURE__ */ jsx("div", { className: styles.content(), children: /* @__PURE__ */ jsx(
             "div",
             {
               ref: canvasRef,
-              className: tv.canvas(),
+              className: styles.canvas(),
               style: transformStyle,
               onMouseDown: handleMouseDown,
-              onDoubleClick: handleDoubleClick,
               children: /* @__PURE__ */ jsx(
                 "img",
                 {
                   src,
                   alt: fileName || "Preview",
-                  className: tv.image(),
-                  style: naturalSize ? {
-                    width: naturalSize.width * baseScale,
-                    height: naturalSize.height * baseScale
-                  } : void 0,
+                  className: styles.image(),
                   draggable: false,
                   loading: "eager",
                   decoding: "async",
@@ -571,7 +432,7 @@ var PicturePreview = forwardRef(
               )
             }
           ) }),
-          isError || isLoading || control.enable === false ? null : /* @__PURE__ */ jsxs("div", { className: tv.controlGroup(), children: [
+          isError || isLoading ? null : /* @__PURE__ */ jsxs("div", { className: styles.controlGroup(), children: [
             /* @__PURE__ */ jsx(
               IconButton,
               {
@@ -588,90 +449,82 @@ var PicturePreview = forwardRef(
                 children: /* @__PURE__ */ jsx(Delete, {})
               }
             ),
-            /* @__PURE__ */ jsxs(
-              Dropdown2,
-              {
-                selection: true,
-                open: menuIsOpen,
-                onOpenChange: setMenuIsOpen,
-                children: [
-                  /* @__PURE__ */ jsx(
-                    Dropdown2.Trigger,
-                    {
-                      variant: "ghost",
-                      className: "border-x-default rounded-none",
-                      size: "large",
-                      children: /* @__PURE__ */ jsxs("span", { className: "flex-1", children: [
-                        actualZoomPercent,
-                        "%"
-                      ] })
-                    }
-                  ),
-                  /* @__PURE__ */ jsxs(Dropdown2.Content, { children: [
-                    /* @__PURE__ */ jsx(
-                      Dropdown2.Item,
-                      {
-                        onMouseUp: () => handleZoomMenuItemClick(zoomRef.current + ZOOM_STEP),
-                        shortcut: {
-                          keys: "+",
-                          modifier: "command"
-                        },
-                        children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomIn })
-                      }
-                    ),
-                    /* @__PURE__ */ jsx(
-                      Dropdown2.Item,
-                      {
-                        onMouseUp: () => handleZoomMenuItemClick(zoomRef.current - ZOOM_STEP),
-                        shortcut: {
-                          keys: "-",
-                          modifier: "command"
-                        },
-                        children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomOut })
-                      }
-                    ),
-                    /* @__PURE__ */ jsx(
-                      Dropdown2.Item,
-                      {
-                        selected: actualZoomPercent === 50,
-                        onMouseUp: () => setActualZoomPercent(50),
-                        children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomTo50 })
-                      }
-                    ),
-                    /* @__PURE__ */ jsx(
-                      Dropdown2.Item,
-                      {
-                        selected: actualZoomPercent === 100,
-                        onMouseUp: () => setActualZoomPercent(100),
-                        children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomTo100 })
-                      }
-                    ),
-                    /* @__PURE__ */ jsx(
-                      Dropdown2.Item,
-                      {
-                        selected: actualZoomPercent === 200,
-                        onMouseUp: () => setActualZoomPercent(200),
-                        children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomTo200 })
-                      }
-                    ),
-                    /* @__PURE__ */ jsx(Dropdown2.Divider, {}),
-                    /* @__PURE__ */ jsx(
-                      Dropdown2.Item,
-                      {
-                        onMouseUp: () => {
-                          fitToView();
-                        },
-                        shortcut: {
-                          keys: "1",
-                          modifier: "command"
-                        },
-                        children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.fitToScreen })
-                      }
-                    )
+            /* @__PURE__ */ jsxs(Dropdown2, { selection: true, children: [
+              /* @__PURE__ */ jsx(
+                Dropdown2.Trigger,
+                {
+                  variant: "ghost",
+                  className: "border-x-default rounded-none",
+                  size: "large",
+                  children: /* @__PURE__ */ jsxs("span", { className: "flex-1", children: [
+                    Math.round(zoom * 100),
+                    "%"
                   ] })
-                ]
-              }
-            ),
+                }
+              ),
+              /* @__PURE__ */ jsxs(Dropdown2.Content, { children: [
+                /* @__PURE__ */ jsx(
+                  Dropdown2.Item,
+                  {
+                    onMouseUp: () => handleZoomMenuItemClick(zoomRef.current + ZOOM_STEP),
+                    shortcut: {
+                      keys: "+",
+                      modifier: "command"
+                    },
+                    children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomIn })
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Dropdown2.Item,
+                  {
+                    onMouseUp: () => handleZoomMenuItemClick(zoomRef.current - ZOOM_STEP),
+                    shortcut: {
+                      keys: "-",
+                      modifier: "command"
+                    },
+                    children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomOut })
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Dropdown2.Item,
+                  {
+                    selected: zoomRef.current === 0.5,
+                    onMouseUp: () => handleZoomMenuItemClick(0.5),
+                    children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomTo50 })
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Dropdown2.Item,
+                  {
+                    selected: zoomRef.current === 1,
+                    onMouseUp: () => handleZoomMenuItemClick(1),
+                    children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomTo100 })
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Dropdown2.Item,
+                  {
+                    selected: zoomRef.current === 2,
+                    onMouseUp: () => handleZoomMenuItemClick(2),
+                    children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.zoomTo200 })
+                  }
+                ),
+                /* @__PURE__ */ jsx(Dropdown2.Divider, {}),
+                /* @__PURE__ */ jsx(
+                  Dropdown2.Item,
+                  {
+                    onMouseUp: () => {
+                      fitToView();
+                    },
+                    shortcut: {
+                      keys: "1",
+                      modifier: "command"
+                    },
+                    children: /* @__PURE__ */ jsx("span", { className: "flex-1", children: defaultText.fitToScreen })
+                  }
+                )
+              ] })
+            ] }),
             /* @__PURE__ */ jsx(
               IconButton,
               {

package/dist/components/popover/dist/index.d.ts

@@ -41,11 +41,6 @@ interface PopoverProps extends Omit<React__default.HTMLAttributes<HTMLElement>,
      */
     root?: HTMLElement | null;
     triggerRef?: React__default.RefObject<HTMLElement>;
-    /**
-     * CSS selector string to find the trigger element in the DOM.
-     * Alternative to triggerRef for cases where you want to use a selector instead of a ref.
-     */
-    triggerSelector?: string;
 }
 interface PopoverComponent extends React__default.FC<PopoverProps> {
     Content: typeof ModalContent;

package/dist/components/popover/dist/index.js

@@ -221,8 +221,7 @@ function useFloatingPopover({
   matchTriggerWidth = false,
   transitionStylesProps = {
     duration: 0
-  },
-  triggerSelector
+  }
 }) {
   const [isClosing, setIsClosing] = useState(false);
   const positionRef = useRef({ x: 0, y: 0 });
@@ -386,22 +385,6 @@ function useFloatingPopover({
     },
     [refs]
   );
-  const isOpenRef = useRef(innerOpen);
-  isOpenRef.current = innerOpen;
-  useEffect(() => {
-    if (!triggerSelector) return;
-    const element = document.querySelector(triggerSelector);
-    if (!element) return;
-    refs.setReference(element);
-    const handleClick = (e) => {
-      e.preventDefault();
-      handleOpenChange(!isOpenRef.current);
-    };
-    element.addEventListener("click", handleClick);
-    return () => {
-      element.removeEventListener("click", handleClick);
-    };
-  }, [triggerSelector, refs, handleOpenChange]);
   return {
     refs,
     triggerRefs,
@@ -426,7 +409,6 @@ var DragPopover = memo(function DragPopover2({
   className,
   children,
   triggerRef: externalTriggerRef,
-  triggerSelector,
   draggable = false,
   placement = "bottom",
   interactions = "click",
@@ -485,8 +467,7 @@ var DragPopover = memo(function DragPopover2({
     closeOnEscape,
     rememberPosition,
     resetDragState,
-    resetPosition,
-    triggerSelector
+    resetPosition
   });
   useEffect(() => {
     if (externalTriggerRef) {