xertica-ui 2.1.4 → 2.1.6

package/dist/use-file-upload-CRJR68Tj.cjs

@@ -0,0 +1,403 @@
+"use strict";
+const React = require("react");
+function usePagination({
+  totalItems,
+  pageSize = 10,
+  initialPage = 1,
+  page: controlledPage,
+  onPageChange,
+  siblingCount = 1
+}) {
+  const [internalPage, setInternalPage] = React.useState(initialPage);
+  const isControlled = controlledPage !== void 0;
+  const currentPage = isControlled ? controlledPage : internalPage;
+  const totalPages = Math.max(1, Math.ceil(totalItems / pageSize));
+  const setPage = React.useCallback(
+    (p) => {
+      const clamped = Math.min(Math.max(1, p), totalPages);
+      if (!isControlled) setInternalPage(clamped);
+      onPageChange == null ? void 0 : onPageChange(clamped);
+    },
+    [isControlled, onPageChange, totalPages]
+  );
+  const startIndex = (currentPage - 1) * pageSize;
+  const endIndex = Math.min(startIndex + pageSize, totalItems);
+  const canGoPrev = currentPage > 1;
+  const canGoNext = currentPage < totalPages;
+  const isFirstPage = currentPage === 1;
+  const isLastPage = currentPage === totalPages;
+  const items = React.useMemo(() => {
+    const range = (start, end) => Array.from({ length: Math.max(0, end - start + 1) }, (_, i) => start + i);
+    const leftSibling = Math.max(currentPage - siblingCount, 1);
+    const rightSibling = Math.min(currentPage + siblingCount, totalPages);
+    const showLeftEllipsis = leftSibling > 2;
+    const showRightEllipsis = rightSibling < totalPages - 1;
+    const pageNumbers = [];
+    pageNumbers.push(1);
+    if (!showLeftEllipsis) {
+      for (const p of range(2, leftSibling - 1)) pageNumbers.push(p);
+    }
+    for (const p of range(Math.max(leftSibling, 2), Math.min(rightSibling, totalPages - 1))) {
+      pageNumbers.push(p);
+    }
+    if (!showRightEllipsis) {
+      for (const p of range(rightSibling + 1, totalPages - 1)) pageNumbers.push(p);
+    }
+    if (totalPages > 1) pageNumbers.push(totalPages);
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = pageNumbers.filter((p) => {
+      if (seen.has(p)) return false;
+      seen.add(p);
+      return true;
+    });
+    const result = [];
+    for (let i = 0; i < deduped.length; i++) {
+      result.push({ type: "page", page: deduped[i] });
+      if (i < deduped.length - 1 && deduped[i + 1] - deduped[i] > 1) {
+        result.push({ type: "ellipsis", key: `ellipsis-${deduped[i]}` });
+      }
+    }
+    return result;
+  }, [currentPage, siblingCount, totalPages]);
+  const goTo = React.useCallback((p) => setPage(p), [setPage]);
+  const next = React.useCallback(() => setPage(currentPage + 1), [currentPage, setPage]);
+  const prev = React.useCallback(() => setPage(currentPage - 1), [currentPage, setPage]);
+  const first = React.useCallback(() => setPage(1), [setPage]);
+  const last = React.useCallback(() => setPage(totalPages), [setPage, totalPages]);
+  return {
+    currentPage,
+    totalPages,
+    startIndex,
+    endIndex,
+    canGoPrev,
+    canGoNext,
+    isFirstPage,
+    isLastPage,
+    items,
+    goTo,
+    next,
+    prev,
+    first,
+    last
+  };
+}
+function findParent(nodes, targetId) {
+  var _a;
+  for (const n of nodes) {
+    if ((_a = n.children) == null ? void 0 : _a.some((c) => c.id === targetId)) return n;
+    if (n.children) {
+      const found = findParent(n.children, targetId);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function useTreeView({
+  data,
+  defaultExpanded = [],
+  selectedNodeId,
+  onNodeClick,
+  onNodeSelect
+}) {
+  const [expanded, setExpanded] = React.useState(new Set(defaultExpanded));
+  const [internalSelectedId, setInternalSelectedId] = React.useState(void 0);
+  const nodeRefs = React.useRef(/* @__PURE__ */ new Map());
+  const isControlled = selectedNodeId !== void 0;
+  const effectiveSelectedId = isControlled ? selectedNodeId : internalSelectedId;
+  const getNodeRef = React.useCallback(
+    (nodeId) => (el) => {
+      if (el) nodeRefs.current.set(nodeId, el);
+      else nodeRefs.current.delete(nodeId);
+    },
+    []
+  );
+  const getVisibleNodes = React.useCallback(() => {
+    const result = [];
+    const traverse = (nodes) => {
+      var _a;
+      for (const node of nodes) {
+        result.push(node);
+        if (((_a = node.children) == null ? void 0 : _a.length) && expanded.has(node.id)) traverse(node.children);
+      }
+    };
+    traverse(data);
+    return result;
+  }, [data, expanded]);
+  const toggleExpand = React.useCallback((nodeId) => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      next.has(nodeId) ? next.delete(nodeId) : next.add(nodeId);
+      return next;
+    });
+  }, []);
+  const handleSelect = React.useCallback(
+    (node) => {
+      if (!isControlled) setInternalSelectedId(node.id);
+      onNodeSelect == null ? void 0 : onNodeSelect(node);
+      onNodeClick == null ? void 0 : onNodeClick(node);
+    },
+    [isControlled, onNodeClick, onNodeSelect]
+  );
+  const handleKeyDown = React.useCallback(
+    (e, node) => {
+      var _a, _b;
+      const visibleNodes = getVisibleNodes();
+      const idx = visibleNodes.findIndex((n) => n.id === node.id);
+      const hasChildren = !!((_a = node.children) == null ? void 0 : _a.length);
+      const isExpanded = expanded.has(node.id);
+      const focusNode = (id) => {
+        var _a2;
+        (_a2 = nodeRefs.current.get(id)) == null ? void 0 : _a2.focus();
+      };
+      switch (e.key) {
+        case "ArrowDown": {
+          e.preventDefault();
+          const next = visibleNodes[idx + 1];
+          if (next) focusNode(next.id);
+          break;
+        }
+        case "ArrowUp": {
+          e.preventDefault();
+          const prev = visibleNodes[idx - 1];
+          if (prev) focusNode(prev.id);
+          break;
+        }
+        case "ArrowRight": {
+          e.preventDefault();
+          if (hasChildren && !isExpanded) {
+            toggleExpand(node.id);
+          } else if (hasChildren && isExpanded && ((_b = node.children) == null ? void 0 : _b.length)) {
+            focusNode(node.children[0].id);
+          }
+          break;
+        }
+        case "ArrowLeft": {
+          e.preventDefault();
+          if (hasChildren && isExpanded) {
+            toggleExpand(node.id);
+          } else {
+            const parent = findParent(data, node.id);
+            if (parent) focusNode(parent.id);
+          }
+          break;
+        }
+        case "Home": {
+          e.preventDefault();
+          if (visibleNodes.length > 0) focusNode(visibleNodes[0].id);
+          break;
+        }
+        case "End": {
+          e.preventDefault();
+          const last = visibleNodes[visibleNodes.length - 1];
+          if (last) focusNode(last.id);
+          break;
+        }
+        case "Enter": {
+          e.preventDefault();
+          if (hasChildren) toggleExpand(node.id);
+          handleSelect(node);
+          break;
+        }
+        case " ": {
+          e.preventDefault();
+          if (hasChildren) {
+            toggleExpand(node.id);
+          } else {
+            handleSelect(node);
+          }
+          break;
+        }
+      }
+    },
+    [data, expanded, getVisibleNodes, handleSelect, toggleExpand]
+  );
+  return {
+    expanded,
+    effectiveSelectedId,
+    nodeRefs,
+    getNodeRef,
+    toggleExpand,
+    handleSelect,
+    handleKeyDown,
+    getVisibleNodes
+  };
+}
+function useStepper({
+  totalSteps,
+  initialStep = 1,
+  step: controlledStep,
+  onStepChange,
+  onBeforeNext
+}) {
+  const [internalStep, setInternalStep] = React.useState(
+    () => Math.min(Math.max(1, initialStep), totalSteps)
+  );
+  const isControlled = controlledStep !== void 0;
+  const currentStep = isControlled ? controlledStep : internalStep;
+  const setStep = React.useCallback(
+    (s) => {
+      const clamped = Math.min(Math.max(1, s), totalSteps);
+      if (!isControlled) setInternalStep(clamped);
+      onStepChange == null ? void 0 : onStepChange(clamped);
+    },
+    [isControlled, onStepChange, totalSteps]
+  );
+  const isFirstStep = currentStep === 1;
+  const isLastStep = currentStep === totalSteps;
+  const canGoPrev = currentStep > 1;
+  const canGoNext = currentStep < totalSteps;
+  const next = React.useCallback(async () => {
+    if (!canGoNext) return;
+    if (onBeforeNext) {
+      const allowed = await onBeforeNext(currentStep);
+      if (!allowed) return;
+    }
+    setStep(currentStep + 1);
+  }, [canGoNext, currentStep, onBeforeNext, setStep]);
+  const prev = React.useCallback(() => {
+    if (!canGoPrev) return;
+    setStep(currentStep - 1);
+  }, [canGoPrev, currentStep, setStep]);
+  const goTo = React.useCallback((s) => setStep(s), [setStep]);
+  const reset = React.useCallback(() => setStep(1), [setStep]);
+  return {
+    currentStep,
+    totalSteps,
+    isFirstStep,
+    isLastStep,
+    canGoPrev,
+    canGoNext,
+    next,
+    prev,
+    goTo,
+    reset
+  };
+}
+function matchesAccept(file, accept) {
+  const tokens = accept.split(",").map((t) => t.trim().toLowerCase());
+  return tokens.some((token) => {
+    if (token.startsWith(".")) return file.name.toLowerCase().endsWith(token);
+    if (token.endsWith("/*")) return file.type.startsWith(token.slice(0, -1));
+    return file.type === token;
+  });
+}
+function useFileUpload({
+  maxFiles = 1,
+  maxSize = 5 * 1024 * 1024,
+  onFilesChange,
+  onError,
+  disabled = false,
+  accept
+} = {}) {
+  const [files, setFiles] = React.useState([]);
+  const [dragActive, setDragActive] = React.useState(false);
+  const [errorMessage, setErrorMessage] = React.useState(null);
+  const inputRef = React.useRef(null);
+  const handleFiles = React.useCallback(
+    (newFiles) => {
+      if (!newFiles) return;
+      setErrorMessage(null);
+      const filesArray = accept ? Array.from(newFiles).filter((f) => matchesAccept(f, accept)) : Array.from(newFiles);
+      const oversized = filesArray.filter((f) => f.size > maxSize);
+      const validFiles = filesArray.filter((f) => f.size <= maxSize);
+      let pendingError = null;
+      if (oversized.length > 0) {
+        const limitMB = (maxSize / 1024 / 1024).toFixed(0);
+        pendingError = {
+          msg: `${oversized.length} arquivo(s) excedem o limite de ${limitMB}MB e não foram adicionados.`,
+          files: oversized,
+          reason: "size"
+        };
+      }
+      setFiles((prev) => {
+        const merged = maxFiles === 1 ? validFiles.slice(0, 1) : [...prev, ...validFiles].slice(0, maxFiles);
+        const countRejected = maxFiles === 1 ? validFiles.slice(1) : [...prev, ...validFiles].slice(maxFiles);
+        if (countRejected.length > 0) {
+          pendingError = {
+            msg: `Apenas ${maxFiles} arquivo(s) permitido(s). ${countRejected.length} arquivo(s) não foram adicionados.`,
+            files: countRejected,
+            reason: "count"
+          };
+        }
+        onFilesChange == null ? void 0 : onFilesChange(merged);
+        return merged;
+      });
+      if (pendingError) {
+        setErrorMessage(pendingError.msg);
+        onError == null ? void 0 : onError(pendingError.files, pendingError.reason);
+      }
+    },
+    [maxFiles, maxSize, onError, onFilesChange]
+  );
+  const handleDrag = React.useCallback((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (e.type === "dragenter" || e.type === "dragover") {
+      setDragActive(true);
+    } else if (e.type === "dragleave") {
+      setDragActive(false);
+    }
+  }, []);
+  const handleDrop = React.useCallback(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      setDragActive(false);
+      if (disabled) return;
+      handleFiles(e.dataTransfer.files);
+    },
+    [disabled, handleFiles]
+  );
+  const handleChange = React.useCallback(
+    (e) => {
+      e.preventDefault();
+      if (disabled) return;
+      handleFiles(e.target.files);
+    },
+    [disabled, handleFiles]
+  );
+  const removeFile = React.useCallback(
+    (index) => {
+      setFiles((prev) => {
+        const updated = prev.filter((_, i) => i !== index);
+        onFilesChange == null ? void 0 : onFilesChange(updated);
+        if (updated.length === 0) setErrorMessage(null);
+        return updated;
+      });
+      if (inputRef.current) {
+        inputRef.current.value = "";
+      }
+    },
+    [onFilesChange]
+  );
+  const openFileDialog = React.useCallback(() => {
+    var _a;
+    if (!disabled) {
+      setErrorMessage(null);
+      (_a = inputRef.current) == null ? void 0 : _a.click();
+    }
+  }, [disabled]);
+  const clearFiles = React.useCallback(() => {
+    setFiles([]);
+    setErrorMessage(null);
+    onFilesChange == null ? void 0 : onFilesChange([]);
+    if (inputRef.current) inputRef.current.value = "";
+  }, [onFilesChange]);
+  return {
+    files,
+    dragActive,
+    errorMessage,
+    inputRef,
+    handleFiles,
+    handleDrag,
+    handleDrop,
+    handleChange,
+    removeFile,
+    openFileDialog,
+    clearFiles
+  };
+}
+exports.useFileUpload = useFileUpload;
+exports.usePagination = usePagination;
+exports.useStepper = useStepper;
+exports.useTreeView = useTreeView;