playbook_ui 14.18.0 → 14.19.0.pre.alpha.PLAY20937693

data/app/pb_kits/playbook/pb_draggable/index.js

@@ -1,24 +1,26 @@
 import PbEnhancedElement from "../pb_enhanced_element";
 
-const DRAGGABLE_SELECTOR = "[data-pb-draggable]";
+const DRAGGABLE_SELECTOR  = "[data-pb-draggable]";
 const DRAGGABLE_CONTAINER = ".pb_draggable_container";
+const NEEDS_CLONE         = ["shadow", "outline", "line"];   // clone only for these types
 
 export default class PbDraggable extends PbEnhancedElement {
-  static get selector() {
-    return DRAGGABLE_SELECTOR;
-  }
+  static get selector() { return DRAGGABLE_SELECTOR; }
 
   connect() {
     this.state = {
-      items: [],
-      dragData: { id: "", initialGroup: "" },
-      isDragging: "",
-      activeContainer: ""
+      items:        [],
+      dragData:     { id: "", initialGroup: "" },
+      isDragging:   "",
+      activeContainer: "",
     };
 
-    this.draggedItem = null;
+    this.draggedItem   = null;
     this.draggedItemId = null;
+    this.dragGhost     = null;
     this.hasMultipleContainers = false;
+    this.dragZoneType  = "";
+    this.dragZoneColor = "";
 
     document.addEventListener("DOMContentLoaded", () => this.bindEventListeners());
   }
@@ -26,13 +28,12 @@ export default class PbDraggable extends PbEnhancedElement {
   setState(newState) {
     this.state = { ...this.state, ...newState };
     if (newState.items) {
-      const customEvent = new CustomEvent('pb-draggable-reorder', {
+      this.element.dispatchEvent(new CustomEvent("pb-draggable-reorder", {
         detail: {
           reorderedItems: this.state.items,
-          containerId: this.element.querySelector(DRAGGABLE_CONTAINER).id
-        }
-      });
-      this.element.dispatchEvent(customEvent);
+          containerId:    this.element.querySelector(DRAGGABLE_CONTAINER).id,
+        },
+      }));
     }
   }
 
@@ -43,71 +44,102 @@ export default class PbDraggable extends PbEnhancedElement {
 
     // Needed to prevent images within draggable items from being independently draggable
     // Needed if using Image kit in draggable items
-    this.element.querySelectorAll(".pb_draggable_item img").forEach(img => {
-      img.setAttribute("draggable", "false");
-    });
-
-    this.element.querySelectorAll(".pb_draggable_item").forEach(item => {
-      item.addEventListener("dragstart", this.handleDragStart.bind(this));
-      item.addEventListener("dragend", this.handleDragEnd.bind(this));
-      item.addEventListener("dragenter", this.handleDragEnter.bind(this));
-    });
+    this.element.querySelectorAll(".pb_draggable_item img")
+      .forEach(img => img.setAttribute("draggable", "false"));
+
+    this.element.querySelectorAll(".pb_draggable_item")
+      .forEach(item => {
+        item.addEventListener("dragstart", this.handleDragStart.bind(this));
+        item.addEventListener("dragend",   this.handleDragEnd.bind(this));
+        item.addEventListener("dragenter", this.handleDragEnter.bind(this));
+      });
 
-    containers.forEach(container => {
-      container.addEventListener("dragover", this.handleDragOver.bind(this));
-      container.addEventListener("drop", this.handleDrop.bind(this));
+    containers.forEach(c => {
+      c.addEventListener("dragover", this.handleDragOver.bind(this));
+      c.addEventListener("drop",     this.handleDrop.bind(this));
     });
   }
 
+  /* ---------------- DRAG START ---------------- */
   handleDragStart(event) {
     // Needed to prevent images within draggable items from being independently draggable
     // Needed if using Image kit in draggable items
-    if (event.target.tagName.toLowerCase() === 'img') {
+    if (event.target.tagName.toLowerCase() === "img") {
       event.preventDefault();
       return;
     }
 
-    const container = event.target.closest(DRAGGABLE_CONTAINER);
-    this.draggedItem = event.target;
+    const container    = event.target.closest(DRAGGABLE_CONTAINER);
+    this.draggedItem   = event.target;
     this.draggedItemId = event.target.id;
+    this.dragZoneType  = this.element.dataset.dropZoneType  || "";
+    this.dragZoneColor = this.element.dataset.dropZoneColor || "";
 
     this.setState({
-      dragData: { id: this.draggedItemId, initialGroup: container.id },
-      isDragging: this.draggedItemId
+      dragData:   { id: this.draggedItemId, initialGroup: container.id },
+      isDragging: this.draggedItemId,
     });
 
-    event.target.classList.add("is_dragging");
+    this.draggedItem.classList.add(
+      "is_dragging",
+      `drop_zone_${this.dragZoneType}`,
+      `drop_zone_color_${this.dragZoneColor}`,
+    );
+
     if (event.dataTransfer) {
-      event.dataTransfer.effectAllowed = 'move';
-      event.dataTransfer.setData('text/plain', this.draggedItemId);
+      event.dataTransfer.effectAllowed = "move";
+      event.dataTransfer.setData("text/plain", this.draggedItemId);
+
+      /* ---------- custom ghost clone (shadow + outline only) ---------- */
+      if (NEEDS_CLONE.includes(this.dragZoneType)) {
+        const ghost = this.draggedItem.cloneNode(true);
+        ghost.classList.remove(
+          "is_dragging",
+          `drop_zone_${this.dragZoneType}`,
+          `drop_zone_color_${this.dragZoneColor}`,
+        );
+        const { width, height } = this.draggedItem.getBoundingClientRect();
+        Object.assign(ghost.style, {
+          border:    "none",
+          width:     `${width}px`,
+          height:    `${height}px`,
+          position:  "absolute",
+          top:      "-9999px",
+          left:     "-9999px",
+          boxSizing: "border-box",
+          zIndex:    "9999",
+        });
+        document.body.appendChild(ghost);
+        this.dragGhost = ghost;
+        event.dataTransfer.setDragImage(ghost, width / 2, height / 2);
+      }
+      /* ---------------------------------------------------------------- */
     }
 
-    setTimeout(() => {
-      event.target.style.opacity = '0.5';
-    }, 0);
+    if (this.dragZoneType !== "line") {
+      requestAnimationFrame(() => (event.target.style.opacity = "0.5"));
+    }
   }
 
+  /* ---------------- DRAG ENTER ---------------- */
   handleDragEnter(event) {
     if (!this.draggedItem || event.target === this.draggedItem) return;
-
-    if (this.hasMultipleContainers) {
-      this.handleMultiContainerDragEnter(event);
-    } else {
-      this.handleSingleContainerDragEnter(event);
-    }
+    this.hasMultipleContainers
+      ? this.handleMultiContainerDragEnter(event)
+      : this.handleSingleContainerDragEnter(event);
   }
 
   handleSingleContainerDragEnter(event) {
-    const targetItem = event.target.closest('.pb_draggable_item');
+    const targetItem = event.target.closest(".pb_draggable_item");
+    // If we're entering a container directly or there's no target item
     if (!targetItem) return;
 
     const container = targetItem.parentNode;
-    const items = Array.from(container.children);
-
-    const draggedIndex = items.indexOf(this.draggedItem);
-    const targetIndex = items.indexOf(targetItem);
+    const items     = Array.from(container.children);
+    const fromIdx   = items.indexOf(this.draggedItem);
+    const toIdx     = items.indexOf(targetItem);
 
-    if (draggedIndex > targetIndex) {
+    if (fromIdx > toIdx) {
       container.insertBefore(this.draggedItem, targetItem);
     } else {
       container.insertBefore(this.draggedItem, targetItem.nextSibling);
@@ -116,146 +148,113 @@ export default class PbDraggable extends PbEnhancedElement {
 
   handleMultiContainerDragEnter(event) {
     const targetContainer = event.target.closest(DRAGGABLE_CONTAINER);
-    const targetItem = event.target.closest('.pb_draggable_item');
-
+    const targetItem      = event.target.closest(".pb_draggable_item");
     if (!targetContainer) return;
 
-    // If we're entering a container directly or there's no target item
     if (!targetItem) {
-      const lastItem = targetContainer.querySelector('.pb_draggable_item:last-child');
-      if (lastItem) {
-        targetContainer.insertBefore(this.draggedItem, lastItem.nextSibling);
-      } else {
-        targetContainer.appendChild(this.draggedItem);
-      }
+      const last = targetContainer.querySelector(".pb_draggable_item:last-child");
+      last
+        ? targetContainer.insertBefore(this.draggedItem, last.nextSibling)
+        : targetContainer.appendChild(this.draggedItem);
       return;
     }
 
-    const container = targetItem.parentNode;
-    const items = Array.from(container.children);
-
-    const newItems = [...items].map(item => ({
-      id: item.id,
-      container: container.id
-    }));
-
-    this.setState({ items: newItems });
+    const items = Array.from(targetContainer.children);
+    this.setState({ items: items.map(i => ({ id: i.id, container: targetContainer.id })) });
 
-    const rect = targetItem.getBoundingClientRect();
-    const middleY = rect.top + rect.height / 2;
+    const midY = targetItem.getBoundingClientRect().top +
+                 targetItem.getBoundingClientRect().height / 2;
 
-    if (event.clientY < middleY) {
-      container.insertBefore(this.draggedItem, targetItem);
+    if (event.clientY < midY) {
+      targetContainer.insertBefore(this.draggedItem, targetItem);
     } else {
-      container.insertBefore(this.draggedItem, targetItem.nextSibling);
+      targetContainer.insertBefore(this.draggedItem, targetItem.nextSibling);
     }
   }
 
+  /* ---------------- DRAG OVER ---------------- */
   handleDragOver(event) {
     event.preventDefault();
     event.stopPropagation();
-
-    if (this.hasMultipleContainers) {
-      this.handleMultiContainerDragOver(event);
-    } else {
-      this.handleSingleContainerDragOver(event);
-    }
+    this.hasMultipleContainers
+      ? this.handleMultiContainerDragOver(event)
+      : this.handleSingleContainerDragOver(event);
   }
 
   handleSingleContainerDragOver(event) {
     const container = event.target.closest(DRAGGABLE_CONTAINER);
-    if (container) {
-      container.classList.add("active_container");
-    }
+    if (container) container.classList.add("active_container");
   }
 
   handleMultiContainerDragOver(event) {
-    let container;
-    if (event.target.matches(DRAGGABLE_CONTAINER)) {
-      container = event.target;
-    } else {
-      container = event.target.closest(DRAGGABLE_CONTAINER);
-    }
-
-    if (container) {
-      this.setState({ activeContainer: container.id });
-      container.classList.add("active_container");
-
-      // If dragging over empty container or below last item
-      const lastItem = container.querySelector('.pb_draggable_item:last-child');
-      if (!lastItem || (lastItem && event.clientY > lastItem.getBoundingClientRect().bottom)) {
-        if (this.draggedItem && this.draggedItem.parentNode !== container) {
-          container.appendChild(this.draggedItem);
-        }
+    const container = event.target.matches(DRAGGABLE_CONTAINER)
+      ? event.target
+      : event.target.closest(DRAGGABLE_CONTAINER);
+    if (!container) return;
+
+    this.setState({ activeContainer: container.id });
+    container.classList.add("active_container");
+
+    const last = container.querySelector(".pb_draggable_item:last-child");
+    if (!last || event.clientY > last.getBoundingClientRect().bottom) {
+      if (this.draggedItem && this.draggedItem.parentNode !== container) {
+        container.appendChild(this.draggedItem);
       }
     }
   }
 
+  /* ---------------- DROP ---------------- */
   handleDrop(event) {
     event.preventDefault();
     event.stopPropagation();
 
-    let container;
-    if (event.target.matches(DRAGGABLE_CONTAINER)) {
-      container = event.target;
-    } else {
-      container = event.target.closest(DRAGGABLE_CONTAINER);
-    }
-
+    const container = event.target.matches(DRAGGABLE_CONTAINER)
+      ? event.target
+      : event.target.closest(DRAGGABLE_CONTAINER);
     if (!container || !this.draggedItem) return;
 
     container.classList.remove("active_container");
-    this.draggedItem.style.opacity = '1';
+    this.draggedItem.style.opacity = "1";
 
     // Handle empty containers
-    if (this.hasMultipleContainers && !container.querySelector('.pb_draggable_item')) {
+    if (this.hasMultipleContainers && !container.querySelector(".pb_draggable_item")) {
       container.appendChild(this.draggedItem);
     }
 
     // Updated order of items as an array of item IDs
-    const reorderedItems = Array.from(
-      this.element.querySelectorAll('.pb_draggable_item')
-    ).map(item => ({
-      id: item.id,
-      container: item.closest(DRAGGABLE_CONTAINER).id
-    }));
-
-    // Store reordered items in a data attribute on the container
-    container.setAttribute("data-reordered-items", JSON.stringify(reorderedItems));
+    const reorderedItems = Array.from(this.element.querySelectorAll(".pb_draggable_item"))
+      .map(i => ({ id: i.id, container: i.closest(DRAGGABLE_CONTAINER).id }));
 
-    const customEvent = new CustomEvent('pb-draggable-reorder', {
-      detail: {
-        reorderedItems,
-        containerId: container.id,
-      }
-    });
-
-    this.element.dispatchEvent(customEvent);
-
-    this.setState({
-      items: reorderedItems,
-      isDragging: "",
-      activeContainer: ""
-    });
+    container.dataset.reorderedItems = JSON.stringify(reorderedItems);
+    this.element.dispatchEvent(new CustomEvent("pb-draggable-reorder", {
+      detail: { reorderedItems, containerId: container.id },
+    }));
 
-    this.draggedItem = null;
+    this.setState({ items: reorderedItems, isDragging: "", activeContainer: "" });
+    this.draggedItem   = null;
     this.draggedItemId = null;
   }
 
+  /* ---------------- DRAG END ---------------- */
   handleDragEnd(event) {
-    event.target.classList.remove("is_dragging");
-    event.target.style.opacity = '1';
+    event.target.classList.remove(
+      "is_dragging",
+      `drop_zone_${this.dragZoneType}`,
+      `drop_zone_color_${this.dragZoneColor}`,
+    );
+    event.target.style.opacity = "1";
+
+    if (this.dragGhost) {
+      document.body.removeChild(this.dragGhost);
+      this.dragGhost = null;
+    }
 
-    this.setState({
-      isDragging: "",
-      activeContainer: ""
-    });
+    this.setState({ isDragging: "", activeContainer: "" });
 
-    this.draggedItem = null;
-    this.draggedItemId = null;
+    this.element.querySelectorAll(DRAGGABLE_CONTAINER)
+      .forEach(c => c.classList.remove("active_container"));
 
-    this.element.querySelectorAll(DRAGGABLE_CONTAINER).forEach(container => {
-      container.classList.remove("active_container");
-    });
+    this.draggedItem   = null;
+    this.draggedItemId = null;
   }
 }

data/app/pb_kits/playbook/pb_draggable/subcomponents/DraggableItem.tsx

@@ -8,6 +8,7 @@ import {
 } from "../../utilities/props";
 import { globalProps } from "../../utilities/globalProps";
 import { DraggableContext } from "../context";
+import { noop } from '../../utilities/object'
 
 type DraggableItemProps = {
   aria?: { [key: string]: string };
@@ -17,6 +18,13 @@ type DraggableItemProps = {
   data?: { [key: string]: string };
   htmlOptions?: {[key: string]: string | number | boolean | (() => void)},
   id?: string;
+  onDrag?: () => void,
+  onDragEnd?: () => void,
+  onDragEnter?: () => void,
+  onDragLeave?: () => void,
+  onDragOver?: () => void,
+  onDragStart?: () => void,
+  onDrop?: () => void,
   dragId?: string;
   tag?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'span' | 'div' | 'tr' | 'th' | 'td' | 'thead' | 'col' | 'tbody',
 };
@@ -31,7 +39,14 @@ const DraggableItem = (props: DraggableItemProps) => {
     htmlOptions = {},
     id,
     dragId,
-    tag="div"
+    tag="div",
+    onDrag = noop,
+    onDragEnd = noop,
+    onDragEnter = noop,
+    onDragLeave = noop,
+    onDragOver = noop,
+    onDragStart = noop,
+    onDrop = noop,
   } = props;
 
   const {
@@ -61,7 +76,7 @@ const DraggableItem = (props: DraggableItemProps) => {
   );
 
   // Enhanced drag start handler that preserves dimensions
-  const onDragStart = (e: React.DragEvent) => {
+  const handleDragStartWithCustom = (e: React.DragEvent) => {
     if (dropZone !== 'ghost' && itemRef.current) {
       // Create a clone for the drag image
       const clone = itemRef.current.cloneNode(true) as HTMLElement;
@@ -96,6 +111,9 @@ const DraggableItem = (props: DraggableItemProps) => {
 
     // Call the original handler
     handleDragStart(dragId, container);
+
+    // Custom event handler
+    onDragStart()
   };
 
   return (
@@ -107,9 +125,19 @@ const DraggableItem = (props: DraggableItemProps) => {
         draggable
         id={id}
         key={dragId}
-        onDragEnd={() => handleDragEnd()}
-        onDragEnter={() => handleDragEnter(dragId, container)}
-        onDragStart={onDragStart}
+        onDrag={onDrag}
+        onDragEnd={() => {
+          handleDragEnd()
+          onDragEnd()
+        }}
+        onDragEnter={() => {
+          handleDragEnter(dragId, container)
+          onDragEnter()
+        }}
+        onDragLeave={onDragLeave}
+        onDragOver={onDragOver}
+        onDragStart={handleDragStartWithCustom}
+        onDrop={onDrop}
         ref={itemRef}
     >
       {children}

data/app/pb_kits/playbook/pb_dropdown/_dropdown.scss

@@ -41,6 +41,11 @@
         outline: unset;
         transition: box-shadow 0.15s ease-in-out;
       }
+      &:focus-within {
+        box-shadow: 0px 0px 0 1px $primary !important;
+        outline: unset;
+        transition: box-shadow 0.15s ease-in-out;
+      }
 
       &[class*="_select_only"] {
         box-shadow: inset 0 -11px 20px rgba($primary, 0.05);

data/app/pb_kits/playbook/pb_dropdown/_dropdown.tsx

@@ -36,7 +36,6 @@ type DropdownProps = {
     onSelect?: (arg: GenericObject) => null;
     options: GenericObject;
     separators?: boolean;
-    triggerRef?: any;
     variant?: "default" | "subtle";
 };
 
@@ -65,7 +64,6 @@ let Dropdown = (props: DropdownProps, ref: any): React.ReactElement | null => {
         onSelect,
         options,
         separators = true,
-        triggerRef,
         variant = "default",
     } = props;
 
@@ -91,7 +89,7 @@ let Dropdown = (props: DropdownProps, ref: any): React.ReactElement | null => {
     const [focusedOptionIndex, setFocusedOptionIndex] = useState(-1);
 
     const dropdownRef = useRef(null);
-    const inputRef = useRef(null);
+    const inputRef = useRef<HTMLInputElement>(null);
     const inputWrapperRef = useRef(null);
     const dropdownContainerRef = useRef(null);
 
@@ -99,15 +97,7 @@ let Dropdown = (props: DropdownProps, ref: any): React.ReactElement | null => {
         separateChildComponents(children);
 
     useEffect(() => {
-        // Set the parent element of the trigger to relative to allow for absolute positioning of the dropdown
-        //Only needed for when useDropdown hook used with external trigger
-        if (triggerRef?.current) {
-            const parentElement = triggerRef.current.parentNode;
-            if (parentElement) {
-                parentElement.style.position = 'relative';
-            }
-        }
-        // Handle clicks outside the dropdown
+     // Handle clicks outside the dropdown
         const handleClick = handleClickOutside({
             inputWrapperRef,
             dropdownContainerRef,
@@ -167,7 +157,7 @@ let Dropdown = (props: DropdownProps, ref: any): React.ReactElement | null => {
     };
 
     const handleWrapperClick = () => {
-        autocomplete && inputRef.current.focus();
+        autocomplete && inputRef?.current?.focus();
         toggleDropdown();
     };
 
@@ -202,7 +192,7 @@ let Dropdown = (props: DropdownProps, ref: any): React.ReactElement | null => {
             {...htmlProps}
             className={classes}
             id={id}
-            style={triggerRef ? { position: "absolute" } : { position: "relative" }}
+            style={{position: "relative"}}
         >
             <DropdownContext.Provider
                 value={{
@@ -225,8 +215,7 @@ let Dropdown = (props: DropdownProps, ref: any): React.ReactElement | null => {
                     setIsDropDownClosed,
                     setIsInputFocused,
                     setSelected,
-                    toggleDropdown,
-                    triggerRef
+                    toggleDropdown
                 }}
             >
                 {label &&

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_error.html.erb

@@ -1,4 +1,4 @@
-<% 
+<%
   options = [
     { label: 'United States', value: 'United States', id: 'us' },
     { label: 'Canada', value: 'Canada', id: 'ca' },
@@ -6,4 +6,7 @@
   ]
 %>
 
-<%= pb_rails("dropdown", props: { error: "Please make a valid selection", options: options }) %>
+<%= pb_rails("dropdown", props: {
+  error: raw(pb_rails("icon", props: { icon: "warning" }) + " Please make a valid selection"),
+  options: options
+}) %>

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_error.jsx

@@ -1,9 +1,12 @@
 import React, { useState } from 'react'
 import Dropdown from '../../pb_dropdown/_dropdown'
+import Icon from '../../pb_icon/_icon'
 
 const DropdownError = (props) => {
     const [selectedOption, setSelectedOption] = useState()
-    const error = selectedOption?.value ? null : "Please make a valid selection"
+    const error = selectedOption?.value ? null : (<>
+        <Icon icon="warning" /> Please make a valid selection
+    </>)
     const options = [
         {
             label: "United States",

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_with_autocomplete.html.erb

@@ -0,0 +1,28 @@
+<% 
+  options = [
+    {
+      label: "United States",
+      value: "United States",
+      areaCode: "+1",
+      icon: "🇺🇸",
+      id: "us"
+    },
+    {
+      label: "United Kingdom",
+      value: "United Kingdom",
+      areaCode: "+44",
+      icon: "🇬🇧", 
+      id: "gb"
+    },
+    {
+      label: "Pakistan",
+      value: "Pakistan",
+      areaCode: "+92",
+      icon: "🇵🇰",
+      id: "pk"
+    }
+  ]
+
+%>
+
+<%= pb_rails("dropdown", props: {options: options, autocomplete: true}) %>