@ioca/react 1.4.76 → 1.4.77

package/lib/types/components/tree/item.js

@@ -0,0 +1,132 @@
+import icon_default from "../icon/index.js";
+import checkbox_default from "../checkbox/index.js";
+import classNames from "classnames";
+import { useState } from "react";
+import { KeyboardArrowDownRound } from "/Users/iann/codes/ioca-react/node_modules/.pnpm/@ricons+material@0.12.0/node_modules/@ricons/material/es/index.js";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+//#region packages/components/tree/item.tsx
+function TreeList(props) {
+	const { data = [], depth = 0, round, style, className, parent, nodeProps, ...restProps } = props;
+	const contents = data.map((item, i) => {
+		const { type } = item;
+		const title = item[nodeProps.title];
+		const itemKey = item[nodeProps.key] || (parent?.key !== void 0 ? `${parent.key}-${i}` : `${i}`);
+		item.key = itemKey;
+		item.parent = parent;
+		if (type === "title") return /* @__PURE__ */ jsx("div", {
+			className: "i-tree-group-title",
+			children: title
+		}, i);
+		if (type && type !== "item") return /* @__PURE__ */ jsx("div", {
+			className: `i-tree-type-${type}`,
+			children: title
+		}, i);
+		return /* @__PURE__ */ jsx(TreeItem, {
+			index: i,
+			item,
+			depth,
+			nodeProps,
+			...restProps
+		}, itemKey);
+	});
+	if (depth > 0) return /* @__PURE__ */ jsx(Fragment$1, { children: contents });
+	return /* @__PURE__ */ jsx("div", {
+		className: classNames("i-tree", className, { "i-tree-round": round }),
+		style,
+		children: contents
+	});
+}
+const Header = (props) => {
+	const { as: Tag = "a", href, selected, children, ...restProps } = props;
+	const className = classNames("i-tree-item-header", { "i-tree-item-selected": selected });
+	if (typeof Tag === "string") return /* @__PURE__ */ jsx(Tag, {
+		href,
+		className,
+		...restProps,
+		children
+	});
+	return /* @__PURE__ */ jsx(Tag, {
+		to: href || "",
+		className,
+		...restProps,
+		children
+	});
+};
+const TreeItem = (props) => {
+	const { item, depth = 0, index, selected, checked = [], partofs = {}, checkable, nodeProps, renderExtra, onItemClick, onItemSelect, onItemCheck, ...restProps } = props;
+	const { as, key = "", href, icon, title, expanded, disabled } = item;
+	const children = item[nodeProps.children];
+	const [expand, setExpand] = useState(expanded);
+	const handleExpand = (e, fromToggle) => {
+		if (fromToggle) {
+			e.preventDefault();
+			e.stopPropagation();
+		}
+		if (disabled || !children?.length) return;
+		setExpand((v) => !v);
+	};
+	const handleItemClick = (e) => {
+		if (disabled) {
+			e.preventDefault();
+			e.stopPropagation();
+			return;
+		}
+		handleExpand(e);
+		onItemClick?.(item, e);
+		onItemSelect?.(key, item);
+	};
+	const handleItemCheck = (checked) => onItemCheck?.(item, checked, []);
+	const itemChecked = checked.includes(key);
+	return /* @__PURE__ */ jsxs("div", {
+		className: classNames("i-tree-item", { "i-tree-expand": expand }),
+		children: [/* @__PURE__ */ jsxs(Header, {
+			as,
+			href,
+			style: { paddingLeft: `${depth * 1.5 + .5}em` },
+			selected: selected === key,
+			onClick: handleItemClick,
+			children: [
+				checkable && /* @__PURE__ */ jsx(checkbox_default.Item, {
+					value: itemChecked,
+					partof: !itemChecked && partofs[key],
+					className: "i-tree-checkbox",
+					onChange: handleItemCheck,
+					onClick: (e) => e.stopPropagation()
+				}),
+				icon && /* @__PURE__ */ jsx("span", {
+					className: "i-tree-item-icon",
+					children: icon
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "i-tree-item-title",
+					children: title
+				}),
+				renderExtra?.(item),
+				children && /* @__PURE__ */ jsx(icon_default, {
+					icon: /* @__PURE__ */ jsx(KeyboardArrowDownRound, {}),
+					className: "i-tree-toggle",
+					onClick: (e) => handleExpand(e, true)
+				})
+			]
+		}), children?.length && /* @__PURE__ */ jsx("div", {
+			className: "i-tree-item-content",
+			children: /* @__PURE__ */ jsx(TreeList, {
+				data: children,
+				depth: depth + 1,
+				selected,
+				checkable,
+				parent: item,
+				partofs,
+				checked,
+				nodeProps,
+				renderExtra,
+				onItemClick,
+				onItemSelect,
+				onItemCheck,
+				...restProps
+			})
+		})]
+	});
+};
+//#endregion
+export { TreeList };

package/lib/types/components/tree/tree.d.ts

@@ -1,6 +1,3 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ITree } from './type.js';
-
-declare const Tree: (props: ITree) => react_jsx_runtime.JSX.Element;
-
-export { Tree as default };
+import { ITree } from './type';
+declare const Tree: (props: ITree) => import("react/jsx-runtime").JSX.Element;
+export default Tree;

package/lib/types/components/tree/tree.js

@@ -0,0 +1,125 @@
+import { TreeList } from "./item.js";
+import { useEffect, useImperativeHandle, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import "./index.css";
+//#region packages/components/tree/tree.tsx
+const defaultNodeProps = {
+	key: "key",
+	title: "title",
+	children: "children"
+};
+const Tree = (props) => {
+	const { data = [], ref, selected, checked = [], disabledRelated, nodeProps, onItemSelect, onItemCheck, ...restProps } = props;
+	const [selectedKey, setSelectedKey] = useState(selected);
+	const [checkedKeys, setCheckedKeys] = useState(checked);
+	const [partofs, setPartofs] = useState({});
+	const nodeMapsRef = useRef(/* @__PURE__ */ new Map());
+	const oNodeProps = Object.assign({}, defaultNodeProps, nodeProps);
+	const isChecked = (key) => checkedKeys.includes(key || "");
+	const checkItem = (item, checked, direction) => {
+		const { key = "", parent, children } = item;
+		const shouldChanged = { [key]: checked };
+		const partofs = { [key]: false };
+		if (disabledRelated) return [shouldChanged];
+		if (checked) {
+			if (parent && direction !== "leaf") {
+				const hasUnchecked = parent.children?.some((o) => o.key !== key && !isChecked(o.key));
+				const [changes, parts] = checkItem(parent, true, "root");
+				if (!hasUnchecked) Object.assign(shouldChanged, changes);
+				Object.assign(partofs, hasUnchecked ? parts : {}, { [parent.key]: true });
+			}
+			if (children?.length && direction !== "root") children.map((o) => {
+				if (isChecked(o.key)) return;
+				const [changes] = checkItem(o, true, "leaf");
+				Object.assign(shouldChanged, changes);
+				partofs[o.key] = false;
+			});
+			return [shouldChanged, partofs];
+		}
+		if (parent && direction !== "leaf") {
+			const [changes, parts] = checkItem(parent, false, "root");
+			Object.assign(shouldChanged, changes);
+			const hasChecked = parent.children?.some((o) => isChecked(o.key) && o.key !== key);
+			Object.assign(partofs, hasChecked ? {} : parts, {
+				[parent.key]: hasChecked,
+				[key]: false
+			});
+		}
+		if (children?.length && direction !== "root") children.map((o) => {
+			const [changes] = checkItem(o, false, "leaf");
+			if (!isChecked(o.key)) return;
+			Object.assign(shouldChanged, changes);
+			partofs[o.key] = false;
+		});
+		return [shouldChanged, partofs];
+	};
+	const handleCheck = (item, checked) => {
+		const [shouldChanged, partofs] = checkItem(item, checked);
+		const changedKeys = Object.keys(shouldChanged);
+		const nextChecked = checked ? Array.from(new Set([...checkedKeys, ...changedKeys])) : checkedKeys.filter((k) => !changedKeys.includes(k));
+		setCheckedKeys(nextChecked);
+		setPartofs((p) => ({
+			...p,
+			...partofs
+		}));
+		onItemCheck?.(item, checked, nextChecked);
+	};
+	const handleSelect = (key, item) => {
+		if (!props.selectable) return;
+		setSelectedKey(key);
+		onItemSelect?.(key, item);
+	};
+	useEffect(() => {
+		if (selected === void 0) return;
+		setSelectedKey(selected);
+	}, [selected]);
+	useEffect(() => {
+		nodeMapsRef.current.clear();
+		const { key, children } = oNodeProps;
+		const recursive = (nodes) => {
+			nodes.map((o) => {
+				nodeMapsRef.current.set(o[key], o);
+				o[children]?.length > 0 && recursive(o[children]);
+			});
+		};
+		recursive(data);
+	}, [data]);
+	useImperativeHandle(ref, () => {
+		return {
+			getChecked: () => {
+				const items = [];
+				checkedKeys.map((k) => {
+					const item = nodeMapsRef.current.get(k);
+					items.push(item);
+				});
+				return [checkedKeys, items];
+			},
+			getSelected: () => {
+				return [selectedKey, nodeMapsRef.current.get(selectedKey)];
+			},
+			getPartofs: () => {
+				const items = [];
+				return [Object.keys(partofs).filter((k) => {
+					const indeterminate = partofs[k];
+					if (indeterminate) {
+						const item = nodeMapsRef.current.get(k);
+						items.push(item);
+					}
+					return indeterminate;
+				}), items];
+			}
+		};
+	});
+	return /* @__PURE__ */ jsx(TreeList, {
+		data,
+		selected: selectedKey,
+		checked: checkedKeys,
+		partofs,
+		nodeProps: oNodeProps,
+		onItemCheck: handleCheck,
+		onItemSelect: handleSelect,
+		...restProps
+	});
+};
+//#endregion
+export { Tree as default };

package/lib/types/components/tree/type.d.ts

@@ -1,7 +1,12 @@
-import { ForwardRefExoticComponent, RefAttributes, ReactNode, RefObject, CSSProperties, MouseEvent } from 'react';
+import { CSSProperties, ForwardRefExoticComponent, MouseEvent, ReactNode, RefAttributes, RefObject } from 'react';
 import { LinkProps } from 'react-router';
-
-interface ITreeItem {
+export interface ITreeHeader extends Pick<ITreeItem, "as" | "href"> {
+    selected?: boolean;
+    style?: CSSProperties;
+    children: ReactNode;
+    onClick?: (e: MouseEvent<HTMLElement>) => void;
+}
+export interface ITreeItem {
     as?: "a" | "button" | ForwardRefExoticComponent<LinkProps & RefAttributes<HTMLAnchorElement>>;
     key?: string;
     type?: "item" | "title" | string;
@@ -15,7 +20,16 @@ interface ITreeItem {
     parent?: ITreeItem;
     [key: string]: any;
 }
-interface ITree {
+export interface PropsTreeItem extends Omit<ITree, "data" | "nodeProps"> {
+    index?: number;
+    item: ITreeItem;
+    nodeProps: {
+        key: string;
+        title: string;
+        children: string;
+    };
+}
+export interface ITree {
     data: ITreeItem[];
     parent?: ITreeItem;
     ref?: RefObject<RefTree | null>;
@@ -39,10 +53,8 @@ interface ITree {
     onItemSelect?: (key: string, item: ITreeItem) => void;
     onItemCheck?: (item: ITreeItem, checked: boolean, checkedKeys: string[]) => void;
 }
-interface RefTree {
+export interface RefTree {
     getChecked: () => [string[], ITreeItem[]];
     getSelected: () => [string?, ITreeItem?];
     getPartofs: () => [string[], ITreeItem[]];
 }
-
-export type { ITree, ITreeItem, RefTree };

package/lib/types/components/upload/index.d.ts

@@ -1,5 +1,2 @@
-import Upload from './upload.js';
-
-
-
-export { Upload as default };
+import { default as Upload } from './upload';
+export default Upload;

package/lib/types/components/upload/index.js

@@ -0,0 +1,5 @@
+import Upload from "./upload.js";
+//#region packages/components/upload/index.tsx
+var upload_default = Upload;
+//#endregion
+export { upload_default as default };

package/lib/types/components/upload/renderFile.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+import { IUploadItem } from './type';
+export declare const ListContainer: (props: any) => import("react/jsx-runtime").JSX.Element;
+declare const FileListItem: (props: IUploadItem & {
+    ref?: RefObject<HTMLDivElement | null>;
+}) => string | number | bigint | boolean | Iterable<import('react').ReactNode> | Promise<string | number | bigint | boolean | import('react').ReactPortal | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<import('react').ReactNode>> | import("react/jsx-runtime").JSX.Element;
+export default FileListItem;

package/lib/types/components/upload/renderFile.js

@@ -0,0 +1,94 @@
+import icon_default from "../icon/index.js";
+import { formatBytes, getFileType } from "../../js/utils.js";
+import helpericon_default from "../utils/helpericon/index.js";
+import { TFileType } from "../../js/usePreview/type.js";
+import image_default from "../image/index.js";
+import { title } from "/Users/iann/codes/ioca-react/node_modules/.pnpm/radash@12.1.1/node_modules/radash/dist/esm/index.mjs";
+import { ListAltRound } from "/Users/iann/codes/ioca-react/node_modules/.pnpm/@ricons+material@0.12.0/node_modules/@ricons/material/es/index.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import SortableContainer from "react-easy-sort";
+//#region packages/components/upload/renderFile.tsx
+const ListContainer = (props) => {
+	const { sortable, onSortEnd, itemProps, ...restProps } = props;
+	const customProps = {
+		className: "i-upload-list",
+		onClick: (e) => {
+			e.stopPropagation();
+			e.preventDefault();
+		}
+	};
+	if (!sortable) return /* @__PURE__ */ jsx("div", {
+		...customProps,
+		...restProps
+	});
+	return /* @__PURE__ */ jsx(SortableContainer, {
+		draggedItemClassName: "i-upload-item-dragged",
+		onSortEnd,
+		...customProps,
+		...restProps
+	});
+};
+const FileListItem = (props) => {
+	const { ref, mode, index, file, renderItem, onRemove, onPreview } = props;
+	if (!file) return "";
+	const { id, name, size, url, src } = file;
+	const type = getFileType(name, file.type);
+	if (renderItem) return renderItem(file, index);
+	const CloseBtn = /* @__PURE__ */ jsx(helpericon_default, {
+		active: true,
+		className: "i-upload-delete",
+		onClick: (e) => {
+			e.stopPropagation();
+			e.preventDefault();
+			onRemove(index);
+		}
+	});
+	switch (mode) {
+		case "card":
+			let node = /* @__PURE__ */ jsx(Fragment, {});
+			switch (type) {
+				case TFileType.IMAGE:
+					node = /* @__PURE__ */ jsx(image_default, {
+						lazyload: true,
+						src: url || src,
+						fit: "cover",
+						onMouseDown: (e) => e.preventDefault()
+					});
+					break;
+				case TFileType.VIDEO:
+					node = /* @__PURE__ */ jsx("video", {
+						src: url || src,
+						preload: "none"
+					});
+					break;
+				default:
+					node = /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(icon_default, { icon: /* @__PURE__ */ jsx(ListAltRound, {}) }), /* @__PURE__ */ jsx("span", {
+						className: "i-upload-file-name",
+						children: title(name)
+					})] });
+					break;
+			}
+			return /* @__PURE__ */ jsxs("div", {
+				ref,
+				title: name,
+				className: "i-upload-item-card",
+				onClick: () => onPreview?.(index),
+				children: [node, CloseBtn]
+			});
+		default: return /* @__PURE__ */ jsxs("div", {
+			ref,
+			className: "i-upload-item",
+			onClick: () => onPreview?.(index),
+			children: [
+				/* @__PURE__ */ jsx("span", { children: name }),
+				/* @__PURE__ */ jsx("i", {
+					className: "i-upload-size",
+					children: formatBytes(size ?? 0)
+				}),
+				CloseBtn
+			]
+		}, id);
+	}
+};
+//#endregion
+export { ListContainer, FileListItem as default };

package/lib/types/components/upload/type.d.ts

@@ -1,8 +1,7 @@
-import { InputHTMLAttributes, RefObject, ReactNode, ChangeEvent } from 'react';
-import { BaseInput } from '../../type/index.js';
-import { IButton } from '../button/type.js';
-
-interface IUpload extends Omit<BaseInput, "ref">, Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "onChange"> {
+import { ChangeEvent, InputHTMLAttributes, ReactNode, RefObject } from 'react';
+import { BaseInput } from '../../type';
+import { IButton } from '../button/type';
+export interface IUpload extends Omit<BaseInput, "ref">, Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "onChange"> {
     ref?: RefObject<RefUpload | null>;
     files?: IFile[];
     initialFiles?: IFile[] | File[];
@@ -22,16 +21,21 @@ interface IUpload extends Omit<BaseInput, "ref">, Omit<InputHTMLAttributes<HTMLI
     onRemove?: (file: IFile) => void;
     onUpload?: (result: any) => void | Promise<any>;
 }
-interface IFile extends File {
+export interface IFile extends File {
     id: string;
     instance?: File;
     src?: string;
     url?: string;
     [key: string]: any;
 }
-interface RefUpload {
+export interface IUploadItem extends Pick<IUpload, "mode" | "renderItem"> {
+    file?: IFile;
+    index: number;
+    status?: string;
+    onRemove: (i: number) => void;
+    onPreview?: (i: number) => void;
+}
+export interface RefUpload {
     getFileList: () => IFile[];
     setFileList: (files?: IFile[] | File[]) => void;
 }
-
-export type { IFile, IUpload, RefUpload };

package/lib/types/components/upload/upload.d.ts

@@ -1,6 +1,3 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { IUpload } from './type.js';
-
-declare const Upload: (props: IUpload) => react_jsx_runtime.JSX.Element;
-
-export { Upload as default };
+import { IUpload } from './type';
+declare const Upload: (props: IUpload) => import("react/jsx-runtime").JSX.Element;
+export default Upload;

package/lib/types/components/upload/upload.js

@@ -0,0 +1,162 @@
+import button_default from "../button/index.js";
+import icon_default from "../icon/index.js";
+import { arrayMove } from "../../js/utils.js";
+import usePreview from "../../js/usePreview/index.js";
+import InputContainer from "../input/container.js";
+import FileListItem, { ListContainer } from "./renderFile.js";
+import classNames from "classnames";
+import { uid } from "/Users/iann/codes/ioca-react/node_modules/.pnpm/radash@12.1.1/node_modules/radash/dist/esm/index.mjs";
+import { useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { DriveFolderUploadOutlined, PlusSharp } from "/Users/iann/codes/ioca-react/node_modules/.pnpm/@ricons+material@0.12.0/node_modules/@ricons/material/es/index.js";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { SortableItem } from "react-easy-sort";
+import "./index.css";
+//#region packages/components/upload/upload.tsx
+const Upload = (props) => {
+	const { ref, label, labelInline, value, files = [], initialFiles, placeholder, status = "normal", message, className, style, children, defaultButtonProps, mode = "default", cardSize = "4em", disabled, sortable, limit = props.multiple ? Infinity : 1, multiple, renderItem, shouldUpload = () => true, uploader, onChange, onFilesChange, onUpload, ...restProps } = props;
+	const [fileList, setFileListState] = useState(files);
+	const [uploadMessage, setUploadMessage] = useState(message);
+	const inputRef = useRef(null);
+	const preview = usePreview();
+	const defBtnProps = Object.assign({ children: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(icon_default, { icon: /* @__PURE__ */ jsx(DriveFolderUploadOutlined, {}) }), " 上传"] }) }, defaultButtonProps);
+	const trigger = useMemo(() => {
+		if (children) return children;
+		switch (mode) {
+			case "card": return /* @__PURE__ */ jsx(button_default, {
+				className: "i-upload-card-btn color-5",
+				square: true,
+				flat: true,
+				outline: true,
+				disabled,
+				children: /* @__PURE__ */ jsx(icon_default, { icon: /* @__PURE__ */ jsx(PlusSharp, {}) })
+			});
+			default: return /* @__PURE__ */ jsx(button_default, {
+				...defBtnProps,
+				className: classNames("i-upload-btn", defBtnProps.className),
+				disabled
+			});
+		}
+	}, [mode, children]);
+	const handleChange = (e) => {
+		const files = Array.from(e.target.files || []);
+		const before = fileList;
+		const changed = [];
+		files.map((f) => {
+			const { id, name, size, type } = f;
+			const same = before.find((pf) => {
+				const { name: n, size: s, type: t } = pf;
+				return n === name && s === size && t === type;
+			});
+			const src = URL.createObjectURL(f);
+			Object.assign(f, {
+				id: id ?? uid(7),
+				src: src ?? f.name,
+				url: src ?? f.name
+			});
+			!same && changed.push(f);
+		});
+		const after = [...before, ...changed];
+		const last = after.at(-1);
+		const nextFiles = multiple ? after.slice(0, limit) : last ? [last] : [];
+		setFileListState(nextFiles);
+		setUploadMessage(message);
+		onFilesChange?.(nextFiles, changed, e);
+		onChange?.(nextFiles, e);
+		handleUpload(changed);
+		inputRef.current && (inputRef.current.value = "");
+	};
+	const handleRemove = (i) => {
+		const [ ...files] = fileList;
+		const changed = files.splice(i, 1);
+		URL.revokeObjectURL(changed[0]?.src || "");
+		setFileListState(files);
+		onFilesChange?.(files, changed);
+		onChange?.(files);
+		inputRef.current && (inputRef.current.value = "");
+	};
+	const handleUpload = async (files) => {
+		if (!uploader) return;
+		const shouldUploadFiles = files.filter(shouldUpload);
+		const result = Promise.all(shouldUploadFiles.map(uploader));
+		return onUpload?.(result);
+	};
+	const handlePreview = (i) => {
+		preview({
+			items: fileList,
+			initial: i
+		});
+	};
+	const setFileList = (files) => {
+		if (!files) return;
+		setFileListState(files.map((f) => {
+			const file = f;
+			return {
+				...file,
+				id: file.id ?? uid(7)
+			};
+		}));
+	};
+	const handleSortEnd = (before, after) => {
+		const [ ...files] = fileList;
+		const nextFiles = arrayMove(files, before, after);
+		setFileListState(nextFiles);
+		onChange?.(nextFiles);
+	};
+	useEffect(() => {
+		setUploadMessage(message);
+	}, [status, message]);
+	useEffect(() => {
+		setFileListState(value?.filter?.((file) => !!file.id) ?? []);
+	}, [value]);
+	useEffect(() => {
+		setFileList(initialFiles);
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getFileList: () => fileList,
+		setFileList
+	}), [fileList]);
+	return /* @__PURE__ */ jsx(InputContainer, {
+		as: "div",
+		label,
+		labelInline,
+		className: classNames("i-input-label-file", className),
+		style,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: classNames("i-upload-inner", { [`i-upload-${mode}`]: mode !== "default" }),
+			style: { ["--upload-card-size"]: cardSize },
+			children: [
+				/* @__PURE__ */ jsx(ListContainer, {
+					sortable,
+					onSortEnd: handleSortEnd,
+					children: fileList.map((file, i) => {
+						const node = /* @__PURE__ */ jsx(FileListItem, {
+							index: i,
+							file,
+							mode,
+							renderItem,
+							onRemove: handleRemove,
+							onPreview: handlePreview
+						}, i);
+						if (!sortable) return node;
+						return /* @__PURE__ */ jsx(SortableItem, { children: node }, i);
+					})
+				}),
+				uploadMessage && /* @__PURE__ */ jsx("span", {
+					className: "i-upload-message",
+					children: uploadMessage
+				}),
+				fileList.length < limit && /* @__PURE__ */ jsxs("label", { children: [/* @__PURE__ */ jsx("input", {
+					...restProps,
+					disabled,
+					ref: inputRef,
+					type: "file",
+					className: "i-input-file-hidden",
+					multiple,
+					onChange: handleChange
+				}), trigger] })
+			]
+		})
+	});
+};
+//#endregion
+export { Upload as default };

package/lib/types/components/utils/empty/index.d.ts

@@ -0,0 +1 @@
+export default function Empty(props: any): import("react/jsx-runtime").JSX.Element;

package/lib/types/components/utils/empty/index.js

@@ -0,0 +1,14 @@
+import classNames from "classnames";
+import { InboxTwotone } from "/Users/iann/codes/ioca-react/node_modules/.pnpm/@ricons+material@0.12.0/node_modules/@ricons/material/es/index.js";
+import { jsx } from "react/jsx-runtime";
+import "./index.css";
+//#region packages/components/utils/empty/index.tsx
+function Empty(props) {
+	const { className, ...restProps } = props;
+	return /* @__PURE__ */ jsx(InboxTwotone, {
+		className: classNames("i-empty", className),
+		...restProps
+	});
+}
+//#endregion
+export { Empty as default };

package/lib/types/components/utils/helpericon/helpericon.d.ts

@@ -0,0 +1,3 @@
+import { IHelperIcon } from './type';
+declare const Helpericon: (props: IHelperIcon) => import("react/jsx-runtime").JSX.Element;
+export default Helpericon;