fuck malware, fuck you

apps/web/src/hooks/timeline/use-timeline-snapping.ts

@@ -16,7 +16,7 @@ export interface SnapResult {
 }
 
 export interface UseTimelineSnappingOptions {
-  snapThreshold?: number; // Distance in pixels to trigger snapping
+  snapThreshold?: number;
   enableElementSnapping?: boolean;
   enablePlayheadSnapping?: boolean;
 }
@@ -27,21 +27,21 @@ export function useTimelineSnapping({
   enablePlayheadSnapping = true,
 }: UseTimelineSnappingOptions = {}) {
   const findSnapPoints = useCallback(
-    (
-      tracks: TimelineTrack[],
-      currentTime: number,
-      playheadTime: number,
-      zoomLevel: number,
-      excludeElementId?: string,
-    ): SnapPoint[] => {
+    ({
+      tracks,
+      playheadTime,
+      excludeElementId,
+    }: {
+      tracks: Array<TimelineTrack>;
+      playheadTime: number;
+      excludeElementId?: string;
+    }): SnapPoint[] => {
       const snapPoints: SnapPoint[] = [];
 
-      // Add element snap points
       if (enableElementSnapping) {
-        tracks.forEach((track) => {
-          track.elements.forEach((element) => {
-            // Skip the element being dragged
-            if (element.id === excludeElementId) return;
+        for (const track of tracks) {
+          for (const element of track.elements) {
+            if (element.id === excludeElementId) continue;
 
             const elementStart = element.startTime;
             const elementEnd = element.startTime + element.duration;
@@ -60,11 +60,10 @@ export function useTimelineSnapping({
                 trackId: track.id,
               },
             );
-          });
-        });
+          }
+        }
       }
 
-      // Add playhead snap point
       if (enablePlayheadSnapping) {
         snapPoints.push({
           time: playheadTime,
@@ -78,24 +77,28 @@ export function useTimelineSnapping({
   );
 
   const snapToNearestPoint = useCallback(
-    (
-      targetTime: number,
-      snapPoints: SnapPoint[],
-      zoomLevel: number,
-    ): SnapResult => {
+    ({
+      targetTime,
+      snapPoints,
+      zoomLevel,
+    }: {
+      targetTime: number;
+      snapPoints: Array<SnapPoint>;
+      zoomLevel: number;
+    }): SnapResult => {
       const pixelsPerSecond = TIMELINE_CONSTANTS.PIXELS_PER_SECOND * zoomLevel;
       const thresholdInSeconds = snapThreshold / pixelsPerSecond;
 
       let closestSnapPoint: SnapPoint | null = null;
       let closestDistance = Infinity;
 
-      snapPoints.forEach((snapPoint) => {
+      for (const snapPoint of snapPoints) {
         const distance = Math.abs(targetTime - snapPoint.time);
         if (distance < thresholdInSeconds && distance < closestDistance) {
           closestDistance = distance;
           closestSnapPoint = snapPoint;
         }
-      });
+      }
 
       return {
         snappedTime: closestSnapPoint
@@ -109,34 +112,38 @@ export function useTimelineSnapping({
   );
 
   const snapElementEdge = useCallback(
-    (
-      targetTime: number,
-      elementDuration: number,
-      tracks: TimelineTrack[],
-      playheadTime: number,
-      zoomLevel: number,
-      excludeElementId?: string,
-      snapToStart = true, // true for start edge, false for end edge
-    ): SnapResult => {
-      const snapPoints = findSnapPoints(
+    ({
+      targetTime,
+      elementDuration,
+      tracks,
+      playheadTime,
+      zoomLevel,
+      excludeElementId,
+      snapToStart = true,
+    }: {
+      targetTime: number;
+      elementDuration: number;
+      tracks: Array<TimelineTrack>;
+      playheadTime: number;
+      zoomLevel: number;
+      excludeElementId?: string;
+      snapToStart?: boolean;
+    }): SnapResult => {
+      const snapPoints = findSnapPoints({
         tracks,
-        targetTime,
         playheadTime,
-        zoomLevel,
         excludeElementId,
-      );
+      });
 
-      // For end edge snapping, we need to account for element duration
       const effectiveTargetTime = snapToStart
         ? targetTime
         : targetTime + elementDuration;
-      const snapResult = snapToNearestPoint(
-        effectiveTargetTime,
+      const snapResult = snapToNearestPoint({
+        targetTime: effectiveTargetTime,
         snapPoints,
         zoomLevel,
-      );
+      });
 
-      // Adjust the snapped time back for end edge
       if (!snapToStart && snapResult.snapPoint) {
         snapResult.snappedTime = snapResult.snappedTime - elementDuration;
       }