@ldelia/react-media 0.6.0 → 0.6.2

package/dist/components/reproduction-widget/inner-players/YouTubeInnerPlayer.js

@@ -1,4 +1,4 @@
-import React, { useRef } from 'react';
+import React, { useEffect, useRef } from 'react';
 import ReactPlayer from 'react-player/lazy';
 export const YouTubeInnerPlayer = ({ videoId, onReady, onVideoUnavailable }) => {
     const hasErrorRef = useRef(false);
@@ -35,5 +35,13 @@ export const YouTubeInnerPlayer = ({ videoId, onReady, onVideoUnavailable }) =>
             console.warn('Unhandled YouTube error:', error);
         }
     };
+    // Reset refs when videoId changes
+    useEffect(() => {
+        hasErrorRef.current = false;
+        if (readyTimeoutRef.current) {
+            clearTimeout(readyTimeoutRef.current);
+            readyTimeoutRef.current = null;
+        }
+    }, [videoId]);
     return (React.createElement(ReactPlayer, { url: `https://www.youtube.com/watch?v=${videoId}`, onReady: handleReady, onError: handleError }));
 };

package/dist/components/timeline/RangeSelectorCanvas/RangeSelectorCanvas.js

@@ -3,19 +3,28 @@ import styled from 'styled-components';
 import { ZoomContext } from '../ZoomContext/ZoomContext';
 import { pixelToSeconds, secondsToPixel } from '../utils/utils';
 const OverlayCanvas = styled.canvas `
-  position: absolute;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-  color: cadetblue;
-  cursor: pointer;
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    color: cadetblue;
+    cursor: pointer;
 `;
+var DragMode;
+(function (DragMode) {
+    DragMode[DragMode["NONE"] = 0] = "NONE";
+    DragMode[DragMode["CREATE"] = 1] = "CREATE";
+    DragMode[DragMode["RESIZE_START"] = 2] = "RESIZE_START";
+    DragMode[DragMode["RESIZE_END"] = 3] = "RESIZE_END";
+})(DragMode || (DragMode = {}));
+const RESIZE_HANDLE_WIDTH = 10; // Width in pixels for the resize handle detection zone
 const RangeSelectorCanvas = ({ selectedRange, onChange, onRangeChange, }) => {
     const canvasRef = useRef(null);
     const zoomContextValue = useContext(ZoomContext);
     const [selection, setSelection] = useState({ start: null, end: null });
-    const [isDragging, setIsDragging] = useState(false);
+    const [dragMode, setDragMode] = useState(DragMode.NONE);
+    const [cursorStyle, setCursorStyle] = useState('pointer');
     const getMousePointerPixelPosition = (e) => {
         const canvas = canvasRef.current;
         let rect = canvas.getBoundingClientRect();
@@ -32,56 +41,118 @@ const RangeSelectorCanvas = ({ selectedRange, onChange, onRangeChange, }) => {
         context.fillRect(pixelX0, 0, pixelX1 - pixelX0, context.canvas.height);
         context.globalAlpha = 1.0;
     };
-    // Handle mouse down (start of selection)
+    // Check if mouse is near the start or end edge of the selection
+    const isNearSelectionEdge = (pixel) => {
+        if (selectedRange.length !== 2)
+            return { isNear: false, edge: null };
+        const startPixel = secondsToPixel(zoomContextValue, selectedRange[0]);
+        const endPixel = secondsToPixel(zoomContextValue, selectedRange[1]);
+        if (Math.abs(pixel - startPixel) <= RESIZE_HANDLE_WIDTH) {
+            return { isNear: true, edge: 'start' };
+        }
+        else if (Math.abs(pixel - endPixel) <= RESIZE_HANDLE_WIDTH) {
+            return { isNear: true, edge: 'end' };
+        }
+        return { isNear: false, edge: null };
+    };
+    // Handle mouse move for cursor style when not dragging
+    const handleMouseOver = (event) => {
+        const pixel = getMousePointerPixelPosition(event);
+        const { isNear } = isNearSelectionEdge(pixel);
+        if (isNear) {
+            setCursorStyle('col-resize');
+        }
+        else {
+            setCursorStyle('pointer');
+        }
+    };
+    // Handle mouse down (start of selection or resize)
     const handleMouseDown = (event) => {
         const canvas = canvasRef.current;
         if (!canvas)
             return;
         const pixel = getMousePointerPixelPosition(event);
         const second = pixelToSeconds(zoomContextValue, pixel);
-        setSelection({ start: second, end: null });
-        setIsDragging(true);
+        const { isNear, edge } = isNearSelectionEdge(pixel);
+        if (isNear && edge === 'start') {
+            setDragMode(DragMode.RESIZE_START);
+            setSelection({ start: selectedRange[0], end: selectedRange[1] });
+        }
+        else if (isNear && edge === 'end') {
+            setDragMode(DragMode.RESIZE_END);
+            setSelection({ start: selectedRange[0], end: selectedRange[1] });
+        }
+        else {
+            setDragMode(DragMode.CREATE);
+            setSelection({ start: second, end: null });
+        }
     };
-    // Handle mouse up (end of selection or single click)
+    // Handle mouse up (end of selection/resize or single click)
     const handleMouseUp = (event) => {
         const canvas = canvasRef.current;
         if (!canvas)
             return;
         const pixel = getMousePointerPixelPosition(event);
         const seconds = pixelToSeconds(zoomContextValue, pixel);
-        if (isDragging) {
-            setSelection(prevSelection => {
-                if (prevSelection.start === seconds) {
-                    onChange(seconds);
-                    return { start: null, end: null };
-                }
-                else {
-                    const curatedSelection = seconds < prevSelection.start ? [seconds, prevSelection.start] : [prevSelection.start, seconds];
-                    onRangeChange(curatedSelection);
-                    return {
-                        start: curatedSelection[0],
-                        end: curatedSelection[1],
-                    };
-                }
-            });
+        if (dragMode === DragMode.CREATE) {
+            if (selection.start === seconds) {
+                // Single click
+                onChange(seconds);
+                setSelection({ start: null, end: null });
+            }
+            else {
+                // Created a new selection
+                const curatedSelection = seconds < selection.start
+                    ? [seconds, selection.start]
+                    : [selection.start, seconds];
+                onRangeChange(curatedSelection);
+                setSelection({
+                    start: curatedSelection[0],
+                    end: curatedSelection[1],
+                });
+            }
+        }
+        else if (dragMode === DragMode.RESIZE_START || dragMode === DragMode.RESIZE_END) {
+            // Resizing completed
+            if (selection.start !== null && selection.end !== null) {
+                const curatedSelection = [
+                    Math.min(selection.start, selection.end),
+                    Math.max(selection.start, selection.end)
+                ];
+                onRangeChange(curatedSelection);
+            }
         }
-        setIsDragging(false);
+        setDragMode(DragMode.NONE);
     };
     // Handle mouse move (for dragging)
     const handleMouseMove = (event) => {
-        if (!isDragging)
-            return; // the mouse is moving over the canvas but the user has not clicked yet
+        // Update cursor first (always check this regardless of drag state)
+        handleMouseOver(event);
+        if (dragMode === DragMode.NONE)
+            return;
         const canvas = canvasRef.current;
         if (!canvas)
             return;
         const pixel = getMousePointerPixelPosition(event);
         const seconds = pixelToSeconds(zoomContextValue, pixel);
-        setSelection(prevSelection => {
-            return {
+        if (dragMode === DragMode.CREATE) {
+            setSelection(prevSelection => ({
+                start: prevSelection.start,
+                end: seconds,
+            }));
+        }
+        else if (dragMode === DragMode.RESIZE_START) {
+            setSelection(prevSelection => ({
+                start: seconds,
+                end: prevSelection.end,
+            }));
+        }
+        else if (dragMode === DragMode.RESIZE_END) {
+            setSelection(prevSelection => ({
                 start: prevSelection.start,
                 end: seconds,
-            };
-        });
+            }));
+        }
     };
     useEffect(() => {
         const canvas = canvasRef.current;
@@ -91,7 +162,7 @@ const RangeSelectorCanvas = ({ selectedRange, onChange, onRangeChange, }) => {
         if (selectedRange.length !== 2 || zoomContextValue.timelineWrapperWidth === 0)
             return;
         drawRect(secondsToPixel(zoomContextValue, selectedRange[0]), secondsToPixel(zoomContextValue, selectedRange[1]));
-    }, [selectedRange]);
+    }, [selectedRange, zoomContextValue]);
     useEffect(() => {
         const canvas = canvasRef.current;
         // https://stackoverflow.com/questions/8696631/canvas-drawings-like-lines-are-blurry
@@ -101,6 +172,6 @@ const RangeSelectorCanvas = ({ selectedRange, onChange, onRangeChange, }) => {
             return;
         drawRect(secondsToPixel(zoomContextValue, selection.start), secondsToPixel(zoomContextValue, selection.end));
     }, [selection, zoomContextValue]);
-    return (React.createElement(OverlayCanvas, { ref: canvasRef, onMouseDown: handleMouseDown, onMouseMove: handleMouseMove, onMouseUp: handleMouseUp, className: 'media-timeline-range-selector-canvas' }));
+    return (React.createElement(OverlayCanvas, { ref: canvasRef, onMouseDown: handleMouseDown, onMouseMove: handleMouseMove, onMouseUp: handleMouseUp, style: { cursor: cursorStyle }, className: 'media-timeline-range-selector-canvas' }));
 };
 export default React.memo(RangeSelectorCanvas);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ldelia/react-media",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "A React components collection for media-related features.",
   "private": false,
   "keywords": [