@spinjs/components 0.0.0-stage → 0.1.0-preview.1

package/dist/file-upload/file-upload.machine.js

@@ -0,0 +1,59 @@
+import { filesOf, initial, matchesPattern, patterns, splitFiles } from "./file-upload.state.js";
+import { addFiles, clearValue, removeFile, setFiles, setValue } from "./file-upload.transitions.js";
+import { createMachine } from "@spinjs/runtime/fsm";
+// src/file-upload/file-upload.machine.ts
+/**
+* File-upload machine: the dropzone's modes and the accept/reject split.
+*/
+function fileUpload(args = {}, authored = () => false) {
+	return createMachine({
+		id: "file-upload",
+		initial: "idle",
+		context: initial(args, authored),
+		fields: {
+			value: { event: "VALUE.SET" },
+			multiple: {},
+			directory: {},
+			accept: {},
+			maxFiles: {},
+			maxSize: {},
+			minSize: {},
+			disabled: {}
+		},
+		on: {
+			"VALUE.SET": [{ assign: setValue }],
+			"VALUE.CLEAR": [{ assign: clearValue }],
+			"FILE.REMOVE": [{ assign: removeFile }]
+		},
+		states: {
+			idle: { on: {
+				"INPUT.CHANGE": [{ assign: setFiles }],
+				"DROP": [{
+					target: "idle",
+					assign: addFiles
+				}],
+				"DROPZONE.FOCUS": [{ target: "focused" }],
+				"DROPZONE.DRAG_OVER": [{ target: "dragging" }]
+			} },
+			focused: { on: {
+				"DROPZONE.BLUR": [{ target: "idle" }],
+				"INPUT.CHANGE": [{ assign: setFiles }],
+				"DROP": [{
+					target: "idle",
+					assign: addFiles
+				}],
+				"DROPZONE.DRAG_OVER": [{ target: "dragging" }]
+			} },
+			dragging: { on: {
+				"DROP": [{
+					target: "idle",
+					assign: addFiles
+				}],
+				"DROPZONE.DRAG_LEAVE": [{ target: "idle" }]
+			} }
+		}
+	});
+}
+export { fileUpload, filesOf, initial, matchesPattern, patterns, splitFiles };
+
+//# sourceMappingURL=file-upload.machine.js.map

package/dist/file-upload/file-upload.presentation.d.ts

@@ -0,0 +1,182 @@
+import { FileRecord, FileRejection, FileUploadArgs, FileUploadContext, FileUploadState } from "./file-upload.state.js";
+import { FileUploadEvents, FileUploadValueChange } from "./file-upload.events.js";
+import { ApiOf, SlotViewFor } from "@spinjs/runtime";
+export interface FileUploadCommands {
+  openFilePicker(): void;
+  removeFile(name: string): void;
+  clear(): void;
+}
+export interface FileRow {
+  readonly value: string;
+  readonly file: FileRecord;
+}
+type SlotLike<R> = SlotViewFor<R, FileUploadContext, FileUploadEvents, FileUploadState>;
+export declare const formatBytes: (bytes: number) => string;
+export declare const def: {
+  name: string;
+  machine: (props: FileUploadArgs, authored: (name: string) => boolean) => import("@spinjs/runtime").Machine<FileUploadContext, FileUploadEvents, FileUploadState>;
+  parts: {
+    root: {
+      attrs: (scope: import("@spinjs/runtime").PartView<unknown, FileUploadContext, Record<string, unknown>, import("@spinjs/runtime").EventUnion<FileUploadEvents>, FileUploadState>) => {
+        id: string;
+        "data-disabled": string | undefined;
+        dir: string;
+      };
+    };
+    label: {
+      attrs: (scope: import("@spinjs/runtime").PartView<unknown, FileUploadContext, Record<string, unknown>, import("@spinjs/runtime").EventUnion<FileUploadEvents>, FileUploadState>) => {
+        id: string;
+      };
+    };
+    dropzone: {
+      attrs: (scope: import("@spinjs/runtime").PartView<unknown, FileUploadContext, Record<string, unknown>, import("@spinjs/runtime").EventUnion<FileUploadEvents>, FileUploadState>) => {
+        "data-focus": string | undefined;
+        "data-dragging": string | undefined;
+        "data-disabled": string | undefined;
+        onClick: () => void;
+        onFocus: () => void;
+        onBlur: () => void;
+        onDragOver: (event: DragEvent) => void;
+        onDragLeave: () => void;
+        onDrop: (event: DragEvent) => void;
+        onPaste: (event: ClipboardEvent) => void;
+        id: string;
+        tabIndex: number | undefined;
+        role: string;
+      };
+    };
+    hiddenInput: {
+      id: string;
+      attrs: (scope: import("@spinjs/runtime").PartView<unknown, FileUploadContext, Record<string, unknown>, import("@spinjs/runtime").EventUnion<FileUploadEvents>, FileUploadState>) => {
+        id: string;
+        type: string;
+        multiple: boolean;
+        webkitdirectory: boolean | undefined;
+        accept: string | undefined;
+        disabled: boolean;
+        hidden: boolean;
+        onChange: (event: Event) => void;
+      };
+    };
+    itemGroup: {
+      id: string;
+      attrs: (scope: import("@spinjs/runtime").PartView<unknown, FileUploadContext, Record<string, unknown>, import("@spinjs/runtime").EventUnion<FileUploadEvents>, FileUploadState>) => {
+        id: string;
+        role: string;
+      };
+    };
+    clearTrigger: {
+      id: string;
+      attrs: (scope: import("@spinjs/runtime").PartView<unknown, FileUploadContext, Record<string, unknown>, import("@spinjs/runtime").EventUnion<FileUploadEvents>, FileUploadState>) => {
+        id: string;
+        "aria-label": string;
+        hidden: boolean;
+        onClick: () => void;
+      };
+    };
+  };
+  slots: {
+    item: {
+      indexes: (context: FileUploadContext) => {
+        value: string;
+        file: FileRecord;
+      }[];
+      attrs: (scope: SlotLike<FileRow>) => {
+        id: string;
+        role: string;
+      };
+    };
+    itemName: {
+      id: string;
+      indexes: (context: FileUploadContext) => {
+        value: string;
+        file: FileRecord;
+      }[];
+      attrs: (scope: SlotLike<FileRow>) => {
+        id: string;
+      };
+    };
+    itemDeleteTrigger: {
+      id: string;
+      indexes: (context: FileUploadContext) => {
+        value: string;
+        file: FileRecord;
+      }[];
+      attrs: (scope: SlotLike<FileRow>) => {
+        onClick: () => void;
+        id: string;
+        "aria-label": string;
+        "data-disabled": string | undefined;
+      };
+    };
+  };
+  commands: {
+    openFilePicker: {
+      view: ({ id, root }: {
+        readonly args: readonly unknown[];
+        readonly id: (part: string, slot?: unknown) => string;
+        readonly focus: (part: string, slot?: unknown) => void;
+        readonly measure: (part: string, slot?: unknown) => DOMRect | null;
+        readonly root: () => Element;
+      }) => void;
+    };
+    removeFile: {
+      event: ([name]: [name: string]) => {
+        type: "FILE.REMOVE";
+        name: string;
+      };
+    };
+    clear: {
+      event: () => {
+        type: "VALUE.CLEAR";
+      };
+    };
+  };
+  readers: {
+    acceptedFiles: {
+      read: (context: FileUploadContext) => FileRecord[];
+    };
+    rejectedFiles: {
+      read: (context: FileUploadContext) => FileRejection[];
+    };
+    focused: {
+      read: (_context: FileUploadContext, state: FileUploadState) => state is "focused";
+    };
+    dragging: {
+      read: (_context: FileUploadContext, state: FileUploadState) => state is "dragging";
+    };
+    disabled: {
+      read: (context: FileUploadContext) => boolean;
+    };
+  };
+  methods: {
+    getAcceptedRows: {
+      call: (context: FileUploadContext) => {
+        value: string;
+        file: FileRecord;
+      }[];
+    };
+    getItemSizeText: {
+      call: (_context: FileUploadContext, _state: FileUploadState, [row]: [row: FileRow]) => string;
+    };
+    getItemPathText: {
+      call: (_context: FileUploadContext, _state: FileUploadState, [row]: [row: FileRow]) => string;
+    };
+  };
+  events: {
+    "value-change": {
+      prop: string;
+      watch: (context: FileUploadContext) => string[];
+      detail: (_watched: readonly unknown[], _event: {
+        readonly type: string;
+      } | undefined, _props: Record<string, unknown> | undefined, context: FileUploadContext) => {
+        acceptedFiles: FileRecord[];
+        rejectedFiles: FileRejection[];
+      };
+    };
+  };
+};
+export type FileUploadApi = ApiOf<typeof def>;
+export declare const fileUpload: import("@spinjs/runtime").DefinedComponent<FileUploadApi, FileUploadArgs>;
+export type { FileRecord, FileRejection, FileUploadValueChange };
+//# sourceMappingURL=file-upload.presentation.d.ts.map

package/dist/file-upload/file-upload.presentation.js

@@ -0,0 +1,256 @@
+import { fileUpload as fileUpload$1 } from "./file-upload.machine.js";
+import { ariaDisabled, ariaLabelledBy, dataAttr, defineComponent, isRecord } from "@spinjs/runtime";
+// src/file-upload/file-upload.presentation.ts
+/** Opening the hidden input is a view reflex, not a machine move — the
+* press that opened it must not be re-read by the input's own click
+* handling, so the click waits a frame. The node is read through the
+* framework id path, never held. */
+const openPicker = (id, root) => {
+	if (typeof document === "undefined") return;
+	const node = root().querySelector(`[id="${id("hiddenInput")}"]`);
+	if (!(node instanceof HTMLInputElement)) return;
+	(typeof requestAnimationFrame === "function" ? requestAnimationFrame : (fn) => {
+		fn();
+		return 0;
+	})(() => node.click());
+};
+const isDirectoryFile = (file) => "webkitRelativePath" in file;
+/** A directory pick carries a folder-relative path; flat picks do not. */
+const relativePath = (file) => {
+	if (!isDirectoryFile(file)) return "";
+	const path = file.webkitRelativePath;
+	return typeof path === "string" ? path : "";
+};
+/** The `FileList` is read once at the event; it is live afterwards. */
+const toRecords = (list) => {
+	if (list === null) return [];
+	const files = [];
+	for (let at = 0; at < list.length; at++) {
+		const file = list[at];
+		if (file === void 0) continue;
+		files.push({
+			name: file.name,
+			size: file.size,
+			type: file.type,
+			path: relativePath(file)
+		});
+	}
+	return files;
+};
+const formatBytes = (bytes) => {
+	if (bytes < 1024) return `${bytes} B`;
+	const kb = bytes / 1024;
+	if (kb < 1024) return `${kb < 10 ? kb.toFixed(1).replace(/\.0$/, "") : Math.round(kb)} KB`;
+	const mb = kb / 1024;
+	return `${mb < 10 ? mb.toFixed(1).replace(/\.0$/, "") : Math.round(mb)} MB`;
+};
+/** Row delete handlers, cached per bridge: the scope reads live through
+* proxies, so a cached closure never goes stale. */
+const deleteHandlersByBridge = /* @__PURE__ */ new WeakMap();
+const deleteHandlerFor = (scope, row) => {
+	let byName = deleteHandlersByBridge.get(scope.id);
+	if (byName === void 0) {
+		byName = /* @__PURE__ */ new Map();
+		deleteHandlersByBridge.set(scope.id, byName);
+	}
+	const hit = byName.get(row.value);
+	if (hit !== void 0) return hit;
+	const made = { onClick: () => scope.send({
+		type: "FILE.REMOVE",
+		name: row.value
+	}) };
+	byName.set(row.value, made);
+	return made;
+};
+const def = {
+	name: "file-upload",
+	machine: (props, authored) => fileUpload$1(props, authored),
+	parts: {
+		root: { attrs: (scope) => ({
+			id: scope.id(""),
+			"data-disabled": dataAttr(scope.context.disabled === true),
+			dir: "ltr"
+		}) },
+		label: { attrs: (scope) => ({ id: scope.id("label") }) },
+		dropzone: { attrs: (scope) => {
+			const focused = scope.state === "focused";
+			const dragging = scope.state === "dragging";
+			const disabled = scope.context.disabled === true;
+			return {
+				id: scope.id("dropzone"),
+				tabIndex: disabled ? void 0 : 0,
+				role: "button",
+				...ariaLabelledBy(scope, { part: "label" }),
+				...ariaDisabled(disabled ? true : void 0),
+				"data-focus": dataAttr(focused),
+				"data-dragging": dataAttr(dragging),
+				"data-disabled": dataAttr(disabled),
+				onClick: () => {
+					if (disabled) return;
+					openPicker(scope.id, scope.root);
+				},
+				onFocus: () => scope.send({ type: "DROPZONE.FOCUS" }),
+				onBlur: () => scope.send({ type: "DROPZONE.BLUR" }),
+				onDragOver: (event) => {
+					event.preventDefault();
+					if (disabled) return;
+					if (!dragging) scope.send({ type: "DROPZONE.DRAG_OVER" });
+				},
+				onDragLeave: () => scope.send({ type: "DROPZONE.DRAG_LEAVE" }),
+				onDrop: (event) => {
+					event.preventDefault();
+					if (disabled) return;
+					scope.send({
+						type: "DROP",
+						files: toRecords(event.dataTransfer?.files ?? null)
+					});
+				},
+				onPaste: (event) => {
+					const files = event.clipboardData?.files ?? null;
+					if (files === null || files.length === 0) return;
+					event.preventDefault();
+					if (disabled) return;
+					scope.send({
+						type: "DROP",
+						files: toRecords(files)
+					});
+				}
+			};
+		} },
+		hiddenInput: {
+			id: "hidden-input",
+			attrs: (scope) => {
+				const ctx = scope.context;
+				return {
+					id: scope.id("hiddenInput"),
+					type: "file",
+					multiple: ctx.multiple,
+					webkitdirectory: ctx.directory ? true : void 0,
+					accept: ctx.accept.length > 0 ? ctx.accept : void 0,
+					disabled: scope.context.disabled,
+					hidden: true,
+					onChange: (event) => {
+						const node = event.target;
+						if (!(node instanceof HTMLInputElement)) return;
+						scope.send({
+							type: "INPUT.CHANGE",
+							files: toRecords(node.files)
+						});
+					}
+				};
+			}
+		},
+		itemGroup: {
+			id: "items",
+			attrs: (scope) => ({
+				id: scope.id("itemGroup"),
+				role: "list"
+			})
+		},
+		clearTrigger: {
+			id: "clear",
+			attrs: (scope) => ({
+				id: scope.id("clearTrigger"),
+				"aria-label": "Clear",
+				hidden: scope.context.acceptedFiles.length === 0,
+				onClick: () => scope.send({ type: "VALUE.CLEAR" })
+			})
+		}
+	},
+	slots: {
+		item: {
+			indexes: (context) => context.acceptedFiles.map((entry) => ({
+				value: entry.name,
+				file: entry
+			})),
+			attrs: (scope) => {
+				const row = scope.slot;
+				return {
+					id: scope.id("item", row.value),
+					role: "listitem"
+				};
+			}
+		},
+		itemName: {
+			id: "name",
+			indexes: (context) => context.acceptedFiles.map((entry) => ({
+				value: entry.name,
+				file: entry
+			})),
+			attrs: (scope) => {
+				const row = scope.slot;
+				return { id: scope.id("itemName", row.value) };
+			}
+		},
+		itemDeleteTrigger: {
+			id: "delete",
+			indexes: (context) => context.acceptedFiles.map((entry) => ({
+				value: entry.name,
+				file: entry
+			})),
+			attrs: (scope) => {
+				const row = scope.slot;
+				return {
+					id: scope.id("itemDeleteTrigger", row.value),
+					"aria-label": `Remove ${row.value}`,
+					"data-disabled": dataAttr(scope.context.disabled === true),
+					...deleteHandlerFor(scope, row)
+				};
+			}
+		}
+	},
+	commands: {
+		openFilePicker: { view: ({ id, root }) => {
+			openPicker(id, root);
+		} },
+		removeFile: { event: ([name]) => ({
+			type: "FILE.REMOVE",
+			name
+		}) },
+		clear: { event: () => ({ type: "VALUE.CLEAR" }) }
+	},
+	readers: {
+		acceptedFiles: { read: (context) => context.acceptedFiles },
+		rejectedFiles: { read: (context) => context.rejectedFiles },
+		focused: { read: (_context, state) => state === "focused" },
+		dragging: { read: (_context, state) => state === "dragging" },
+		disabled: { read: (context) => context.disabled }
+	},
+	methods: {
+		getAcceptedRows: { call: (context) => context.acceptedFiles.map((entry) => ({
+			value: entry.name,
+			file: entry
+		})) },
+		getItemSizeText: { call: (_context, _state, [row]) => {
+			if (!isRecord(row)) return formatBytes(0);
+			const file = row["file"];
+			if (!isRecord(file)) return formatBytes(0);
+			const size = file["size"];
+			return formatBytes(typeof size === "number" && Number.isFinite(size) ? size : 0);
+		} },
+		getItemPathText: { call: (_context, _state, [row]) => {
+			if (!isRecord(row)) return "";
+			const file = row["file"];
+			if (!isRecord(file)) return "";
+			const path = file["path"];
+			const name = file["name"];
+			if (typeof path === "string" && path.length > 0) return path;
+			return typeof name === "string" ? name : "";
+		} }
+	},
+	events: { "value-change": {
+		prop: "onValueChange",
+		watch: (context) => {
+			const ctx = context;
+			return [ctx.acceptedFiles.map((file) => file.name).join(","), ctx.rejectedFiles.map((item) => `${item.file.name}:${item.code}`).join(",")];
+		},
+		detail: (_watched, _event, _props, context) => ({
+			acceptedFiles: [...context.acceptedFiles],
+			rejectedFiles: [...context.rejectedFiles]
+		})
+	} }
+};
+const fileUpload = defineComponent(def);
+export { def, fileUpload, formatBytes };
+
+//# sourceMappingURL=file-upload.presentation.js.map

package/dist/file-upload/file-upload.state.d.ts

@@ -0,0 +1,52 @@
+export type FileUploadState = "idle" | "focused" | "dragging";
+export interface FileRecord {
+  readonly name: string;
+  readonly size: number;
+  readonly type: string;
+  readonly path: string;
+}
+export interface FileRejection {
+  readonly file: FileRecord;
+  readonly code: string;
+}
+export interface FileUploadContext {
+  acceptedFiles: FileRecord[];
+  rejectedFiles: FileRejection[];
+  multiple: boolean;
+  directory: boolean;
+  accept: string;
+  maxFiles: number;
+  maxSize: number;
+  minSize: number;
+  disabled: boolean;
+}
+export interface FileUploadArgs {
+  value?: string | readonly Partial<FileRecord>[];
+  multiple?: boolean;
+  directory?: boolean;
+  accept?: string;
+  maxFiles?: number;
+  maxSize?: number;
+  minSize?: number;
+  disabled?: boolean;
+  defaultDisabled?: boolean;
+}
+/** A write carries the records themselves, or the JSON text a host wrote;
+ * well-shaped entries survive, anything else is no file. */
+export declare function filesOf(raw: unknown): FileRecord[];
+export declare function initial(args: FileUploadArgs | undefined, authored: (name: string) => boolean): FileUploadContext;
+/** The accept list as patterns; an empty list accepts everything. */
+export declare const patterns: (accept: string) => readonly string[];
+/** One accepted pattern against one file: an extension or a MIME family. */
+export declare function matchesPattern(file: FileRecord, pattern: string): boolean;
+export interface SplitResult {
+  readonly accepted: readonly FileRecord[];
+  readonly rejected: readonly FileRejection[];
+}
+export declare function splitFiles(files: readonly FileRecord[], rules: {
+  readonly accept: string;
+  readonly maxSize: number;
+  readonly minSize: number;
+  readonly maxFiles: number;
+}, alreadyAccepted?: number): SplitResult;
+//# sourceMappingURL=file-upload.state.d.ts.map

package/dist/file-upload/file-upload.state.js

@@ -0,0 +1,72 @@
+import { coerceJsonArray, defaultTwin, isRecord } from "@spinjs/runtime";
+// src/file-upload/file-upload.state.ts
+/** A write carries the records themselves, or the JSON text a host wrote;
+* well-shaped entries survive, anything else is no file. */
+function filesOf(raw) {
+	const list = Array.isArray(raw) ? raw : typeof raw === "string" && raw.length > 0 ? coerceJsonArray(raw, []) : [];
+	const files = [];
+	for (const entry of list) {
+		if (!isRecord(entry)) continue;
+		const name = entry["name"];
+		const size = entry["size"];
+		if (typeof name !== "string" || typeof size !== "number" || !Number.isFinite(size)) continue;
+		const type = entry["type"];
+		const path = entry["path"];
+		files.push({
+			name,
+			size,
+			type: typeof type === "string" ? type : "",
+			path: typeof path === "string" ? path : ""
+		});
+	}
+	return files;
+}
+function initial(args = {}, authored) {
+	const written = (field) => authored(field) || authored(defaultTwin(field)) || args[defaultTwin(field)] !== void 0;
+	const count = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+	return {
+		acceptedFiles: written("value") ? filesOf(args.value) : [],
+		rejectedFiles: [],
+		multiple: written("multiple") ? args.multiple === true : false,
+		directory: written("directory") ? args.directory === true : false,
+		accept: written("accept") && typeof args.accept === "string" ? args.accept : "",
+		maxFiles: written("maxFiles") ? count(args.maxFiles) : 0,
+		maxSize: written("maxSize") ? count(args.maxSize) : 0,
+		minSize: written("minSize") ? count(args.minSize) : 0,
+		disabled: written("disabled") ? args.disabled === true : false
+	};
+}
+/** The accept list as patterns; an empty list accepts everything. */
+const patterns = (accept) => accept.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+/** One accepted pattern against one file: an extension or a MIME family. */
+function matchesPattern(file, pattern) {
+	if (pattern.startsWith(".")) return file.name.toLowerCase().endsWith(pattern.toLowerCase());
+	const slash = pattern.indexOf("/");
+	if (slash === -1) return file.type === pattern;
+	const [family, suffix] = [pattern.slice(0, slash), pattern.slice(slash + 1)];
+	if (suffix === "*") return file.type.startsWith(`${family}/`);
+	return file.type === pattern;
+}
+function splitFiles(files, rules, alreadyAccepted = 0) {
+	const accepted = [];
+	const rejected = [];
+	const list = patterns(rules.accept);
+	let count = alreadyAccepted;
+	for (const file of files) {
+		const code = list.length > 0 && !list.some((pattern) => matchesPattern(file, pattern)) ? "accept" : rules.maxSize > 0 && file.size > rules.maxSize ? "too-large" : rules.minSize > 0 && file.size < rules.minSize ? "too-small" : rules.maxFiles > 0 && count >= rules.maxFiles ? "too-many" : null;
+		if (code === null) {
+			accepted.push(file);
+			count += 1;
+		} else rejected.push({
+			file,
+			code
+		});
+	}
+	return {
+		accepted,
+		rejected
+	};
+}
+export { filesOf, initial, matchesPattern, patterns, splitFiles };
+
+//# sourceMappingURL=file-upload.state.js.map

package/dist/file-upload/file-upload.transitions.d.ts

@@ -0,0 +1,11 @@
+import { FileUploadContext } from "./file-upload.state.js";
+import { FileUploadEvents } from "./file-upload.events.js";
+import { AssignFor } from "@spinjs/runtime/fsm";
+type FileUploadAssign<K extends keyof FileUploadEvents = keyof FileUploadEvents> = AssignFor<FileUploadContext, FileUploadEvents, K>;
+export declare const setFiles: FileUploadAssign<"INPUT.CHANGE">;
+export declare const addFiles: FileUploadAssign<"DROP">;
+export declare const setValue: FileUploadAssign<"VALUE.SET">;
+export declare const clearValue: () => Partial<FileUploadContext>;
+export declare const removeFile: FileUploadAssign<"FILE.REMOVE">;
+export {};
+//# sourceMappingURL=file-upload.transitions.d.ts.map

package/dist/file-upload/file-upload.transitions.js

@@ -0,0 +1,32 @@
+import { filesOf, splitFiles } from "./file-upload.state.js";
+// src/file-upload/file-upload.transitions.ts
+const setFiles = (ctx, e) => {
+	const split = splitFiles(e.files, ctx);
+	return {
+		acceptedFiles: ctx.multiple ? [...split.accepted] : split.accepted.slice(0, 1),
+		rejectedFiles: [...split.rejected]
+	};
+};
+const addFiles = (ctx, e) => {
+	const split = splitFiles(e.files, ctx, ctx.acceptedFiles.length);
+	if (!ctx.multiple) return {
+		acceptedFiles: split.accepted.slice(0, 1),
+		rejectedFiles: [...split.rejected]
+	};
+	return {
+		acceptedFiles: [...ctx.acceptedFiles, ...split.accepted],
+		rejectedFiles: [...ctx.rejectedFiles, ...split.rejected]
+	};
+};
+const setValue = (_ctx, e) => ({
+	acceptedFiles: filesOf(e.value),
+	rejectedFiles: []
+});
+const clearValue = () => ({
+	acceptedFiles: [],
+	rejectedFiles: []
+});
+const removeFile = (ctx, e) => ({ acceptedFiles: ctx.acceptedFiles.filter((file) => file.name !== e.name) });
+export { addFiles, clearValue, removeFile, setFiles, setValue };
+
+//# sourceMappingURL=file-upload.transitions.js.map