fix: unable to resize elements to be bigger

apps/web/src/hooks/use-timeline-element-resize.ts

@@ -1,83 +1,103 @@
-import { useState } from "react";
+import { useState, useEffect } from "react";
-import { ResizeState, TimelineElement, TimelineTrack } from "@/types/timeline";
+import { ResizeState, TimelineElement, TimelineTrack } from "@/types/timeline";
-
+
-interface UseTimelineElementResizeProps {
+interface UseTimelineElementResizeProps {
-  element: TimelineElement;
+  element: TimelineElement;
-  track: TimelineTrack;
+  track: TimelineTrack;
-  zoomLevel: number;
+  zoomLevel: number;
-  onUpdateTrim: (
+  onUpdateTrim: (
-    trackId: string,
+    trackId: string,
-    elementId: string,
+    elementId: string,
-    trimStart: number,
+    trimStart: number,
-    trimEnd: number
+    trimEnd: number
-  ) => void;
+  ) => void;
-}
+}
-
+
-export function useTimelineElementResize({
+export function useTimelineElementResize({
-  element,
+  element,
-  track,
+  track,
-  zoomLevel,
+  zoomLevel,
-  onUpdateTrim,
+  onUpdateTrim,
-}: UseTimelineElementResizeProps) {
+}: UseTimelineElementResizeProps) {
-  const [resizing, setResizing] = useState<ResizeState | null>(null);
+  const [resizing, setResizing] = useState<ResizeState | null>(null);
-
+
-  const handleResizeStart = (
+  // Set up document-level mouse listeners during resize (like proper drag behavior)
-    e: React.MouseEvent,
+  useEffect(() => {
-    elementId: string,
+    if (!resizing) return;
-    side: "left" | "right"
+
-  ) => {
+    const handleDocumentMouseMove = (e: MouseEvent) => {
-    e.stopPropagation();
+      updateTrimFromMouseMove({ clientX: e.clientX });
-    e.preventDefault();
+    };
-
+
-    setResizing({
+    const handleDocumentMouseUp = () => {
-      elementId,
+      handleResizeEnd();
-      side,
+    };
-      startX: e.clientX,
+
-      initialTrimStart: element.trimStart,
+    // Add document-level listeners for proper drag behavior
-      initialTrimEnd: element.trimEnd,
+    document.addEventListener("mousemove", handleDocumentMouseMove);
-    });
+    document.addEventListener("mouseup", handleDocumentMouseUp);
-  };
+
-
+    return () => {
-  const updateTrimFromMouseMove = (e: { clientX: number }) => {
+      document.removeEventListener("mousemove", handleDocumentMouseMove);
-    if (!resizing) return;
+      document.removeEventListener("mouseup", handleDocumentMouseUp);
-
+    };
-    const deltaX = e.clientX - resizing.startX;
+  }, [resizing]); // Re-run when resizing state changes
-    const deltaTime = deltaX / (50 * zoomLevel);
+
-
+  const handleResizeStart = (
-    if (resizing.side === "left") {
+    e: React.MouseEvent,
-      const newTrimStart = Math.max(
+    elementId: string,
-        0,
+    side: "left" | "right"
-        Math.min(
+  ) => {
-          element.duration - element.trimEnd - 0.1,
+    e.stopPropagation();
-          resizing.initialTrimStart + deltaTime
+    e.preventDefault();
-        )
+
-      );
+    setResizing({
-      onUpdateTrim(track.id, element.id, newTrimStart, element.trimEnd);
+      elementId,
-    } else {
+      side,
-      const newTrimEnd = Math.max(
+      startX: e.clientX,
-        0,
+      initialTrimStart: element.trimStart,
-        Math.min(
+      initialTrimEnd: element.trimEnd,
-          element.duration - element.trimStart - 0.1,
+    });
-          resizing.initialTrimEnd - deltaTime
+  };
-        )
+
-      );
+  const updateTrimFromMouseMove = (e: { clientX: number }) => {
-      onUpdateTrim(track.id, element.id, element.trimStart, newTrimEnd);
+    if (!resizing) return;
-    }
+
-  };
+    const deltaX = e.clientX - resizing.startX;
-
+    // Reasonable sensitivity for resize operations - similar to timeline scale
-  const handleResizeMove = (e: React.MouseEvent) => {
+    const deltaTime = deltaX / (50 * zoomLevel);
-    updateTrimFromMouseMove(e);
+
-  };
+    if (resizing.side === "left") {
-
+      const maxAllowed = element.duration - resizing.initialTrimEnd - 0.1;
-  const handleResizeEnd = () => {
+      const calculated = resizing.initialTrimStart + deltaTime;
-    setResizing(null);
+      const newTrimStart = Math.max(0, Math.min(maxAllowed, calculated));
-  };
+
-
+      onUpdateTrim(track.id, element.id, newTrimStart, resizing.initialTrimEnd);
-  return {
+    } else {
-    resizing,
+      // For right resize (expanding element), allow trimEnd to go to 0 but cap at element duration
-    isResizing: resizing !== null,
+      const calculated = resizing.initialTrimEnd - deltaTime;
-    handleResizeStart,
+      // Prevent negative trim AND prevent trimEnd from exceeding element duration
-    handleResizeMove,
+      const maxTrimEnd = element.duration - resizing.initialTrimStart - 0.1; // Leave at least 0.1s visible
-    handleResizeEnd,
+      const newTrimEnd = Math.max(0, Math.min(maxTrimEnd, calculated));
-  };
+
-}
+      onUpdateTrim(track.id, element.id, resizing.initialTrimStart, newTrimEnd);
+    }
+  };
+
+  const handleResizeMove = (e: React.MouseEvent) => {
+    updateTrimFromMouseMove(e);
+  };
+
+  const handleResizeEnd = () => {
+    setResizing(null);
+  };
+
+  return {
+    resizing,
+    isResizing: resizing !== null,
+    handleResizeStart,
+    // Return empty handlers since we use document listeners now
+    handleResizeMove: () => {}, // Not used anymore
+    handleResizeEnd: () => {}, // Not used anymore
+  };
+}