@wix/astro 0.2.13 → 0.2.15

package/dist/dev-toolbar/Editor/dnd.js

@@ -0,0 +1,1161 @@
+import { useDragLoader } from "../../hooks/use-loader-context.js";
+import React from "react";
+// Store the loader functions for global access
+let showDragLoader = null;
+let hideDragLoader = null;
+// Hook to initialize the loader functions
+export function useDragLoaderInit() {
+    const { showDragLoader: show, hideDragLoader: hide } = useDragLoader();
+    // Update the global references
+    showDragLoader = show;
+    hideDragLoader = hide;
+}
+// Constants
+var EditorAttributes;
+(function (EditorAttributes) {
+    EditorAttributes["DATA_PICASSO_DRAGGING"] = "data-picasso-dragging";
+    EditorAttributes["DATA_PICASSO_DRAG_SAVED_STYLE"] = "data-picasso-drag-saved-style";
+    EditorAttributes["DATA_PICASSO_DRAG_DIRECTION"] = "data-picasso-drag-direction";
+    EditorAttributes["DATA_PICASSO_DRAG_START_POSITION"] = "data-picasso-drag-start-position";
+    EditorAttributes["DATA_PICASSO_ORIGINAL_PARENT"] = "data-picasso-original-parent";
+})(EditorAttributes || (EditorAttributes = {}));
+// Add this near the top with other constants
+const VALID_DROP_TARGET_CLASS = "picasso-valid-drop-target";
+const INVALID_DROP_TARGET_CLASS = "picasso-invalid-drop-target";
+// Store component move instructions internally
+let componentMoveInstructions = [];
+// Function to create a component move instruction
+function createComponentMoveChange(component, sourceFile, fromLine, toLine, parentNode, parentId, toFile, originalParentNode, originalParentId) {
+    // Create the base instruction
+    const instruction = {
+        type: "componentMove",
+        timestamp: new Date().toISOString(),
+        component,
+        toLine,
+        parentNode,
+        parentId,
+        originalParentNode,
+        originalParentId
+    };
+    // For cross-file moves, add toFile property
+    if (toFile && toFile !== sourceFile) {
+        // Use type assertion to add toFile to the instruction
+        // This works around TypeScript errors if the types.tsx update hasn't been picked up
+        instruction.toFile = toFile;
+    }
+    return {
+        file: sourceFile,
+        line: fromLine,
+        instruction,
+    };
+}
+// Function to add a component move change to the list
+function addComponentMoveChange(change) {
+    componentMoveInstructions.push(change);
+    console.log("Component move change added:", change);
+}
+// Export a function to get all component move changes
+export function getComponentMoveChanges() {
+    return [...componentMoveInstructions];
+}
+// Export a function to clear component move changes
+export function clearComponentMoveChanges() {
+    componentMoveInstructions = [];
+}
+// Helper functions
+function elementFromDomId(domId) {
+    return document.getElementById(domId);
+}
+function calculateMouseOffset(el, mouseX, mouseY) {
+    const rect = el.getBoundingClientRect();
+    return {
+        x: mouseX - rect.left,
+        y: mouseY - rect.top,
+    };
+}
+function isValidHtmlElement(node) {
+    return node instanceof HTMLElement;
+}
+function createStub(el) {
+    const stub = document.createElement("div");
+    stub.id = "drag-stub";
+    stub.style.height = `${el.offsetHeight}px`;
+    stub.style.width = `${el.offsetWidth}px`;
+    stub.style.background = "#e0e0e0";
+    stub.style.border = "2px dashed #aaa";
+    stub.style.borderRadius = "4px";
+    // Insert stub before the element being dragged
+    if (el.parentElement) {
+        el.parentElement.insertBefore(stub, el);
+    }
+}
+// Add a variable to track the last insertion point to prevent jitter
+let lastInsertionTarget = null;
+let lastUpdateTime = 0;
+const JITTER_THRESHOLD_PX = 20; // Minimum distance in pixels to trigger a change
+const DEBOUNCE_DELAY = 150; // Minimum delay between updates in milliseconds
+// Add variables to track last position for smooth movement
+let lastDragX = 0;
+let lastDragY = 0;
+const MOVEMENT_SMOOTHING = 0.5; // Higher = less smoothing but more responsive
+// Add a variable to store the last stable insertion index
+let lastStableIndex = -1;
+let stablePositionCount = 0;
+const STABILITY_THRESHOLD = 3; // Number of consistent positions before committing
+function moveStub(el, x, y) {
+    const stub = document.getElementById("drag-stub");
+    if (!stub)
+        return;
+    // Check if we're over a different container
+    const dropTarget = getDropTargetAt(x, y, el);
+    // If no drop target found, use the original parent
+    const originalParentId = el.getAttribute(EditorAttributes.DATA_PICASSO_ORIGINAL_PARENT);
+    const originalParent = originalParentId ? document.getElementById(originalParentId) : null;
+    const currentParent = stub.parentElement;
+    // Determine which container to use (drop target or original parent)
+    let targetContainer = dropTarget || (originalParent || el.parentElement);
+    // CRITICAL SAFETY CHECK: Never allow the stub to be its own container
+    // This prevents "Failed to execute 'appendChild' on 'Node': The new child element contains the parent" error
+    if (targetContainer === stub) {
+        console.error("Prevented circular reference: stub trying to append to itself");
+        targetContainer = originalParent || el.parentElement;
+        // If we still have an invalid container, abort the operation
+        if (!targetContainer || targetContainer === stub) {
+            console.error("Cannot find valid container for stub, aborting drag operation");
+            removeStub();
+            endAllDrag();
+            return;
+        }
+    }
+    // Additional safety check to prevent circular references:
+    // 1. Ensure target container is not null
+    // 2. Ensure it's not the element itself
+    // 3. Ensure it's not a descendant of the element
+    if (!targetContainer ||
+        targetContainer === el ||
+        isChildOf(targetContainer, el)) {
+        console.warn("Prevented potential circular reference in moveStub");
+        // Fall back to the original parent as a safe option
+        targetContainer = originalParent || el.parentElement;
+        // If we still have an invalid container, abort the operation
+        if (!targetContainer || targetContainer === el || isChildOf(targetContainer, el)) {
+            console.error("Cannot find valid container for stub, aborting drag operation");
+            removeStub();
+            endAllDrag();
+            return;
+        }
+    }
+    // If the stub isn't already in the target container, move it
+    if (targetContainer && currentParent !== targetContainer) {
+        // Remove stub from current parent
+        if (currentParent) {
+            currentParent.removeChild(stub);
+        }
+        // One more safety check before appending
+        try {
+            // Add to new container
+            targetContainer.appendChild(stub);
+            console.log("Moved stub to new container:", targetContainer.tagName, targetContainer.id);
+            // Reset stability tracking when container changes
+            lastStableIndex = -1;
+            stablePositionCount = 0;
+            // Update immediately without delay
+            lastUpdateTime = 0;
+        }
+        catch (e) {
+            console.error("Error moving stub to new container:", e);
+            // If we encounter an error, clean up and end the drag
+            removeStub();
+            endAllDrag();
+            return;
+        }
+    }
+    // If no valid container found, don't proceed
+    if (!targetContainer)
+        return;
+    // Now position within the container
+    const children = Array.from(targetContainer.children).filter((child) => isValidHtmlElement(child) && child !== el && child !== stub);
+    // If no children to compare, stub is already in the right place
+    if (children.length === 0)
+        return;
+    // Throttle updates to prevent jitter
+    const now = Date.now();
+    if (now - lastUpdateTime < DEBOUNCE_DELAY) {
+        return;
+    }
+    // Get layout direction
+    const direction = getDisplayDirection(targetContainer);
+    // Sort children based on their position in the document
+    children.sort((a, b) => {
+        const aRect = a.getBoundingClientRect();
+        const bRect = b.getBoundingClientRect();
+        if (direction === "row") {
+            return aRect.left - bRect.left; // Sort by X for row
+        }
+        else {
+            return aRect.top - bRect.top; // Sort by Y for column
+        }
+    });
+    // Find insertion point
+    let insertBefore = null;
+    let currentInsertionIndex = -1;
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        const rect = child.getBoundingClientRect();
+        if (direction === "row") {
+            // For row layout, compare X position
+            if (x < rect.left + rect.width / 2) {
+                insertBefore = child;
+                currentInsertionIndex = i;
+                break;
+            }
+        }
+        else {
+            // For column layout, compare Y position
+            if (y < rect.top + rect.height / 2) {
+                insertBefore = child;
+                currentInsertionIndex = i;
+                break;
+            }
+        }
+    }
+    // If we didn't find an insertion point, we would insert at the end
+    if (insertBefore === null) {
+        currentInsertionIndex = children.length;
+    }
+    // Stability check - only commit position changes when they've been stable for a few checks
+    if (currentInsertionIndex === lastStableIndex) {
+        stablePositionCount++;
+    }
+    else {
+        lastStableIndex = currentInsertionIndex;
+        stablePositionCount = 1;
+    }
+    // Only update if position has been stable for a while or if it's far from the last position
+    let needsUpdate = false;
+    if (stablePositionCount >= STABILITY_THRESHOLD) {
+        needsUpdate = true;
+    }
+    else if (insertBefore &&
+        lastInsertionTarget &&
+        insertBefore !== lastInsertionTarget) {
+        // Check if the distance between old and new position is significant
+        const insertRect = insertBefore.getBoundingClientRect();
+        const lastRect = lastInsertionTarget.getBoundingClientRect();
+        const distance = direction === "row"
+            ? Math.abs(insertRect.left - lastRect.left)
+            : Math.abs(insertRect.top - lastRect.top);
+        needsUpdate = distance > JITTER_THRESHOLD_PX * 2;
+    }
+    else if (insertBefore === null && lastInsertionTarget === null) {
+        // Both null, check if stub is already at the end
+        const isAtEnd = stub.nextElementSibling === null;
+        needsUpdate = !isAtEnd;
+    }
+    else if (insertBefore !== lastInsertionTarget) {
+        // One is null and the other isn't, definitely an update
+        needsUpdate = true;
+    }
+    // Only update the DOM if necessary
+    if (needsUpdate) {
+        // Move stub to the determined position
+        if (insertBefore) {
+            // Check if we'd be moving to the same place
+            if (stub.nextElementSibling !== insertBefore) {
+                console.log("Moving stub before element:", insertBefore.tagName);
+                targetContainer.insertBefore(stub, insertBefore);
+            }
+        }
+        else {
+            // If no insert point found, append to the end
+            if (stub.nextElementSibling !== null) {
+                console.log("Moving stub to end of container");
+                targetContainer.appendChild(stub);
+            }
+        }
+        // Log the achieved position
+        const allChildren = Array.from(targetContainer.children);
+        const stubPosition = allChildren.indexOf(stub);
+        console.log("Stub now at position", stubPosition, "of", allChildren.length);
+        // Update tracking variables
+        lastInsertionTarget = insertBefore;
+        lastUpdateTime = now;
+    }
+}
+// Reset the tracking variables when drag ends
+function removeStub() {
+    const stub = document.getElementById("drag-stub");
+    if (stub)
+        stub.remove();
+    // Reset tracking variables
+    lastInsertionTarget = null;
+    lastUpdateTime = 0;
+    lastStableIndex = -1;
+    stablePositionCount = 0;
+}
+function getCurrentStubIndex(parent, draggingEl) {
+    const stub = document.getElementById("drag-stub");
+    if (!stub)
+        return -1;
+    // The stub might be in a different parent now
+    const stubParent = stub.parentElement;
+    if (!stubParent)
+        return -1;
+    // Get all children of the stub's parent, excluding the dragging element
+    const childrenWithoutDraggingEl = Array.from(stubParent.children).filter((child) => isValidHtmlElement(child) && child !== draggingEl);
+    // Find the index of the stub in this filtered list
+    const stubIndex = childrenWithoutDraggingEl.indexOf(stub);
+    // Debug logging
+    console.log("Stub parent:", stubParent.tagName, stubParent.id);
+    console.log("Filtered children length:", childrenWithoutDraggingEl.length);
+    console.log("Stub found at filtered index:", stubIndex);
+    return stubIndex;
+}
+function restoreElementStyle(el) {
+    const savedStyleStr = el.getAttribute(EditorAttributes.DATA_PICASSO_DRAG_SAVED_STYLE);
+    if (!savedStyleStr)
+        return;
+    try {
+        const savedStyle = JSON.parse(savedStyleStr);
+        for (const [key, value] of Object.entries(savedStyle)) {
+            if (value) {
+                el.style[key] = value;
+            }
+            else {
+                el.style[key] = "";
+            }
+        }
+        // Ensure these critical styles are explicitly reset
+        el.style.zIndex = "";
+        el.style.opacity = "";
+        el.style.pointerEvents = "";
+        el.style.boxShadow = "";
+        el.style.transition = "";
+    }
+    catch (e) {
+        console.error("Error restoring element style:", e);
+    }
+}
+function getOrAssignDomId(el) {
+    if (el.id)
+        return el.id;
+    const newId = `picasso-element-${Math.random().toString(36).substr(2, 9)}`;
+    el.id = newId;
+    return newId;
+}
+function getDomElement(el, deep = true) {
+    return {
+        type: el.tagName.toLowerCase(),
+        id: getOrAssignDomId(el),
+    };
+}
+function getDisplayDirection(parent) {
+    const style = window.getComputedStyle(parent);
+    if (style.display === "flex" || style.display === "inline-flex") {
+        // Check for row or row-reverse
+        if (style.flexDirection === "row" ||
+            style.flexDirection === "row-reverse") {
+            return "row";
+        }
+        // All other flex directions (column, column-reverse) are treated as column
+    }
+    // Default to column for non-flex containers or column flex
+    return "column";
+}
+// Add a helper for direction-aware positioning
+function getPositionInDirection(element, parent) {
+    const direction = getDisplayDirection(parent);
+    const rect = element.getBoundingClientRect();
+    const siblings = Array.from(parent.children).filter((child) => isValidHtmlElement(child) && child !== element);
+    // Sort siblings based on their position
+    return {
+        before: siblings.filter((sibling) => {
+            const sibRect = sibling.getBoundingClientRect();
+            return direction === "row"
+                ? sibRect.left < rect.left // For row direction, compare X position
+                : sibRect.top < rect.top; // For column direction, compare Y position
+        }),
+        after: siblings.filter((sibling) => {
+            const sibRect = sibling.getBoundingClientRect();
+            return direction === "row"
+                ? sibRect.left >= rect.left // For row direction, compare X position
+                : sibRect.top >= rect.top; // For column direction, compare Y position
+        }),
+    };
+}
+// Find the closest draggable element (with data-source attribute)
+function findDraggableElement(el) {
+    // Check if current element has data-source
+    if (el.hasAttribute("data-source")) {
+        return el;
+    }
+    // Find closest parent with data-source
+    let current = el;
+    while (current && current !== document.body) {
+        if (current.hasAttribute("data-source")) {
+            return current;
+        }
+        current = current.parentElement;
+    }
+    return null;
+}
+// Hook implementation
+export function ButtonBar({ el, onHighlight, showDragOnly = false, dragButtonClassNames }) {
+    // Add duplicate button click handler
+    async function onDuplicate(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        // Find the draggable element (element with data-source or closest parent with it)
+        const draggableEl = findDraggableElement(el);
+        if (draggableEl) {
+            // Get the source location from the data-source attribute
+            const source = draggableEl.getAttribute("data-source") ||
+                draggableEl.getAttribute("data-source-main");
+            if (source) {
+                const [sourceFile, line] = source.split(":");
+                try {
+                    // Send duplication change to the API
+                    const response = await fetch("http://localhost:3000/api/chat/canvas/change", {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify([
+                            {
+                                file: sourceFile,
+                                line: parseInt(line),
+                                instruction: {
+                                    type: "duplicate_element",
+                                },
+                            },
+                        ]),
+                    });
+                    if (!response.ok) {
+                        throw new Error(`HTTP error! status: ${response.status}`);
+                    }
+                }
+                catch (error) {
+                    console.error("Error duplicating element:", error);
+                }
+            }
+        }
+    }
+    // Add delete button click handler
+    async function onDelete(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        // Find the draggable element (element with data-source or closest parent with it)
+        const draggableEl = findDraggableElement(el);
+        if (draggableEl) {
+            // Get the source location from the data-source attribute
+            const source = draggableEl.getAttribute("data-source") ||
+                draggableEl.getAttribute("data-source-main");
+            if (source) {
+                const [sourceFile, line] = source.split(":");
+                try {
+                    // Send deletion change to the API
+                    const response = await fetch("http://localhost:3000/api/chat/canvas/change", {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify([
+                            {
+                                file: sourceFile,
+                                line: parseInt(line),
+                                instruction: {
+                                    type: "delete_element",
+                                },
+                            },
+                        ]),
+                    });
+                    if (!response.ok) {
+                        throw new Error(`HTTP error! status: ${response.status}`);
+                    }
+                }
+                catch (error) {
+                    console.error("Error deleting element:", error);
+                }
+            }
+        }
+    }
+    let startX = 0;
+    let startY = 0;
+    let isDragging = false;
+    let mouseOffsetX = 0;
+    let mouseOffsetY = 0;
+    function onDrag(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        // Find the draggable element (element with data-source or closest parent with it)
+        const draggableEl = findDraggableElement(el);
+        // If no draggable element found, do nothing
+        if (!draggableEl) {
+            console.warn("No draggable element found with data-source attribute");
+            return;
+        }
+        // Ensure element has ID for dragging
+        getOrAssignDomId(draggableEl);
+        // Store the initial mouse position
+        startX = e.clientX;
+        startY = e.clientY;
+        // Calculate mouse offset relative to the element for more accurate dragging
+        const rect = draggableEl.getBoundingClientRect();
+        mouseOffsetX = startX - rect.left;
+        mouseOffsetY = startY - rect.top;
+        // Store the mouse offset on the element for later use
+        // Store the mouse offset on the element for later use
+        draggableEl.dataset["picassoDragMouseOffset"] = JSON.stringify({
+            x: mouseOffsetX,
+            y: mouseOffsetY,
+        });
+        isDragging = true;
+        // Start the drag operation
+        startDrag(draggableEl.id);
+        const handleMove = (moveEvent) => {
+            if (!isDragging)
+                return;
+            const currentX = moveEvent.clientX;
+            const currentY = moveEvent.clientY;
+            // Pass the current mouse coordinates for positioning
+            drag(draggableEl.id, currentX, currentY);
+        };
+        const handleUp = async () => {
+            if (!isDragging)
+                return;
+            isDragging = false;
+            // Reset element label position to "absolute" to prepare for recalculation
+            const elementLabel = document.querySelector('.element-label');
+            if (elementLabel) {
+                elementLabel.style.position = "absolute";
+            }
+            const result = endDrag(draggableEl.id);
+            if (result && result.parent && result.child && result.newIndex !== -1) {
+                const parentEl = elementFromDomId(result.parent.id);
+                const childEl = elementFromDomId(result.child.id);
+                if (parentEl && childEl) {
+                    const children = Array.from(parentEl.children);
+                    const currentIndex = children.indexOf(childEl);
+                    // Only move if needed
+                    if (currentIndex !== result.newIndex) {
+                        console.log("Moving element from index", currentIndex, "to", result.newIndex);
+                        // Get all children without the element we're moving
+                        const filteredChildren = Array.from(parentEl.children).filter((child) => child !== childEl);
+                        // If the target index is at the end, we simply append
+                        if (result.newIndex >= filteredChildren.length) {
+                            console.log("Appending element to the end");
+                            parentEl.appendChild(childEl);
+                        }
+                        else {
+                            // Otherwise, we need to insert before the element at the target index
+                            // in the filtered list (which doesn't include the element we're moving)
+                            const targetNode = filteredChildren[result.newIndex];
+                            console.log("Inserting element before", targetNode.tagName);
+                            parentEl.insertBefore(childEl, targetNode);
+                        }
+                        // Make sure the element is correctly positioned and selectable again
+                        childEl.style.position =
+                            childEl.style.position === "static"
+                                ? "relative"
+                                : childEl.style.position;
+                        childEl.style.pointerEvents = "";
+                        const sourceFile = result.sourceFile;
+                        const fromLine = result.fromLine;
+                        // Get the target element's data-source to determine the correct toLine
+                        let toLine = fromLine; // Default fallback
+                        let targetFile = sourceFile; // Default to the same file for intra-file movement
+                        // Get the actual element at the new position
+                        const filteredChildren = Array.from(parentEl.children).filter((child) => child !== childEl);
+                        if (result.newIndex < filteredChildren.length) {
+                            // Get the element we're inserting before
+                            const targetElement = filteredChildren[result.newIndex];
+                            const targetSource = targetElement.getAttribute("data-source");
+                            if (targetSource) {
+                                const [targetSourceFile, targetLineStr] = targetSource.split(":");
+                                targetFile = targetSourceFile; // Set the target file from the element we're inserting before
+                                toLine = parseInt(targetLineStr, 10);
+                            }
+                        }
+                        else if (filteredChildren.length > 0) {
+                            // If we're appending at the end, get the last element's line + 1
+                            const lastElement = filteredChildren[filteredChildren.length - 1];
+                            const lastSource = lastElement.getAttribute("data-source");
+                            if (lastSource) {
+                                const [lastSourceFile, lastLineStr] = lastSource.split(":");
+                                targetFile = lastSourceFile; // Set the target file from the last element
+                                toLine = parseInt(lastLineStr, 10) + 1;
+                            }
+                        }
+                        else {
+                            // If there are no other children, try to get file info from the parent
+                            const parentSource = parentEl.getAttribute("data-source");
+                            if (parentSource) {
+                                const [parentSourceFile] = parentSource.split(":");
+                                targetFile = parentSourceFile; // Use the parent's file
+                                toLine = 1; // Default to line 1 if we can't determine
+                            }
+                        }
+                        // Check if this is a cross-file move
+                        const isCrossFileMove = targetFile !== sourceFile;
+                        // Create and add a component move change
+                        const moveChange = createComponentMoveChange(result.child.type, sourceFile, fromLine, toLine, result.parent.type, result.parent.id, isCrossFileMove ? targetFile : undefined);
+                        // Add the change
+                        addComponentMoveChange(moveChange);
+                        // Apply the change immediately instead of waiting for save button
+                        try {
+                            // Get all move changes
+                            const moveChanges = getComponentMoveChanges();
+                            if (moveChanges.length > 0) {
+                                // Show the loader before applying changes
+                                if (showDragLoader) {
+                                    showDragLoader("Applying change...");
+                                }
+                                // Send the changes to the API
+                                const response = await fetch("http://localhost:3000/api/chat/canvas/change", {
+                                    method: "POST",
+                                    headers: {
+                                        "Content-Type": "application/json",
+                                    },
+                                    body: JSON.stringify(moveChanges),
+                                });
+                                if (!response.ok) {
+                                    console.error("Error applying drag changes:", response.status, response.statusText);
+                                    // Hide loader on error
+                                    if (hideDragLoader) {
+                                        hideDragLoader();
+                                    }
+                                    throw new Error(`HTTP error! status: ${response.status}`);
+                                }
+                                await response.json();
+                                // Clear the move changes since they've been applied
+                                clearComponentMoveChanges();
+                                // Note: Don't hide the loader here
+                                // The HMR detection will handle hiding the loader and reloading the page
+                            }
+                        }
+                        catch (error) {
+                            console.error("Error applying drag changes:", error);
+                            // Hide loader on error
+                            if (hideDragLoader) {
+                                hideDragLoader();
+                            }
+                        }
+                        // Log the move
+                        console.log(`Component ${result.child.type} moved ${isCrossFileMove ? `from ${sourceFile} to ${targetFile}` : `in ${sourceFile}`} from line ${fromLine} to line ${toLine}`);
+                        // Re-highlight the element to restore selection UI
+                        if (onHighlight) {
+                            // Slight delay to ensure DOM is updated
+                            setTimeout(() => {
+                                onHighlight(childEl);
+                                // Explicitly update the element label position
+                                const elementLabel = document.querySelector('.element-label');
+                                if (elementLabel) {
+                                    const rect = childEl.getBoundingClientRect();
+                                    elementLabel.style.position = "absolute";
+                                    elementLabel.style.left = `${window.scrollX + rect.left}px`;
+                                    elementLabel.style.top = `${window.scrollY + rect.top - 20}px`;
+                                    elementLabel.style.zIndex = "";
+                                }
+                            }, 10);
+                        }
+                    }
+                }
+            }
+            // Clean up the stored data
+            delete draggableEl.dataset["picassoDragMouseOffset"];
+            document.removeEventListener("mousemove", handleMove);
+            document.removeEventListener("mouseup", handleUp);
+        };
+        document.addEventListener("mousemove", handleMove);
+        document.addEventListener("mouseup", handleUp);
+    }
+    return (React.createElement(React.Fragment, null,
+        React.createElement("button", { className: `drag-button`, onMouseDown: onDrag },
+            React.createElement("i", { className: dragButtonClassNames })),
+        !showDragOnly && (React.createElement(React.Fragment, null,
+            React.createElement("button", { className: "duplicate-button", onClick: onDuplicate }, "Duplicate"),
+            React.createElement("button", { className: "delete-button", onClick: onDelete }, "Delete")))));
+}
+// Add function to update visual indicators
+function updateDropTargetVisuals(draggingElement) {
+    // Only proceed if the element is bound
+    const isBound = draggingElement.getAttribute('data-binding-same-as-rendering-component') === 'true';
+    if (!isBound) {
+        return;
+    }
+    // Get the rendering component value of the dragging element
+    const draggingRendering = draggingElement.getAttribute('data-picasso-rendering-comp');
+    // Get all potential drop targets
+    const allDropTargets = findValidDropTargets();
+    // First, clear any existing visual indicators
+    clearDropTargetVisuals();
+    // Only highlight valid drop targets
+    allDropTargets.forEach(target => {
+        const targetRendering = target.getAttribute('data-picasso-rendering-comp');
+        // Only add visual indicator for compatible targets
+        if (draggingRendering === targetRendering) {
+            target.classList.add(VALID_DROP_TARGET_CLASS);
+        }
+    });
+}
+// Add function to clean up visuals
+function clearDropTargetVisuals() {
+    // Remove visual indicators from all elements
+    document.querySelectorAll(`.${VALID_DROP_TARGET_CLASS}, .${INVALID_DROP_TARGET_CLASS}`).forEach(el => {
+        el.classList.remove(VALID_DROP_TARGET_CLASS, INVALID_DROP_TARGET_CLASS);
+    });
+}
+// Modify startDrag to allow panel elements
+export function startDrag(domId) {
+    const el = elementFromDomId(domId);
+    if (!el) {
+        console.warn(`Start drag element not found: ${domId}`);
+        return null;
+    }
+    /*   // Allow panel elements to be dragged without edit mode
+      if (!isFromPanel(el)) {
+        // Keep existing edit mode check for non-panel elements
+        const isEditMode = document.documentElement.hasAttribute('data-picasso-edit');
+        if (!isEditMode) {
+          console.warn('Not in edit mode');
+          return null;
+        }
+      } */
+    const parent = el.parentElement;
+    if (!parent) {
+        console.warn("Start drag parent not found");
+        return null;
+    }
+    // Store the original parent for reference
+    el.setAttribute(EditorAttributes.DATA_PICASSO_ORIGINAL_PARENT, getOrAssignDomId(parent));
+    const htmlChildren = Array.from(parent.children).filter(isValidHtmlElement);
+    const originalIndex = htmlChildren.indexOf(el);
+    prepareElementForDragging(el);
+    createStub(el);
+    // Store the element's initial position and dimensions for reference
+    const rect = el.getBoundingClientRect();
+    const pos = {
+        left: rect.left + window.scrollX,
+        top: rect.top + window.scrollY,
+        width: rect.width,
+        height: rect.height,
+    };
+    el.setAttribute(EditorAttributes.DATA_PICASSO_DRAG_START_POSITION, JSON.stringify(pos));
+    // Add visual indicators if element is bound
+    updateDropTargetVisuals(el);
+    return originalIndex;
+}
+// Add panel element handling to drag function
+export function drag(domId, x, y) {
+    const el = elementFromDomId(domId);
+    if (!el) {
+        console.warn("Dragging element not found");
+        return;
+    }
+    // Special handling for panel elements
+    /*if (isFromPanel(el)) {
+      el.style.position = "fixed";
+      el.style.pointerEvents = "none";
+      el.style.zIndex = "9999";
+      el.style.opacity = "0.8";
+      el.style.boxShadow = "0 5px 10px rgba(0,0,0,0.2)";
+      el.style.left = `${x}px`;
+      el.style.top = `${y}px`;
+      moveStub(el, x, y);
+      return;
+    }*/
+    try {
+        // Visual styling for dragged element
+        const styles = window.getComputedStyle(el);
+        // Get the stored mouse offset
+        let offsetX = 20, offsetY = 20; // Default offsets
+        try {
+            const dragData = el.dataset["picassoDragMouseOffset"];
+            if (dragData) {
+                const mouseOffset = JSON.parse(dragData);
+                offsetX = mouseOffset.x || offsetX;
+                offsetY = mouseOffset.y || offsetY;
+            }
+        }
+        catch (e) {
+            console.error("Error parsing drag data:", e);
+        }
+        // Position the element precisely at the mouse position with offset
+        el.style.left = `${x - offsetX}px`;
+        el.style.top = `${y - offsetY}px`;
+        el.style.width = styles.width;
+        el.style.height = styles.height;
+        el.style.position = "fixed";
+        el.style.pointerEvents = "none";
+        el.style.zIndex = "9999";
+        el.style.opacity = "0.8";
+        el.style.boxShadow = "0 5px 10px rgba(0,0,0,0.2)";
+        // Remove transition to ensure instant response
+        el.style.transition = "";
+        // Update the element-label position if it exists
+        const elementLabel = document.querySelector('.element-label');
+        if (elementLabel && el.dataset["selected"] === "true") {
+            elementLabel.style.left = `${x - offsetX}px`;
+            elementLabel.style.top = `${Math.max(0, y - offsetY - 20)}px`;
+            elementLabel.style.position = "fixed";
+            elementLabel.style.zIndex = "10000"; // Ensure it's above the dragged element
+        }
+        // Calculate smoothed positions for stub positioning only
+        let smoothX = x;
+        let smoothY = y;
+        // Apply smoothing only for stub positioning to reduce jitter
+        if (lastDragX !== 0 || lastDragY !== 0) {
+            smoothX = x * MOVEMENT_SMOOTHING + lastDragX * (1 - MOVEMENT_SMOOTHING);
+            smoothY = y * MOVEMENT_SMOOTHING + lastDragY * (1 - MOVEMENT_SMOOTHING);
+        }
+        // Update last positions
+        lastDragX = smoothX;
+        lastDragY = smoothY;
+        // Try to move the stub - wrap in try/catch to prevent errors from crashing the app
+        try {
+            moveStub(el, smoothX, smoothY);
+        }
+        catch (e) {
+            console.error("Error moving stub:", e);
+            // Clean up and abort drag if there's an error
+            removeStub();
+            cleanUpElementAfterDragging(el);
+        }
+        // Update visual indicators if element is bound
+        updateDropTargetVisuals(el);
+    }
+    catch (error) {
+        console.error("Error in drag function:", error);
+        // Clean up and abort if anything goes wrong
+        endAllDrag();
+    }
+}
+// Modify endDrag and endAllDrag to clean up visuals
+export function endDrag(domId) {
+    // Clear visual indicators
+    clearDropTargetVisuals();
+    // Reset smoothing variables
+    lastDragX = 0;
+    lastDragY = 0;
+    const el = elementFromDomId(domId);
+    if (!el) {
+        console.warn("End drag element not found");
+        endAllDrag();
+        return null;
+    }
+    // Remove transition before cleanup to prevent visual glitches
+    if (el.style.transition) {
+        el.style.transition = "";
+    }
+    // Get the original parent ID
+    const originalParentId = el.getAttribute(EditorAttributes.DATA_PICASSO_ORIGINAL_PARENT);
+    const originalParent = originalParentId ? elementFromDomId(originalParentId) : null;
+    // Get the stub
+    const stub = document.getElementById("drag-stub");
+    if (!stub) {
+        console.warn("Stub not found");
+        cleanUpElementAfterDragging(el);
+        return null;
+    }
+    // Get the stub's parent (this could be different from the original parent)
+    const stubParent = stub.parentElement;
+    if (!stubParent) {
+        console.warn("Stub parent not found");
+        cleanUpElementAfterDragging(el);
+        removeStub();
+        return null;
+    }
+    // Get the stub index in its current parent
+    const stubIndex = getCurrentStubIndex(stubParent, el);
+    console.log("End drag with stub at index:", stubIndex);
+    // Clean up elements after recording the position
+    cleanUpElementAfterDragging(el);
+    if (stubIndex === -1) {
+        console.warn("Stub not found in parent element");
+        removeStub();
+        return null;
+    }
+    // Determine if this is a cross-container move
+    const isCrossContainerMove = originalParent !== stubParent;
+    // Get source file information from data-source attribute
+    let sourceFile;
+    let fromLine;
+    const sourceAttr = el.getAttribute("data-source");
+    if (sourceAttr) {
+        const [file, lineStr] = sourceAttr.split(":");
+        sourceFile = file;
+        fromLine = parseInt(lineStr, 10);
+    }
+    // Create result with appropriate parent information
+    const result = {
+        newIndex: stubIndex,
+        child: getDomElement(el, false),
+        parent: getDomElement(stubParent, false),
+        sourceFile,
+        fromLine
+    };
+    // Add original parent info for cross-container moves
+    if (isCrossContainerMove && originalParent) {
+        result.originalParent = getDomElement(originalParent, false);
+    }
+    // Clean up the stub
+    removeStub();
+    return result;
+}
+function prepareElementForDragging(el) {
+    const saved = el.getAttribute(EditorAttributes.DATA_PICASSO_DRAG_SAVED_STYLE);
+    if (saved) {
+        return;
+    }
+    // Store more style properties to ensure complete restoration
+    const style = {
+        position: el.style.position,
+        transform: el.style.transform,
+        width: el.style.width,
+        height: el.style.height,
+        left: el.style.left,
+        top: el.style.top,
+        zIndex: el.style.zIndex,
+        opacity: el.style.opacity,
+        pointerEvents: el.style.pointerEvents,
+        boxShadow: el.style.boxShadow,
+        transition: el.style.transition,
+        outline: el.style.outline,
+    };
+    // Store if the element was selected
+    const wasSelected = el.dataset["selected"] === "true";
+    el.setAttribute(EditorAttributes.DATA_PICASSO_DRAG_SAVED_STYLE, JSON.stringify(style));
+    el.setAttribute(EditorAttributes.DATA_PICASSO_DRAGGING, "true");
+    // Preserve the selected state if it was selected
+    if (wasSelected) {
+        el.dataset["selected"] = "true";
+    }
+    if (el.getAttribute(EditorAttributes.DATA_PICASSO_DRAG_DIRECTION) !== null) {
+        const parent = el.parentElement;
+        if (parent) {
+            const displayDirection = getDisplayDirection(parent);
+            el.setAttribute(EditorAttributes.DATA_PICASSO_DRAG_DIRECTION, displayDirection);
+        }
+    }
+}
+function cleanUpElementAfterDragging(el) {
+    console.log("Cleaning up element after dragging:", el);
+    // Make sure to restore the original position type
+    const computedStyle = window.getComputedStyle(el);
+    // First restore saved style
+    restoreElementStyle(el);
+    // Remove drag attributes
+    removeDragAttributes(el);
+    // Remove panel ID if element is from panel
+    /*if (isFromPanel(el)) {
+      console.log("Element is from panel, removing ID");
+      // Store the ID value for the result object
+      const panelId = el.id;
+      // Remove the ID to generate a new one in the page
+      el.removeAttribute('id');
+      console.log("Removed panel ID:", panelId);
+    }*/
+    // Ensure pointerEvents is enabled again
+    el.style.pointerEvents = "";
+    // Make sure the element is properly positioned
+    // If it was static and we made it relative, leave it as relative to maintain highlighting
+    if (el.style.position === "fixed") {
+        // If we moved to fixed, restore to original or relative
+        const originalPos = computedStyle.position === "static" ? "relative" : computedStyle.position;
+        el.style.position = originalPos;
+    }
+    // Reset the element-label position if it exists
+    const elementLabel = document.querySelector('.element-label');
+    if (elementLabel && el.dataset["selected"] === "true") {
+        // Get the new position of the element after it's been positioned
+        setTimeout(() => {
+            const rect = el.getBoundingClientRect();
+            elementLabel.style.position = "absolute";
+            elementLabel.style.left = `${window.scrollX + rect.left}px`;
+            elementLabel.style.top = `${window.scrollY + rect.top - 20}px`;
+            elementLabel.style.zIndex = "";
+        }, 0);
+    }
+    // Ensure ID is still assigned
+    getOrAssignDomId(el);
+}
+function removeDragAttributes(el) {
+    el.removeAttribute(EditorAttributes.DATA_PICASSO_DRAG_SAVED_STYLE);
+    el.removeAttribute(EditorAttributes.DATA_PICASSO_DRAGGING);
+    el.removeAttribute(EditorAttributes.DATA_PICASSO_DRAG_DIRECTION);
+    el.removeAttribute(EditorAttributes.DATA_PICASSO_DRAG_START_POSITION);
+    el.removeAttribute(EditorAttributes.DATA_PICASSO_ORIGINAL_PARENT);
+    // Clean up any additional drag-related data attributes
+    delete el.dataset["picassoDragMouseOffset"];
+    delete el.dataset["picassoCurrentDirection"];
+}
+export function endAllDrag() {
+    // Clear visual indicators
+    clearDropTargetVisuals();
+    // Reset all smoothing and position tracking
+    lastDragX = 0;
+    lastDragY = 0;
+    lastInsertionTarget = null;
+    lastUpdateTime = 0;
+    lastStableIndex = -1;
+    stablePositionCount = 0;
+    const draggingElements = document.querySelectorAll(`[${EditorAttributes.DATA_PICASSO_DRAGGING}]`);
+    // Collect elements that need their position updated
+    const elementsToUpdate = [];
+    for (const el of draggingElements) {
+        // Remove transitions before cleanup
+        el.style.transition = "";
+        cleanUpElementAfterDragging(el);
+        // Extra safety - make sure critical styles are reset
+        el.style.position =
+            el.style.position === "fixed"
+                ? "relative"
+                : el.style.position;
+        el.style.pointerEvents = "";
+        el.style.zIndex = "";
+        el.style.top = "";
+        el.style.left = "";
+        // Add to list for updating element label position
+        if (el.dataset['selected'] === "true") {
+            elementsToUpdate.push(el);
+        }
+    }
+    // Reset element label positions
+    setTimeout(() => {
+        // Reset any element-label that might be in fixed position
+        const elementLabel = document.querySelector('.element-label');
+        if (elementLabel && elementsToUpdate.length > 0) {
+            const el = elementsToUpdate[0]; // Use the first selected element
+            const rect = el.getBoundingClientRect();
+            elementLabel.style.position = "absolute";
+            elementLabel.style.left = `${window.scrollX + rect.left}px`;
+            elementLabel.style.top = `${window.scrollY + rect.top - 20}px`;
+            elementLabel.style.zIndex = "";
+        }
+    }, 0);
+    removeStub();
+}
+// Find valid drop targets (containers that can accept dragged elements)
+function findValidDropTargets() {
+    // Get the stub element
+    const stub = document.getElementById("drag-stub");
+    // Only consider elements with a data-source attribute as valid drop targets
+    const potentialTargets = Array.from(document.querySelectorAll("[data-source]"));
+    // Filter out elements that are too small or invalid
+    return potentialTargets.filter((el) => {
+        const element = el;
+        // Explicitly exclude the stub from valid drop targets
+        if (stub && element === stub) {
+            return false;
+        }
+        // Exclude any element inside or related to button bar or element controls
+        if (element.classList.contains("drag-button") ||
+            element.classList.contains("duplicate-button") ||
+            element.classList.contains("delete-button") ||
+            element.closest(".element-controls") !== null ||
+            element.classList.contains("ButtonBar") ||
+            element.tagName.toLowerCase() === "buttonbar" ||
+            // Check if the element is a direct parent of control buttons
+            Array.from(element.children).some(child => child.classList?.contains("drag-button") ||
+                child.classList?.contains("duplicate-button") ||
+                child.classList?.contains("delete-button"))) {
+            return false;
+        }
+        // Check if the element is a button and print its children types
+        if (element.tagName.toLowerCase() === "button") {
+            console.log("Button children types:");
+            Array.from(element.childNodes).forEach((child, index) => {
+                let nodeType = "Unknown";
+                if (child.nodeType === Node.TEXT_NODE) {
+                    nodeType = "Text";
+                }
+                else if (child.nodeType === Node.ELEMENT_NODE) {
+                    nodeType = `Element (${child.tagName})`;
+                }
+                else if (child.nodeType === Node.COMMENT_NODE) {
+                    nodeType = "Comment";
+                }
+                console.log(`Child ${index}: ${nodeType}`);
+            });
+        }
+        // Check if the element is already a parent with at least one non-text child
+        const hasNonTextChild = Array.from(element.children).some((child) => isValidHtmlElement(child) && child.nodeType === Node.ELEMENT_NODE);
+        const rect = element.getBoundingClientRect();
+        // Ensure it's a reasonable size (not too small) and has at least one non-text child
+        return (rect.width > 10 &&
+            rect.height > 10 &&
+            isValidHtmlElement(element) &&
+            hasNonTextChild);
+    });
+}
+// Check if an element is a child of another element
+function isChildOf(child, parent) {
+    let node = child.parentElement;
+    while (node) {
+        if (node === parent)
+            return true;
+        node = node.parentElement;
+    }
+    return false;
+}
+// Helper function to check binding compatibility
+function isBindingCompatible(draggingElement, dropTarget) {
+    // Check if element is bound to its rendering component
+    const isBound = draggingElement.getAttribute('data-binding-same-as-rendering-component') === 'true';
+    if (!isBound) {
+        return true; // If not bound, can be dropped anywhere
+    }
+    // Get rendering component values
+    const draggingRendering = draggingElement.getAttribute('data-picasso-rendering-comp');
+    const targetRendering = dropTarget.getAttribute('data-picasso-rendering-comp');
+    // If bound, only allow dropping into targets with matching rendering component
+    return draggingRendering === targetRendering;
+}
+// Get element at point, checking for valid drop targets
+function getDropTargetAt(x, y, draggingElement) {
+    // Get all elements at the given point
+    const elements = document.elementsFromPoint(x, y);
+    // Get valid drop targets
+    const validDropTargets = findValidDropTargets();
+    // Find the first valid drop target at this point
+    for (const el of elements) {
+        if (isValidHtmlElement(el) && el !== draggingElement && !isChildOf(el, draggingElement)) {
+            const htmlEl = el;
+            // Check if this element is in our valid drop targets list
+            if (validDropTargets.includes(htmlEl)) {
+                // Don't allow dropping into panel elements
+                if (htmlEl.id?.startsWith('panel') || isInPanel(htmlEl)) {
+                    console.warn("Can't drop elements into the panel");
+                    continue;
+                }
+                // Check binding compatibility
+                if (!isBindingCompatible(draggingElement, htmlEl)) {
+                    console.warn("Drop target rejected due to binding constraints");
+                    continue;
+                }
+                // Also check if the drop target is a descendant of the dragging element
+                // This prevents the "Failed to execute 'appendChild' on 'Node': The new child element contains the parent" error
+                if (!isChildOf(draggingElement, htmlEl)) {
+                    return htmlEl;
+                }
+                else {
+                    console.warn("Prevented dropping into descendant element to avoid circular reference");
+                }
+            }
+        }
+    }
+    return null;
+}
+// Add a helper function to check if an element is inside the panel
+function isInPanel(el) {
+    // Check if the element itself or any parent has an ID starting with 'panel'
+    let current = el;
+    while (current && current !== document.body) {
+        if (current.id?.startsWith('panel')) {
+            return true;
+        }
+        current = current.parentElement;
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dnd.js","sourceRoot":"","sources":["../../../src/dev-toolbar/Editor/dnd.tsx"],"names":[],"mappings":"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"}