@kopexa/sight 17.12.0 → 17.13.0

package/dist/chunk-DWZQIPCX.mjs

@@ -0,0 +1,301 @@
+"use client";
+import {
+  messages
+} from "./chunk-FBTSAODG.mjs";
+
+// src/hooks/use-file-upload/index.ts
+import { useSafeIntl } from "@kopexa/i18n";
+import { formatBytes } from "@kopexa/shared-utils";
+import {
+  useCallback,
+  useRef,
+  useState
+} from "react";
+var useFileUpload = (options = {}) => {
+  const {
+    maxFiles = Number.POSITIVE_INFINITY,
+    maxSize = Number.POSITIVE_INFINITY,
+    accept = "*",
+    multiple = false,
+    initialFiles = [],
+    onFilesChange,
+    onFilesAdded,
+    onError
+  } = options;
+  const t = useSafeIntl();
+  const [state, setState] = useState({
+    files: initialFiles.map((file) => ({
+      file,
+      id: file.id,
+      preview: file.url
+    })),
+    isDragging: false,
+    errors: []
+  });
+  const inputRef = useRef(null);
+  const validateFile = useCallback(
+    (file) => {
+      if (file instanceof File) {
+        if (file.size > maxSize) {
+          return t.formatMessage(messages.file_exceeds_max, {
+            name: file.name,
+            max: formatBytes(maxSize)
+          });
+        }
+      } else {
+        if (file.size > maxSize) {
+          return t.formatMessage(messages.file_exceeds_max, {
+            name: file.name,
+            max: formatBytes(maxSize)
+          });
+        }
+      }
+      if (accept !== "*") {
+        const acceptedTypes = accept.split(",").map((type) => type.trim());
+        const fileType = file instanceof File ? file.type || "" : file.type;
+        const fileExtension = `.${file instanceof File ? file.name.split(".").pop() : file.name.split(".").pop()}`;
+        const isAccepted = acceptedTypes.some((type) => {
+          if (type.startsWith(".")) {
+            return fileExtension.toLowerCase() === type.toLowerCase();
+          }
+          if (type.endsWith("/*")) {
+            const baseType = type.split("/")[0];
+            return fileType.startsWith(`${baseType}/`);
+          }
+          return fileType === type;
+        });
+        if (!isAccepted) {
+          return t.formatMessage(messages.file_not_accepted, {
+            name: file instanceof File ? file.name : file.name
+          });
+        }
+      }
+      return null;
+    },
+    [accept, maxSize, t.formatMessage]
+  );
+  const createPreview = useCallback(
+    (file) => {
+      if (file instanceof File) {
+        return URL.createObjectURL(file);
+      }
+      return file.url;
+    },
+    []
+  );
+  const generateUniqueId = useCallback((file) => {
+    if (file instanceof File) {
+      return `${file.name}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    }
+    return file.id;
+  }, []);
+  const clearFiles = useCallback(() => {
+    setState((prev) => {
+      for (const file of prev.files) {
+        if (file.preview && file.file instanceof File && file.file.type.startsWith("image/")) {
+          URL.revokeObjectURL(file.preview);
+        }
+      }
+      if (inputRef.current) {
+        inputRef.current.value = "";
+      }
+      const newState = {
+        ...prev,
+        files: [],
+        errors: []
+      };
+      onFilesChange == null ? void 0 : onFilesChange(newState.files);
+      return newState;
+    });
+  }, [onFilesChange]);
+  const addFiles = useCallback(
+    (newFiles) => {
+      if (!newFiles || newFiles.length === 0) return;
+      const newFilesArray = Array.from(newFiles);
+      const errors = [];
+      setState((prev) => ({ ...prev, errors: [] }));
+      if (!multiple) {
+        clearFiles();
+      }
+      if (multiple && maxFiles !== Number.POSITIVE_INFINITY && state.files.length + newFilesArray.length > maxFiles) {
+        errors.push(
+          t.formatMessage(messages.too_many_files, {
+            max: maxFiles
+          })
+        );
+        onError == null ? void 0 : onError(errors);
+        setState((prev) => ({ ...prev, errors }));
+        return;
+      }
+      const validFiles = [];
+      for (const file of newFilesArray) {
+        if (multiple) {
+          const isDuplicate = state.files.some(
+            (existingFile) => existingFile.file.name === file.name && existingFile.file.size === file.size
+          );
+          if (isDuplicate) {
+            return;
+          }
+        }
+        if (file.size > maxSize) {
+          errors.push(
+            multiple ? `Some files exceed the maximum size of ${formatBytes(maxSize)}.` : `File exceeds the maximum size of ${formatBytes(maxSize)}.`
+          );
+          continue;
+        }
+        const error = validateFile(file);
+        if (error) {
+          errors.push(error);
+        } else {
+          validFiles.push({
+            file,
+            id: generateUniqueId(file),
+            preview: createPreview(file)
+          });
+        }
+      }
+      if (validFiles.length > 0) {
+        onFilesAdded == null ? void 0 : onFilesAdded(validFiles);
+        setState((prev) => {
+          const newFiles2 = !multiple ? validFiles : [...prev.files, ...validFiles];
+          onFilesChange == null ? void 0 : onFilesChange(newFiles2);
+          return {
+            ...prev,
+            files: newFiles2,
+            errors
+          };
+        });
+      } else if (errors.length > 0) {
+        onError == null ? void 0 : onError(errors);
+        setState((prev) => ({
+          ...prev,
+          errors
+        }));
+      }
+      if (inputRef.current) {
+        inputRef.current.value = "";
+      }
+    },
+    [
+      onError,
+      state.files,
+      maxFiles,
+      multiple,
+      maxSize,
+      validateFile,
+      createPreview,
+      generateUniqueId,
+      clearFiles,
+      onFilesChange,
+      onFilesAdded,
+      t.formatMessage
+    ]
+  );
+  const removeFile = useCallback(
+    (id) => {
+      setState((prev) => {
+        const fileToRemove = prev.files.find((file) => file.id === id);
+        if ((fileToRemove == null ? void 0 : fileToRemove.preview) && fileToRemove.file instanceof File && fileToRemove.file.type.startsWith("image/")) {
+          URL.revokeObjectURL(fileToRemove.preview);
+        }
+        const newFiles = prev.files.filter((file) => file.id !== id);
+        onFilesChange == null ? void 0 : onFilesChange(newFiles);
+        return {
+          ...prev,
+          files: newFiles,
+          errors: []
+        };
+      });
+    },
+    [onFilesChange]
+  );
+  const clearErrors = useCallback(() => {
+    setState((prev) => ({
+      ...prev,
+      errors: []
+    }));
+  }, []);
+  const handleDragEnter = useCallback((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setState((prev) => ({ ...prev, isDragging: true }));
+  }, []);
+  const handleDragLeave = useCallback((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (e.currentTarget.contains(e.relatedTarget)) {
+      return;
+    }
+    setState((prev) => ({ ...prev, isDragging: false }));
+  }, []);
+  const handleDragOver = useCallback((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+  }, []);
+  const handleDrop = useCallback(
+    (e) => {
+      var _a;
+      e.preventDefault();
+      e.stopPropagation();
+      setState((prev) => ({ ...prev, isDragging: false }));
+      if ((_a = inputRef.current) == null ? void 0 : _a.disabled) {
+        return;
+      }
+      if (e.dataTransfer.files && e.dataTransfer.files.length > 0) {
+        if (!multiple) {
+          const file = e.dataTransfer.files[0];
+          addFiles([file]);
+        } else {
+          addFiles(e.dataTransfer.files);
+        }
+      }
+    },
+    [addFiles, multiple]
+  );
+  const handleFileChange = useCallback(
+    (e) => {
+      if (e.target.files && e.target.files.length > 0) {
+        addFiles(e.target.files);
+      }
+    },
+    [addFiles]
+  );
+  const openFileDialog = useCallback(() => {
+    if (inputRef.current) {
+      inputRef.current.click();
+    }
+  }, []);
+  const getInputProps = useCallback(
+    (props = {}) => {
+      return {
+        ...props,
+        type: "file",
+        onChange: handleFileChange,
+        accept: props.accept || accept,
+        multiple: props.multiple !== void 0 ? props.multiple : multiple,
+        ref: inputRef
+      };
+    },
+    [accept, multiple, handleFileChange]
+  );
+  return [
+    state,
+    {
+      addFiles,
+      removeFile,
+      clearFiles,
+      clearErrors,
+      handleDragEnter,
+      handleDragLeave,
+      handleDragOver,
+      handleDrop,
+      handleFileChange,
+      openFileDialog,
+      getInputProps
+    }
+  ];
+};
+
+export {
+  useFileUpload
+};

package/dist/chunk-EAJ3DTJ3.mjs

@@ -0,0 +1,59 @@
+"use client";
+
+// src/components/file-upload/utils/format-accept-types.ts
+var WILDCARD_GROUPS = {
+  "image/*": "common image formats",
+  "audio/*": "common audio formats",
+  "video/*": "common video formats",
+  "application/*": "common document formats"
+};
+var MIME_TO_LABEL = {
+  "image/png": "PNG",
+  "image/jpeg": "JPG",
+  "image/jpg": "JPG",
+  "application/pdf": "PDF",
+  "text/csv": "CSV",
+  "text/plain": "TXT"
+};
+var EXT_TO_LABEL = {
+  ".png": "PNG",
+  ".jpg": "JPG",
+  ".jpeg": "JPG",
+  ".pdf": "PDF",
+  ".csv": "CSV",
+  ".txt": "TXT"
+};
+function normalizeToken(token) {
+  return token.trim().toLowerCase();
+}
+function formatAcceptedTypes(accept) {
+  var _a, _b;
+  if (!accept || typeof accept !== "string") return "";
+  const tokens = accept.split(",").map(normalizeToken).filter(Boolean);
+  const labels = [];
+  for (const token of tokens) {
+    if (WILDCARD_GROUPS[token]) {
+      labels.push(WILDCARD_GROUPS[token]);
+      continue;
+    }
+    if (token.startsWith(".")) {
+      labels.push(
+        (_a = EXT_TO_LABEL[token]) != null ? _a : token.replace(/^\./, "").toUpperCase()
+      );
+      continue;
+    }
+    if (token.includes("/")) {
+      labels.push((_b = MIME_TO_LABEL[token]) != null ? _b : token.split("/")[1].toUpperCase());
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return labels.filter((x) => {
+    if (seen.has(x)) return false;
+    seen.add(x);
+    return true;
+  }).join(", ");
+}
+
+export {
+  formatAcceptedTypes
+};

package/dist/chunk-FBTSAODG.mjs

@@ -0,0 +1,25 @@
+"use client";
+
+// src/hooks/use-file-upload/messages.ts
+import { defineMessages } from "@kopexa/i18n";
+var messages = defineMessages({
+  file_exceeds_max: {
+    id: "use_file_upload.file_exceeds_max",
+    defaultMessage: `File "{name}" exceeds the maximum size of {max}.`,
+    description: "Shown when a single file is larger than allowed"
+  },
+  file_not_accepted: {
+    id: "use_file_upload.file_not_accepted",
+    defaultMessage: `File "{name}" is not an accepted file type.`,
+    description: "Shown when file type/extension doesn't match accept"
+  },
+  too_many_files: {
+    id: "file_upload.too_many_files",
+    defaultMessage: "You can only upload a maximum of {max} files.",
+    description: "Shown when maxFiles would be exceeded"
+  }
+});
+
+export {
+  messages
+};

package/dist/chunk-G57FFIKP.mjs

@@ -0,0 +1,48 @@
+"use client";
+
+// src/components/blankstate/blankstate.tsx
+import { cn } from "@kopexa/shared-utils";
+import {
+  blankstate
+} from "@kopexa/theme";
+import { jsx, jsxs } from "react/jsx-runtime";
+var Blankstate = (props) => {
+  const {
+    className,
+    children,
+    classNames,
+    icon,
+    title,
+    description,
+    size,
+    bordered,
+    narrow,
+    ...rest
+  } = props;
+  const styles = blankstate({ size, bordered, narrow });
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: styles.root({ className: cn(classNames == null ? void 0 : classNames.root, className) }),
+      ...rest,
+      children: /* @__PURE__ */ jsxs("div", { className: styles.container({ className: classNames == null ? void 0 : classNames.container }), children: [
+        icon && /* @__PURE__ */ jsx("div", { className: styles.icon({ className: classNames == null ? void 0 : classNames.icon }), children: icon }),
+        title && /* @__PURE__ */ jsx("h2", { className: styles.title({ className: classNames == null ? void 0 : classNames.title }), children: title }),
+        description && /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: styles.description({
+              className: classNames == null ? void 0 : classNames.description
+            }),
+            children: description
+          }
+        ),
+        children && /* @__PURE__ */ jsx("div", { className: styles.actions({ className: classNames == null ? void 0 : classNames.actions }), children })
+      ] })
+    }
+  );
+};
+
+export {
+  Blankstate
+};

package/dist/chunk-GR3VEF4M.mjs

@@ -0,0 +1 @@
+"use client";

package/dist/chunk-HISY6ZIK.mjs

@@ -0,0 +1 @@
+"use client";

package/dist/chunk-HUHVPC6T.mjs

@@ -0,0 +1,17 @@
+"use client";
+
+// src/components/textarea/textarea.tsx
+import { textarea } from "@kopexa/theme";
+import { jsx } from "react/jsx-runtime";
+var Textarea = (props) => {
+  const { className, size, ...rest } = props;
+  const styles = textarea({
+    className,
+    size
+  });
+  return /* @__PURE__ */ jsx("textarea", { "data-slot": "textarea", className: styles, ...rest });
+};
+
+export {
+  Textarea
+};

package/dist/chunk-HVOS7SXF.mjs

@@ -0,0 +1,15 @@
+"use client";
+
+// src/components/file-upload/utils/data-url-to-file.ts
+async function dataUrlToFile(dataUrl, fileName, typeHint) {
+  const res = await fetch(dataUrl);
+  const blob = await res.blob();
+  const type = typeHint || blob.type || "image/png";
+  const ext = type.includes("jpeg") ? "jpg" : type.split("/")[1] || "png";
+  const safeName = fileName.replace(/\.[^.]+$/, "");
+  return new File([blob], `${safeName}-cropped.${ext}`, { type });
+}
+
+export {
+  dataUrlToFile
+};

package/dist/chunk-PKG2E3MX.mjs

@@ -0,0 +1 @@
+"use client";

package/dist/chunk-POVIOFVF.mjs

@@ -0,0 +1,18 @@
+"use client";
+import {
+  Skeleton
+} from "./chunk-DU3OVIBY.mjs";
+
+// src/components/skeleton/skeleton-avatar.tsx
+import { cn } from "@kopexa/shared-utils";
+import { skeletonAvatar } from "@kopexa/theme";
+import { jsx } from "react/jsx-runtime";
+var SkeletonAvatar = (props) => {
+  const { size, className, ...restProps } = props;
+  const baseStyle = skeletonAvatar({ size });
+  return /* @__PURE__ */ jsx(Skeleton, { ...restProps, className: cn(baseStyle, className) });
+};
+
+export {
+  SkeletonAvatar
+};

package/dist/chunk-RK7G2GYB.mjs

@@ -0,0 +1,45 @@
+"use client";
+
+// src/components/file-upload/messages.ts
+import { defineMessages } from "@kopexa/i18n";
+var messages = defineMessages({
+  change_avatar: {
+    id: "file_upload.change_avatar",
+    defaultMessage: "Change Avatar",
+    description: "Label for changing the avatar image"
+  },
+  upload_avatar: {
+    id: "file_upload.upload_avatar",
+    defaultMessage: "Upload Avatar",
+    description: "Label for uploading a new avatar image"
+  },
+  remove_avatar: {
+    id: "file_upload.remove_avatar",
+    defaultMessage: "Remove Avatar",
+    description: "Label for removing the current avatar image"
+  },
+  avatar_uploaded: {
+    id: "file_upload.avatar_uploaded",
+    defaultMessage: "Avatar uploaded",
+    description: "Message displayed when the avatar is uploaded successfully"
+  },
+  accepted_file_types: {
+    id: "file_upload.accepted_file_types",
+    defaultMessage: "{types}{size, select, none {} other { up to {size}}}",
+    description: "Message indicating the accepted file types for upload"
+  },
+  cancel: {
+    id: "file_upload.cancel",
+    defaultMessage: "Cancel",
+    description: "Label for canceling the file upload"
+  },
+  apply_crop: {
+    id: "file_upload.apply_crop",
+    defaultMessage: "Apply",
+    description: "Label for applying the crop to the image"
+  }
+});
+
+export {
+  messages
+};