@ctrl-ui/react 0.8.0

package/dist/lib/diff.js

@@ -0,0 +1,315 @@
+import { diffChars, diffWordsWithSpace, parsePatch, structuredPatch } from "diff";
+//#region src/lib/diff.ts
+const DEFAULT_CONTEXT = 3;
+const DEFAULT_MAX_LINE_DIFF_LENGTH = 2e3;
+function splitLines(text) {
+	if (text.length === 0) return [];
+	const lines = text.split("\n");
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return lines;
+}
+function stripGitPrefix(name) {
+	if (name === void 0) return void 0;
+	if (name === "/dev/null") return name;
+	return name.replace(/^[ab]\//, "");
+}
+function computeWordDiff(oldText, newText, kind, maxLength) {
+	if (kind === "none") return [void 0, void 0];
+	if (maxLength > 0 && oldText.length + newText.length > maxLength) return [void 0, void 0];
+	const changes = kind === "char" ? diffChars(oldText, newText) : diffWordsWithSpace(oldText, newText);
+	const oldSegments = [];
+	const newSegments = [];
+	for (const change of changes) {
+		if (change.value.length === 0) continue;
+		if (change.added) newSegments.push({
+			text: change.value,
+			emphasis: true
+		});
+		else if (change.removed) oldSegments.push({
+			text: change.value,
+			emphasis: true
+		});
+		else {
+			oldSegments.push({
+				text: change.value,
+				emphasis: false
+			});
+			newSegments.push({
+				text: change.value,
+				emphasis: false
+			});
+		}
+	}
+	return [oldSegments, newSegments];
+}
+function diffRunEnd(lines, start, type) {
+	let end = start;
+	while (lines[end]?.type === type) end += 1;
+	return end;
+}
+function attachWordDiff(lines, kind, maxLength) {
+	if (kind === "none") return;
+	let index = 0;
+	while (index < lines.length) {
+		if (lines[index]?.type !== "del") {
+			index += 1;
+			continue;
+		}
+		const delEnd = diffRunEnd(lines, index, "del");
+		const addEnd = diffRunEnd(lines, delEnd, "add");
+		const pairCount = Math.min(delEnd - index, addEnd - delEnd);
+		for (let pair = 0; pair < pairCount; pair += 1) {
+			const delLine = lines[index + pair];
+			const addLine = lines[delEnd + pair];
+			if (!delLine || !addLine) continue;
+			const [oldSegments, newSegments] = computeWordDiff(delLine.text, addLine.text, kind, maxLength);
+			delLine.segments = oldSegments;
+			addLine.segments = newSegments;
+		}
+		index = addEnd;
+	}
+}
+function hunkLines(hunk) {
+	const lines = [];
+	let oldNo = hunk.oldStart;
+	let newNo = hunk.newStart;
+	for (const raw of hunk.lines) {
+		if (raw.length === 0) continue;
+		const marker = raw[0];
+		const text = raw.slice(1);
+		if (marker === "\\") continue;
+		if (marker === "-") {
+			lines.push({
+				type: "del",
+				oldNo,
+				text
+			});
+			oldNo += 1;
+		} else if (marker === "+") {
+			lines.push({
+				type: "add",
+				newNo,
+				text
+			});
+			newNo += 1;
+		} else {
+			lines.push({
+				type: "context",
+				oldNo,
+				newNo,
+				text
+			});
+			oldNo += 1;
+			newNo += 1;
+		}
+	}
+	return lines;
+}
+function hunkHeaderScope(hunk) {
+	const raw = hunkRawHeader.get(hunk);
+	if (!raw) return void 0;
+	const trimmed = raw.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+const hunkRawHeader = /* @__PURE__ */ new WeakMap();
+function toDiffFile(patch, options, oldLines, newLines, isPartial) {
+	const kind = options.lineDiffType ?? "word";
+	const maxLength = options.maxLineDiffLength ?? DEFAULT_MAX_LINE_DIFF_LENGTH;
+	const summary = summarizeHunks(patch.hunks, kind, maxLength);
+	const oldName = stripGitPrefix(patch.oldFileName);
+	const newName = stripGitPrefix(patch.newFileName);
+	const name = resolveDiffFileName(options.name, oldName, newName);
+	const type = resolveDiffFileType(oldName, newName, oldLines, newLines, isPartial);
+	return {
+		name,
+		oldName: type === "rename" ? oldName : void 0,
+		type,
+		lang: options.lang,
+		hunks: summary.hunks,
+		oldLines,
+		newLines,
+		isPartial,
+		additions: summary.additions,
+		deletions: summary.deletions
+	};
+}
+function countLineChanges(lines) {
+	let additions = 0;
+	let deletions = 0;
+	for (const line of lines) {
+		if (line.type === "add") additions += 1;
+		if (line.type === "del") deletions += 1;
+	}
+	return {
+		additions,
+		deletions
+	};
+}
+function summarizeHunks(rawHunks, kind, maxLength) {
+	const hunks = [];
+	let additions = 0;
+	let deletions = 0;
+	let previousOldEnd = 0;
+	for (const raw of rawHunks) {
+		const lines = hunkLines(raw);
+		attachWordDiff(lines, kind, maxLength);
+		const changes = countLineChanges(lines);
+		additions += changes.additions;
+		deletions += changes.deletions;
+		hunks.push({
+			header: hunkHeaderScope(raw),
+			oldStart: raw.oldStart,
+			oldCount: raw.oldLines,
+			newStart: raw.newStart,
+			newCount: raw.newLines,
+			lines,
+			collapsedBefore: Math.max(0, raw.oldStart - 1 - previousOldEnd)
+		});
+		previousOldEnd = raw.oldStart - 1 + raw.oldLines;
+	}
+	return {
+		hunks,
+		additions,
+		deletions
+	};
+}
+function resolveDiffFileName(explicitName, oldName, newName) {
+	if (explicitName !== void 0) return explicitName;
+	if (newName && newName !== "/dev/null") return newName;
+	return oldName ?? "file";
+}
+function resolveDiffFileType(oldName, newName, oldLines, newLines, isPartial) {
+	if (oldName === "/dev/null" || !isPartial && oldLines.length === 0 && newLines.length > 0) return "new";
+	if (newName === "/dev/null" || !isPartial && newLines.length === 0 && oldLines.length > 0) return "deleted";
+	if (oldName !== void 0 && newName !== void 0 && oldName !== newName) return "rename";
+	return "change";
+}
+function buildDiffFromFiles(oldText, newText, options = {}) {
+	const name = options.name ?? "file";
+	const context = options.context ?? DEFAULT_CONTEXT;
+	return toDiffFile(structuredPatch(name, name, oldText, newText, "", "", { context }), options, splitLines(oldText), splitLines(newText), false);
+}
+function buildDiffFromPatch(patchText, options = {}) {
+	let patches;
+	try {
+		patches = parsePatch(patchText);
+		indexRawHunkHeaders(patchText, patches);
+	} catch {
+		patches = parsePatchLenient(patchText);
+	}
+	return patches.map((patch) => toDiffFile(patch, options, [], [], true));
+}
+function emptyStructuredPatch() {
+	return {
+		oldFileName: void 0,
+		newFileName: void 0,
+		oldHeader: void 0,
+		newHeader: void 0,
+		hunks: []
+	};
+}
+function patchFileName(rest) {
+	return rest.split("	", 1)[0]?.trim() ?? "";
+}
+function reconcileHunkCounts(hunk) {
+	let oldCount = 0;
+	let newCount = 0;
+	for (const line of hunk.lines) {
+		const marker = line[0];
+		if (marker === "+") newCount += 1;
+		else if (marker === "-") oldCount += 1;
+		else if (marker === "\\") continue;
+		else {
+			oldCount += 1;
+			newCount += 1;
+		}
+	}
+	hunk.oldLines = oldCount;
+	hunk.newLines = newCount;
+}
+function ensureCurrentFile(state) {
+	state.current ??= emptyStructuredPatch();
+	return state.current;
+}
+function closeLenientHunk(state) {
+	if (state.current && state.hunk) {
+		reconcileHunkCounts(state.hunk);
+		state.current.hunks.push(state.hunk);
+	}
+	state.hunk = void 0;
+}
+function closeLenientFile(state) {
+	closeLenientHunk(state);
+	if (state.current) state.files.push(state.current);
+	state.current = void 0;
+}
+function lenientHunkHeader(line) {
+	const match = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@(.*)$/);
+	if (!match) return void 0;
+	return {
+		oldStart: Number(match[1]),
+		newStart: Number(match[2]),
+		scope: match[3] ?? ""
+	};
+}
+function isHunkBodyLine(line) {
+	const marker = line[0];
+	return marker === " " || marker === "+" || marker === "-" || marker === "\\";
+}
+function consumeLenientPatchLine(state, line) {
+	if (line.startsWith("diff --git")) {
+		closeLenientFile(state);
+		state.current = emptyStructuredPatch();
+		return;
+	}
+	if (line.startsWith("--- ")) {
+		if (state.current) closeLenientHunk(state);
+		ensureCurrentFile(state).oldFileName = patchFileName(line.slice(4));
+		return;
+	}
+	if (line.startsWith("+++ ")) {
+		ensureCurrentFile(state).newFileName = patchFileName(line.slice(4));
+		return;
+	}
+	const header = lenientHunkHeader(line);
+	if (header) {
+		closeLenientHunk(state);
+		ensureCurrentFile(state);
+		state.hunk = {
+			oldStart: header.oldStart,
+			oldLines: 0,
+			newStart: header.newStart,
+			newLines: 0,
+			lines: []
+		};
+		hunkRawHeader.set(state.hunk, header.scope);
+		return;
+	}
+	if (!state.hunk) return;
+	if (isHunkBodyLine(line)) {
+		state.hunk.lines.push(line);
+		return;
+	}
+	closeLenientHunk(state);
+}
+function parsePatchLenient(patchText) {
+	const state = { files: [] };
+	for (const line of patchText.split("\n")) consumeLenientPatchLine(state, line);
+	closeLenientFile(state);
+	return state.files;
+}
+function indexRawHunkHeaders(patchText, patches) {
+	const scopes = [];
+	for (const line of patchText.split("\n")) {
+		const scope = line.match(/^@@[^@]*@@(.*)$/)?.[1];
+		if (scope !== void 0) scopes.push(scope);
+	}
+	let hunkIndex = 0;
+	for (const patch of patches) for (const hunk of patch.hunks) {
+		const scope = scopes[hunkIndex];
+		if (scope !== void 0) hunkRawHeader.set(hunk, scope);
+		hunkIndex += 1;
+	}
+}
+//#endregion
+export { buildDiffFromFiles, buildDiffFromPatch, computeWordDiff, diffRunEnd };

package/dist/lib/dropzone-validation.d.ts

@@ -0,0 +1,66 @@
+import { DropzoneVisualState } from "../hooks/use-dropzone.js";
+//#region src/lib/dropzone-validation.d.ts
+type DropzoneSelectionMode = "append" | "replace";
+declare const DropzoneErrorCode: {
+  readonly FileInvalidType: "file-invalid-type";
+  readonly FileTooLarge: "file-too-large";
+  readonly FileTooSmall: "file-too-small";
+  readonly TooManyFiles: "too-many-files";
+  readonly FileAlreadySelected: "file-already-selected";
+};
+type DropzoneErrorCodeValue = (typeof DropzoneErrorCode)[keyof typeof DropzoneErrorCode];
+type DropzoneAccept = Readonly<Record<string, readonly string[]>>;
+type DropzoneFileError = {
+  code: DropzoneErrorCodeValue | string;
+  message: string;
+};
+type DropzoneFileRejection = {
+  file: File;
+  errors: readonly DropzoneFileError[];
+};
+type DropzoneValidatorResult = DropzoneFileError | readonly DropzoneFileError[] | null;
+type DropzoneValidator = (file: File, signal: AbortSignal) => DropzoneValidatorResult | Promise<DropzoneValidatorResult>;
+type DropzonePolicy = {
+  accept?: DropzoneAccept;
+  minSize?: number;
+  maxSize?: number;
+  maxFiles?: number;
+  multiple?: boolean;
+  selectionMode?: DropzoneSelectionMode;
+  allowDuplicates?: boolean;
+  validator?: DropzoneValidator;
+};
+type DropzoneFileMetadata = {
+  name?: string;
+  size?: number;
+  type?: string;
+  lastModified?: number;
+  webkitRelativePath?: string;
+};
+type DropzoneProcessResult = {
+  acceptedFiles: readonly File[];
+  fileRejections: readonly DropzoneFileRejection[];
+  value: readonly File[];
+  removedFiles: readonly File[];
+};
+type DropzoneDragVerdictOptions = {
+  customExtraction?: boolean;
+};
+type NormalizedAcceptEntry = {
+  mime: string;
+  extensions: readonly string[];
+};
+declare function normalizeDropzoneAccept(accept: DropzoneAccept | undefined): readonly NormalizedAcceptEntry[];
+declare function compileDropzoneAccept(accept: DropzoneAccept | undefined): string | undefined;
+declare function isDropzoneFileAccepted(file: Pick<File, "name" | "type">, accept: DropzoneAccept | undefined): boolean;
+declare function normalizeDropzoneMaxFiles(maxFiles: number | undefined): number;
+declare function getDropzoneSelectionMode(policy: DropzonePolicy | undefined): DropzoneSelectionMode;
+declare function getDropzoneCapacity(policy: DropzonePolicy | undefined): number;
+declare function getDropzoneFileIdentity(file: DropzoneFileMetadata): string;
+declare function toDropzoneError(value: unknown): Error;
+declare function validateDropzoneFile(file: File, policy: DropzonePolicy | undefined, signal: AbortSignal): Promise<readonly DropzoneFileError[]>;
+declare function processDropzoneFiles(files: readonly File[], currentValue: readonly File[], policy: DropzonePolicy | undefined, signal: AbortSignal): Promise<DropzoneProcessResult>;
+declare function getDropzoneDragVerdict(files: readonly DropzoneFileMetadata[] | null, currentValue: readonly File[], policy: DropzonePolicy | undefined, options?: DropzoneDragVerdictOptions): Exclude<DropzoneVisualState, "idle" | "processing">;
+declare function formatDropzoneFileSize(size: number): string;
+//#endregion
+export { DropzoneAccept, DropzoneDragVerdictOptions, DropzoneErrorCode, DropzoneErrorCodeValue, DropzoneFileError, DropzoneFileMetadata, DropzoneFileRejection, DropzonePolicy, DropzoneProcessResult, DropzoneSelectionMode, DropzoneValidator, DropzoneValidatorResult, compileDropzoneAccept, formatDropzoneFileSize, getDropzoneCapacity, getDropzoneDragVerdict, getDropzoneFileIdentity, getDropzoneSelectionMode, isDropzoneFileAccepted, normalizeDropzoneAccept, normalizeDropzoneMaxFiles, processDropzoneFiles, toDropzoneError, validateDropzoneFile };

package/dist/lib/dropzone-validation.js

@@ -0,0 +1,228 @@
+//#region src/lib/dropzone-validation.ts
+const DropzoneErrorCode = {
+	FileInvalidType: "file-invalid-type",
+	FileTooLarge: "file-too-large",
+	FileTooSmall: "file-too-small",
+	TooManyFiles: "too-many-files",
+	FileAlreadySelected: "file-already-selected"
+};
+const DEFAULT_POLICY = {
+	minSize: 0,
+	maxSize: Number.POSITIVE_INFINITY,
+	maxFiles: 0,
+	multiple: true,
+	selectionMode: "append",
+	allowDuplicates: false
+};
+function normalizeDropzoneAccept(accept) {
+	if (!accept) return [];
+	return Object.entries(accept).flatMap(([rawMime, rawExtensions]) => {
+		const mime = rawMime.trim().toLowerCase();
+		const extensions = Array.from(new Set(rawExtensions.flatMap((rawExtension) => {
+			const extension = rawExtension.trim().toLowerCase();
+			if (!extension) return [];
+			return [extension.startsWith(".") ? extension : `.${extension}`];
+		})));
+		return mime || extensions.length > 0 ? [{
+			mime,
+			extensions
+		}] : [];
+	});
+}
+function compileDropzoneAccept(accept) {
+	const values = normalizeDropzoneAccept(accept).flatMap(({ mime, extensions }) => {
+		if (extensions.length > 0) return extensions;
+		return mime ? [mime] : [];
+	});
+	return values.length > 0 ? values.join(",") : void 0;
+}
+function isDropzoneFileAccepted(file, accept) {
+	return getFileAcceptance(file, normalizeDropzoneAccept(accept)) === "accept";
+}
+function normalizeDropzoneMaxFiles(maxFiles) {
+	const value = maxFiles ?? DEFAULT_POLICY.maxFiles;
+	if (!Number.isFinite(value) || value <= 0) return Number.POSITIVE_INFINITY;
+	return Math.max(1, Math.floor(value));
+}
+function getDropzoneSelectionMode(policy) {
+	return policy?.multiple === false ? "replace" : policy?.selectionMode ?? DEFAULT_POLICY.selectionMode;
+}
+function getDropzoneCapacity(policy) {
+	return policy?.multiple === false ? 1 : normalizeDropzoneMaxFiles(policy?.maxFiles);
+}
+function getDropzoneFileIdentity(file) {
+	return `${file.webkitRelativePath || file.name || ""}\0${file.size ?? ""}\0${file.type?.toLowerCase() ?? ""}\0${file.lastModified ?? ""}`;
+}
+function toDropzoneError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+async function validateDropzoneFile(file, policy, signal) {
+	const errors = [];
+	const minSize = policy?.minSize ?? DEFAULT_POLICY.minSize;
+	const maxSize = policy?.maxSize ?? DEFAULT_POLICY.maxSize;
+	if (!isDropzoneFileAccepted(file, policy?.accept)) errors.push({
+		code: DropzoneErrorCode.FileInvalidType,
+		message: "File type is not accepted."
+	});
+	if (file.size < minSize) errors.push({
+		code: DropzoneErrorCode.FileTooSmall,
+		message: `File is smaller than the ${formatDropzoneFileSize(minSize)} minimum.`
+	});
+	if (file.size > maxSize) errors.push({
+		code: DropzoneErrorCode.FileTooLarge,
+		message: `File is larger than the ${formatDropzoneFileSize(maxSize)} limit.`
+	});
+	if (policy?.validator) {
+		signal.throwIfAborted();
+		const result = await policy.validator(file, signal);
+		signal.throwIfAborted();
+		if (result) errors.push(...normalizeValidatorErrors(result));
+	}
+	return errors;
+}
+async function processDropzoneFiles(files, currentValue, policy, signal) {
+	signal.throwIfAborted();
+	const validatedFiles = await Promise.all(files.map(async (file) => ({
+		file,
+		errors: await validateDropzoneFile(file, policy, signal)
+	})));
+	signal.throwIfAborted();
+	const acceptedFiles = [];
+	const fileRejections = [];
+	const selectionMode = getDropzoneSelectionMode(policy);
+	const capacity = getDropzoneCapacity(policy);
+	const selectedFiles = selectionMode === "append" ? [...currentValue] : [];
+	const selectedIdentities = new Set(policy?.allowDuplicates ? [] : (selectionMode === "append" ? currentValue : []).map(getDropzoneFileIdentity));
+	for (const { file, errors } of validatedFiles) {
+		if (errors.length > 0) {
+			fileRejections.push({
+				file,
+				errors
+			});
+			continue;
+		}
+		const identity = getDropzoneFileIdentity(file);
+		if (!policy?.allowDuplicates && selectedIdentities.has(identity)) {
+			fileRejections.push({
+				file,
+				errors: [{
+					code: DropzoneErrorCode.FileAlreadySelected,
+					message: `File "${file.name}" is already selected.`
+				}]
+			});
+			continue;
+		}
+		if (selectedFiles.length >= capacity) {
+			fileRejections.push({
+				file,
+				errors: [{
+					code: DropzoneErrorCode.TooManyFiles,
+					message: "Too many files."
+				}]
+			});
+			continue;
+		}
+		acceptedFiles.push(file);
+		selectedFiles.push(file);
+		selectedIdentities.add(identity);
+	}
+	if (selectionMode === "replace" && acceptedFiles.length === 0) return {
+		acceptedFiles,
+		fileRejections,
+		value: currentValue,
+		removedFiles: []
+	};
+	return {
+		acceptedFiles,
+		fileRejections,
+		value: selectedFiles,
+		removedFiles: selectionMode === "replace" ? getRemovedFiles(currentValue, selectedFiles) : []
+	};
+}
+function getDropzoneDragVerdict(files, currentValue, policy, options = {}) {
+	const selectionMode = getDropzoneSelectionMode(policy);
+	const capacity = getDropzoneCapacity(policy);
+	if (selectionMode === "append" && currentValue.length >= capacity) return "reject";
+	if (!files || files.length === 0) return "unknown";
+	const availableSlots = selectionMode === "append" ? capacity - currentValue.length : capacity;
+	if (files.length > availableSlots) return "reject";
+	const normalizedAccept = normalizeDropzoneAccept(policy?.accept);
+	const metadataVerdicts = files.map((file) => getDropzoneMetadataVerdict(file, normalizedAccept, policy));
+	if (metadataVerdicts.includes("reject")) return "reject";
+	const duplicateVerdict = getDropzoneDuplicateVerdict(files, currentValue, policy, selectionMode);
+	if (duplicateVerdict === "reject") return "reject";
+	if (policy?.validator || options.customExtraction || metadataVerdicts.includes("unknown") || duplicateVerdict === "unknown") return "unknown";
+	return "accept";
+}
+function formatDropzoneFileSize(size) {
+	const safeSize = Number.isFinite(size) && size >= 0 ? size : 0;
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB"
+	];
+	if (safeSize === 0) return "0 B";
+	const unitIndex = Math.min(Math.floor(Math.log(safeSize) / Math.log(1024)), units.length - 1);
+	return `${Math.round(safeSize / 1024 ** unitIndex * 10) / 10} ${units[unitIndex]}`;
+}
+function getFileAcceptance(file, entries) {
+	if (entries.length === 0) return "accept";
+	const verdicts = entries.map((entry) => getAcceptEntryVerdict(file, entry));
+	if (verdicts.includes("accept")) return "accept";
+	return verdicts.includes("unknown") ? "unknown" : "reject";
+}
+function getAcceptEntryVerdict(file, { mime, extensions }) {
+	if (extensions.length > 0) {
+		if (!file.name) return "unknown";
+		const name = file.name.toLowerCase();
+		return extensions.some((extension) => name.endsWith(extension)) ? "accept" : "reject";
+	}
+	if (!file.type) return "unknown";
+	const type = file.type.toLowerCase();
+	return (mime.endsWith("/*") ? type.startsWith(mime.slice(0, -1)) : type === mime) ? "accept" : "reject";
+}
+function getDropzoneMetadataVerdict(file, normalizedAccept, policy) {
+	const acceptance = getFileAcceptance(file, normalizedAccept);
+	if (acceptance === "reject") return "reject";
+	if (file.size === void 0) return "unknown";
+	if (file.size < (policy?.minSize ?? DEFAULT_POLICY.minSize)) return "reject";
+	if (file.size > (policy?.maxSize ?? DEFAULT_POLICY.maxSize)) return "reject";
+	return acceptance;
+}
+function getDropzoneDuplicateVerdict(files, currentValue, policy, selectionMode) {
+	if (policy?.allowDuplicates) return "accept";
+	const selectedIdentities = new Set(selectionMode === "append" ? currentValue.map(getDropzoneFileIdentity) : []);
+	let hasUnknownIdentity = false;
+	for (const file of files) {
+		if (!hasCompleteIdentity(file)) {
+			hasUnknownIdentity = true;
+			continue;
+		}
+		const identity = getDropzoneFileIdentity(file);
+		if (selectedIdentities.has(identity)) return "reject";
+		selectedIdentities.add(identity);
+	}
+	return hasUnknownIdentity ? "unknown" : "accept";
+}
+function isDropzoneErrorList(result) {
+	return Array.isArray(result);
+}
+function normalizeValidatorErrors(result) {
+	return isDropzoneErrorList(result) ? result : [result];
+}
+function hasCompleteIdentity(file) {
+	return Boolean(file.webkitRelativePath || file.name) && file.size !== void 0 && file.type !== void 0 && file.lastModified !== void 0;
+}
+function getRemovedFiles(currentValue, nextValue) {
+	const unmatchedNext = [...nextValue];
+	return currentValue.filter((file) => {
+		const index = unmatchedNext.indexOf(file);
+		if (index < 0) return true;
+		unmatchedNext.splice(index, 1);
+		return false;
+	});
+}
+//#endregion
+export { DropzoneErrorCode, compileDropzoneAccept, formatDropzoneFileSize, getDropzoneCapacity, getDropzoneDragVerdict, getDropzoneFileIdentity, getDropzoneSelectionMode, isDropzoneFileAccepted, normalizeDropzoneAccept, normalizeDropzoneMaxFiles, processDropzoneFiles, toDropzoneError, validateDropzoneFile };

package/dist/lib/env-file.d.ts

@@ -0,0 +1,28 @@
+//#region src/lib/env-file.d.ts
+interface EnvironmentVariableEntry {
+  key: string;
+  value: string;
+}
+declare const ENV_FILE_MAX_SIZE: number;
+declare const DUPLICATE_ENVIRONMENT_VARIABLE_MESSAGE = "Environment variable keys must be unique";
+declare class DuplicateEnvironmentVariableKeyError extends Error {
+  readonly key: string;
+  constructor(key: string);
+}
+declare function createEmptyEnvironmentVariableEntry(): EnvironmentVariableEntry;
+declare function rowsFromEnvironmentVariables(envVars: Record<string, unknown> | undefined): EnvironmentVariableEntry[];
+declare function getDuplicateEnvironmentVariableKeys(rows: readonly EnvironmentVariableEntry[]): Set<string>;
+declare function collectEnvironmentVariables(rows: readonly EnvironmentVariableEntry[]): Record<string, string>;
+declare function parseEnvFileText(text: string): EnvironmentVariableEntry[];
+declare function rowsToEnvFileText(rows: readonly EnvironmentVariableEntry[]): string;
+declare function readEnvFile(file: File, options?: {
+  maxSize?: number;
+}): Promise<{
+  ok: true;
+  entries: EnvironmentVariableEntry[];
+} | {
+  ok: false;
+  error: string;
+}>;
+//#endregion
+export { DUPLICATE_ENVIRONMENT_VARIABLE_MESSAGE, DuplicateEnvironmentVariableKeyError, ENV_FILE_MAX_SIZE, EnvironmentVariableEntry, collectEnvironmentVariables, createEmptyEnvironmentVariableEntry, getDuplicateEnvironmentVariableKeys, parseEnvFileText, readEnvFile, rowsFromEnvironmentVariables, rowsToEnvFileText };