@almadar/ui 2.5.2 → 2.7.0

package/dist/{chunk-GOZKH7QW.js → chunk-WGJIL4YR.js}

@@ -1,8 +1,38 @@
 import { useEventBus } from './chunk-YXZM3WCF.js';
 import { en_default } from './chunk-TSETXL2E.js';
-import React2, { createContext, useContext, useState, useMemo, useCallback, useEffect } from 'react';
+import React2, { createContext, useRef, useEffect, useCallback, useContext, useState, useMemo } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
+function useInfiniteScroll(onLoadMore, options = {}) {
+  const { rootMargin = "200px", hasMore = true, isLoading = false } = options;
+  const observerRef = useRef(null);
+  const callbackRef = useRef(onLoadMore);
+  callbackRef.current = onLoadMore;
+  const hasMoreRef = useRef(hasMore);
+  hasMoreRef.current = hasMore;
+  const isLoadingRef = useRef(isLoading);
+  isLoadingRef.current = isLoading;
+  useEffect(() => {
+    return () => {
+      observerRef.current?.disconnect();
+    };
+  }, []);
+  const sentinelRef = useCallback((node) => {
+    observerRef.current?.disconnect();
+    if (!node) return;
+    observerRef.current = new IntersectionObserver(
+      (entries) => {
+        const entry = entries[0];
+        if (entry.isIntersecting && hasMoreRef.current && !isLoadingRef.current) {
+          callbackRef.current();
+        }
+      },
+      { rootMargin }
+    );
+    observerRef.current.observe(node);
+  }, [rootMargin]);
+  return { sentinelRef };
+}
 var { $meta: _meta, ...coreMessages } = en_default;
 var coreLocale = coreMessages;
 var I18nContext = createContext({
@@ -93,6 +123,241 @@ function parseQueryBinding(binding) {
     field: parts.length > 1 ? parts.slice(1).join(".") : void 0
   };
 }
+function useLongPress(onLongPress, options = {}) {
+  const { duration = 500, moveThreshold = 10 } = options;
+  const timerRef = useRef(null);
+  const startPos = useRef({ x: 0, y: 0 });
+  const isPressedRef = useRef(false);
+  const firedRef = useRef(false);
+  const cancel = useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    isPressedRef.current = false;
+  }, []);
+  const onPointerDown = useCallback((e) => {
+    firedRef.current = false;
+    startPos.current = { x: e.clientX, y: e.clientY };
+    isPressedRef.current = true;
+    timerRef.current = setTimeout(() => {
+      firedRef.current = true;
+      isPressedRef.current = false;
+      onLongPress();
+    }, duration);
+  }, [duration, onLongPress]);
+  const onPointerMove = useCallback((e) => {
+    if (!isPressedRef.current) return;
+    const dx = e.clientX - startPos.current.x;
+    const dy = e.clientY - startPos.current.y;
+    if (Math.sqrt(dx * dx + dy * dy) > moveThreshold) {
+      cancel();
+    }
+  }, [moveThreshold, cancel]);
+  const onPointerUp = useCallback(() => {
+    cancel();
+  }, [cancel]);
+  const onPointerCancel = useCallback(() => {
+    cancel();
+  }, [cancel]);
+  return {
+    onPointerDown,
+    onPointerMove,
+    onPointerUp,
+    onPointerCancel,
+    isPressed: isPressedRef.current
+  };
+}
+function useSwipeGesture(callbacks, options = {}) {
+  const { threshold = 50, velocityThreshold = 0.3, preventDefault = false } = options;
+  const startX = useRef(0);
+  const startY = useRef(0);
+  const startTime = useRef(0);
+  const currentX = useRef(0);
+  const tracking = useRef(false);
+  const offsetXRef = useRef(0);
+  const isSwipingRef = useRef(false);
+  const onPointerDown = useCallback((e) => {
+    startX.current = e.clientX;
+    startY.current = e.clientY;
+    currentX.current = e.clientX;
+    startTime.current = Date.now();
+    tracking.current = true;
+    isSwipingRef.current = false;
+    offsetXRef.current = 0;
+    e.target.setPointerCapture?.(e.pointerId);
+  }, []);
+  const onPointerMove = useCallback((e) => {
+    if (!tracking.current) return;
+    if (preventDefault) e.preventDefault();
+    currentX.current = e.clientX;
+    const dx = e.clientX - startX.current;
+    const dy = e.clientY - startY.current;
+    if (Math.abs(dx) > 10 && Math.abs(dx) > Math.abs(dy)) {
+      isSwipingRef.current = true;
+      offsetXRef.current = dx;
+    }
+  }, [preventDefault]);
+  const onPointerUp = useCallback((e) => {
+    if (!tracking.current) return;
+    tracking.current = false;
+    const dx = e.clientX - startX.current;
+    const dy = e.clientY - startY.current;
+    const elapsed = Date.now() - startTime.current;
+    const velocity = Math.abs(dx) / Math.max(elapsed, 1);
+    offsetXRef.current = 0;
+    isSwipingRef.current = false;
+    if (Math.abs(dx) < threshold && velocity < velocityThreshold) return;
+    if (Math.abs(dx) > Math.abs(dy)) {
+      if (dx < -threshold) callbacks.onSwipeLeft?.();
+      else if (dx > threshold) callbacks.onSwipeRight?.();
+    } else {
+      if (dy < -threshold) callbacks.onSwipeUp?.();
+      else if (dy > threshold) callbacks.onSwipeDown?.();
+    }
+  }, [threshold, velocityThreshold, callbacks]);
+  const onPointerCancel = useCallback(() => {
+    tracking.current = false;
+    offsetXRef.current = 0;
+    isSwipingRef.current = false;
+  }, []);
+  return {
+    onPointerDown,
+    onPointerMove,
+    onPointerUp,
+    onPointerCancel,
+    offsetX: offsetXRef.current,
+    isSwiping: isSwipingRef.current
+  };
+}
+function useDragReorder(initialItems, onReorder) {
+  const [items, setItems] = useState(initialItems);
+  const [dragIndex, setDragIndex] = useState(-1);
+  const [dragOverIndex, setDragOverIndex] = useState(-1);
+  const itemsRef = useRef(initialItems);
+  if (initialItems !== itemsRef.current) {
+    itemsRef.current = initialItems;
+    setItems(initialItems);
+  }
+  const isDragging = dragIndex >= 0;
+  const handleDragStart = useCallback((index) => (e) => {
+    e.preventDefault();
+    setDragIndex(index);
+    setDragOverIndex(index);
+    e.target.setPointerCapture?.(e.pointerId);
+  }, []);
+  const handleDragMove = useCallback((index) => (e) => {
+    if (dragIndex < 0) return;
+    const target = document.elementFromPoint(e.clientX, e.clientY);
+    if (!target) return;
+    let el = target;
+    while (el && !el.dataset.dragIndex) {
+      el = el.parentElement;
+    }
+    if (el?.dataset.dragIndex) {
+      const overIndex = parseInt(el.dataset.dragIndex, 10);
+      if (!isNaN(overIndex) && overIndex !== dragOverIndex) {
+        setDragOverIndex(overIndex);
+      }
+    }
+  }, [dragIndex, dragOverIndex]);
+  const handleDragEnd = useCallback(() => {
+    if (dragIndex >= 0 && dragOverIndex >= 0 && dragIndex !== dragOverIndex) {
+      const newItems = [...items];
+      const [movedItem] = newItems.splice(dragIndex, 1);
+      newItems.splice(dragOverIndex, 0, movedItem);
+      setItems(newItems);
+      onReorder(dragIndex, dragOverIndex, items[dragIndex]);
+    }
+    setDragIndex(-1);
+    setDragOverIndex(-1);
+  }, [dragIndex, dragOverIndex, items, onReorder]);
+  const getDragHandleProps = useCallback((index) => ({
+    onPointerDown: handleDragStart(index),
+    style: { cursor: "grab", touchAction: "none" },
+    "aria-grabbed": dragIndex === index,
+    role: "button"
+  }), [handleDragStart, dragIndex]);
+  const getItemProps = useCallback((index) => ({
+    onPointerMove: handleDragMove(index),
+    onPointerUp: handleDragEnd,
+    "aria-dropeffect": "move",
+    "data-drag-index": String(index),
+    style: {
+      opacity: dragIndex === index ? 0.5 : 1,
+      transition: isDragging ? "transform 150ms ease" : void 0,
+      transform: isDragging && dragOverIndex >= 0 ? index === dragIndex ? "scale(1.02)" : index > dragIndex && index <= dragOverIndex ? "translateY(-100%)" : index < dragIndex && index >= dragOverIndex ? "translateY(100%)" : void 0 : void 0
+    }
+  }), [handleDragMove, handleDragEnd, dragIndex, dragOverIndex, isDragging]);
+  return {
+    items,
+    dragIndex,
+    dragOverIndex,
+    isDragging,
+    getDragHandleProps,
+    getItemProps
+  };
+}
+function usePullToRefresh(onRefresh, options = {}) {
+  const { threshold = 60, maxPull = 120 } = options;
+  const [pullDistance, setPullDistance] = useState(0);
+  const [isPulling, setIsPulling] = useState(false);
+  const [isRefreshing, setIsRefreshing] = useState(false);
+  const startY = useRef(0);
+  const scrollTopRef = useRef(0);
+  const onTouchStart = useCallback((e) => {
+    const container = e.currentTarget;
+    scrollTopRef.current = container.scrollTop;
+    if (scrollTopRef.current <= 0) {
+      startY.current = e.touches[0].clientY;
+      setIsPulling(true);
+    }
+  }, []);
+  const onTouchMove = useCallback((e) => {
+    if (!isPulling || isRefreshing) return;
+    const container = e.currentTarget;
+    if (container.scrollTop > 0) {
+      setPullDistance(0);
+      return;
+    }
+    const dy = e.touches[0].clientY - startY.current;
+    if (dy > 0) {
+      const distance = Math.min(dy * 0.5, maxPull);
+      setPullDistance(distance);
+    }
+  }, [isPulling, isRefreshing, maxPull]);
+  const onTouchEnd = useCallback(() => {
+    if (!isPulling) return;
+    setIsPulling(false);
+    if (pullDistance >= threshold && !isRefreshing) {
+      setIsRefreshing(true);
+      setPullDistance(threshold);
+      onRefresh();
+    } else {
+      setPullDistance(0);
+    }
+  }, [isPulling, pullDistance, threshold, isRefreshing, onRefresh]);
+  const endRefresh = useCallback(() => {
+    setIsRefreshing(false);
+    setPullDistance(0);
+  }, []);
+  const containerProps = {
+    onTouchStart,
+    onTouchMove,
+    onTouchEnd,
+    style: {
+      transform: pullDistance > 0 ? `translateY(${pullDistance}px)` : void 0,
+      transition: isPulling ? "none" : "transform 300ms ease-out"
+    }
+  };
+  return {
+    pullDistance,
+    isPulling,
+    isRefreshing,
+    containerProps,
+    endRefresh
+  };
+}
 var SelectionContext = createContext(null);
 var defaultCompareEntities = (a, b) => {
   if (a === b) return true;
@@ -383,4 +648,4 @@ function useEntitySuspense(entity, id) {
   } };
 }
 
-export { EntityDataProvider, I18nProvider, SelectionContext, SelectionProvider, createTranslate, entityDataKeys, parseQueryBinding, useEntity, useEntityDataAdapter, useEntityDetail, useEntityList, useEntityListSuspense, useEntitySuspense, useQuerySingleton, useSelection, useSelectionOptional, useTranslate };
+export { EntityDataProvider, I18nProvider, SelectionContext, SelectionProvider, createTranslate, entityDataKeys, parseQueryBinding, useDragReorder, useEntity, useEntityDataAdapter, useEntityDetail, useEntityList, useEntityListSuspense, useEntitySuspense, useInfiniteScroll, useLongPress, usePullToRefresh, useQuerySingleton, useSelection, useSelectionOptional, useSwipeGesture, useTranslate };