@nlabs/gothamui 1.8.0

package/lib/components/DropUpload/DropUpload.js

@@ -0,0 +1,323 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '@nlabs/utils';
+import { FileImage, UploadCloud, X } from 'lucide-react';
+import { memo, useCallback, useEffect, useId, useMemo, useRef, useState } from 'react';
+const imageMimeTypes = new Set([
+    'image/jpeg',
+    'image/png',
+    'image/webp'
+]);
+const createId = (file, index = 0)=>[
+        file.name,
+        file.size,
+        file.lastModified,
+        index
+    ].join('-');
+const parseAccept = (accept = '')=>accept.split(',').map((value)=>value.trim().toLowerCase()).filter(Boolean);
+const acceptsFile = (file, accept = '')=>{
+    const acceptRules = parseAccept(accept);
+    if (!acceptRules.length) {
+        return true;
+    }
+    const fileType = file.type.toLowerCase();
+    const fileName = file.name.toLowerCase();
+    return acceptRules.some((rule)=>{
+        if (rule.endsWith('/*')) {
+            return fileType.startsWith(rule.slice(0, -1));
+        }
+        if (rule.startsWith('.')) {
+            return fileName.endsWith(rule);
+        }
+        return fileType === rule;
+    });
+};
+const createImagePreview = (file)=>{
+    if (!imageMimeTypes.has(file.type)) {
+        return undefined;
+    }
+    return URL.createObjectURL(file);
+};
+const resizeImage = async (file, { imageOutputMimeType = 'image/jpeg', imageOutputQuality = 0.92, imageResizeTargetHeight, imageResizeTargetWidth, imageResizeUpscale = false })=>{
+    if (!imageMimeTypes.has(file.type) || !imageResizeTargetHeight && !imageResizeTargetWidth) {
+        return file;
+    }
+    const sourceUrl = URL.createObjectURL(file);
+    const image = new Image();
+    image.src = sourceUrl;
+    await image.decode();
+    const widthRatio = imageResizeTargetWidth ? imageResizeTargetWidth / image.width : Number.POSITIVE_INFINITY;
+    const heightRatio = imageResizeTargetHeight ? imageResizeTargetHeight / image.height : Number.POSITIVE_INFINITY;
+    const scale = Math.min(widthRatio, heightRatio, imageResizeUpscale ? Number.POSITIVE_INFINITY : 1);
+    if (scale >= 1 && !imageResizeUpscale) {
+        URL.revokeObjectURL(sourceUrl);
+        return file;
+    }
+    const canvas = document.createElement('canvas');
+    canvas.width = Math.max(1, Math.round(image.width * scale));
+    canvas.height = Math.max(1, Math.round(image.height * scale));
+    const context = canvas.getContext('2d');
+    context?.drawImage(image, 0, 0, canvas.width, canvas.height);
+    URL.revokeObjectURL(sourceUrl);
+    const blob = await new Promise((resolve)=>{
+        canvas.toBlob(resolve, imageOutputMimeType, imageOutputQuality);
+    });
+    if (!blob) {
+        return file;
+    }
+    return new File([
+        blob
+    ], file.name, {
+        lastModified: file.lastModified,
+        type: imageOutputMimeType
+    });
+};
+const filesToItems = (files)=>files.map((file, index)=>({
+            file,
+            id: createId(file, index),
+            previewUrl: createImagePreview(file)
+        }));
+const DropUploadComponent = ({ accept, browseLabel = 'browse', className, defaultFiles = [], disabled = false, files, helperText, imageOutputMimeType = 'image/jpeg', imageOutputQuality = 0.92, imageResizeTargetHeight, imageResizeTargetWidth, imageResizeUpscale = false, label = 'Drop files here or', maxFileSize, maxFiles = Number.POSITIVE_INFINITY, multiple = true, onFilesChange, onReject, previewClassName, ref, showPreviews = true, transformImages = true, ...props })=>{
+    const inputId = useId();
+    const inputRef = useRef(null);
+    const itemsRef = useRef([]);
+    const [isDragging, setIsDragging] = useState(false);
+    const [internalItems, setInternalItems] = useState(()=>filesToItems(defaultFiles));
+    const isControlled = Array.isArray(files);
+    const items = useMemo(()=>isControlled ? filesToItems(files || []) : internalItems, [
+        files,
+        internalItems,
+        isControlled
+    ]);
+    useEffect(()=>{
+        const nextPreviewUrls = new Set(items.map((item)=>item.previewUrl).filter(Boolean));
+        itemsRef.current.forEach((item)=>{
+            if (item.previewUrl && !nextPreviewUrls.has(item.previewUrl)) {
+                URL.revokeObjectURL(item.previewUrl);
+            }
+        });
+        itemsRef.current = items;
+    }, [
+        items
+    ]);
+    useEffect(()=>()=>{
+            itemsRef.current.forEach((item)=>{
+                if (item.previewUrl) {
+                    URL.revokeObjectURL(item.previewUrl);
+                }
+            });
+        }, []);
+    const updateItems = useCallback((nextItems)=>{
+        if (!isControlled) {
+            setInternalItems(nextItems);
+        }
+        onFilesChange?.(nextItems.map((item)=>item.file), nextItems);
+    }, [
+        isControlled,
+        onFilesChange
+    ]);
+    const addFiles = useCallback(async (incomingFiles)=>{
+        if (disabled) {
+            return;
+        }
+        const currentItems = multiple ? items : [];
+        const acceptedFiles = [];
+        const rejections = [];
+        const remainingSlots = Math.max(0, maxFiles - currentItems.length);
+        incomingFiles.forEach((file)=>{
+            if (acceptedFiles.length >= remainingSlots) {
+                rejections.push({
+                    file,
+                    reason: 'max-files'
+                });
+                return;
+            }
+            if (!acceptsFile(file, accept)) {
+                rejections.push({
+                    file,
+                    reason: 'type'
+                });
+                return;
+            }
+            if (maxFileSize && file.size > maxFileSize) {
+                rejections.push({
+                    file,
+                    reason: 'max-size'
+                });
+                return;
+            }
+            acceptedFiles.push(file);
+        });
+        if (rejections.length) {
+            onReject?.(rejections);
+        }
+        if (!acceptedFiles.length) {
+            return;
+        }
+        const transformedFiles = transformImages ? await Promise.all(acceptedFiles.map((file)=>resizeImage(file, {
+                imageOutputMimeType,
+                imageOutputQuality,
+                imageResizeTargetHeight,
+                imageResizeTargetWidth,
+                imageResizeUpscale
+            }))) : acceptedFiles;
+        updateItems([
+            ...currentItems,
+            ...filesToItems(transformedFiles)
+        ]);
+    }, [
+        accept,
+        disabled,
+        imageOutputMimeType,
+        imageOutputQuality,
+        imageResizeTargetHeight,
+        imageResizeTargetWidth,
+        imageResizeUpscale,
+        items,
+        maxFileSize,
+        maxFiles,
+        multiple,
+        onReject,
+        transformImages,
+        updateItems
+    ]);
+    const onInputChange = async (event)=>{
+        await addFiles(Array.from(event.target.files || []));
+        event.target.value = '';
+    };
+    const onDragOver = (event)=>{
+        event.preventDefault();
+        setIsDragging(true);
+    };
+    const onDragLeave = (event)=>{
+        event.preventDefault();
+        if (event.currentTarget === event.target) {
+            setIsDragging(false);
+        }
+    };
+    const onDrop = async (event)=>{
+        event.preventDefault();
+        setIsDragging(false);
+        await addFiles(Array.from(event.dataTransfer.files || []));
+    };
+    const onKeyDown = (event)=>{
+        if (event.key === 'Enter' || event.key === ' ') {
+            event.preventDefault();
+            inputRef.current?.click();
+        }
+    };
+    const removeItem = (id)=>{
+        updateItems(items.filter((item)=>item.id !== id));
+    };
+    return /*#__PURE__*/ _jsxs("div", {
+        className: cn('flex w-full flex-col gap-4', className),
+        ref: ref,
+        ...props,
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                "aria-disabled": disabled,
+                className: cn('group relative flex min-h-44 w-full cursor-pointer flex-col items-center justify-center rounded-xl border border-dashed border-border bg-transparent px-6 py-8 text-center transition-colors', 'focus-within:border-ring focus-within:ring-3 focus-within:ring-ring/30', 'hover:border-primary/70 hover:bg-primary/5', disabled && 'cursor-not-allowed opacity-50', isDragging && 'border-primary bg-primary/10'),
+                onClick: ()=>inputRef.current?.click(),
+                onDragLeave: onDragLeave,
+                onDragOver: onDragOver,
+                onDrop: onDrop,
+                onKeyDown: onKeyDown,
+                role: "button",
+                tabIndex: disabled ? -1 : 0,
+                children: [
+                    /*#__PURE__*/ _jsx("input", {
+                        accept: accept,
+                        className: "sr-only",
+                        disabled: disabled,
+                        id: inputId,
+                        multiple: multiple,
+                        onChange: onInputChange,
+                        ref: inputRef,
+                        type: "file"
+                    }),
+                    /*#__PURE__*/ _jsx(UploadCloud, {
+                        "aria-hidden": "true",
+                        className: "mb-4 size-10 text-muted-foreground transition-colors group-hover:text-primary"
+                    }),
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "text-sm font-medium text-foreground",
+                        children: [
+                            /*#__PURE__*/ _jsxs("span", {
+                                children: [
+                                    label,
+                                    " "
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx("label", {
+                                className: "cursor-pointer text-primary underline-offset-4 hover:underline",
+                                htmlFor: inputId,
+                                children: browseLabel
+                            })
+                        ]
+                    }),
+                    helperText && /*#__PURE__*/ _jsx("div", {
+                        className: "mt-2 text-sm text-muted-foreground",
+                        children: helperText
+                    })
+                ]
+            }),
+            showPreviews && !!items.length && /*#__PURE__*/ _jsx("div", {
+                className: "grid gap-3 sm:grid-cols-2 lg:grid-cols-3",
+                children: items.map((item)=>/*#__PURE__*/ _jsxs("div", {
+                        className: cn('group/item relative overflow-hidden rounded-lg border border-border bg-card text-card-foreground', previewClassName),
+                        children: [
+                            /*#__PURE__*/ _jsx("div", {
+                                className: "flex aspect-video items-center justify-center bg-muted",
+                                children: item.previewUrl ? /*#__PURE__*/ _jsx("img", {
+                                    alt: item.file.name,
+                                    className: "size-full object-cover",
+                                    src: item.previewUrl
+                                }) : /*#__PURE__*/ _jsx(FileImage, {
+                                    "aria-hidden": "true",
+                                    className: "size-9 text-muted-foreground"
+                                })
+                            }),
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "flex items-center justify-between gap-3 px-3 py-2",
+                                children: [
+                                    /*#__PURE__*/ _jsxs("div", {
+                                        className: "min-w-0",
+                                        children: [
+                                            /*#__PURE__*/ _jsx("p", {
+                                                className: "truncate text-sm font-medium",
+                                                children: item.file.name
+                                            }),
+                                            /*#__PURE__*/ _jsxs("p", {
+                                                className: "text-xs text-muted-foreground",
+                                                children: [
+                                                    Math.ceil(item.file.size / 1024),
+                                                    " KB"
+                                                ]
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ _jsx("button", {
+                                        "aria-label": `Remove ${item.file.name}`,
+                                        className: "inline-flex size-8 shrink-0 cursor-pointer items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none",
+                                        disabled: disabled,
+                                        onClick: (event)=>{
+                                            event.stopPropagation();
+                                            removeItem(item.id);
+                                        },
+                                        type: "button",
+                                        children: /*#__PURE__*/ _jsx(X, {
+                                            "aria-hidden": "true",
+                                            className: "size-4"
+                                        })
+                                    })
+                                ]
+                            })
+                        ]
+                    }, item.id))
+            })
+        ]
+    });
+};
+export const DropUpload = /*#__PURE__*/ memo(DropUploadComponent);
+DropUpload.displayName = 'DropUpload';
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/DropUpload/DropUpload.tsx"],"sourcesContent":["import {cn} from '@nlabs/utils';\nimport {FileImage, UploadCloud, X} from 'lucide-react';\nimport {memo,\n  useCallback,\n  useEffect,\n  useId,\n  useMemo,\n  useRef,\n  useState\n} from 'react';\n\nimport type {\n  ChangeEvent,\n  DragEvent,\n  HTMLAttributes,\n  KeyboardEvent,\n  ReactNode,\n  Ref\n} from 'react';\n\nexport type DropUploadRejectionReason = 'max-files' | 'max-size' | 'type';\n\nexport interface DropUploadItem {\n  readonly file: File;\n  readonly id: string;\n  readonly previewUrl?: string;\n}\n\nexport interface DropUploadRejection {\n  readonly file: File;\n  readonly reason: DropUploadRejectionReason;\n}\n\nexport interface DropUploadProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'onDrop'> {\n  readonly accept?: string;\n  readonly browseLabel?: string;\n  readonly defaultFiles?: readonly File[];\n  readonly disabled?: boolean;\n  readonly files?: readonly File[];\n  readonly helperText?: ReactNode;\n  readonly imageOutputMimeType?: 'image/jpeg' | 'image/png' | 'image/webp';\n  readonly imageOutputQuality?: number;\n  readonly imageResizeTargetHeight?: number;\n  readonly imageResizeTargetWidth?: number;\n  readonly imageResizeUpscale?: boolean;\n  readonly label?: ReactNode;\n  readonly maxFileSize?: number;\n  readonly maxFiles?: number;\n  readonly multiple?: boolean;\n  readonly onFilesChange?: (files: File[], items: DropUploadItem[]) => void;\n  readonly onReject?: (rejections: DropUploadRejection[]) => void;\n  readonly previewClassName?: string;\n  readonly ref?: Ref<HTMLDivElement>;\n  readonly showPreviews?: boolean;\n  readonly transformImages?: boolean;\n}\n\nconst imageMimeTypes = new Set(['image/jpeg', 'image/png', 'image/webp']);\n\nconst createId = (file: File, index = 0): string => [\n  file.name,\n  file.size,\n  file.lastModified,\n  index\n].join('-');\n\nconst parseAccept = (accept = ''): string[] => accept\n  .split(',')\n  .map((value) => value.trim().toLowerCase())\n  .filter(Boolean);\n\nconst acceptsFile = (file: File, accept = ''): boolean => {\n  const acceptRules = parseAccept(accept);\n\n  if(!acceptRules.length) {\n    return true;\n  }\n\n  const fileType = file.type.toLowerCase();\n  const fileName = file.name.toLowerCase();\n\n  return acceptRules.some((rule) => {\n    if(rule.endsWith('/*')) {\n      return fileType.startsWith(rule.slice(0, -1));\n    }\n\n    if(rule.startsWith('.')) {\n      return fileName.endsWith(rule);\n    }\n\n    return fileType === rule;\n  });\n};\n\nconst createImagePreview = (file: File): string | undefined => {\n  if(!imageMimeTypes.has(file.type)) {\n    return undefined;\n  }\n\n  return URL.createObjectURL(file);\n};\n\nconst resizeImage = async (\n  file: File,\n  {\n    imageOutputMimeType = 'image/jpeg',\n    imageOutputQuality = 0.92,\n    imageResizeTargetHeight,\n    imageResizeTargetWidth,\n    imageResizeUpscale = false\n  }: Pick<\n    DropUploadProps,\n    'imageOutputMimeType' |\n    'imageOutputQuality' |\n    'imageResizeTargetHeight' |\n    'imageResizeTargetWidth' |\n    'imageResizeUpscale'\n  >\n): Promise<File> => {\n  if(!imageMimeTypes.has(file.type) || (!imageResizeTargetHeight && !imageResizeTargetWidth)) {\n    return file;\n  }\n\n  const sourceUrl = URL.createObjectURL(file);\n  const image = new Image();\n  image.src = sourceUrl;\n  await image.decode();\n\n  const widthRatio = imageResizeTargetWidth ? imageResizeTargetWidth / image.width : Number.POSITIVE_INFINITY;\n  const heightRatio = imageResizeTargetHeight ? imageResizeTargetHeight / image.height : Number.POSITIVE_INFINITY;\n  const scale = Math.min(widthRatio, heightRatio, imageResizeUpscale ? Number.POSITIVE_INFINITY : 1);\n\n  if(scale >= 1 && !imageResizeUpscale) {\n    URL.revokeObjectURL(sourceUrl);\n    return file;\n  }\n\n  const canvas = document.createElement('canvas');\n  canvas.width = Math.max(1, Math.round(image.width * scale));\n  canvas.height = Math.max(1, Math.round(image.height * scale));\n\n  const context = canvas.getContext('2d');\n  context?.drawImage(image, 0, 0, canvas.width, canvas.height);\n  URL.revokeObjectURL(sourceUrl);\n\n  const blob = await new Promise<Blob | null>((resolve) => {\n    canvas.toBlob(resolve, imageOutputMimeType, imageOutputQuality);\n  });\n\n  if(!blob) {\n    return file;\n  }\n\n  return new File([blob], file.name, {\n    lastModified: file.lastModified,\n    type: imageOutputMimeType\n  });\n};\n\nconst filesToItems = (files: readonly File[]): DropUploadItem[] => files.map((file, index) => ({\n  file,\n  id: createId(file, index),\n  previewUrl: createImagePreview(file)\n}));\n\nconst DropUploadComponent = ({\n  accept,\n  browseLabel = 'browse',\n  className,\n  defaultFiles = [],\n  disabled = false,\n  files,\n  helperText,\n  imageOutputMimeType = 'image/jpeg',\n  imageOutputQuality = 0.92,\n  imageResizeTargetHeight,\n  imageResizeTargetWidth,\n  imageResizeUpscale = false,\n  label = 'Drop files here or',\n  maxFileSize,\n  maxFiles = Number.POSITIVE_INFINITY,\n  multiple = true,\n  onFilesChange,\n  onReject,\n  previewClassName,\n  ref,\n  showPreviews = true,\n  transformImages = true,\n  ...props\n}: DropUploadProps) => {\n  const inputId = useId();\n  const inputRef = useRef<HTMLInputElement>(null);\n  const itemsRef = useRef<DropUploadItem[]>([]);\n  const [isDragging, setIsDragging] = useState(false);\n  const [internalItems, setInternalItems] = useState<DropUploadItem[]>(() => filesToItems(defaultFiles));\n  const isControlled = Array.isArray(files);\n  const items = useMemo(\n    () => (isControlled ? filesToItems(files || []) : internalItems),\n    [files, internalItems, isControlled]\n  );\n\n  useEffect(() => {\n    const nextPreviewUrls = new Set(items.map((item) => item.previewUrl).filter(Boolean));\n\n    itemsRef.current.forEach((item) => {\n      if(item.previewUrl && !nextPreviewUrls.has(item.previewUrl)) {\n        URL.revokeObjectURL(item.previewUrl);\n      }\n    });\n\n    itemsRef.current = items;\n  }, [items]);\n\n  useEffect(() => () => {\n    itemsRef.current.forEach((item) => {\n      if(item.previewUrl) {\n        URL.revokeObjectURL(item.previewUrl);\n      }\n    });\n  }, []);\n\n  const updateItems = useCallback((nextItems: DropUploadItem[]) => {\n    if(!isControlled) {\n      setInternalItems(nextItems);\n    }\n\n    onFilesChange?.(nextItems.map((item) => item.file), nextItems);\n  }, [isControlled, onFilesChange]);\n\n  const addFiles = useCallback(async (incomingFiles: File[]) => {\n    if(disabled) {\n      return;\n    }\n\n    const currentItems = multiple ? items : [];\n    const acceptedFiles: File[] = [];\n    const rejections: DropUploadRejection[] = [];\n    const remainingSlots = Math.max(0, maxFiles - currentItems.length);\n\n    incomingFiles.forEach((file) => {\n      if(acceptedFiles.length >= remainingSlots) {\n        rejections.push({file, reason: 'max-files'});\n        return;\n      }\n\n      if(!acceptsFile(file, accept)) {\n        rejections.push({file, reason: 'type'});\n        return;\n      }\n\n      if(maxFileSize && file.size > maxFileSize) {\n        rejections.push({file, reason: 'max-size'});\n        return;\n      }\n\n      acceptedFiles.push(file);\n    });\n\n    if(rejections.length) {\n      onReject?.(rejections);\n    }\n\n    if(!acceptedFiles.length) {\n      return;\n    }\n\n    const transformedFiles = transformImages\n      ? await Promise.all(acceptedFiles.map((file) => resizeImage(file, {\n        imageOutputMimeType,\n        imageOutputQuality,\n        imageResizeTargetHeight,\n        imageResizeTargetWidth,\n        imageResizeUpscale\n      })))\n      : acceptedFiles;\n\n    updateItems([\n      ...currentItems,\n      ...filesToItems(transformedFiles)\n    ]);\n  }, [\n    accept,\n    disabled,\n    imageOutputMimeType,\n    imageOutputQuality,\n    imageResizeTargetHeight,\n    imageResizeTargetWidth,\n    imageResizeUpscale,\n    items,\n    maxFileSize,\n    maxFiles,\n    multiple,\n    onReject,\n    transformImages,\n    updateItems\n  ]);\n\n  const onInputChange = async (event: ChangeEvent<HTMLInputElement>) => {\n    await addFiles(Array.from(event.target.files || []));\n    event.target.value = '';\n  };\n\n  const onDragOver = (event: DragEvent<HTMLDivElement>) => {\n    event.preventDefault();\n    setIsDragging(true);\n  };\n\n  const onDragLeave = (event: DragEvent<HTMLDivElement>) => {\n    event.preventDefault();\n\n    if(event.currentTarget === event.target) {\n      setIsDragging(false);\n    }\n  };\n\n  const onDrop = async (event: DragEvent<HTMLDivElement>) => {\n    event.preventDefault();\n    setIsDragging(false);\n    await addFiles(Array.from(event.dataTransfer.files || []));\n  };\n\n  const onKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {\n    if(event.key === 'Enter' || event.key === ' ') {\n      event.preventDefault();\n      inputRef.current?.click();\n    }\n  };\n\n  const removeItem = (id: string) => {\n    updateItems(items.filter((item) => item.id !== id));\n  };\n\n  return (\n    <div className={cn('flex w-full flex-col gap-4', className)} ref={ref} {...props}>\n      <div\n        aria-disabled={disabled}\n        className={cn(\n          'group relative flex min-h-44 w-full cursor-pointer flex-col items-center justify-center rounded-xl border border-dashed border-border bg-transparent px-6 py-8 text-center transition-colors',\n          'focus-within:border-ring focus-within:ring-3 focus-within:ring-ring/30',\n          'hover:border-primary/70 hover:bg-primary/5',\n          disabled && 'cursor-not-allowed opacity-50',\n          isDragging && 'border-primary bg-primary/10'\n        )}\n        onClick={() => inputRef.current?.click()}\n        onDragLeave={onDragLeave}\n        onDragOver={onDragOver}\n        onDrop={onDrop}\n        onKeyDown={onKeyDown}\n        role=\"button\"\n        tabIndex={disabled ? -1 : 0}>\n        <input\n          accept={accept}\n          className=\"sr-only\"\n          disabled={disabled}\n          id={inputId}\n          multiple={multiple}\n          onChange={onInputChange}\n          ref={inputRef}\n          type=\"file\"\n        />\n        <UploadCloud aria-hidden=\"true\" className=\"mb-4 size-10 text-muted-foreground transition-colors group-hover:text-primary\" />\n        <div className=\"text-sm font-medium text-foreground\">\n          <span>{label} </span>\n          <label className=\"cursor-pointer text-primary underline-offset-4 hover:underline\" htmlFor={inputId}>\n            {browseLabel}\n          </label>\n        </div>\n        {helperText && (\n          <div className=\"mt-2 text-sm text-muted-foreground\">\n            {helperText}\n          </div>\n        )}\n      </div>\n\n      {showPreviews && !!items.length && (\n        <div className=\"grid gap-3 sm:grid-cols-2 lg:grid-cols-3\">\n          {items.map((item) => (\n            <div\n              className={cn(\n                'group/item relative overflow-hidden rounded-lg border border-border bg-card text-card-foreground',\n                previewClassName\n              )}\n              key={item.id}>\n              <div className=\"flex aspect-video items-center justify-center bg-muted\">\n                {item.previewUrl ? (\n                  <img\n                    alt={item.file.name}\n                    className=\"size-full object-cover\"\n                    src={item.previewUrl}\n                  />\n                ) : (\n                  <FileImage aria-hidden=\"true\" className=\"size-9 text-muted-foreground\" />\n                )}\n              </div>\n              <div className=\"flex items-center justify-between gap-3 px-3 py-2\">\n                <div className=\"min-w-0\">\n                  <p className=\"truncate text-sm font-medium\">{item.file.name}</p>\n                  <p className=\"text-xs text-muted-foreground\">{Math.ceil(item.file.size / 1024)} KB</p>\n                </div>\n                <button\n                  aria-label={`Remove ${item.file.name}`}\n                  className=\"inline-flex size-8 shrink-0 cursor-pointer items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none\"\n                  disabled={disabled}\n                  onClick={(event) => {\n                    event.stopPropagation();\n                    removeItem(item.id);\n                  }}\n                  type=\"button\">\n                  <X aria-hidden=\"true\" className=\"size-4\" />\n                </button>\n              </div>\n            </div>\n          ))}\n        </div>\n      )}\n    </div>\n  );\n};\n\nexport const DropUpload = memo(DropUploadComponent);\nDropUpload.displayName = 'DropUpload';\n"],"names":["cn","FileImage","UploadCloud","X","memo","useCallback","useEffect","useId","useMemo","useRef","useState","imageMimeTypes","Set","createId","file","index","name","size","lastModified","join","parseAccept","accept","split","map","value","trim","toLowerCase","filter","Boolean","acceptsFile","acceptRules","length","fileType","type","fileName","some","rule","endsWith","startsWith","slice","createImagePreview","has","undefined","URL","createObjectURL","resizeImage","imageOutputMimeType","imageOutputQuality","imageResizeTargetHeight","imageResizeTargetWidth","imageResizeUpscale","sourceUrl","image","Image","src","decode","widthRatio","width","Number","POSITIVE_INFINITY","heightRatio","height","scale","Math","min","revokeObjectURL","canvas","document","createElement","max","round","context","getContext","drawImage","blob","Promise","resolve","toBlob","File","filesToItems","files","id","previewUrl","DropUploadComponent","browseLabel","className","defaultFiles","disabled","helperText","label","maxFileSize","maxFiles","multiple","onFilesChange","onReject","previewClassName","ref","showPreviews","transformImages","props","inputId","inputRef","itemsRef","isDragging","setIsDragging","internalItems","setInternalItems","isControlled","Array","isArray","items","nextPreviewUrls","item","current","forEach","updateItems","nextItems","addFiles","incomingFiles","currentItems","acceptedFiles","rejections","remainingSlots","push","reason","transformedFiles","all","onInputChange","event","from","target","onDragOver","preventDefault","onDragLeave","currentTarget","onDrop","dataTransfer","onKeyDown","key","click","removeItem","div","aria-disabled","onClick","role","tabIndex","input","onChange","aria-hidden","span","htmlFor","img","alt","p","ceil","button","aria-label","stopPropagation","DropUpload","displayName"],"mappings":"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"}

package/lib/components/DropUpload/DropUpload.stories.js

@@ -0,0 +1,48 @@
+import React from 'react';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { DropUpload } from './DropUpload.js';
+const meta = {
+    argTypes: {
+        accept: {
+            control: 'text'
+        },
+        disabled: {
+            control: 'boolean'
+        },
+        helperText: {
+            control: 'text'
+        },
+        label: {
+            control: 'text'
+        },
+        maxFiles: {
+            control: 'number'
+        },
+        multiple: {
+            control: 'boolean'
+        },
+        showPreviews: {
+            control: 'boolean'
+        }
+    },
+    component: DropUpload,
+    parameters: {
+        layout: 'centered'
+    },
+    title: 'Components/Form/DropUpload'
+};
+export default meta;
+export const Default = {
+    args: {
+        accept: 'image/*,.pdf',
+        helperText: 'PNG, JPG, or PDF up to 5 MB',
+        label: 'Drop assets here or',
+        maxFiles: 3,
+        multiple: true,
+        showPreviews: false,
+        transformImages: false
+    },
+    play: interactWithCanvas
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/Empty/Empty.d.ts

@@ -0,0 +1,11 @@
+import type { HTMLAttributes } from 'react';
+export type EmptyMediaVariant = 'default' | 'icon';
+export declare const Empty: ({ className, ...props }: HTMLAttributes<HTMLDivElement>) => import("react").JSX.Element;
+export declare const EmptyHeader: ({ className, ...props }: HTMLAttributes<HTMLDivElement>) => import("react").JSX.Element;
+export interface EmptyMediaProps extends HTMLAttributes<HTMLDivElement> {
+    readonly variant?: EmptyMediaVariant;
+}
+export declare const EmptyMedia: ({ className, variant, ...props }: EmptyMediaProps) => import("react").JSX.Element;
+export declare const EmptyTitle: ({ className, ...props }: HTMLAttributes<HTMLDivElement>) => import("react").JSX.Element;
+export declare const EmptyDescription: ({ className, ...props }: HTMLAttributes<HTMLParagraphElement>) => import("react").JSX.Element;
+export declare const EmptyContent: ({ className, ...props }: HTMLAttributes<HTMLDivElement>) => import("react").JSX.Element;

package/lib/components/Empty/Empty.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '@nlabs/utils';
+const mediaClasses = {
+    default: 'bg-transparent',
+    icon: 'flex size-10 shrink-0 items-center justify-center rounded-lg bg-muted text-foreground [&_svg:not([class*=size-])]:size-6'
+};
+export const Empty = ({ className, ...props })=>/*#__PURE__*/ _jsx("div", {
+        className: cn('flex min-w-0 flex-1 flex-col items-center justify-center gap-6 rounded-lg border border-dashed border-border p-6 text-center text-balance md:p-12', className),
+        "data-slot": "empty",
+        ...props
+    });
+export const EmptyHeader = ({ className, ...props })=>/*#__PURE__*/ _jsx("div", {
+        className: cn('flex max-w-sm flex-col items-center gap-2 text-center', className),
+        "data-slot": "empty-header",
+        ...props
+    });
+export const EmptyMedia = ({ className, variant = 'default', ...props })=>/*#__PURE__*/ _jsx("div", {
+        className: cn('mb-2 flex shrink-0 items-center justify-center [&_svg]:pointer-events-none [&_svg]:shrink-0', mediaClasses[variant], className),
+        "data-slot": "empty-media",
+        "data-variant": variant,
+        ...props
+    });
+export const EmptyTitle = ({ className, ...props })=>/*#__PURE__*/ _jsx("div", {
+        className: cn('text-lg font-medium tracking-tight', className),
+        "data-slot": "empty-title",
+        ...props
+    });
+export const EmptyDescription = ({ className, ...props })=>/*#__PURE__*/ _jsx("p", {
+        className: cn('text-sm/relaxed text-muted-foreground [&>a]:underline [&>a]:underline-offset-4 [&>a:hover]:text-primary', className),
+        "data-slot": "empty-description",
+        ...props
+    });
+export const EmptyContent = ({ className, ...props })=>/*#__PURE__*/ _jsx("div", {
+        className: cn('flex w-full max-w-sm min-w-0 flex-col items-center gap-4 text-sm text-balance', className),
+        "data-slot": "empty-content",
+        ...props
+    });
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/Empty/Empty.stories.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Search } from 'lucide-react';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { Button } from '../Button/Button.js';
+import { Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle } from './Empty.js';
+const meta = {
+    argTypes: {
+        className: {
+            control: 'text'
+        }
+    },
+    component: Empty,
+    parameters: {
+        layout: 'centered'
+    },
+    title: 'Components/Empty'
+};
+export default meta;
+export const Default = {
+    args: {
+        className: 'w-[28rem]'
+    },
+    play: interactWithCanvas,
+    render: (args)=>/*#__PURE__*/ _jsxs(Empty, {
+            ...args,
+            children: [
+                /*#__PURE__*/ _jsxs(EmptyHeader, {
+                    children: [
+                        /*#__PURE__*/ _jsx(EmptyMedia, {
+                            variant: "icon",
+                            children: /*#__PURE__*/ _jsx(Search, {})
+                        }),
+                        /*#__PURE__*/ _jsx(EmptyTitle, {
+                            children: "No results"
+                        }),
+                        /*#__PURE__*/ _jsx(EmptyDescription, {
+                            children: "Try changing the filters or creating a new saved view."
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ _jsx(EmptyContent, {
+                    children: /*#__PURE__*/ _jsx(Button, {
+                        label: "Create view",
+                        size: "sm"
+                    })
+                })
+            ]
+        })
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy9jb21wb25lbnRzL0VtcHR5L0VtcHR5LnN0b3JpZXMudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCBmcm9tICdyZWFjdCc7XG5pbXBvcnQge1NlYXJjaH0gZnJvbSAnbHVjaWRlLXJlYWN0JztcbmltcG9ydCB7aW50ZXJhY3RXaXRoQ2FudmFzfSBmcm9tICcuLi8uLi91dGlscy9zdG9yeUludGVyYWN0aW9ucy5qcyc7XG5pbXBvcnQge0J1dHRvbn0gZnJvbSAnLi4vQnV0dG9uL0J1dHRvbi5qcyc7XG5pbXBvcnQge0VtcHR5LCBFbXB0eUNvbnRlbnQsIEVtcHR5RGVzY3JpcHRpb24sIEVtcHR5SGVhZGVyLCBFbXB0eU1lZGlhLCBFbXB0eVRpdGxlfSBmcm9tICcuL0VtcHR5LmpzJztcblxuaW1wb3J0IHR5cGUge01ldGEsIFN0b3J5T2JqfSBmcm9tICdAbmxhYnMvbGV4L3N0b3J5Ym9vayc7XG5cbmNvbnN0IG1ldGE6IE1ldGE8dHlwZW9mIEVtcHR5PiA9IHtcbiAgYXJnVHlwZXM6IHtcbiAgICBjbGFzc05hbWU6IHtcbiAgICAgIGNvbnRyb2w6ICd0ZXh0J1xuICAgIH1cbiAgfSxcbiAgY29tcG9uZW50OiBFbXB0eSxcbiAgcGFyYW1ldGVyczoge1xuICAgIGxheW91dDogJ2NlbnRlcmVkJ1xuICB9LFxuICB0aXRsZTogJ0NvbXBvbmVudHMvRW1wdHknXG59O1xuXG5leHBvcnQgZGVmYXVsdCBtZXRhO1xuXG50eXBlIFN0b3J5ID0gU3RvcnlPYmo8dHlwZW9mIEVtcHR5PjtcblxuZXhwb3J0IGNvbnN0IERlZmF1bHQ6IFN0b3J5ID0ge1xuICBhcmdzOiB7XG4gICAgY2xhc3NOYW1lOiAndy1bMjhyZW1dJ1xuICB9LFxuICBwbGF5OiBpbnRlcmFjdFdpdGhDYW52YXMsXG4gIHJlbmRlcjogKGFyZ3MpID0+IChcbiAgICA8RW1wdHkgey4uLmFyZ3N9PlxuICAgICAgPEVtcHR5SGVhZGVyPlxuICAgICAgICA8RW1wdHlNZWRpYSB2YXJpYW50PVwiaWNvblwiPlxuICAgICAgICAgIDxTZWFyY2ggLz5cbiAgICAgICAgPC9FbXB0eU1lZGlhPlxuICAgICAgICA8RW1wdHlUaXRsZT5ObyByZXN1bHRzPC9FbXB0eVRpdGxlPlxuICAgICAgICA8RW1wdHlEZXNjcmlwdGlvbj5UcnkgY2hhbmdpbmcgdGhlIGZpbHRlcnMgb3IgY3JlYXRpbmcgYSBuZXcgc2F2ZWQgdmlldy48L0VtcHR5RGVzY3JpcHRpb24+XG4gICAgICA8L0VtcHR5SGVhZGVyPlxuICAgICAgPEVtcHR5Q29udGVudD5cbiAgICAgICAgPEJ1dHRvbiBsYWJlbD1cIkNyZWF0ZSB2aWV3XCIgc2l6ZT1cInNtXCIgLz5cbiAgICAgIDwvRW1wdHlDb250ZW50PlxuICAgIDwvRW1wdHk+XG4gIClcbn07XG4iXSwibmFtZXMiOlsiUmVhY3QiLCJTZWFyY2giLCJpbnRlcmFjdFdpdGhDYW52YXMiLCJCdXR0b24iLCJFbXB0eSIsIkVtcHR5Q29udGVudCIsIkVtcHR5RGVzY3JpcHRpb24iLCJFbXB0eUhlYWRlciIsIkVtcHR5TWVkaWEiLCJFbXB0eVRpdGxlIiwibWV0YSIsImFyZ1R5cGVzIiwiY2xhc3NOYW1lIiwiY29udHJvbCIsImNvbXBvbmVudCIsInBhcmFtZXRlcnMiLCJsYXlvdXQiLCJ0aXRsZSIsIkRlZmF1bHQiLCJhcmdzIiwicGxheSIsInJlbmRlciIsInZhcmlhbnQiLCJsYWJlbCIsInNpemUiXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPQSxXQUFXLFFBQVE7QUFDMUIsU0FBUUMsTUFBTSxRQUFPLGVBQWU7QUFDcEMsU0FBUUMsa0JBQWtCLFFBQU8sbUNBQW1DO0FBQ3BFLFNBQVFDLE1BQU0sUUFBTyxzQkFBc0I7QUFDM0MsU0FBUUMsS0FBSyxFQUFFQyxZQUFZLEVBQUVDLGdCQUFnQixFQUFFQyxXQUFXLEVBQUVDLFVBQVUsRUFBRUMsVUFBVSxRQUFPLGFBQWE7QUFJdEcsTUFBTUMsT0FBMkI7SUFDL0JDLFVBQVU7UUFDUkMsV0FBVztZQUNUQyxTQUFTO1FBQ1g7SUFDRjtJQUNBQyxXQUFXVjtJQUNYVyxZQUFZO1FBQ1ZDLFFBQVE7SUFDVjtJQUNBQyxPQUFPO0FBQ1Q7QUFFQSxlQUFlUCxLQUFLO0FBSXBCLE9BQU8sTUFBTVEsVUFBaUI7SUFDNUJDLE1BQU07UUFDSlAsV0FBVztJQUNiO0lBQ0FRLE1BQU1sQjtJQUNObUIsUUFBUSxDQUFDRixxQkFDUCxNQUFDZjtZQUFPLEdBQUdlLElBQUk7OzhCQUNiLE1BQUNaOztzQ0FDQyxLQUFDQzs0QkFBV2MsU0FBUTtzQ0FDbEIsY0FBQSxLQUFDckI7O3NDQUVILEtBQUNRO3NDQUFXOztzQ0FDWixLQUFDSDtzQ0FBaUI7Ozs7OEJBRXBCLEtBQUNEOzhCQUNDLGNBQUEsS0FBQ0Y7d0JBQU9vQixPQUFNO3dCQUFjQyxNQUFLOzs7OztBQUl6QyxFQUFFIn0=

package/lib/components/EmptyState/EmptyState.d.ts

@@ -0,0 +1,15 @@
+import type { ButtonProps } from '../Button/Button.js';
+import type { ReactNode } from 'react';
+export interface EmptyStateProps {
+    readonly action?: ReactNode;
+    readonly actionClassName?: string;
+    readonly actionIcon?: ReactNode;
+    readonly actionLabel?: string;
+    readonly actionProps?: Omit<ButtonProps, 'children' | 'icon' | 'label' | 'onClick' | 'variant'>;
+    readonly className?: string;
+    readonly description: string;
+    readonly icon?: ReactNode;
+    readonly onAction?: () => void;
+    readonly title: string;
+}
+export declare const EmptyState: ({ action, actionClassName, actionIcon, actionLabel, actionProps, className, description, icon, onAction, title }: EmptyStateProps) => import("react").JSX.Element;

package/lib/components/EmptyState/EmptyState.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '@nlabs/utils';
+import { Button } from '../Button/Button.js';
+const defaultIcon = /*#__PURE__*/ _jsx("svg", {
+    "aria-hidden": "true",
+    className: "mx-auto size-12 text-gray-400 dark:text-gray-500",
+    fill: "none",
+    stroke: "currentColor",
+    viewBox: "0 0 24 24",
+    children: /*#__PURE__*/ _jsx("path", {
+        d: "M9 13h6m-3-3v6m-9 1V7a2 2 0 012-2h6l2 2h6a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2z",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: 2,
+        vectorEffect: "non-scaling-stroke"
+    })
+});
+export const EmptyState = ({ action, actionClassName, actionIcon, actionLabel, actionProps, className, description, icon = defaultIcon, onAction, title })=>/*#__PURE__*/ _jsxs("div", {
+        className: cn('flex flex-col items-center text-center', className),
+        children: [
+            icon,
+            /*#__PURE__*/ _jsx("h3", {
+                className: "mt-2 text-sm font-semibold text-gray-900 dark:text-white",
+                children: title
+            }),
+            /*#__PURE__*/ _jsx("p", {
+                className: "mt-1 text-sm text-gray-500 dark:text-gray-400",
+                children: description
+            }),
+            (action || actionLabel) && /*#__PURE__*/ _jsx("div", {
+                className: "mt-6 flex justify-center",
+                children: action || /*#__PURE__*/ _jsx(Button, {
+                    className: actionClassName,
+                    icon: actionIcon,
+                    label: actionLabel,
+                    onClick: onAction,
+                    variant: "contained",
+                    ...actionProps
+                })
+            })
+        ]
+    });
+
+//# sourceMappingURL=data:application/json;base64,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