@widgetic/design-system 0.3.68

package/dist/components/widget-system/Moveable.svelte

@@ -0,0 +1,661 @@
+<script lang="ts">
+    import { onMount, createEventDispatcher } from 'svelte';
+
+    // Props
+    export let width: string = "100%";
+    export let height: string = "100%";
+    export let minWidth: number = 50;
+    export let minHeight: number = 50;
+    export let enableResize: boolean = true;
+    export let className: string = "";  // New prop for additional CSS classes
+    
+
+    // Internal state
+    let container: HTMLElement;
+    let hoverContainer: HTMLElement;
+    let isDragging: boolean = false;
+    let isResizing: boolean = false;
+    let isHovering: boolean = false;
+    let isInitialized: boolean = false;
+    let resizeDirection: string = '';
+    let initialPos = { x: 0, y: 0 };
+    let initialSize = { width: 0, height: 0 };
+    let currentWidth = 0;
+    let currentHeight = 0;
+    let currentLeft = 0;
+    let currentTop = 0;
+    let startPoint = { x: 0, y: 0 };
+    let showSizeInfo = false;
+    let isMac = false;
+    
+    // Key modifiers
+    let isCmdCtrlKeyDown = false;  // Command(Mac) or Control(Win) for dragging
+    let isSpaceKeyDown = false;    // Space key for dragging (alternative)
+    let isShiftKeyDown = false;    // Shift for proportional resize
+    let isAltOptKeyDown = false;   // Alt/Option for symmetrical resize
+
+    // Event dispatcher
+    const dispatch = createEventDispatcher();
+
+    // Parse size from string (e.g. "400px") to number
+    function parseSize(size: string): number {
+        if (typeof size !== 'string') return 0;
+        return parseInt(size.replace('px', '')) || 0;
+    }
+
+    function logState(prefix: string) {
+        // console.log(`${prefix} - Position: (${currentLeft.toFixed(1)}, ${currentTop.toFixed(1)}), Size: ${Math.round(currentWidth)}x${Math.round(currentHeight)}`);
+    }
+
+    // Track key states
+    function handleKeyDown(e: KeyboardEvent) {
+        if ((isMac && e.key === 'Meta') || (!isMac && e.key === 'Control')) {
+            isCmdCtrlKeyDown = true;
+            updateContainerClasses();
+        } else if (e.key === ' ') { // Space key
+            isSpaceKeyDown = true;
+            updateContainerClasses();
+            // Prevent page scrolling when space is pressed
+            if (e.target === document.body) {
+                e.preventDefault();
+            }
+        } else if (e.key === 'Shift') {
+            isShiftKeyDown = true;
+            updateContainerClasses();
+        } else if (e.key === 'Alt') {
+            e.preventDefault(); // Prevent browser menu
+            isAltOptKeyDown = true;
+            updateContainerClasses();
+        }
+    }
+
+    function handleKeyUp(e: KeyboardEvent) {
+        if ((isMac && e.key === 'Meta') || (!isMac && e.key === 'Control')) {
+            isCmdCtrlKeyDown = false;
+            updateContainerClasses();
+        } else if (e.key === ' ') { // Space key
+            isSpaceKeyDown = false;
+            updateContainerClasses();
+        } else if (e.key === 'Shift') {
+            isShiftKeyDown = false;
+            updateContainerClasses();
+        } else if (e.key === 'Alt') {
+            isAltOptKeyDown = false;
+            updateContainerClasses();
+        }
+    }
+    
+    function updateContainerClasses() {
+        if (!container) return;
+        
+        // Reset all mode classes
+        container.classList.remove('drag-mode');
+        container.classList.remove('proportional-mode');
+        container.classList.remove('symmetrical-mode');
+        container.classList.remove('combined-mode');
+        
+        // Apply appropriate mode class based on key combination
+        if (isCmdCtrlKeyDown || isSpaceKeyDown) {
+            container.classList.add('drag-mode');
+        }
+        
+        if (isShiftKeyDown && isAltOptKeyDown) {
+            container.classList.add('combined-mode');
+        } else if (isShiftKeyDown) {
+            container.classList.add('proportional-mode');
+        } else if (isAltOptKeyDown) {
+            container.classList.add('symmetrical-mode');
+        }
+    }
+
+    // Track hover state
+    function handleMouseEnter() {
+        if (isInitialized) {
+            isHovering = true;
+        }
+    }
+
+    function handleMouseLeave() {
+        if (!isResizing && !isDragging) {
+            isHovering = false;
+        }
+    }
+
+    onMount(() => {
+        // Detect if we're on a Mac
+        isMac = typeof navigator !== 'undefined' && navigator.platform.toUpperCase().indexOf('MAC') >= 0;
+        
+        // Initialize from props first if they are in px format
+        const initialWidth = parseSize(width);
+        const initialHeight = parseSize(height);
+
+        if (initialWidth > 0 && initialHeight > 0) {
+            currentWidth = initialWidth;
+            currentHeight = initialHeight;
+        }
+
+        // After first render, get actual container dimensions
+        setTimeout(() => {
+            const rect = container.getBoundingClientRect();
+            
+            // Only update if we couldn't parse from props
+            if (currentWidth === 0) currentWidth = rect.width;
+            if (currentHeight === 0) currentHeight = rect.height;
+            
+            // Set initial position (centered in the parent container if possible)
+            if (container.parentElement) {
+                const parentRect = container.parentElement.getBoundingClientRect();
+                currentLeft = (parentRect.width - currentWidth) / 2;
+                currentTop = (parentRect.height - currentHeight) / 2;
+            } else {
+                currentLeft = 0;
+                currentTop = 0;
+            }
+
+            // console.log("Moveable component initialized", { currentWidth, currentHeight, currentLeft, currentTop });
+            // Set initialized to true only after component is fully set up
+            isInitialized = true;
+        }, 0);
+
+        // Add key event listeners
+        document.addEventListener('keydown', handleKeyDown);
+        document.addEventListener('keyup', handleKeyUp);
+
+        // Clean up event listeners on destroy
+        return () => {
+            document.removeEventListener('mousemove', handleMouseMove);
+            document.removeEventListener('mouseup', handleMouseUp);
+            document.removeEventListener('keydown', handleKeyDown);
+            document.removeEventListener('keyup', handleKeyUp);
+        };
+    });
+
+    // Handle mouse events for drag
+    function handleMouseDown(e: MouseEvent) {
+        // Only allow dragging when Command/Control key or Space key is down
+        if (!(isCmdCtrlKeyDown || isSpaceKeyDown) || isResizing) return;
+        
+        // Prevent starting a drag on resize handles
+        if ((e.target as HTMLElement).classList.contains('resize-handle')) {
+            return;
+        }
+        
+        isDragging = true;
+        initialPos = { x: currentLeft, y: currentTop };
+        startPoint = { x: e.clientX, y: e.clientY };
+        
+        document.addEventListener('mousemove', handleMouseMove);
+        document.addEventListener('mouseup', handleMouseUp);
+        document.body.style.cursor = 'move';
+        logState("Drag started");
+        e.preventDefault();
+    }
+
+    function handleMouseMove(e: MouseEvent) {
+        if (isDragging && !isResizing) {
+            const dx = e.clientX - startPoint.x;
+            const dy = e.clientY - startPoint.y;
+            
+            currentLeft = initialPos.x + dx;
+            currentTop = initialPos.y + dy;
+            
+            logState("Dragging");
+            dispatch('move', { left: currentLeft, top: currentTop });
+        } else if (isResizing) {
+            handleResize(e.clientX, e.clientY);
+        }
+    }
+
+    function handleMouseUp() {
+        if (isDragging) {
+            isDragging = false;
+            document.removeEventListener('mousemove', handleMouseMove);
+            document.removeEventListener('mouseup', handleMouseUp);
+            document.body.style.cursor = '';
+            logState("Drag ended");
+            dispatch('moveEnd', { left: currentLeft, top: currentTop });
+            showSizeInfo = false;
+        } else if (isResizing) {
+            isResizing = false;
+            resizeDirection = '';
+            document.removeEventListener('mousemove', handleMouseMove);
+            document.removeEventListener('mouseup', handleMouseUp);
+            logState("Resize ended");
+            dispatch('resizeEnd', { width: currentWidth, height: currentHeight });
+            showSizeInfo = false;
+        }
+    }
+
+    // Handle resize
+    function handleResizeStart(e: MouseEvent, direction: string) {
+        if (!enableResize) return;
+        
+        isResizing = true;
+        showSizeInfo = true;
+        resizeDirection = direction;
+        
+        // Mark the handle as active
+        const handle = e.target as HTMLElement;
+        if (handle) {
+            handle.classList.add('active');
+        }
+        
+        initialSize = { width: currentWidth, height: currentHeight };
+        initialPos = { x: currentLeft, y: currentTop };
+        startPoint = { x: e.clientX, y: e.clientY };
+        
+        document.addEventListener('mousemove', handleMouseMove);
+        document.addEventListener('mouseup', handleMouseUp);
+        
+        e.preventDefault();
+        e.stopPropagation();
+    }
+
+    function handleResize(clientX: number, clientY: number) {
+        const dx = clientX - startPoint.x;
+        const dy = clientY - startPoint.y;
+        
+        // Calculate center point for symmetrical resize
+        const centerX = initialPos.x + initialSize.width / 2;
+        const centerY = initialPos.y + initialSize.height / 2;
+        
+        let newWidth = initialSize.width;
+        let newHeight = initialSize.height;
+        let newLeft = initialPos.x;
+        let newTop = initialPos.y;
+        
+        // Store original resize direction for later reference
+        const originalDirection = resizeDirection;
+        let cornerDeltaX = 0;
+        let cornerDeltaY = 0;
+        
+        // Apply symmetrical resize first if Alt is held (with or without Shift)
+        if (isAltOptKeyDown) {
+            // Get the delta for the corner being dragged
+            switch (resizeDirection) {
+                case 'tl':
+                    cornerDeltaX = -dx;
+                    cornerDeltaY = -dy;
+                    break;
+                case 'tr':
+                    cornerDeltaX = dx;
+                    cornerDeltaY = -dy;
+                    break;
+                case 'bl':
+                    cornerDeltaX = -dx;
+                    cornerDeltaY = dy;
+                    break;
+                case 'br':
+                    cornerDeltaX = dx;
+                    cornerDeltaY = dy;
+                    break;
+            }
+            
+            // Apply the delta to all corners symmetrically
+            newWidth = Math.max(initialSize.width + cornerDeltaX * 2, minWidth);
+            newHeight = Math.max(initialSize.height + cornerDeltaY * 2, minHeight);
+            
+            // Center the widget
+            newLeft = centerX - newWidth / 2;
+            newTop = centerY - newHeight / 2;
+        } else {
+            // Standard resize without symmetry
+            switch (resizeDirection) {
+                case 'tl':
+                    newWidth = Math.max(initialSize.width - dx, minWidth);
+                    newHeight = Math.max(initialSize.height - dy, minHeight);
+                    newLeft = initialPos.x + (initialSize.width - newWidth);
+                    newTop = initialPos.y + (initialSize.height - newHeight);
+                    break;
+                case 'tr':
+                    newWidth = Math.max(initialSize.width + dx, minWidth);
+                    newHeight = Math.max(initialSize.height - dy, minHeight);
+                    newTop = initialPos.y + (initialSize.height - newHeight);
+                    break;
+                case 'bl':
+                    newWidth = Math.max(initialSize.width - dx, minWidth);
+                    newHeight = Math.max(initialSize.height + dy, minHeight);
+                    newLeft = initialPos.x + (initialSize.width - newWidth);
+                    break;
+                case 'br':
+                    newWidth = Math.max(initialSize.width + dx, minWidth);
+                    newHeight = Math.max(initialSize.height + dy, minHeight);
+                    break;
+            }
+        }
+        
+        // Apply proportional resize if shift is held
+        if (isShiftKeyDown) {
+            const aspectRatio = initialSize.width / initialSize.height;
+            const currentRatio = newWidth / newHeight;
+            
+            if (currentRatio > aspectRatio) {
+                newWidth = newHeight * aspectRatio;
+            } else {
+                newHeight = newWidth / aspectRatio;
+            }
+            
+            // Adjust position based on resize direction, except when in symmetrical mode
+            if (!isAltOptKeyDown) {
+                switch (resizeDirection) {
+                    case 'tl':
+                        newLeft = initialPos.x + initialSize.width - newWidth;
+                        newTop = initialPos.y + initialSize.height - newHeight;
+                        break;
+                    case 'tr':
+                        newTop = initialPos.y + initialSize.height - newHeight;
+                        break;
+                    case 'bl':
+                        newLeft = initialPos.x + initialSize.width - newWidth;
+                        break;
+                }
+            } else {
+                // When both Shift and Alt are pressed, keep centered
+                newLeft = centerX - newWidth / 2;
+                newTop = centerY - newHeight / 2;
+            }
+        }
+        
+        // Apply the final values
+        currentWidth = Math.max(newWidth, minWidth);
+        currentHeight = Math.max(newHeight, minHeight);
+        currentLeft = newLeft;
+        currentTop = newTop;
+        
+        dispatch('resize', { width: currentWidth, height: currentHeight });
+    }
+
+    // Export methods to be accessible from parent
+    export function getDimensions() {
+        return {
+            width: currentWidth,
+            height: currentHeight,
+            left: currentLeft,
+            top: currentTop
+        };
+    }
+
+    export function setPosition(left: number, top: number) {
+        currentLeft = left;
+        currentTop = top;
+    }
+
+    export function setDimensions(newWidth: number, newHeight: number) {
+        currentWidth = Math.max(newWidth, minWidth);
+        currentHeight = Math.max(newHeight, minHeight);
+    }
+</script>
+
+<!-- Hover area container with padding -->
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div 
+    bind:this={hoverContainer}
+    class="hover-container {className}"
+    style="position: absolute; left: {currentLeft - 8}px; top: {currentTop - 8}px; width: {currentWidth + 16}px; height: {currentHeight + 16}px;"
+    on:mouseenter={handleMouseEnter}
+    on:mouseleave={handleMouseLeave}
+>
+    <!-- Actual moveable container -->
+    <!-- svelte-ignore a11y_no_static_element_interactions -->
+    <div 
+        bind:this={container}
+        class="moveable-container {isCmdCtrlKeyDown || isSpaceKeyDown ? 'drag-mode' : ''} {isShiftKeyDown && !isAltOptKeyDown ? 'proportional-mode' : ''} {isAltOptKeyDown && !isShiftKeyDown ? 'symmetrical-mode' : ''} {isShiftKeyDown && isAltOptKeyDown ? 'combined-mode' : ''}"
+        class:hovering={isHovering}
+        style="position: absolute; left: 8px; top: 8px; width: {currentWidth}px; height: {currentHeight}px;"
+        on:mousedown={handleMouseDown}
+    >
+        <slot></slot>
+        
+        {#if enableResize}
+            <!-- Resize handles for all corners -->
+            <!-- svelte-ignore a11y_mouse_events_have_key_events -->
+            <div 
+                class="resize-handle tl" 
+                class:active={isResizing && resizeDirection === 'tl'} 
+                on:mousedown={(e) => handleResizeStart(e, 'tl')}
+            ></div>
+            <!-- svelte-ignore a11y_mouse_events_have_key_events -->
+            <div 
+                class="resize-handle tr" 
+                class:active={isResizing && resizeDirection === 'tr'} 
+                on:mousedown={(e) => handleResizeStart(e, 'tr')}
+            ></div>
+            <!-- svelte-ignore a11y_mouse_events_have_key_events -->
+            <div 
+                class="resize-handle bl" 
+                class:active={isResizing && resizeDirection === 'bl'} 
+                on:mousedown={(e) => handleResizeStart(e, 'bl')}
+            ></div>
+            <!-- svelte-ignore a11y_mouse_events_have_key_events -->
+            <div 
+                class="resize-handle br" 
+                class:active={isResizing && resizeDirection === 'br'} 
+                on:mousedown={(e) => handleResizeStart(e, 'br')}
+            ></div>
+        {/if}
+
+        <!-- Size information display -->
+        {#if (isResizing || showSizeInfo) && currentWidth > 0 && currentHeight > 0}
+            <div class="size-info">
+                {Math.round(currentWidth)} × {Math.round(currentHeight)}
+            </div>
+        {/if}
+    </div>
+</div>
+
+<!-- Key shortcut guide (uncomment if needed) -->
+<!-- <div class="key-guide">
+    <span>Hold {isMac ? 'Command ⌘' : 'Control'} or Space to drag</span>
+    <span>Hold Shift ⇧ for proportional resize</span>
+    <span>Hold {isMac ? 'Option ⌥' : 'Alt'} for symmetrical resize</span>
+</div> -->
+
+<style>
+    /* Color variables for mode styles */
+    :root {
+        /* Drag mode - Light Blue */
+        --drag-color: #2196F3;
+        --drag-opacity: 0.45;
+        
+        /* Proportional mode - Green */
+        --proportional-color: #4CAF50;
+        --proportional-opacity: 0;
+        
+        /* Symmetrical mode - Orange */
+        --symmetrical-color: #FF9800;
+        --symmetrical-opacity: 0;
+        
+        /* Combined mode - Purple */
+        --combined-color: #e736f4;
+        --combined-opacity: 0;
+    }
+
+    .hover-container {
+        position: absolute;
+        box-sizing: border-box;
+        background-color: transparent;
+        z-index: 10;
+    }
+    
+    .moveable-container {
+        position: relative;
+        box-sizing: border-box;
+        cursor: default;
+        border: 1px solid transparent;
+        z-index: 1; /* Lower z-index for the widget */
+    }
+
+    /* Move cursor only when hovering the container in drag mode */
+    .moveable-container.drag-mode {
+        cursor: move !important;
+    }
+
+    .moveable-container::before {
+        content: '';
+        position: absolute;
+        inset: -1px;
+        background-color: transparent;
+        border: 1px solid transparent;
+        pointer-events: none;
+        z-index: 2; /* Higher than widget content, but lower than resize handles */
+    }
+
+    /* Various mode styles */
+    .moveable-container.drag-mode::before {
+        /* Fallback for browsers that don't support color-mix */
+        background-color: rgba(33, 150, 243, 0.15);
+        background-color: color-mix(in srgb, var(--drag-color), transparent calc(100% - calc(var(--drag-opacity) * 100%)));
+        border-color: var(--drag-color);
+        pointer-events: auto; /* Block pointer events when in drag mode */
+    }
+    
+    /* Make sure resize handles maintain their cursors even in drag mode */
+    .moveable-container.drag-mode .resize-handle {
+        cursor: nwse-resize !important;
+    }
+    
+    .moveable-container.drag-mode .resize-handle.tr,
+    .moveable-container.drag-mode .resize-handle.bl {
+        cursor: nesw-resize !important;
+    }
+    
+    .moveable-container.proportional-mode::before {
+        /* Fallback for browsers that don't support color-mix */
+        background-color: rgba(76, 175, 80, 0.15);
+        background-color: color-mix(in srgb, var(--proportional-color), transparent calc(100% - calc(var(--proportional-opacity) * 100%)));
+        border-color: var(--proportional-color);
+    }
+    
+    .moveable-container.symmetrical-mode::before {
+        /* Fallback for browsers that don't support color-mix */
+        background-color: rgba(255, 152, 0, 0.15);
+        background-color: color-mix(in srgb, var(--symmetrical-color), transparent calc(100% - calc(var(--symmetrical-opacity) * 100%)));
+        border-color: var(--symmetrical-color);
+    }
+    
+    .moveable-container.combined-mode::before {
+        /* Fallback for browsers that don't support color-mix */
+        background-color: rgba(244, 67, 54, 0.15);
+        background-color: color-mix(in srgb, var(--combined-color), transparent calc(100% - calc(var(--combined-opacity) * 100%)));
+        border-color: var(--combined-color);
+    }
+    
+    .resize-handle {
+        position: absolute;
+        width: 16px;
+        height: 16px;
+        background-color: #ffffff;
+        border: 2px solid hsl(var(--grey5));
+        border-radius: 50%;
+        z-index: 100; /* High z-index for resize handles */
+        opacity: 0;
+        transform: scale(0);
+        visibility: hidden;
+        transition: all 200ms ease;
+    }
+    
+    /* Show resize handles when container is hovered or during resize */
+    .hovering:not(.drag-mode) .resize-handle,
+    .resize-handle.active {
+        opacity: 1;
+        transform: scale(1);
+        visibility: visible;
+    }
+    
+    /* Hide resize handles when in drag mode except active ones */
+    .moveable-container.drag-mode .resize-handle:not(.active) {
+        opacity: 0;
+        transform: scale(0);
+        visibility: hidden;
+    }
+    
+    /* Handle hover state */
+    .resize-handle:hover,
+    .resize-handle.active {
+        width: 20px;
+        height: 20px;
+        margin-top: -2px;
+        margin-left: -2px;
+        border-color: hsl(var(--grey7));
+        visibility: visible;
+    }
+    
+    /* Right-side handles need different margin adjustment */
+    .resize-handle.tr:hover,
+    .resize-handle.tr.active {
+        margin-right: -2px;
+        margin-left: 0;
+    }
+
+    .resize-handle.br:hover,
+    .resize-handle.br.active {
+        margin-right: -2px;
+        margin-left: 0;
+    }
+    
+    /* Ensure active handle stays visible in drag mode */
+    .moveable-container.drag-mode .resize-handle.active {
+        opacity: 1;
+        visibility: visible;
+        width: 20px;
+        height: 20px;
+        border-color: hsl(var(--grey7));
+    }
+    
+    .tl {
+        top: -8px;
+        left: -8px;
+        cursor: nwse-resize;
+    }
+    
+    .tr {
+        top: -8px;
+        right: -8px;
+        cursor: nesw-resize;
+    }
+    
+    .bl {
+        bottom: -8px;
+        left: -8px;
+        cursor: nesw-resize;
+    }
+    
+    .br {
+        bottom: -8px;
+        right: -8px;
+        cursor: nwse-resize;
+    }
+    
+    .size-info {
+        position: absolute;
+        bottom: -30px;
+        left: 0;
+        right: 0;
+        margin: 0 auto;
+        text-align: center;
+        background-color: rgba(0, 0, 0, 0.7);
+        color: white;
+        padding: 4px 8px;
+        border-radius: 4px;
+        font-size: 12px;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        width: -moz-fit-content;
+        width: fit-content;
+        z-index: 200; /* Highest z-index for info tooltip */
+    }
+    
+    .key-guide {
+        position: absolute;
+        bottom: -35px;
+        left: 0;
+        right: 0;
+        margin: 0 auto;
+        display: flex;
+        gap: 10px;
+        justify-content: center;
+        font-size: 12px;
+        color: #555;
+        pointer-events: none;
+        z-index: 150; /* High z-index for key guide */
+    }
+</style>