funda-ui 4.5.666 → 4.5.671

package/lib/esm/MultipleSelect/utils/func.ts

@@ -34,8 +34,28 @@ export function multiSelControlOptionExist(arr: any[], val: any) {
  * @returns 
  */
 export function uniqueArr(arr: any[]) {
-    return arr.filter((item: any, index: number, self: any[]) => index === self.findIndex((t) => (t.value === item.value)));
+    return arr.filter((item: any, index: number, self: any[]) => index === self.findIndex((t) => (t.id == item.id)));
 }
 
+/**
+ * Remove Duplicate objects from Options
+ * @param {Array} arr 
+ * @returns 
+ */
+export function uniqueOpt(arr: any[]) {
+    return arr.flat().filter((item: any, index: number, self: any[]) => index === self.findIndex((t) => (t.id === item.id)));
+}
 
 
+/**
+ * Sort JSON arrays according to the order of the numeric arrays
+ * @param {Array<Number>|Array<String>} orderArray 
+ * @param {Array<*>} arr 
+ * @param {String} field 
+ * @returns 
+ */
+export function sortedJsonArray(orderArray: number[] | string[], arr: any[], field: string = 'value') {
+    return orderArray.map((orderId: number | string) =>
+        arr.find(item => item[field] === orderId)
+    );
+}

package/lib/esm/Tabs/Tabs.tsx

@@ -18,7 +18,7 @@ export type TabsProps = {
     animTransitionDuration?: number;
     /** -- */
     style?: React.CSSProperties;
-    onChange?: (nav: any, targetId: any, index: number, persistentIndex: number) => void;
+    onChange?: (nav: HTMLElement, targetId: string, index: number, persistentIndex: number) => void;
     onLoad?: (func: Function) => void;
 	children: React.ReactNode | React.ReactNode[];
     

package/lib/esm/Textarea/index.tsx

@@ -50,6 +50,8 @@ export type TextareaProps = {
     onBlur?: (e: any, el: any) => void;
     onFocus?: (e: any, el: any) => void;
     onPressEnter?: (e: any, el: any) => void;
+    onKeyDown?: (e: any, el: any) => void;
+    onKeyUp?: (e: any, el: any) => void;
     onResize?: (el: any, params: number[]) => void;
     
 };
@@ -96,6 +98,8 @@ const Textarea = forwardRef((props: TextareaProps, externalRef: any) => {
         onBlur,
         onFocus,
         onPressEnter,
+        onKeyDown,
+        onKeyUp,
         onResize,
         ...attributes
     } = props;
@@ -288,7 +292,12 @@ const Textarea = forwardRef((props: TextareaProps, externalRef: any) => {
             set: (value: string, cb?: any) => {
                 setChangedVal(`${value}`);
                 cb?.();
-            }
+            },
+            aiPredictReset: () => {
+                setTimeout(() => { // Avoid conflicts with other asynchronous states, resulting in invalid clearing
+                    setCurrentSuggestion('');
+                }, 0);
+            },
         }),
         [contentRef]
     );
@@ -363,6 +372,10 @@ const Textarea = forwardRef((props: TextareaProps, externalRef: any) => {
     }
 
     function handleKeyPressed(event: KeyboardEvent<HTMLTextAreaElement>) {
+
+        onKeyDown?.(event, valRef.current);
+
+
         if (typeof (onKeyPressedCallback) === 'function') {
             const newData: any = onKeyPressedCallback(event, valRef.current);
             if (newData) setChangedVal(newData);  // Avoid the error "react checkbox changing an uncontrolled input to be controlled"
@@ -418,6 +431,9 @@ const Textarea = forwardRef((props: TextareaProps, externalRef: any) => {
 
     }
 
+    function handleKeyUp(event: KeyboardEvent<HTMLTextAreaElement>) {
+        onKeyUp?.(event, valRef.current);
+    }
 
     useEffect(() => {
 
@@ -534,6 +550,7 @@ const Textarea = forwardRef((props: TextareaProps, externalRef: any) => {
                                 }
                             }}
                             onKeyDown={handleKeyPressed}
+                            onKeyUp={handleKeyUp}
                             disabled={disabled || null}
                             required={required || null}
                             readOnly={readOnly || null}

package/lib/esm/Tree/TreeList.tsx

@@ -40,6 +40,7 @@ export type TreeListProps = {
     getCheckedData?: any[];
     updategetCheckedData?: any;
     onSelect?: (e: any, val: any, func: Function) => void;
+    onDoubleSelect?: (e: any, val: any, func: Function) => void;
     onCollapse?: (e: any, val: any, func: Function) => void;
     onCheck?: (val: any) => void;
     evInitValue?: (key: React.Key | null, fetch: FetchConfig | null, firstRender: boolean) => void;
@@ -64,6 +65,7 @@ export default function TreeList(props: TreeListProps) {
         getCheckedData,
         updategetCheckedData,
         onSelect,
+        onDoubleSelect,
         onCollapse,
         onCheck,
         evInitValue
@@ -285,6 +287,34 @@ export default function TreeList(props: TreeListProps) {
         }
     }
     
+    function handleDoubleSelect(e: any) {
+        e.preventDefault();
+        e.stopPropagation();
+        
+        const hyperlink = e.currentTarget;
+
+        if ( hyperlink.classList.contains('selected') ) {
+            activeClass(hyperlink, 'remove', 'selected');
+        } else {
+            [].slice.call(hyperlink.closest('.tree-diagram__wrapper').querySelectorAll('li > a')).forEach((node: any) => {
+                activeClass(node, 'remove', 'selected');
+            });
+            activeClass(hyperlink, 'add', 'selected');
+        }
+
+     
+        onDoubleSelect?.(e, {
+            key: hyperlink.dataset.key,
+            slug: hyperlink.dataset.slug,
+            link: hyperlink.dataset.link,
+            optiondata: hyperlink.dataset.optiondata
+        }, typeof evInitValue !== 'function' ? ()=>void(0) : evInitValue);
+
+        if ( disableArrow ) {
+            handleCollapse(e);
+        }
+    }
+    
 
     function titleArrowGenerator() {
         return disableArrow ? loadingIcon : null;
@@ -522,6 +552,7 @@ export default function TreeList(props: TreeListProps) {
                                 href={item.link === '#' ? `${item.link}-${i}` : item.link} 
                                 aria-expanded="false" 
                                 onClick={handleSelect} 
+                                onDoubleClick={handleDoubleSelect} 
                                 data-link={item.link} 
                                 data-slug={item.slug} 
                                 data-key={item.key}
@@ -553,6 +584,7 @@ export default function TreeList(props: TreeListProps) {
                                                 first={false} 
                                                 arrow={arrow} 
                                                 onSelect={onSelect} 
+                                                onDoubleSelect={onDoubleSelect}
                                                 onCollapse={onCollapse} 
                                                 onCheck={onCheck}
                                                 disableArrow={disableArrow} 

package/lib/esm/Tree/index.tsx

@@ -75,6 +75,7 @@ export type TreeProps = {
     /** -- */
     id?: string;
     onSelect?: (e: any, val: any, func: Function) => void;
+    onDoubleSelect?: (e: any, val: any, func: Function) => void;
     onCollapse?: (e: any, val: any, func: Function) => void;
     onCheck?: (val: any) => void;
 };
@@ -95,6 +96,7 @@ const Tree = (props: TreeProps) => {
         data,
         retrieveData,
         onSelect,
+        onDoubleSelect,
         onCollapse,
         onCheck
     } = props;
@@ -374,6 +376,7 @@ const Tree = (props: TreeProps) => {
                     data={Array.isArray(retrieveData) && retrieveData.length > 0 ? filterRetriveData(flatList, retrieveData) : list} 
                     childClassName={childClassName || 'tree-diagram-default-nav'} 
                     onSelect={onSelect} 
+                    onDoubleSelect={onDoubleSelect}
                     onCollapse={onCollapse}
                     onCheck={onCheck}
                     evInitValue={initDefaultValue}

package/lib/esm/Utils/hooks/useBoundedDrag.tsx

@@ -0,0 +1,301 @@
+/**
+ * Bounded Drag
+ * 
+ * @usage:
+
+
+const App = () => {
+    const [items, setItems] = useState<ListItem[]>([]);
+    // ... other states and refs
+      
+    const deepCloneWithReactNode = (obj: any): any => {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+
+        // Handle array
+        if (Array.isArray(obj)) {
+            return obj.map(item => deepCloneWithReactNode(item));
+        }
+
+        // Handle object
+        const clonedObj: any = {};
+        for (const key in obj) {
+            if (key === 'appendControl') {
+                clonedObj[key] = obj[key];
+            } else {
+                clonedObj[key] = deepCloneWithReactNode(obj[key]);
+            }
+        }
+        return clonedObj;
+    };
+
+
+    const getItemWithChildrenIndices = (items: ListItem[], startIndex: number): number[] => {
+        const indices = [startIndex];
+        const startItem = items[startIndex];
+        const startDepth = startItem.depth || 0;
+
+        // Check if subsequent items are child items
+        for (let i = startIndex + 1; i < items.length; i++) {
+            const currentItem = items[i];
+            const currentDepth = currentItem.depth || 0;
+            if (currentDepth > startDepth) {
+                indices.push(i);
+            } else {
+                break;
+            }
+        }
+
+        return indices;
+    };
+
+
+    const { isDragging, dragHandlers } = useBoundedDrag({
+        dragMode,
+        boundarySelector: '.custom-draggable-list',
+        itemSelector:'.custom-draggable-list__item',
+        dragHandleSelector: '.custom-draggable-list__handle',
+        onDragStart: (index: number) => {
+            // Additional drag start logic if needed
+        },
+        onDragOver: (dragIndex: number | null, dropIndex: number | null) => {
+            // Additional drag over logic if needed
+        },
+        onDragEnd: (dragIndex: number | null, dropIndex: number | null) => {
+            if (dragIndex !== null && dropIndex !== null && dragIndex !== dropIndex) {
+                // Handle item movement
+                const newItems = deepCloneWithReactNode(items);
+                const itemsToMove = getItemWithChildrenIndices(newItems, dragIndex);
+                const itemsBeingMoved = itemsToMove.map(index => newItems[index]);
+
+                // ... rest of your existing drag end logic ...
+
+                setItems(updatedItems);
+
+            }
+        }
+    });
+
+    // Update your JSX to use the new handlers
+    return (
+        <ul className="custom-draggable-list">
+        {items.map((item: any, index: number) => (
+            <li
+                // ... other props
+                draggable={!draggable ? undefined : editingItem !== item.id && "true"}
+                onDragStart={!draggable ? undefined : (e) => dragHandlers.handleDragStart(e, index)}
+                onDragOver={!draggable ? undefined : dragHandlers.handleDragOver}
+                onDragEnd={!draggable ? undefined : dragHandlers.handleDragEnd}
+                onTouchStart={!draggable ? undefined : (e) => dragHandlers.handleDragStart(e, index)}
+                onTouchMove={!draggable ? undefined : dragHandlers.handleDragOver}
+                onTouchEnd={!draggable ? undefined : dragHandlers.handleDragEnd}
+            >
+                <li className="custom-draggable-list__item">
+                    <span className="custom-draggable-list__handle">☰</span>
+                    <i>content {indec}<i>
+                </li>
+            </li>
+        ))}
+    </ul>
+);
+
+ */
+
+import { useRef, useState } from 'react';
+
+export interface TouchOffset {
+    x: number;
+    y: number;
+}
+
+export interface BoundedDragOptions {
+    dragMode?: 'handle' | 'block';
+    boundarySelector?: string;
+    itemSelector?: string;
+    dragHandleSelector?: string;
+    onDragStart?: (index: number) => void;
+    onDragOver?: (dragIndex: number | null, dropIndex: number | null) => void;
+    onDragEnd?: (dragIndex: number | null, dropIndex: number | null) => void;
+}
+
+export const useBoundedDrag = (options: BoundedDragOptions = {}) => {
+    const {
+        dragMode = 'handle',
+        boundarySelector = '.custom-draggable-list',
+        itemSelector = '.custom-draggable-list__item',
+        dragHandleSelector = '.custom-draggable-list__handle',
+        onDragStart,
+        onDragOver,
+        onDragEnd
+    } = options;
+
+    const [isDragging, setIsDragging] = useState(false);
+    const dragItem = useRef<number | null>(null);
+    const dragOverItem = useRef<number | null>(null);
+    const dragNode = useRef<HTMLElement | null>(null);
+    const touchOffset = useRef<TouchOffset>({ x: 0, y: 0 });
+    const currentHoverItem = useRef<HTMLElement | null>(null);
+
+    const handleDragStart = (e: React.DragEvent | React.TouchEvent, position: number) => {
+        const isTouch = 'touches' in e;
+        const target = e.target as HTMLElement;
+        
+        // For block mode or handle mode check
+        if (dragMode === 'handle') {
+            const handle = target.closest(dragHandleSelector);
+            if (!handle) {
+                if (!isTouch) e.preventDefault();
+                return false;
+            }
+        }
+
+        // Find the draggable item
+        const listItem = target.closest(itemSelector) as HTMLElement;
+        if (!listItem) return;
+
+        // Check boundary
+        const boundary = listItem.closest(boundarySelector);
+        if (!boundary) return;
+
+        dragItem.current = position;
+        onDragStart?.(position);
+
+        if (isTouch) {
+            e.preventDefault(); // Prevent scrolling
+            const touch = (e as React.TouchEvent).touches[0];
+            const rect = listItem.getBoundingClientRect();
+            const boundaryRect = boundary.getBoundingClientRect();
+
+            // Calculate offset relative to the boundary
+            touchOffset.current = {
+                x: touch.clientX - rect.left,
+                y: touch.clientY - rect.top
+            };
+
+            // Clone the item for dragging
+            dragNode.current = listItem.cloneNode(true) as HTMLElement;
+            dragNode.current.classList.add('dragging');
+            
+            // Style the clone
+            Object.assign(dragNode.current.style, {
+                position: 'fixed',
+                width: `${rect.width}px`,
+                height: `${rect.height}px`,
+                left: `${rect.left}px`,
+                top: `${rect.top}px`,
+                zIndex: '1000',
+                pointerEvents: 'none',
+                transform: 'scale(1.05)',
+                transition: 'transform 0.1s',
+                opacity: '0.9'
+            });
+
+            document.body.appendChild(dragNode.current);
+            setIsDragging(true);
+            listItem.classList.add('dragging-placeholder');
+        } else {
+            // ... desktop drag logic remains the same ...
+        }
+    };
+
+    const handleDragOver = (e: React.DragEvent | React.TouchEvent) => {
+        e.preventDefault();
+        const isTouch = 'touches' in e;
+
+        if (!isTouch) {
+            (e as React.DragEvent).dataTransfer.dropEffect = 'move';
+        }
+
+        // Get the current pointer/touch position
+        const point = isTouch ? 
+            (e as React.TouchEvent).touches[0] : 
+            { clientX: (e as React.DragEvent).clientX, clientY: (e as React.DragEvent).clientY };
+
+        // Update dragged element position for touch events
+        if (isTouch && isDragging && dragNode.current) {
+            dragNode.current.style.left = `${point.clientX - touchOffset.current.x}px`;
+            dragNode.current.style.top = `${point.clientY - touchOffset.current.y}px`;
+        }
+
+        // Find the element below the pointer/touch
+        const elemBelow = document.elementFromPoint(
+            point.clientX,
+            point.clientY
+        );
+
+        if (!elemBelow) return;
+
+        // Find the closest list item
+        const listItem = elemBelow.closest(itemSelector) as HTMLElement;
+        if (!listItem || listItem === currentHoverItem.current) return;
+
+        // Check boundary
+        const boundary = listItem.closest(boundarySelector);
+        if (!boundary) return;
+
+        // Update hover states
+        if (currentHoverItem.current) {
+            currentHoverItem.current.classList.remove('drag-over', 'drag-over-top', 'drag-over-bottom');
+        }
+
+        currentHoverItem.current = listItem;
+        listItem.classList.add('drag-over');
+
+        // Calculate position in list
+        const position = Array.from(listItem.parentNode!.children).indexOf(listItem);
+        dragOverItem.current = position;
+
+        // Determine drop position (top/bottom)
+        const rect = listItem.getBoundingClientRect();
+        const middleY = rect.top + rect.height / 2;
+
+        if (point.clientY < middleY) {
+            listItem.classList.add('drag-over-top');
+        } else {
+            listItem.classList.add('drag-over-bottom');
+        }
+
+        onDragOver?.(dragItem.current, dragOverItem.current);
+    };
+
+    const handleDragEnd = (e: React.DragEvent | React.TouchEvent) => {
+        const isTouch = 'touches' in e;
+        if (isTouch && !isDragging) return;
+
+        onDragEnd?.(dragItem.current, dragOverItem.current);
+
+        // Cleanup
+        if (dragNode.current) {
+            dragNode.current.remove();
+            dragNode.current = null;
+        }
+
+        document.querySelectorAll(itemSelector).forEach(item => {
+            (item as HTMLElement).style.opacity = '1';
+            item.classList.remove(
+                'dragging',
+                'dragging-placeholder',
+                'drag-over',
+                'drag-over-top',
+                'drag-over-bottom'
+            );
+        });
+
+        setIsDragging(false);
+        currentHoverItem.current = null;
+        dragItem.current = null;
+        dragOverItem.current = null;
+    };
+
+    return {
+        isDragging,
+        dragHandlers: {
+            handleDragStart,
+            handleDragOver,
+            handleDragEnd
+        }
+    };
+};
+
+export default useBoundedDrag;