@octane-xplat/files 0.10.0 → 0.11.1

package/dist/native/files.js

@@ -0,0 +1,283 @@
+import { assertSafeFileName, exactBuffer, exportBusy, fileTooLarge, throwIfAborted } from "./file-bytes.js";
+import { openFilePicker } from "@nativescript-community/ui-document-picker";
+import { Application, File, Utils, knownFolders, path } from "@nativescript/core";
+//#region src/files.ts
+var docs = () => knownFolders.documents();
+var READ_CHUNK = 65536;
+var ANDROID_EXPORT_REQUEST_CODE = 1241;
+function pickerTypes(accept) {
+	const values = accept.split(",").map((value) => value.trim()).filter(Boolean);
+	return {
+		extensions: values.filter((value) => value.startsWith(".")).map((value) => value.slice(1)),
+		mimeTypes: values.filter((value) => value.includes("/") && value !== "*/*")
+	};
+}
+function androidDisplayName(uri, nativeUri) {
+	if (!Application.android || !uri.startsWith("content://")) return;
+	try {
+		const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+		const noColumns = null;
+		const noFilter = null;
+		const cursor = activity?.getContentResolver()?.query(nativeUri ?? android.net.Uri.parse(uri), noColumns, noFilter, noColumns, noFilter);
+		if (!cursor) return;
+		try {
+			if (!cursor.moveToFirst()) return;
+			const index = cursor.getColumnIndex("display_name");
+			return index >= 0 ? cursor.getString(index) : void 0;
+		} finally {
+			cursor.close();
+		}
+	} catch {
+		return;
+	}
+}
+function fallbackName(uri) {
+	const segment = uri.split("/").pop() ?? "";
+	try {
+		return decodeURIComponent(segment) || "document";
+	} catch {
+		return segment || "document";
+	}
+}
+async function readContentUri(uri) {
+	const input = (Application.android?.foregroundActivity ?? Application.android?.startActivity)?.getContentResolver()?.openInputStream(android.net.Uri.parse(uri));
+	if (!input) throw new Error(`Unable to open picked file: ${uri}`);
+	const reader = new java.io.BufferedReader(new java.io.InputStreamReader(input));
+	const lines = [];
+	try {
+		let line;
+		while ((line = reader.readLine()) !== null) lines.push(line);
+		return lines.join("\n");
+	} finally {
+		reader.close();
+	}
+}
+async function pickFiles(accept, multiple, opts) {
+	const { extensions, mimeTypes } = pickerTypes(accept);
+	const result = await openFilePicker({
+		extensions,
+		mimeTypes,
+		multipleSelection: multiple,
+		permissions: {
+			read: true,
+			persistable: true
+		},
+		startingFolder: opts?.startingFolder
+	});
+	return (result.files ?? []).map((uri, index) => ({
+		name: androidDisplayName(uri, index === 0 ? result.android : void 0) ?? fallbackName(uri),
+		uri
+	}));
+}
+function openAndroidInput(uri) {
+	const activity = Application.android?.foregroundActivity ?? Application.android?.startActivity;
+	if (uri.startsWith("content://") || uri.startsWith("file://")) return activity?.getContentResolver()?.openInputStream(android.net.Uri.parse(uri));
+	return new java.io.FileInputStream(uri);
+}
+function readAndroidBytes(uri, opts) {
+	const input = openAndroidInput(uri);
+	if (!input) throw new Error(`Unable to open picked file: ${uri}`);
+	const out = new java.io.ByteArrayOutputStream();
+	const chunk = Array.create("byte", READ_CHUNK);
+	try {
+		let count;
+		while ((count = input.read(chunk)) !== -1) {
+			throwIfAborted(opts?.signal);
+			out.write(chunk, 0, count);
+			if (opts?.maxBytes != null && out.size() > opts.maxBytes) throw fileTooLarge(uri, opts.maxBytes);
+		}
+	} finally {
+		input.close();
+	}
+	return new Uint8Array(ArrayBuffer.from(java.nio.ByteBuffer.wrap(out.toByteArray())));
+}
+function iosFilePath(uri) {
+	let p = uri.startsWith("file://") ? uri.slice(7) : uri;
+	if (NSFileManager.defaultManager.fileExistsAtPath(p)) return p;
+	try {
+		const decoded = decodeURIComponent(p);
+		if (decoded !== p && NSFileManager.defaultManager.fileExistsAtPath(decoded)) return decoded;
+	} catch {}
+	return p;
+}
+function readIosBytes(uri, opts) {
+	const p = iosFilePath(uri);
+	const handle = NSFileHandle.fileHandleForReadingAtPath(p);
+	if (!handle) throw new Error(`Unable to open picked file: ${uri}`);
+	const out = NSMutableData.new();
+	try {
+		while (true) {
+			throwIfAborted(opts?.signal);
+			const data = handle.readDataOfLength(READ_CHUNK);
+			if (!data || data.length === 0) break;
+			out.appendData(data);
+			if (opts?.maxBytes != null && out.length > opts.maxBytes) throw fileTooLarge(uri, opts.maxBytes);
+		}
+	} finally {
+		handle.closeFile();
+	}
+	return new Uint8Array(interop.bufferFromData(out));
+}
+function writeAndroidBytes(uri, bytes) {
+	const activity = Application.android?.foregroundActivity ?? Application.android?.startActivity;
+	const out = uri.startsWith("content://") || uri.startsWith("file://") ? activity?.getContentResolver()?.openOutputStream(android.net.Uri.parse(uri)) : new java.io.FileOutputStream(uri);
+	if (!out) throw new Error(`Unable to open destination: ${uri}`);
+	try {
+		java.nio.channels.Channels.newChannel(out).write(exactBuffer(bytes));
+	} finally {
+		out.close();
+	}
+}
+function androidExport(name, bytes, opts) {
+	const activity = Application.android?.foregroundActivity ?? Application.android?.startActivity;
+	if (!activity) return Promise.resolve("unavailable");
+	const Intent = android.content.Intent;
+	const intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
+	intent.addCategory(Intent.CATEGORY_OPENABLE);
+	intent.setType(opts?.mimeType ?? "*/*");
+	intent.putExtra(Intent.EXTRA_TITLE, name);
+	intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION);
+	return new Promise((resolve, reject) => {
+		const onEvent = (event) => {
+			if (event.requestCode !== ANDROID_EXPORT_REQUEST_CODE) return;
+			Application.android.off(Application.android.activityResultEvent, onEvent);
+			const uri = event.intent?.getData?.();
+			if (event.resultCode !== android.app.Activity.RESULT_OK || !uri) {
+				resolve("cancelled");
+				return;
+			}
+			try {
+				writeAndroidBytes(uri.toString(), bytes);
+				resolve("saved");
+			} catch (error) {
+				reject(error);
+			}
+		};
+		Application.android.on(Application.android.activityResultEvent, onEvent);
+		try {
+			activity.startActivityForResult(intent, ANDROID_EXPORT_REQUEST_CODE);
+		} catch (error) {
+			Application.android.off(Application.android.activityResultEvent, onEvent);
+			reject(error);
+		}
+	});
+}
+var activeExport = null;
+var IosExportDelegate = null;
+function iosExportDelegateClass() {
+	if (IosExportDelegate) return IosExportDelegate;
+	IosExportDelegate = class extends NSObject {
+		static ObjCProtocols = [UIDocumentPickerDelegate];
+		finish = null;
+		documentPickerDidPickDocumentAtURL(controller, _url) {
+			this.settle(controller, true);
+		}
+		documentPickerDidPickDocumentsAtURLs(controller, urls) {
+			this.settle(controller, urls.count > 0);
+		}
+		documentPickerWasCancelled(controller) {
+			this.settle(controller, false);
+		}
+		settle(controller, saved) {
+			const finish = this.finish;
+			this.finish = null;
+			controller.delegate = null;
+			finish?.(saved);
+		}
+	};
+	return IosExportDelegate;
+}
+function iosVisibleViewController() {
+	const app = UIApplication.sharedApplication;
+	const keyWindow = app.keyWindow || app.windows.count > 0 && app.windows[0];
+	const getVisible = Utils.ios?.getVisibleViewController;
+	return keyWindow && typeof getVisible === "function" ? getVisible(keyWindow.rootViewController) : null;
+}
+async function iosExport(name, bytes, slot) {
+	const tempPath = path.join(knownFolders.temp().path, name);
+	const staged = NSData.dataWithBytesLength(bytes, bytes.byteLength).writeToFileAtomically(tempPath, true);
+	const removeTemp = () => {
+		try {
+			File.fromPath(tempPath).removeSync();
+		} catch {}
+	};
+	if (!staged) throw new Error(`Failed to stage export file: ${name}`);
+	const visibleVC = iosVisibleViewController();
+	if (!visibleVC) {
+		removeTemp();
+		throw new Error("No visible view controller to present the export picker");
+	}
+	return new Promise((resolve, reject) => {
+		try {
+			const controller = UIDocumentPickerViewController.alloc().initForExportingURLsAsCopy([NSURL.fileURLWithPath(tempPath)], true);
+			const delegate = iosExportDelegateClass().new();
+			delegate.finish = (saved) => {
+				removeTemp();
+				resolve(saved ? "saved" : "cancelled");
+			};
+			slot.delegate = delegate;
+			slot.controller = controller;
+			controller.delegate = delegate;
+			controller.shouldShowFileExtensions = true;
+			visibleVC.presentViewControllerAnimatedCompletion(controller, true, null);
+		} catch (error) {
+			removeTemp();
+			reject(error);
+		}
+	});
+}
+var files = {
+	async pickMultiple(accept = "*/*", opts) {
+		return pickFiles(accept, true, opts);
+	},
+	async pick(accept = "*/*", opts) {
+		return (await pickFiles(accept, false, opts))[0] ?? null;
+	},
+	async readText(ref) {
+		if (ref.uri.startsWith("content://")) return readContentUri(ref.uri);
+		return File.fromPath(Application.android ? ref.uri : iosFilePath(ref.uri)).readText();
+	},
+	async readBytes(ref, opts) {
+		throwIfAborted(opts?.signal);
+		return Application.android ? readAndroidBytes(ref.uri, opts) : readIosBytes(ref.uri, opts);
+	},
+	async writeText(name, text) {
+		assertSafeFileName(name);
+		const p = path.join(docs().path, name);
+		File.fromPath(p).writeTextSync(text);
+		return {
+			name,
+			uri: p
+		};
+	},
+	async writeBytes(name, bytes) {
+		assertSafeFileName(name);
+		const p = path.join(docs().path, name);
+		if (Application.android) writeAndroidBytes(p, bytes);
+		else if (!NSData.dataWithBytesLength(bytes, bytes.byteLength).writeToFileAtomically(p, true)) throw new Error(`Failed to write file: ${p}`);
+		return {
+			name,
+			uri: p
+		};
+	},
+	async export(name, bytes, opts) {
+		assertSafeFileName(name);
+		if (activeExport) throw exportBusy();
+		const slot = {};
+		activeExport = slot;
+		try {
+			return Application.android ? await androidExport(name, bytes, opts) : await iosExport(name, bytes, slot);
+		} finally {
+			if (activeExport === slot) activeExport = null;
+		}
+	},
+	release(ref) {
+		const cachePrefix = knownFolders.temp().path + "/";
+		if (!ref.uri.startsWith(cachePrefix)) return;
+		try {
+			File.fromPath(ref.uri).removeSync();
+		} catch {}
+	}
+};
+//#endregion
+export { files };

package/dist/native/index.js

@@ -0,0 +1,3 @@
+import { files } from "./files.js";
+import { FileInput } from "./FileInput.js";
+export { FileInput, files };

package/dist/native/octane-client-build.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "buildId": "e57a7c76-8a16-49df-8c10-483103f4021b",
+  "mode": "production",
+  "capabilities": {
+    "independentHydration": false
+  }
+}

package/dist/web/FileInput.js

@@ -0,0 +1,263 @@
+import { cx, formatFileSize, normalizePicked, validateFiles } from "./file-input-utils.js";
+import { Fragment, __s, bag5, clone, createElement, createScopedElement, createScopedValue, delegateEvents, evt1, hookSlots, positionalChildren, setEventHandler, setStyle, template, useId, useImperativeHandle, useRef, useState, withSlot } from "octane";
+import { bindSignalAttribute, bindSignalChild, createElementFromConfig, enableSignalBindings } from "octane/internal/client";
+import { Field, Icon, Spinner, Tooltip, useFieldControl } from "@octane-xplat/ui";
+//#region src/FileInput.web.tsrx
+enableSignalBindings(1, true);
+delegateEvents([
+	"dragenter",
+	"dragleave",
+	"dragover",
+	"drop"
+]);
+var _t$0 = /* @__PURE__ */ template("<div></div>");
+var _hs$ = /* @__PURE__ */ hookSlots(9);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$7 = /* @__PURE__ */ Symbol(_hs$ + 7);
+var STATUS_GLYPHS = {
+	error: "⚠",
+	warning: "⚠",
+	success: "✓"
+};
+var FileInputControl = /* @__PURE__ */ __s(function FileInputControl(inputProps, __s, __extra) {
+	const { props } = withSlot(_h$0, useFieldControl, inputProps);
+	const generatedId = useId(_hs$ + 1);
+	const inputId = props.id ?? generatedId;
+	const fileInput = useRef(null, _hs$ + 2);
+	const [dragging, setDragging] = useState(false, _hs$ + 3);
+	const [busy, setBusy] = useState(false, _hs$ + 4);
+	const [validationErrors, setValidationErrors] = useState([], _hs$ + 5);
+	const files = props.value == null ? [] : Array.isArray(props.value) ? props.value : [props.value];
+	const isDisabled = !!props.isDisabled || !!props.isReadOnly;
+	const isBusy = !!props.isLoading || busy;
+	const canClear = files.length > 0 && !isDisabled && !isBusy;
+	const showsDisabledReason = isDisabled && !!props.disabledMessage;
+	const statusType = validationErrors.length ? "error" : props.status?.type;
+	const statusMessage = validationErrors.length ? validationErrors.join(" ") : props.status?.message;
+	const emitValue = (next) => props.isMultiple ? next : next[0] ?? null;
+	const fireChange = (next) => {
+		const emitted = emitValue(next);
+		props.onChange?.(emitted);
+		if (props.changeAction) {
+			setBusy(true);
+			Promise.resolve(props.changeAction(emitted)).finally(() => setBusy(false));
+		}
+	};
+	const acceptRefs = (picked) => {
+		if (isDisabled || isBusy || !picked.length) return;
+		const merged = props.isMultiple ? [...files, ...picked] : picked;
+		const { valid, errors } = validateFiles(merged, {
+			accept: props.accept,
+			maxSize: props.maxSize,
+			maxFiles: props.maxFiles
+		});
+		setValidationErrors(errors);
+		const next = !props.isMultiple && errors.length ? files : valid;
+		if (next.length !== files.length || next.some((file, index) => file.uri !== files[index]?.uri)) fireChange(next);
+	};
+	const removeAt = (index) => {
+		if (isDisabled || isBusy) return;
+		setValidationErrors([]);
+		fireChange(files.filter((_, i) => i !== index));
+	};
+	const pick = () => {
+		if (isDisabled || isBusy) return;
+		if (props.pick) {
+			Promise.resolve(props.pick({
+				accept: props.accept,
+				multiple: props.isMultiple
+			})).then((r) => acceptRefs(normalizePicked(r))).catch((error) => setValidationErrors([String(error?.message ?? error)]));
+			return;
+		}
+		fileInput.current?.click();
+	};
+	const handleFileSelect = (e) => {
+		const list = e.target.files;
+		const picked = [];
+		if (list) for (let i = 0; i < list.length; i++) {
+			const f = list[i];
+			picked.push({
+				name: f.name,
+				uri: URL.createObjectURL(f),
+				size: f.size,
+				mimeType: f.type,
+				file: f
+			});
+		}
+		e.target.value = "";
+		acceptRefs(picked);
+	};
+	const handleDrop = (e) => {
+		e.preventDefault();
+		e.stopPropagation();
+		setDragging(false);
+		if (isDisabled || isBusy) return;
+		const list = e.dataTransfer?.files;
+		if (!list?.length) return;
+		const picked = [];
+		for (let i = 0; i < list.length; i++) {
+			const f = list[i];
+			picked.push({
+				name: f.name,
+				uri: URL.createObjectURL(f),
+				size: f.size,
+				mimeType: f.type,
+				file: f
+			});
+		}
+		acceptRefs(picked);
+	};
+	const dropzone = props.mode === "dropzone";
+	const itemContent = createScopedElement(Fragment, {}, () => positionalChildren([
+		files.length ? createScopedElement("ul", { className: "vx-fileinput-list" }, () => files.map((f, i) => createScopedElement("li", {
+			key: `${f.uri}-${i}`,
+			className: "vx-fileinput-item"
+		}, () => positionalChildren([
+			createElementFromConfig("c:b0d78e7b", Icon, {
+				name: "xplat-upload",
+				size: 14
+			}),
+			createScopedElement("span", { className: "vx-fileinput-itemname" }, () => f.name),
+			f.size != null ? createScopedElement("span", { className: "vx-fileinput-itemsize" }, () => formatFileSize(f.size)) : null,
+			!isDisabled && !isBusy ? createScopedValue(() => createElement("button", {
+				type: "button",
+				className: "vx-fileinput-itemremove",
+				"aria-label": `Remove ${f.name}`,
+				onClick: () => removeAt(i)
+			}, "×")) : null
+		])))) : null,
+		dropzone ? createScopedElement("div", { className: "vx-fileinput-dropzone-hint" }, () => positionalChildren([
+			createElementFromConfig("c:928c8dae", Icon, {
+				name: "xplat-upload",
+				size: 24
+			}),
+			createScopedElement("span", {}, () => isDisabled ? "Upload disabled" : "Drag & drop files here or click to browse"),
+			props.accept ? createScopedElement("span", { className: "vx-fileinput-accept" }, () => props.accept) : null
+		])) : createScopedValue(() => createScopedElement("button", {
+			type: "button",
+			id: inputId,
+			className: "vx-fileinput-trigger",
+			disabled: isDisabled && !showsDisabledReason || void 0,
+			"aria-disabled": showsDisabledReason || void 0,
+			"aria-describedby": props.ariaDescribedBy,
+			"aria-required": props.isRequired && !props.isOptional || void 0,
+			"aria-invalid": statusType === "error" || void 0,
+			"aria-busy": isBusy || void 0,
+			onClick: pick
+		}, () => positionalChildren([
+			createElementFromConfig("c:a0fe8d9f", Icon, {
+				name: "xplat-upload",
+				size: 14
+			}),
+			" ",
+			files.length ? "Choose more files" : "Choose files"
+		]))),
+		dropzone ? createScopedValue(() => createElement("button", {
+			type: "button",
+			id: inputId,
+			className: "vx-fileinput-trigger vx-fileinput-trigger--hidden",
+			disabled: isDisabled && !showsDisabledReason || void 0,
+			"aria-disabled": showsDisabledReason || void 0,
+			"aria-describedby": props.ariaDescribedBy,
+			"aria-required": props.isRequired && !props.isOptional || void 0,
+			"aria-invalid": statusType === "error" || void 0,
+			"aria-busy": isBusy || void 0,
+			onClick: pick
+		}, "Browse files")) : null,
+		canClear ? createScopedValue(() => createElement("button", {
+			type: "button",
+			className: "vx-fileinput-clear",
+			"aria-label": `Clear ${props.fieldLabel ?? props.label ?? "files"}`,
+			onClick: () => {
+				setValidationErrors([]);
+				fireChange([]);
+			}
+		}, "×")) : null,
+		isBusy ? createElementFromConfig("c:47d00c47", Spinner, {
+			busy: true,
+			className: "vx-fileinput-spinner"
+		}) : null,
+		statusType ? props.statusVariant === "tooltip" && statusMessage ? createScopedValue(() => createElementFromConfig("c:86665b9b", Tooltip, {
+			trigger: createScopedValue(() => createScopedElement("span", { className: cx("vx-field-icon", `vx-field-icon--${statusType}`) }, () => STATUS_GLYPHS[statusType])),
+			content: statusMessage
+		})) : createScopedValue(() => createScopedElement("span", { className: cx("vx-field-icon", `vx-field-icon--${statusType}`) }, () => STATUS_GLYPHS[statusType])) : null,
+		statusMessage && props.statusVariant !== "tooltip" ? createScopedValue(() => createScopedElement("span", {
+			className: cx("vx-field-status", `vx-field-status--${statusType}`),
+			role: statusType === "error" ? "alert" : "status"
+		}, () => statusMessage)) : null,
+		createScopedValue(() => createElement("input", {
+			ref: (el) => {
+				fileInput.current = el;
+			},
+			type: "file",
+			className: "vx-fileinput-nativeinput",
+			accept: props.accept,
+			multiple: props.isMultiple || void 0,
+			disabled: isDisabled || void 0,
+			"aria-hidden": "true",
+			tabIndex: -1,
+			onChange: handleFileSelect
+		}))
+	]));
+	useImperativeHandle(props.ref, () => ({
+		open: pick,
+		native: fileInput.current
+	}), void 0, _hs$ + 6);
+	if (__s.block.pending && !__s.block.crossRenderUpdate) return;
+	let _b = __s.slots[0];
+	if (_b === void 0) {
+		let _m1;
+		const _root = clone(_t$0);
+		_m1 = _root;
+		setEventHandler(_root, "$$dragover", (e) => {
+			e.preventDefault();
+			if (!isDisabled && !isBusy) setDragging(true);
+		});
+		setEventHandler(_root, "$$dragenter", (e) => {
+			e.preventDefault();
+		});
+		evt1(_root, "$$dragleave", setDragging, false);
+		setEventHandler(_root, "$$drop", handleDrop);
+		_b = bag5(__s, _root, void 0, _m1, void 0, null, void 0);
+	} else {
+		setEventHandler(_b.b, "$$dragover", (e) => {
+			e.preventDefault();
+			if (!isDisabled && !isBusy) setDragging(true);
+		});
+		setEventHandler(_b.b, "$$drop", handleDrop);
+	}
+	_b.a = bindSignalAttribute(__s, _b.a, _b.b, "class", cx("vx-fileinput", dropzone && "vx-fileinput--dropzone", isDisabled && "vx-fileinput--disabled", isBusy && "vx-fileinput--loading", dragging && "vx-fileinput--dragging", statusType && `vx-fileinput--status-${statusType}`, props.size && `vx-fileinput--size-${props.size}`, props.className), "b:e1094c29", "class");
+	{
+		const _v = props.style;
+		if (_b.c !== _v) {
+			setStyle(_b.b, _v, _b.c);
+			_b.c = _v;
+		}
+	}
+	_b.f = bindSignalChild(__s, _b.f, 1, _b.b, itemContent, "b:11d99fad", null, void 0, void 0, void 0, true);
+});
+var FileInput = function FileInput(props, __s, __extra) {
+	const { inField } = withSlot(_h$7, useFieldControl, props);
+	const cid = useId(_hs$ + 8);
+	const control = createScopedValue(() => createElementFromConfig("c:afa4c501", FileInputControl, { ...props }));
+	if (inField) return control ?? null;
+	return createScopedValue(() => createScopedElement(Field, {
+		inputID: props.id ?? cid,
+		label: props.label,
+		isLabelHidden: props.isLabelHidden,
+		description: props.description,
+		isDisabled: props.isDisabled,
+		disabledMessage: props.disabledMessage,
+		isReadOnly: props.isReadOnly,
+		isLoading: props.isLoading,
+		isRequired: props.isRequired,
+		isOptional: props.isOptional,
+		size: props.size,
+		status: props.status,
+		statusVariant: props.statusVariant,
+		labelTooltip: props.labelTooltip,
+		width: props.width
+	}, () => control, "c:3f29a6d4"));
+};
+//#endregion
+export { FileInput };

package/dist/web/file-bytes.js

@@ -0,0 +1,45 @@
+//#region src/file-bytes.ts
+/**
+* Shared helpers for the binary file primitives (readBytes/writeBytes/export).
+* DOM-free so the native leaf can use it too.
+*/
+/** File names used for sandbox writes and export temp files must be bare
+*  names, not paths — a `/`, `\`, or `..` segment escapes the sandbox. */
+function assertSafeFileName(name) {
+	if (typeof name !== "string" || name.length === 0 || name === "." || name === ".." || name.includes("/") || name.includes("\\") || name.includes("\0")) throw new Error(`Unsafe file name: ${JSON.stringify(name)}`);
+}
+function fileTooLarge(name, maxBytes) {
+	return /* @__PURE__ */ new Error(`${name}: file exceeds the ${maxBytes}-byte limit`);
+}
+/** Named rejection for a second `files.export` while one is in flight. */
+function exportBusy() {
+	const error = /* @__PURE__ */ new Error("files.export: an export is already in progress");
+	error.name = "ExportBusyError";
+	return error;
+}
+function throwIfAborted(signal) {
+	if (!signal?.aborted) return;
+	const thrower = signal.throwIfAborted;
+	if (typeof thrower === "function") thrower.call(signal);
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	throw error;
+}
+/** Concatenate Uint8Array chunks into one exact-length array. */
+function concatBytes(chunks, total) {
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return out;
+}
+/** Return an ArrayBuffer covering exactly this view's byte range — native
+*  marshallers treat the argument as the whole buffer. */
+function exactBuffer(bytes) {
+	if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) return bytes.buffer;
+	return bytes.slice().buffer;
+}
+//#endregion
+export { assertSafeFileName, concatBytes, exactBuffer, exportBusy, fileTooLarge, throwIfAborted };

package/dist/web/file-input-utils.js

@@ -0,0 +1,52 @@
+//#region src/file-input-utils.ts
+function cx(...values) {
+	return values.filter(Boolean).join(" ");
+}
+function normalizePicked(result) {
+	if (result == null) return [];
+	return Array.isArray(result) ? result : [result];
+}
+function fileAccepts(file, accept) {
+	if (!accept) return true;
+	const tokens = accept.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+	if (!tokens.length) return true;
+	const name = file.name.toLowerCase();
+	const mime = (file.mimeType ?? "").toLowerCase();
+	return tokens.some((token) => {
+		if (token === "*/*") return true;
+		if (token.startsWith(".")) return name.endsWith(token);
+		if (token.endsWith("/*")) return mime.startsWith(token.slice(0, -1));
+		return mime === token;
+	});
+}
+function formatFileSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+	if (bytes < 1073741824) return `${(bytes / 1048576).toFixed(1)} MB`;
+	return `${(bytes / 1073741824).toFixed(1)} GB`;
+}
+function validateFiles(files, opts) {
+	const errors = [];
+	const valid = [];
+	for (const file of files) {
+		if (!fileAccepts(file, opts.accept)) {
+			errors.push(`${file.name}: file type not accepted`);
+			continue;
+		}
+		if (opts.maxSize != null && file.size != null && file.size > opts.maxSize) {
+			errors.push(`${file.name}: file exceeds ${formatFileSize(opts.maxSize)}`);
+			continue;
+		}
+		valid.push(file);
+	}
+	if (opts.maxFiles != null && valid.length > opts.maxFiles) {
+		const extra = valid.splice(opts.maxFiles);
+		for (const file of extra) errors.push(`${file.name}: exceeds the ${opts.maxFiles}-file limit`);
+	}
+	return {
+		valid,
+		errors
+	};
+}
+//#endregion
+export { cx, fileAccepts, formatFileSize, normalizePicked, validateFiles };