playbook_ui 15.5.0.pre.alpha.draggablefix12577 → 15.5.0.pre.alpha.typeaheadfix12605

data/app/pb_kits/playbook/pb_draggable/context/index.tsx

@@ -39,56 +39,59 @@ const reducer = (state: InitialStateType, action: ActionType) => {
 
       return { ...state, items: newItems };
     }
-    case 'REORDER_ITEMS_CROSS_CONTAINER': {
+
+    // Used only when enableCrossContainerPreview is true
+    case "REORDER_ITEMS_CROSS_CONTAINER": {
       const { dragId, targetId, newContainer } = action.payload;
       const newItems = [...state.items];
-      const draggedItem = newItems.find(item => item && item.id === dragId);
+      const draggedItem = newItems.find((item) => item && item.id === dragId);
+
+      if (!draggedItem) return state;
+
       const draggedIndex = newItems.indexOf(draggedItem);
-      const targetIndex = newItems.findIndex(item => item && item.id === targetId);
+      const targetIndex = newItems.findIndex(
+        (item) => item && item.id === targetId
+      );
 
-      // Update container temporarily so dropzone preview works correctly
-      const updatedItem = { ...draggedItem, container: newContainer };
+      if (draggedIndex === -1 || targetIndex === -1) return state;
 
+      const updatedItem = { ...draggedItem, container: newContainer };
       newItems.splice(draggedIndex, 1);
       newItems.splice(targetIndex, 0, updatedItem);
 
       return { ...state, items: newItems };
     }
-    case 'MOVE_TO_CONTAINER_END': {
+
+    // Used only when enableCrossContainerPreview is true
+    case "MOVE_TO_CONTAINER_END": {
       const { dragId, newContainer } = action.payload;
       const newItems = [...state.items];
-      const draggedItem = newItems.find(item => item && item.id === dragId);
+      const draggedItem = newItems.find((item) => item && item.id === dragId);
+
+      if (!draggedItem) return state;
+
       const draggedIndex = newItems.indexOf(draggedItem);
+      if (draggedIndex === -1) return state;
 
-      // Update container temporarily so dropzone preview works correctly
       const updatedItem = { ...draggedItem, container: newContainer };
 
       // Remove from current position
       newItems.splice(draggedIndex, 1);
 
-      // Find the last item in the target container and insert after it
-      const lastIndexInContainer = newItems.map(item => item.container).lastIndexOf(newContainer);
+      // Insert at end of target container
+      const lastIndexInContainer = newItems
+        .map((item) => item && item.container)
+        .lastIndexOf(newContainer);
+
       if (lastIndexInContainer === -1) {
-        // Container is empty, add to end
         newItems.push(updatedItem);
       } else {
-        // Insert after last item in container
         newItems.splice(lastIndexInContainer + 1, 0, updatedItem);
       }
 
       return { ...state, items: newItems };
     }
-    case 'RESET_DRAG_CONTAINER': {
-      const { itemId, originalContainer } = action.payload;
-      return {
-        ...state,
-        items: state.items.map(item =>
-          item.id === itemId
-            ? { ...item, container: originalContainer }
-            : item
-        )
-      };
-    }
+
     default:
       return state;
   }
@@ -111,7 +114,9 @@ export const DraggableProvider = ({
   onDrop,
   onDragOver,
   dropZone = { type: 'ghost', color: 'neutral', direction: 'vertical' },
-  providerId = 'default', // fallback provided for backward compatibility, so this does not become a required prop
+  providerId = 'default', // fallback provided for backward compatibility
+  // Opt-in flag for cross-container preview
+  enableCrossContainerPreview = false,
 }: DraggableProviderType) => {
   const [state, dispatch] = useReducer(reducer, initialState);
 
@@ -144,7 +149,6 @@ export const DraggableProvider = ({
   }, [state.items]);
 
   const handleDragStart = (id: string, container: string) => {
-    console.log('[Draggable] handleDragStart:', { id, container, providerId });
     dispatch({ type: 'SET_DRAG_DATA', payload: { id: id, initialGroup: container, originId: providerId } });
     dispatch({ type: 'SET_IS_DRAGGING', payload: id });
     if (onDragStart) onDragStart(id, container);
@@ -154,18 +158,42 @@ export const DraggableProvider = ({
     if (state.dragData.originId !== providerId) return; // Ignore drag events from other providers
 
     if (state.dragData.id !== id) {
-      // Check if this is a cross-container drag
-      const isCrossContainer = state.dragData.initialGroup !== container;
-      console.log('[Draggable] handleDragEnter:', { id, container, isCrossContainer, draggedId: state.dragData.id });
-      
-      if (isCrossContainer) {
-        // Use cross-container reorder to update container temporarily for dropzone preview
-        dispatch({ type: 'REORDER_ITEMS_CROSS_CONTAINER', payload: { dragId: state.dragData.id, targetId: id, newContainer: container } });
+      if (enableCrossContainerPreview) {
+        // Used only when enableCrossContainerPreview is true
+        const draggedItem = state.items.find(
+          (item) => item && item.id === state.dragData.id
+        );
+        const currentContainer =
+          draggedItem && draggedItem.container
+            ? draggedItem.container
+            : state.dragData.initialGroup;
+
+        const isCrossContainer =
+          currentContainer !== container &&
+          (currentContainer !== undefined || container !== undefined);
+
+        if (isCrossContainer) {
+          dispatch({
+            type: "REORDER_ITEMS_CROSS_CONTAINER",
+            payload: {
+              dragId: state.dragData.id,
+              targetId: id,
+              newContainer: container,
+            },
+          });
+        } else {
+          // Same container: keep original behavior
+          dispatch({
+            type: "REORDER_ITEMS",
+            payload: { dragId: state.dragData.id, targetId: id },
+          });
+        }
       } else {
-        // Same container: use normal reorder no need to be fancy nancy
-        dispatch({ type: 'REORDER_ITEMS', payload: { dragId: state.dragData.id, targetId: id } });
+        // Original behavior (no preview across containers)
+        dispatch({type: "REORDER_ITEMS", payload: { dragId: state.dragData.id, targetId: id }});
       }
-      dispatch({ type: 'SET_DRAG_DATA', payload: { id: state.dragData.id, initialGroup: container, originId: providerId } });
+
+      dispatch({type: "SET_DRAG_DATA",payload: {id: state.dragData.id, initialGroup: container, originId: providerId}});
     }
     if (onDragEnter) onDragEnter(id, container);
   };
@@ -174,33 +202,30 @@ export const DraggableProvider = ({
     const draggedItemId = state.dragData.id;
     const originalContainer = state.dragData.initialGroup;
     
-    console.log('[Draggable] handleDragEnd:', { draggedItemId, originalContainer });
-    
-    if (!draggedItemId) {
-      console.warn('[Draggable] handleDragEnd: No draggedItemId found');
-      dispatch({ type: 'SET_IS_DRAGGING', payload: "" });
-      dispatch({ type: 'SET_ACTIVE_CONTAINER', payload: "" });
-      dispatch({ type: 'SET_DRAG_DATA', payload: { id: "", initialGroup: "", originId: "" } });
-      return;
-    }
-    
-    const draggedItem = state.items.find(item => item && item.id === draggedItemId);
-    const finalContainer = draggedItem ? draggedItem.container : originalContainer;
-    
-    console.log('[Draggable] handleDragEnd item found:', { draggedItem: !!draggedItem, finalContainer });
-    
-    // Find items above and below in the same container
-    const itemsInContainer = state.items.filter(item => item && item.container === finalContainer);
-    const indexInContainer = itemsInContainer.findIndex(item => item && item.id === draggedItemId);
-    const itemAbove = indexInContainer > 0 ? itemsInContainer[indexInContainer - 1] : null;
-    const itemBelow = indexInContainer < itemsInContainer.length - 1 ? itemsInContainer[indexInContainer + 1] : null;
-    
     dispatch({ type: 'SET_IS_DRAGGING', payload: "" });
     dispatch({ type: 'SET_ACTIVE_CONTAINER', payload: "" });
     dispatch({ type: 'SET_DRAG_DATA', payload: { id: "", initialGroup: "", originId: "" } });
-    
-    // Pass enhanced info to onDragEnd callback to give dev more context
-    if (onDragEnd) onDragEnd(draggedItemId, finalContainer, originalContainer, itemAbove, itemBelow);
+    if (onDragEnd) {
+      if (!enableCrossContainerPreview) {
+        onDragEnd();
+      } else {
+        const draggedItem = state.items.find(item => item && item.id === draggedItemId);
+        const finalContainer = draggedItem ? draggedItem.container : originalContainer;
+        
+        const itemsInContainer = state.items.filter(item => item && item.container === finalContainer);
+        const indexInContainer = itemsInContainer.findIndex(item => item && item.id === draggedItemId);
+        const itemAbove = indexInContainer > 0 ? itemsInContainer[indexInContainer - 1] : null;
+        const itemBelow = indexInContainer < itemsInContainer.length - 1 ? itemsInContainer[indexInContainer + 1] : null;
+        
+        onDragEnd(
+          draggedItemId,
+          finalContainer,
+          originalContainer,
+          itemAbove,
+          itemBelow
+        );
+      }
+    }
   };
 
   const changeCategory = (itemId: string, container: string) => {
@@ -212,46 +237,31 @@ export const DraggableProvider = ({
 
     const draggedItemId = state.dragData.id;
     const originalContainer = state.dragData.initialGroup;
-    
-    console.log('[Draggable] handleDrop:', { draggedItemId, container, originalContainer });
-    
-    if (!draggedItemId) {
-      console.warn('[Draggable] handleDrop: No draggedItemId found');
-      return; // Guard against missing drag data when dropping too quickly
-    }
-    
-    const draggedItem = state.items.find(item => item && item.id === draggedItemId);
-    
-    if (!draggedItem) {
-      console.error('[Draggable] handleDrop: Item not found in state', { draggedItemId, itemsCount: state.items.length });
-      // Item not found in state: clear drag state and exit
-      dispatch({ type: 'SET_IS_DRAGGING', payload: "" });
-      dispatch({ type: 'SET_ACTIVE_CONTAINER', payload: "" });
-      dispatch({ type: 'SET_DRAG_DATA', payload: { id: "", initialGroup: "", originId: "" } });
-      return;
-    }
-    
-    // If dropping in a different container and item hasn't been moved there yet, move to end
-    if (container !== originalContainer && draggedItem.container !== container) {
-      console.log('[Draggable] handleDrop: Moving to container end');
-      dispatch({ type: 'MOVE_TO_CONTAINER_END', payload: { dragId: draggedItemId, newContainer: container } });
-    }
-    
-    // Find items above and below in the same container
-    const itemsInContainer = state.items.filter(item => item && item.container === container);
-    const indexInContainer = itemsInContainer.findIndex(item => item && item.id === draggedItemId);
-    const itemAbove = indexInContainer > 0 ? itemsInContainer[indexInContainer - 1] : null;
-    const itemBelow = indexInContainer < itemsInContainer.length - 1 ? itemsInContainer[indexInContainer + 1] : null;
-    
+
     dispatch({ type: 'SET_IS_DRAGGING', payload: "" });
     dispatch({ type: 'SET_ACTIVE_CONTAINER', payload: "" });
-    // changeCategory will ensure the container is set correctly on drop for cross container and same container drops
-    changeCategory(draggedItemId, container);
-    
-    // Pass enhanced info to onDrop callback so devs have more context
-    if (onDrop && draggedItem) {
-      const updatedItem = { ...draggedItem, container };
-      onDrop(draggedItemId, container, originalContainer, updatedItem, itemAbove, itemBelow);
+    changeCategory(state.dragData.id, container);
+    if (onDrop) {
+      if (!enableCrossContainerPreview) {
+        onDrop(container);
+      } else {
+        const draggedItem = state.items.find(item => item && item.id === draggedItemId);
+        const updatedItem = draggedItem ? { ...draggedItem, container } : null;
+        
+        const itemsInContainer = state.items.filter(item => item && item.container === container);
+        const indexInContainer = itemsInContainer.findIndex(item => item && item.id === draggedItemId);
+        const itemAbove = indexInContainer > 0 ? itemsInContainer[indexInContainer - 1] : null;
+        const itemBelow = indexInContainer < itemsInContainer.length - 1 ? itemsInContainer[indexInContainer + 1] : null;
+        
+        onDrop(
+          draggedItemId,
+          container,
+          originalContainer,
+          updatedItem,
+          itemAbove,
+          itemBelow
+        );
+      }
     }
   };
 
@@ -260,23 +270,20 @@ export const DraggableProvider = ({
 
     e.preventDefault();
     dispatch({ type: 'SET_ACTIVE_CONTAINER', payload: container });
-    
-    // Guard against missing drag ID
-    if (!state.dragData.id) return;
-    
-    // Find the dragged item
-    const draggedItem = state.items.find(item => item && item.id === state.dragData.id);
-    
-    // Only move to container end if item exists and is in a different container
-    if (draggedItem && draggedItem.container !== container) {
-      console.log('[Draggable] handleDragOver: Moving to container end', { dragId: state.dragData.id, fromContainer: draggedItem.container, toContainer: container });
-      // Move item to end of target container for preview
-      dispatch({ type: 'MOVE_TO_CONTAINER_END', payload: { dragId: state.dragData.id, newContainer: container } });
-      dispatch({ type: 'SET_DRAG_DATA', payload: { id: state.dragData.id, initialGroup: container, originId: providerId } });
-    } else if (!draggedItem) {
-      console.error('[Draggable] handleDragOver: Item not found', { dragId: state.dragData.id, itemsCount: state.items.length });
+
+    if (enableCrossContainerPreview && state.dragData.id) {
+      // Only when enableCrossContainerPreview is true: when hovering over a different container, move item to end
+      const draggedItem = state.items.find(
+        (item) => item && item.id === state.dragData.id
+      );
+      if (draggedItem && draggedItem.container !== container) {
+        dispatch({
+          type: "MOVE_TO_CONTAINER_END",
+          payload: { dragId: state.dragData.id, newContainer: container },
+        });
+      }
     }
-    
+
     if (onDragOver) onDragOver(e, container);
   };
 
@@ -300,4 +307,4 @@ export const DraggableProvider = ({
   return (
     <DragContext.Provider value={contextValue}>{children}</DragContext.Provider>
   );
-};
+};

data/app/pb_kits/playbook/pb_draggable/context/types.ts

@@ -18,6 +18,7 @@ export type ActionType =
 } }
   | { type: 'SET_IS_DRAGGING'; payload: string }
   | { type: 'SET_ACTIVE_CONTAINER'; payload: string }
+  | { type: 'SET_CROSS_CONTAINER_PREVIEW'; payload: boolean }
   | { type: 'CHANGE_CATEGORY'; payload: { itemId: string; container: string } }
   | { type: 'REORDER_ITEMS'; payload: { dragId: string; targetId: string } }
   | { type: 'REORDER_ITEMS_CROSS_CONTAINER'; payload: { dragId: string; targetId: string; newContainer: string } }
@@ -36,9 +37,10 @@ export type ActionType =
     onReorder: (items: ItemType[]) => void;
     onDragStart?: (id: string, container: string) => void;
     onDragEnter?: (id: string, container: string) => void;
-    onDragEnd?: (draggedItemId: string, finalContainer: string, originalContainer: string, itemAbove: ItemType | null, itemBelow: ItemType | null) => void;
-    onDrop?: (draggedItemId: string, droppedContainer: string, originalContainer: string, item: ItemType, itemAbove: ItemType | null, itemBelow: ItemType | null) => void;
+    onDragEnd?: (...args: any[]) => void;
+    onDrop?: (...args: any[]) => void;
     onDragOver?: (e: Event, container: string) => void;
     dropZone?: DropZoneConfig | string; // Can accept string for backward compatibility
     providerId?: string;
+    enableCrossContainerPreview?: boolean;
   }

data/app/pb_kits/playbook/pb_draggable/docs/_draggable_multiple_containers_dropzone.jsx

@@ -83,6 +83,7 @@ const DraggableMultipleContainersDropzone = (props) => {
   return (
     <DraggableProvider 
         dropZone={{type: "outline"}}
+        enableCrossContainerPreview
         initialItems={data}
         onDragEnd={(draggedItemId, finalContainer, originalContainer, itemAbove, itemBelow) => {
           console.log(`Dragged Item ID: ${draggedItemId}`);

data/app/pb_kits/playbook/pb_draggable/docs/_draggable_multiple_containers_dropzone.md

@@ -1,6 +1,8 @@
 The multiple container functionality also supports customized dropzone styling as shown here. 
 
-In addition to this, the `onDrop` and `onDragEnd` event listeners provide several arguments to allow developers more context from the drag event.
+In addition to this, the `enableCrossContainerPreview` prop can be used on the `DraggableProvider` as shown here to enable dropzone preview for cross-container dragging. 
+
+With `enableCrossContainerPreview`, the `onDrop` and `onDragEnd` event listeners will also provide several arguments to allow developers more context from the drag event.
 
 The `onDrop` callback is triggered when an item is successfully dropped into a container. It provides the following arguments:
 

data/app/pb_kits/playbook/pb_typeahead/components/ClearIndicator.tsx

@@ -7,18 +7,29 @@ type ClearContainerProps = {
     id: string,
   },
   clearValue: () => void,
+  innerProps?: any,
 }
 
-const ClearContainer = (props: ClearContainerProps): React.ReactElement => {
-  const { selectProps, clearValue } = props
+const ClearContainer = (props: ClearContainerProps | any): React.ReactElement => {
+  const { selectProps, clearValue, innerProps } = props
   useEffect(() => {
     document.addEventListener(`pb-typeahead-kit-${selectProps.id}:clear`, clearValue)
   }, [clearValue, selectProps.id])
 
+  // To stop this from bubbling up when inside a dialog or other modal
+  const handleMouseDown = (event: React.MouseEvent) => {
+    event.stopPropagation()
+    innerProps?.onMouseDown?.(event)
+  }
+
   return (
     <components.ClearIndicator
         className="clear_indicator"
         {...props}
+        innerProps={{
+          ...innerProps,
+          onMouseDown: handleMouseDown,
+        }}
     />
   )
 }