@wirekyt/dom 0.0.1 → 0.0.2

package/dist/machines/file-upload/index.cjs

@@ -0,0 +1,648 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_create_anatomy = require("../../create-anatomy-BwDn25ph.cjs");
+const require_dom_query = require("../../dom-query-CQzY93XU.cjs");
+const require_event = require("../../event-DDz-mMhM.cjs");
+const require_raf = require("../../raf-BSDcY4UD.cjs");
+const require_visually_hidden = require("../../visually-hidden-BgSCFLz_.cjs");
+const require_array = require("../../array-BGtygd0o.cjs");
+const require_utils = require("../../utils-BH-oBBz2.cjs");
+const require_warning = require("../../warning-HAmFXLHm.cjs");
+const require_core = require("../../core-BNMw-JId.cjs");
+const require_file_utils = require("../../file-utils-B7OJigQq.cjs");
+const require_i18n_utils = require("../../i18n-utils-BD4VtonY.cjs");
+const require_create_props = require("../../create-props-CjLx2oS8.cjs");
+//#region src/machines/file-upload/anatomy.ts
+const anatomy = require_create_anatomy.createAnatomy("file-upload").parts("root", "dropzone", "item", "itemDeleteTrigger", "itemGroup", "itemName", "itemPreview", "itemPreviewImage", "itemSizeText", "label", "trigger", "clearTrigger");
+const parts = anatomy.build();
+//#endregion
+//#region src/machines/file-upload/dom.ts
+const getRootId = (ctx) => ctx.ids?.root ?? `file-upload:${ctx.id}`;
+const getDropzoneId = (ctx) => ctx.ids?.dropzone ?? `file-upload:${ctx.id}:dropzone`;
+const getHiddenInputId = (ctx) => ctx.ids?.hiddenInput ?? `file-upload:${ctx.id}:input`;
+const getTriggerId = (ctx) => ctx.ids?.trigger ?? `file-upload:${ctx.id}:trigger`;
+const getLabelId = (ctx) => ctx.ids?.label ?? `file-upload:${ctx.id}:label`;
+const getItemId = (ctx, id) => ctx.ids?.item?.(id) ?? `file-upload:${ctx.id}:item:${id}`;
+const getItemNameId = (ctx, id) => ctx.ids?.itemName?.(id) ?? `file-upload:${ctx.id}:item-name:${id}`;
+const getItemSizeTextId = (ctx, id) => ctx.ids?.itemSizeText?.(id) ?? `file-upload:${ctx.id}:item-size:${id}`;
+const getItemPreviewId = (ctx, id) => ctx.ids?.itemPreview?.(id) ?? `file-upload:${ctx.id}:item-preview:${id}`;
+const getItemDeleteTriggerId = (ctx, id) => ctx.ids?.itemDeleteTrigger?.(id) ?? `file-upload:${ctx.id}:item-delete:${id}`;
+const getFileId = (file) => require_utils.hash(`${file.name}-${file.size}`);
+const getRootEl = (ctx) => ctx.getById(getRootId(ctx));
+const getHiddenInputEl = (ctx) => ctx.getById(getHiddenInputId(ctx));
+const getDropzoneEl = (ctx) => ctx.getById(getDropzoneId(ctx));
+//#endregion
+//#region src/machines/file-upload/utils.ts
+function isEventWithFiles(event) {
+	const target = require_event.getEventTarget(event);
+	if (!event.dataTransfer) return !!target && "files" in target;
+	return event.dataTransfer.types.some((type) => {
+		return type === "Files" || type === "application/x-moz-file";
+	});
+}
+function isFilesWithinRange(ctx, incomingCount, currentAcceptedFiles) {
+	const { prop, computed } = ctx;
+	if (!computed("multiple") && incomingCount > 1) return false;
+	if (!computed("multiple") && incomingCount + currentAcceptedFiles.length === 2) return true;
+	if (incomingCount + currentAcceptedFiles.length > prop("maxFiles")) return false;
+	return true;
+}
+function getEventFiles(ctx, files, currentAcceptedFiles = [], currentRejectedFiles = []) {
+	const { prop, computed } = ctx;
+	const acceptedFiles = [];
+	const rejectedFiles = [];
+	const validateParams = {
+		acceptedFiles: currentAcceptedFiles,
+		rejectedFiles: currentRejectedFiles
+	};
+	files.forEach((file) => {
+		const [accepted, acceptError] = require_file_utils.isValidFileType(file, computed("acceptAttr"));
+		const [sizeMatch, sizeError] = require_file_utils.isValidFileSize(file, prop("minFileSize"), prop("maxFileSize"));
+		const isDuplicate = currentAcceptedFiles.some((f) => require_file_utils.isFileEqual(f, file)) || acceptedFiles.some((f) => require_file_utils.isFileEqual(f, file));
+		const validateErrors = prop("validate")?.(file, validateParams);
+		const valid = validateErrors ? validateErrors.length === 0 : true;
+		if (accepted && sizeMatch && valid && !isDuplicate) acceptedFiles.push(file);
+		else {
+			const errors = [acceptError, sizeError];
+			if (isDuplicate) errors.push("FILE_EXISTS");
+			if (!valid) errors.push(...validateErrors ?? []);
+			rejectedFiles.push({
+				file,
+				errors: errors.filter(Boolean)
+			});
+		}
+	});
+	if (!isFilesWithinRange(ctx, acceptedFiles.length, currentAcceptedFiles)) {
+		acceptedFiles.forEach((file) => {
+			rejectedFiles.push({
+				file,
+				errors: ["TOO_MANY_FILES"]
+			});
+		});
+		acceptedFiles.splice(0);
+	}
+	return {
+		acceptedFiles,
+		rejectedFiles
+	};
+}
+function setInputFiles(inputEl, files) {
+	const win = require_dom_query.getWindow(inputEl);
+	try {
+		if ("DataTransfer" in win) {
+			const dataTransfer = new win.DataTransfer();
+			files.forEach((file) => {
+				dataTransfer.items.add(file);
+			});
+			inputEl.files = dataTransfer.files;
+		}
+	} catch {}
+}
+//#endregion
+//#region src/machines/file-upload/connect.ts
+const DEFAULT_ITEM_TYPE = "accepted";
+const INTERACTIVE_SELECTOR = "button, a[href], input:not([type='file']), select, textarea, [tabindex], [contenteditable]";
+function isInteractiveTarget(element, container) {
+	if (!element || element.getAttribute("type") === "file") return false;
+	const interactive = element.closest(INTERACTIVE_SELECTOR);
+	return interactive != container && require_dom_query.contains(container, interactive);
+}
+function connect(service, normalize) {
+	const { state, send, prop, computed, scope, context } = service;
+	const disabled = !!prop("disabled");
+	const readOnly = !!prop("readOnly");
+	const required = !!prop("required");
+	const allowDrop = prop("allowDrop");
+	const translations = prop("translations");
+	const dragging = state.matches("dragging");
+	const focused = state.matches("focused") && !disabled;
+	const acceptedFiles = context.get("acceptedFiles");
+	const maxFiles = prop("maxFiles");
+	return {
+		dragging,
+		focused,
+		disabled,
+		readOnly,
+		transforming: context.get("transforming"),
+		maxFilesReached: acceptedFiles.length >= maxFiles,
+		remainingFiles: Math.max(0, maxFiles - acceptedFiles.length),
+		openFilePicker() {
+			if (disabled || readOnly) return;
+			send({ type: "OPEN" });
+		},
+		deleteFile(file, type = DEFAULT_ITEM_TYPE) {
+			if (disabled || readOnly) return;
+			send({
+				type: "FILE.DELETE",
+				file,
+				itemType: type
+			});
+		},
+		acceptedFiles,
+		rejectedFiles: context.get("rejectedFiles"),
+		setFiles(files) {
+			if (disabled || readOnly) return;
+			send({
+				type: "FILES.SET",
+				files,
+				count: files.length
+			});
+		},
+		clearRejectedFiles() {
+			if (disabled || readOnly) return;
+			send({ type: "REJECTED_FILES.CLEAR" });
+		},
+		clearFiles() {
+			if (disabled || readOnly) return;
+			send({ type: "FILES.CLEAR" });
+		},
+		getFileSize(file) {
+			return require_i18n_utils.formatBytes(file.size, prop("locale"));
+		},
+		createFileUrl(file, cb) {
+			const win = scope.getWin();
+			const url = win.URL.createObjectURL(file);
+			cb(url);
+			return () => win.URL.revokeObjectURL(url);
+		},
+		setClipboardFiles(dt) {
+			if (disabled || readOnly) return false;
+			const files = Array.from(dt?.items ?? []).reduce((acc, item) => {
+				if (item.kind !== "file") return acc;
+				const file = item.getAsFile();
+				if (!file) return acc;
+				return [...acc, file];
+			}, []);
+			if (!files.length) return false;
+			send({
+				type: "FILE.SELECT",
+				files
+			});
+			return true;
+		},
+		getRootProps() {
+			return normalize.element({
+				...parts.root.attrs,
+				dir: prop("dir"),
+				id: getRootId(scope),
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-readonly": require_dom_query.dataAttr(readOnly),
+				"data-dragging": require_dom_query.dataAttr(dragging)
+			});
+		},
+		getDropzoneProps(props = {}) {
+			return normalize.element({
+				...parts.dropzone.attrs,
+				dir: prop("dir"),
+				id: getDropzoneId(scope),
+				tabIndex: disabled || readOnly || props.disableClick ? void 0 : 0,
+				role: props.disableClick ? "application" : "button",
+				"aria-label": translations.dropzone,
+				"aria-disabled": disabled || readOnly || void 0,
+				"data-invalid": require_dom_query.dataAttr(prop("invalid")),
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-readonly": require_dom_query.dataAttr(readOnly),
+				"data-dragging": require_dom_query.dataAttr(dragging),
+				onKeyDown(event) {
+					if (disabled || readOnly) return;
+					if (event.defaultPrevented) return;
+					const target = require_event.getEventTarget(event);
+					if (!require_dom_query.contains(event.currentTarget, target)) return;
+					if (isInteractiveTarget(target, event.currentTarget)) return;
+					if (props.disableClick) return;
+					if (event.key !== "Enter" && event.key !== " ") return;
+					send({
+						type: "DROPZONE.CLICK",
+						src: "keydown"
+					});
+				},
+				onClick(event) {
+					if (disabled || readOnly) return;
+					if (event.defaultPrevented) return;
+					if (props.disableClick) return;
+					const target = require_event.getEventTarget(event);
+					if (!require_dom_query.contains(event.currentTarget, target)) return;
+					if (isInteractiveTarget(target, event.currentTarget)) return;
+					if (event.currentTarget.localName === "label") event.preventDefault();
+					send({ type: "DROPZONE.CLICK" });
+				},
+				onDragOver(event) {
+					if (disabled || readOnly) return;
+					if (!allowDrop) return;
+					event.preventDefault();
+					event.stopPropagation();
+					try {
+						event.dataTransfer.dropEffect = "copy";
+					} catch {}
+					if (!isEventWithFiles(event)) return;
+					const count = event.dataTransfer.items.length;
+					send({
+						type: "DROPZONE.DRAG_OVER",
+						count
+					});
+				},
+				onDragLeave(event) {
+					if (disabled || readOnly) return;
+					if (!allowDrop) return;
+					if (require_dom_query.contains(event.currentTarget, event.relatedTarget)) return;
+					send({ type: "DROPZONE.DRAG_LEAVE" });
+				},
+				onDrop(event) {
+					if (disabled || readOnly) return;
+					if (allowDrop) {
+						event.preventDefault();
+						event.stopPropagation();
+					}
+					if (!isEventWithFiles(event)) return;
+					require_file_utils.getFileEntries(event.dataTransfer.items, prop("directory")).then((files) => {
+						send({
+							type: "DROPZONE.DROP",
+							files: require_array.flatArray(files)
+						});
+					});
+				},
+				onFocus() {
+					if (disabled || readOnly) return;
+					send({ type: "DROPZONE.FOCUS" });
+				},
+				onBlur() {
+					if (disabled || readOnly) return;
+					send({ type: "DROPZONE.BLUR" });
+				}
+			});
+		},
+		getTriggerProps() {
+			return normalize.button({
+				...parts.trigger.attrs,
+				dir: prop("dir"),
+				id: getTriggerId(scope),
+				disabled: disabled || readOnly,
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-readonly": require_dom_query.dataAttr(readOnly),
+				"data-invalid": require_dom_query.dataAttr(prop("invalid")),
+				type: "button",
+				onClick(event) {
+					if (disabled || readOnly) return;
+					if (require_dom_query.contains(getDropzoneEl(scope), event.currentTarget)) event.stopPropagation();
+					send({ type: "OPEN" });
+				}
+			});
+		},
+		getHiddenInputProps() {
+			return normalize.input({
+				id: getHiddenInputId(scope),
+				tabIndex: -1,
+				disabled: disabled || readOnly,
+				type: "file",
+				required: prop("required"),
+				capture: prop("capture"),
+				name: prop("name"),
+				accept: computed("acceptAttr"),
+				webkitdirectory: prop("directory") ? "" : void 0,
+				multiple: computed("multiple") || prop("maxFiles") > 1,
+				"aria-hidden": true,
+				onClick(event) {
+					event.stopPropagation();
+					event.currentTarget.value = "";
+				},
+				onInput(event) {
+					if (disabled || readOnly) return;
+					const { files } = event.currentTarget;
+					send({
+						type: "FILE.SELECT",
+						files: files ? Array.from(files) : []
+					});
+				},
+				style: require_visually_hidden.visuallyHiddenStyle
+			});
+		},
+		getItemGroupProps(props = {}) {
+			const { type = DEFAULT_ITEM_TYPE } = props;
+			return normalize.element({
+				...parts.itemGroup.attrs,
+				dir: prop("dir"),
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-type": type
+			});
+		},
+		getItemProps(props) {
+			const { file, type = DEFAULT_ITEM_TYPE } = props;
+			return normalize.element({
+				...parts.item.attrs,
+				dir: prop("dir"),
+				id: getItemId(scope, getFileId(file)),
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-type": type
+			});
+		},
+		getItemNameProps(props) {
+			const { file, type = DEFAULT_ITEM_TYPE } = props;
+			return normalize.element({
+				...parts.itemName.attrs,
+				dir: prop("dir"),
+				id: getItemNameId(scope, getFileId(file)),
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-type": type
+			});
+		},
+		getItemSizeTextProps(props) {
+			const { file, type = DEFAULT_ITEM_TYPE } = props;
+			return normalize.element({
+				...parts.itemSizeText.attrs,
+				dir: prop("dir"),
+				id: getItemSizeTextId(scope, getFileId(file)),
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-type": type
+			});
+		},
+		getItemPreviewProps(props) {
+			const { file, type = DEFAULT_ITEM_TYPE } = props;
+			return normalize.element({
+				...parts.itemPreview.attrs,
+				dir: prop("dir"),
+				id: getItemPreviewId(scope, getFileId(file)),
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-type": type
+			});
+		},
+		getItemPreviewImageProps(props) {
+			const { file, url, type = DEFAULT_ITEM_TYPE } = props;
+			if (!file.type.startsWith("image/")) throw new Error("Preview Image is only supported for image files");
+			return normalize.img({
+				...parts.itemPreviewImage.attrs,
+				alt: translations.itemPreview?.(file),
+				src: url,
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-type": type
+			});
+		},
+		getItemDeleteTriggerProps(props) {
+			const { file, type = DEFAULT_ITEM_TYPE } = props;
+			return normalize.button({
+				...parts.itemDeleteTrigger.attrs,
+				dir: prop("dir"),
+				id: getItemDeleteTriggerId(scope, getFileId(file)),
+				type: "button",
+				disabled: disabled || readOnly,
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-readonly": require_dom_query.dataAttr(readOnly),
+				"data-type": type,
+				"aria-label": translations.deleteFile?.(file),
+				onClick() {
+					if (disabled || readOnly) return;
+					send({
+						type: "FILE.DELETE",
+						file,
+						itemType: type
+					});
+				}
+			});
+		},
+		getLabelProps() {
+			return normalize.label({
+				...parts.label.attrs,
+				dir: prop("dir"),
+				id: getLabelId(scope),
+				htmlFor: getHiddenInputId(scope),
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-required": require_dom_query.dataAttr(required)
+			});
+		},
+		getClearTriggerProps() {
+			return normalize.button({
+				...parts.clearTrigger.attrs,
+				dir: prop("dir"),
+				type: "button",
+				disabled: disabled || readOnly,
+				hidden: acceptedFiles.length === 0,
+				"data-disabled": require_dom_query.dataAttr(disabled),
+				"data-readonly": require_dom_query.dataAttr(readOnly),
+				onClick(event) {
+					if (event.defaultPrevented) return;
+					if (disabled || readOnly) return;
+					send({ type: "FILES.CLEAR" });
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region src/machines/file-upload/machine.ts
+const machine = require_core.createMachine({
+	props({ props }) {
+		return {
+			minFileSize: 0,
+			maxFileSize: Number.POSITIVE_INFINITY,
+			maxFiles: 1,
+			allowDrop: true,
+			preventDocumentDrop: true,
+			defaultAcceptedFiles: [],
+			...props,
+			translations: {
+				dropzone: "dropzone",
+				itemPreview: (file) => `preview of ${file.name}`,
+				deleteFile: (file) => `delete file ${file.name}`,
+				...props.translations
+			}
+		};
+	},
+	initialState() {
+		return "idle";
+	},
+	context({ prop, bindable, getContext }) {
+		return {
+			acceptedFiles: bindable(() => ({
+				defaultValue: prop("defaultAcceptedFiles"),
+				value: prop("acceptedFiles"),
+				isEqual: (a, b) => a.length === b?.length && a.every((file, i) => require_file_utils.isFileEqual(file, b[i])),
+				hash(value) {
+					return value.map((file) => `${file.name}-${file.size}`).join(",");
+				},
+				onChange(value) {
+					const ctx = getContext();
+					prop("onFileAccept")?.({ files: value });
+					prop("onFileChange")?.({
+						acceptedFiles: value,
+						rejectedFiles: ctx.get("rejectedFiles")
+					});
+				}
+			})),
+			rejectedFiles: bindable(() => ({
+				defaultValue: [],
+				isEqual: (a, b) => a.length === b?.length && a.every((file, i) => require_file_utils.isFileEqual(file.file, b[i].file)),
+				onChange(value) {
+					const ctx = getContext();
+					prop("onFileReject")?.({ files: value });
+					prop("onFileChange")?.({
+						acceptedFiles: ctx.get("acceptedFiles"),
+						rejectedFiles: value
+					});
+				}
+			})),
+			transforming: bindable(() => ({ defaultValue: false }))
+		};
+	},
+	computed: {
+		acceptAttr: ({ prop }) => require_file_utils.getAcceptAttrString(prop("accept")),
+		multiple: ({ prop }) => prop("maxFiles") > 1
+	},
+	watch({ track, context, action }) {
+		track([() => context.hash("acceptedFiles")], () => {
+			action(["syncInputElement"]);
+		});
+	},
+	on: {
+		"FILES.SET": { actions: ["setFiles"] },
+		"FILE.SELECT": { actions: ["setEventFiles"] },
+		"FILE.DELETE": { actions: ["removeFile"] },
+		"FILES.CLEAR": { actions: ["clearFiles"] },
+		"REJECTED_FILES.CLEAR": { actions: ["clearRejectedFiles"] }
+	},
+	effects: ["preventDocumentDrop"],
+	states: {
+		idle: { on: {
+			OPEN: { actions: ["openFilePicker"] },
+			"DROPZONE.CLICK": { actions: ["openFilePicker"] },
+			"DROPZONE.FOCUS": { target: "focused" },
+			"DROPZONE.DRAG_OVER": { target: "dragging" }
+		} },
+		focused: { on: {
+			"DROPZONE.BLUR": { target: "idle" },
+			OPEN: { actions: ["openFilePicker"] },
+			"DROPZONE.CLICK": { actions: ["openFilePicker"] },
+			"DROPZONE.DRAG_OVER": { target: "dragging" }
+		} },
+		dragging: { on: {
+			"DROPZONE.DROP": {
+				target: "idle",
+				actions: ["setEventFiles"]
+			},
+			"DROPZONE.DRAG_LEAVE": { target: "idle" }
+		} }
+	},
+	implementations: {
+		effects: { preventDocumentDrop({ prop, scope }) {
+			if (!prop("preventDocumentDrop")) return;
+			if (!prop("allowDrop")) return;
+			if (prop("disabled")) return;
+			const doc = scope.getDoc();
+			const onDragOver = (event) => {
+				event?.preventDefault();
+			};
+			const onDrop = (event) => {
+				if (require_dom_query.contains(getRootEl(scope), require_event.getEventTarget(event))) return;
+				event.preventDefault();
+			};
+			return require_utils.callAll(require_event.addDomEvent(doc, "dragover", onDragOver, false), require_event.addDomEvent(doc, "drop", onDrop, false));
+		} },
+		actions: {
+			syncInputElement({ scope, context }) {
+				queueMicrotask(() => {
+					const inputEl = getHiddenInputEl(scope);
+					if (!inputEl) return;
+					setInputFiles(inputEl, context.get("acceptedFiles"));
+					const win = scope.getWin();
+					inputEl.dispatchEvent(new win.Event("change", { bubbles: true }));
+				});
+			},
+			openFilePicker({ scope }) {
+				require_raf.raf(() => {
+					getHiddenInputEl(scope)?.click();
+				});
+			},
+			setFiles(params) {
+				const { computed, context, event } = params;
+				const { acceptedFiles, rejectedFiles } = getEventFiles(params, event.files);
+				context.set("acceptedFiles", computed("multiple") ? acceptedFiles : acceptedFiles.length > 0 ? [acceptedFiles[0]] : []);
+				context.set("rejectedFiles", rejectedFiles);
+			},
+			setEventFiles(params) {
+				const { computed, context, event, prop } = params;
+				const currentAcceptedFiles = context.get("acceptedFiles");
+				const currentRejectedFiles = context.get("rejectedFiles");
+				const { acceptedFiles, rejectedFiles } = getEventFiles(params, event.files, currentAcceptedFiles, currentRejectedFiles);
+				const set = (files) => {
+					if (computed("multiple")) {
+						context.set("acceptedFiles", (prev) => [...prev, ...files]);
+						context.set("rejectedFiles", rejectedFiles);
+						return;
+					}
+					if (files.length) {
+						context.set("acceptedFiles", [files[0]]);
+						context.set("rejectedFiles", rejectedFiles);
+						return;
+					}
+					if (rejectedFiles.length) {
+						context.set("acceptedFiles", context.get("acceptedFiles"));
+						context.set("rejectedFiles", rejectedFiles);
+					}
+				};
+				const transform = prop("transformFiles");
+				if (transform) {
+					context.set("transforming", true);
+					transform(acceptedFiles).then(set).catch((err) => {
+						require_warning.warn(`[wirekyt/file-upload] error transforming files\n${err}`);
+					}).finally(() => {
+						context.set("transforming", false);
+					});
+				} else set(acceptedFiles);
+			},
+			removeFile({ context, event }) {
+				if (event.itemType === "rejected") {
+					const rejectedFiles = context.get("rejectedFiles").filter((item) => !require_file_utils.isFileEqual(item.file, event.file));
+					context.set("rejectedFiles", rejectedFiles);
+				} else {
+					const files = context.get("acceptedFiles").filter((file) => !require_file_utils.isFileEqual(file, event.file));
+					context.set("acceptedFiles", files);
+				}
+			},
+			clearRejectedFiles({ context }) {
+				context.set("rejectedFiles", []);
+			},
+			clearFiles({ context }) {
+				context.set("acceptedFiles", []);
+				context.set("rejectedFiles", []);
+			}
+		}
+	}
+});
+//#endregion
+//#region src/machines/file-upload/props.ts
+const props = require_create_props.createProps()([
+	"accept",
+	"acceptedFiles",
+	"allowDrop",
+	"capture",
+	"defaultAcceptedFiles",
+	"dir",
+	"directory",
+	"disabled",
+	"getRootNode",
+	"id",
+	"ids",
+	"invalid",
+	"locale",
+	"maxFiles",
+	"maxFileSize",
+	"minFileSize",
+	"name",
+	"onFileAccept",
+	"onFileChange",
+	"onFileReject",
+	"preventDocumentDrop",
+	"readOnly",
+	"required",
+	"transformFiles",
+	"translations",
+	"validate"
+]);
+const splitProps = require_utils.createSplitProps(props);
+const itemProps = require_create_props.createProps()(["file", "type"]);
+const splitItemProps = require_utils.createSplitProps(itemProps);
+//#endregion
+exports.anatomy = anatomy;
+exports.connect = connect;
+exports.itemProps = itemProps;
+exports.machine = machine;
+exports.props = props;
+exports.splitItemProps = splitItemProps;
+exports.splitProps = splitProps;