@morscherlab/mint-sdk 1.0.12 → 1.0.14

package/dist/{composables-BWh0MpcK.js → composables-D9mexHSW.js}

@@ -1,8 +1,8 @@
-import { S as resolveCurrentExperimentId, b as currentExperimentFromContext, x as getInjectedPlatformContext } from "./useProtocolTemplates-BJxS5F0_.js";
+import { S as resolveCurrentExperimentId, b as currentExperimentFromContext, x as getInjectedPlatformContext } from "./useProtocolTemplates-DODHlhxr.js";
 import { r as useSettingsStore, t as useAuthStore } from "./auth-D9q2GIcv.js";
 import { i as usePlatformContext } from "./useFormBuilder-COfYWDuC.js";
-import { i as useApi, r as useRequestSyncState } from "./useExperimentSelector-B3hAGvL4.js";
-import { computed, getCurrentInstance, onMounted, onUnmounted, ref, shallowRef, watch } from "vue";
+import { i as useApi, r as useRequestSyncState } from "./useExperimentSelector-BBaz0w51.js";
+import { computed, getCurrentInstance, onMounted, onUnmounted, ref, shallowRef, toValue, watch } from "vue";
 import axios from "axios";
 //#region src/composables/useAuth.ts
 var TOKEN_REFRESH_MARGIN_MS = 300 * 1e3;
@@ -665,6 +665,669 @@ function usePluginConfig(pluginName) {
 	};
 }
 //#endregion
+//#region src/composables/useCommandHistory.ts
+/** Generic command-stack state for plugin editors with undo/redo controls. */
+function useCommandHistory(options = {}) {
+	const maxDepth = Math.max(1, options.maxDepth ?? 50);
+	const undoStack = ref([]);
+	const redoStack = ref([]);
+	const canUndo = computed(() => undoStack.value.length > 0);
+	const canRedo = computed(() => redoStack.value.length > 0);
+	const undoDescription = computed(() => undoStack.value[undoStack.value.length - 1]?.description ?? "");
+	const redoDescription = computed(() => redoStack.value[redoStack.value.length - 1]?.description ?? "");
+	function push(command) {
+		undoStack.value = [...undoStack.value.slice(-(maxDepth - 1)), command];
+		redoStack.value = [];
+	}
+	function execute(command, executeOptions = {}) {
+		if (executeOptions.skipExecute) {
+			push(command);
+			return;
+		}
+		return afterMaybePromise(command.execute(), () => push(command));
+	}
+	function undo() {
+		const command = undoStack.value[undoStack.value.length - 1];
+		if (!command) return;
+		return afterMaybePromise(command.undo(), () => {
+			undoStack.value = undoStack.value.slice(0, -1);
+			redoStack.value = [...redoStack.value, command];
+		});
+	}
+	function redo() {
+		const command = redoStack.value[redoStack.value.length - 1];
+		if (!command) return;
+		return afterMaybePromise((command.redo ?? command.execute)(), () => {
+			redoStack.value = redoStack.value.slice(0, -1);
+			undoStack.value = [...undoStack.value.slice(-(maxDepth - 1)), command];
+		});
+	}
+	function clear() {
+		undoStack.value = [];
+		redoStack.value = [];
+	}
+	return {
+		undoStack,
+		redoStack,
+		canUndo,
+		canRedo,
+		undoDescription,
+		redoDescription,
+		execute,
+		push,
+		undo,
+		redo,
+		clear
+	};
+}
+function afterMaybePromise(result, callback) {
+	if (isPromiseLike(result)) return result.then(callback);
+	callback();
+}
+function isPromiseLike(value) {
+	return !!value && typeof value.then === "function";
+}
+//#endregion
+//#region src/composables/useOptimisticMutation.ts
+/** Run async mutations with optional optimistic local updates and rollback. */
+function useOptimisticMutation(options) {
+	const loading = shallowRef(false);
+	const error = ref(null);
+	const data = ref(null);
+	const lastSnapshot = ref(void 0);
+	const isIdle = computed(() => !loading.value && data.value === null && error.value === null);
+	function clearError() {
+		error.value = null;
+	}
+	function reset() {
+		loading.value = false;
+		error.value = null;
+		data.value = null;
+		lastSnapshot.value = void 0;
+	}
+	async function run(variables) {
+		const snapshot = options.snapshot?.(variables);
+		const context = {
+			variables,
+			snapshot
+		};
+		loading.value = true;
+		error.value = null;
+		lastSnapshot.value = snapshot;
+		options.apply?.(variables, snapshot);
+		try {
+			const result = await options.mutation(variables);
+			data.value = result;
+			options.commit?.(result, context);
+			options.onSuccess?.(result, context);
+			return result;
+		} catch (err) {
+			options.rollback?.(snapshot, variables, err);
+			error.value = options.readErrorMessage?.(err) ?? readErrorMessage$2(err);
+			options.onError?.(err, context);
+			throw err;
+		} finally {
+			loading.value = false;
+			options.onSettled?.(context);
+		}
+	}
+	return {
+		loading,
+		error,
+		data,
+		lastSnapshot,
+		isIdle,
+		run,
+		clearError,
+		reset
+	};
+}
+function readErrorMessage$2(value) {
+	if (value instanceof Error && value.message) return value.message;
+	if (typeof value === "string" && value.trim()) return value;
+	if (typeof value === "object" && value !== null && "message" in value && typeof value.message === "string" && value.message.trim()) return value.message;
+	return "Request failed.";
+}
+//#endregion
+//#region src/composables/useResourceCrud.ts
+/** Common list/create/update/delete state wrapper for generated plugin clients. */
+function useResourceCrud(options) {
+	const items = ref([...options.initialItems ?? []]);
+	const loading = shallowRef(false);
+	const saving = shallowRef(false);
+	const deleting = shallowRef(false);
+	const error = ref(null);
+	const isBusy = computed(() => loading.value || saving.value || deleting.value);
+	const readMessage = options.readErrorMessage ?? readErrorMessage$1;
+	const getKey = options.getKey ?? defaultGetKey;
+	function clearError() {
+		error.value = null;
+	}
+	function setError(err) {
+		error.value = readMessage(err);
+	}
+	function setItems(nextItems) {
+		items.value = [...nextItems];
+	}
+	function upsertLocal(item) {
+		const key = getKey(item);
+		const index = items.value.findIndex((existing) => getKey(existing) === key);
+		if (index === -1) {
+			items.value = [...items.value, item];
+			return;
+		}
+		items.value = [
+			...items.value.slice(0, index),
+			item,
+			...items.value.slice(index + 1)
+		];
+	}
+	function removeLocal(keyOrItem) {
+		const key = resolveKey(keyOrItem, getKey);
+		items.value = items.value.filter((item) => getKey(item) !== key);
+	}
+	async function load() {
+		loading.value = true;
+		clearError();
+		try {
+			const result = await options.adapter.list();
+			setItems(result);
+			return result;
+		} catch (err) {
+			setError(err);
+			throw err;
+		} finally {
+			loading.value = false;
+		}
+	}
+	async function createItem(payload) {
+		if (!options.adapter.create) throw new Error("[MINT SDK] Resource adapter does not implement create().");
+		saving.value = true;
+		clearError();
+		try {
+			const result = await options.adapter.create(payload);
+			upsertLocal(result);
+			return result;
+		} catch (err) {
+			setError(err);
+			throw err;
+		} finally {
+			saving.value = false;
+		}
+	}
+	async function updateItem(key, payload) {
+		if (!options.adapter.update) throw new Error("[MINT SDK] Resource adapter does not implement update().");
+		saving.value = true;
+		clearError();
+		try {
+			const result = await options.adapter.update(key, payload);
+			upsertLocal(result);
+			return result;
+		} catch (err) {
+			setError(err);
+			throw err;
+		} finally {
+			saving.value = false;
+		}
+	}
+	async function deleteItem(keyOrItem) {
+		if (!options.adapter.remove) throw new Error("[MINT SDK] Resource adapter does not implement remove().");
+		const key = resolveKey(keyOrItem, getKey);
+		deleting.value = true;
+		clearError();
+		try {
+			await options.adapter.remove(key);
+			removeLocal(key);
+		} catch (err) {
+			setError(err);
+			throw err;
+		} finally {
+			deleting.value = false;
+		}
+	}
+	return {
+		items,
+		loading,
+		saving,
+		deleting,
+		error,
+		isBusy,
+		load,
+		createItem,
+		updateItem,
+		deleteItem,
+		setItems,
+		upsertLocal,
+		removeLocal,
+		clearError
+	};
+}
+function createPluginResourceClient(options) {
+	return {
+		list: () => options.list(options.client),
+		create: options.create ? (payload) => options.create(options.client, payload) : void 0,
+		update: options.update ? (key, payload) => options.update(options.client, key, payload) : void 0,
+		remove: options.remove ? (key) => options.remove(options.client, key) : void 0
+	};
+}
+function defaultGetKey(item) {
+	if (item && typeof item === "object" && "id" in item) return item.id;
+	throw new Error("[MINT SDK] Resource items need an id field or a getKey option.");
+}
+function resolveKey(keyOrItem, getKey) {
+	if (typeof keyOrItem === "string" || typeof keyOrItem === "number") return keyOrItem;
+	return getKey(keyOrItem);
+}
+function readErrorMessage$1(value) {
+	if (value instanceof Error && value.message) return value.message;
+	if (typeof value === "string" && value.trim()) return value;
+	if (typeof value === "object" && value !== null && "message" in value && typeof value.message === "string" && value.message.trim()) return value.message;
+	return "Request failed.";
+}
+//#endregion
+//#region src/composables/useFileImport.ts
+/** Stateful file reader for plugin import flows with shared validation and error handling. */
+function useFileImport(options = {}) {
+	const loading = shallowRef(false);
+	const error = ref(null);
+	const fileName = ref("");
+	const result = ref(null);
+	function clear() {
+		loading.value = false;
+		error.value = null;
+		fileName.value = "";
+		result.value = null;
+	}
+	async function importFile(file) {
+		loading.value = true;
+		error.value = null;
+		fileName.value = file.name;
+		try {
+			validateImportFile(file, options);
+			const text = await readFileAsText(file, options.encoding);
+			const parsed = options.parse ? await options.parse(text, file) : text;
+			result.value = parsed;
+			return parsed;
+		} catch (err) {
+			error.value = readErrorMessage(err);
+			throw err;
+		} finally {
+			loading.value = false;
+		}
+	}
+	return {
+		loading,
+		error,
+		fileName,
+		result,
+		importFile,
+		clear
+	};
+}
+function validateImportFile(file, options = {}) {
+	if (options.maxSizeBytes !== void 0 && file.size > options.maxSizeBytes) throw new Error(`File is too large. Maximum size is ${formatBytes(options.maxSizeBytes)}.`);
+	const accept = normalizeAccept(options.accept);
+	if (accept.length === 0) return;
+	const name = file.name.toLowerCase();
+	const type = file.type.toLowerCase();
+	if (!accept.some((entry) => {
+		if (entry.startsWith(".")) return name.endsWith(entry);
+		if (entry.endsWith("/*")) return type.startsWith(entry.slice(0, -1));
+		return type === entry;
+	})) throw new Error(`Unsupported file type. Expected ${accept.join(", ")}.`);
+}
+function readFileAsText(file, encoding) {
+	if (typeof FileReader === "undefined" && typeof file.text === "function") return file.text();
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onload = () => resolve(String(reader.result ?? ""));
+		reader.onerror = () => reject(reader.error ?? /* @__PURE__ */ new Error("Failed to read file."));
+		reader.readAsText(file, encoding);
+	});
+}
+function parseDelimitedText(text, options = {}) {
+	const trim = options.trim ?? true;
+	const delimiter = options.delimiter ?? detectDelimiter(text);
+	const rawRows = parseDelimitedRows(text, delimiter).filter((row) => row.some((cell) => cell.trim().length > 0)).map((row) => trim ? row.map((cell) => cell.trim()) : row);
+	const hasHeaderRow = options.hasHeaderRow ?? !options.headers;
+	const columns = options.headers ? [...options.headers] : hasHeaderRow ? rawRows[0] ?? [] : createColumnNames(maxRowLength(rawRows));
+	return {
+		columns,
+		rows: (hasHeaderRow && !options.headers ? rawRows.slice(1) : rawRows).map((row) => Object.fromEntries(columns.map((column, index) => [column, row[index] ?? ""]))),
+		rawRows,
+		delimiter
+	};
+}
+function detectDelimiter(text) {
+	const firstLine = text.split(/\r?\n/, 1)[0] ?? "";
+	const commaCount = countChar(firstLine, ",");
+	const tabCount = countChar(firstLine, "	");
+	const semicolonCount = countChar(firstLine, ";");
+	if (tabCount > commaCount && tabCount >= semicolonCount) return "	";
+	if (semicolonCount > commaCount) return ";";
+	return ",";
+}
+function parseDelimitedRows(text, delimiter) {
+	const rows = [];
+	let row = [];
+	let field = "";
+	let quoted = false;
+	for (let index = 0; index < text.length; index++) {
+		const char = text[index];
+		const next = text[index + 1];
+		if (char === "\"") {
+			if (quoted && next === "\"") {
+				field += "\"";
+				index++;
+			} else quoted = !quoted;
+			continue;
+		}
+		if (!quoted && char === delimiter) {
+			row.push(field);
+			field = "";
+			continue;
+		}
+		if (!quoted && (char === "\n" || char === "\r")) {
+			if (char === "\r" && next === "\n") index++;
+			row.push(field);
+			rows.push(row);
+			row = [];
+			field = "";
+			continue;
+		}
+		field += char;
+	}
+	row.push(field);
+	rows.push(row);
+	return rows;
+}
+function normalizeAccept(accept) {
+	if (!accept) return [];
+	return (typeof accept === "string" ? accept.split(",") : [...accept]).map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+}
+function createColumnNames(count) {
+	return Array.from({ length: count }, (_, index) => `column_${index + 1}`);
+}
+function maxRowLength(rows) {
+	return rows.reduce((max, row) => Math.max(max, row.length), 0);
+}
+function countChar(value, char) {
+	return [...value].filter((candidate) => candidate === char).length;
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+	return `${Math.round(bytes / (1024 * 1024))} MB`;
+}
+function readErrorMessage(value) {
+	if (value instanceof Error && value.message) return value.message;
+	if (typeof value === "string" && value.trim()) return value;
+	return "Failed to import file.";
+}
+//#endregion
+//#region src/composables/useWellPainting.ts
+var ROW_LABELS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var PLATE_DIMENSIONS = {
+	6: {
+		rows: 2,
+		cols: 3
+	},
+	12: {
+		rows: 3,
+		cols: 4
+	},
+	24: {
+		rows: 4,
+		cols: 6
+	},
+	48: {
+		rows: 6,
+		cols: 8
+	},
+	54: {
+		rows: 6,
+		cols: 9
+	},
+	96: {
+		rows: 8,
+		cols: 12
+	},
+	384: {
+		rows: 16,
+		cols: 24
+	}
+};
+/** Pointer painting/rectangle selection state for WellPlate-based editors. */
+function useWellPainting(options) {
+	const activeMode = ref(options.initialMode ?? "select");
+	const activePayload = ref(options.initialPayload);
+	const isDragging = ref(false);
+	const dragStart = ref(null);
+	const dragEnd = ref(null);
+	const paintTrail = ref(/* @__PURE__ */ new Set());
+	const previewWellIds = computed(() => {
+		if (!isDragging.value) return [];
+		if (activeMode.value === "select") {
+			if (!dragStart.value || !dragEnd.value) return [];
+			return wellIdsInRectangle(dragStart.value, dragEnd.value, toValue(options.format));
+		}
+		return [...paintTrail.value];
+	});
+	function setMode(mode, payload) {
+		activeMode.value = mode;
+		activePayload.value = payload;
+	}
+	function setPayload(payload) {
+		activePayload.value = payload;
+	}
+	function onWellMouseDown(wellId) {
+		const coord = wellIdToCoordinate(wellId);
+		if (!coord) return;
+		isDragging.value = true;
+		dragStart.value = coord;
+		dragEnd.value = coord;
+		paintTrail.value = new Set([wellId]);
+	}
+	function onWellMouseMove(wellId) {
+		if (!isDragging.value) return;
+		const coord = wellIdToCoordinate(wellId);
+		if (!coord) return;
+		dragEnd.value = coord;
+		if (activeMode.value !== "select") paintTrail.value = new Set([...paintTrail.value, wellId]);
+	}
+	function onWellMouseUp() {
+		if (!isDragging.value) return;
+		const wellIds = previewWellIds.value;
+		isDragging.value = false;
+		if (wellIds.length > 0) options.onComplete?.({
+			wellIds,
+			mode: activeMode.value,
+			payload: activePayload.value
+		});
+		clearDragState();
+	}
+	function cancel() {
+		isDragging.value = false;
+		clearDragState();
+	}
+	function clearDragState() {
+		dragStart.value = null;
+		dragEnd.value = null;
+		paintTrail.value = /* @__PURE__ */ new Set();
+	}
+	return {
+		activeMode,
+		activePayload,
+		isDragging,
+		previewWellIds,
+		setMode,
+		setPayload,
+		onWellMouseDown,
+		onWellMouseMove,
+		onWellMouseUp,
+		cancel
+	};
+}
+function wellIdToCoordinate(wellId) {
+	const match = /^([A-Z]+)(\d+)$/i.exec(wellId.trim());
+	if (!match) return null;
+	return {
+		row: rowLabelToIndex$1(match[1].toUpperCase()),
+		col: Number(match[2]) - 1
+	};
+}
+function coordinateToWellId(coord) {
+	return `${indexToRowLabel$1(coord.row)}${coord.col + 1}`;
+}
+function wellIdsInRectangle(start, end, format) {
+	const dimensions = PLATE_DIMENSIONS[format];
+	const minRow = Math.max(0, Math.min(start.row, end.row));
+	const maxRow = Math.min(dimensions.rows - 1, Math.max(start.row, end.row));
+	const minCol = Math.max(0, Math.min(start.col, end.col));
+	const maxCol = Math.min(dimensions.cols - 1, Math.max(start.col, end.col));
+	const ids = [];
+	for (let row = minRow; row <= maxRow; row++) for (let col = minCol; col <= maxCol; col++) ids.push(coordinateToWellId({
+		row,
+		col
+	}));
+	return ids;
+}
+function rowLabelToIndex$1(label) {
+	let result = 0;
+	for (const char of label) result = result * 26 + (char.charCodeAt(0) - 64);
+	return result - 1;
+}
+function indexToRowLabel$1(index) {
+	if (index < 26) return ROW_LABELS[index];
+	let value = index + 1;
+	let label = "";
+	while (value > 0) {
+		value--;
+		label = ROW_LABELS[value % 26] + label;
+		value = Math.floor(value / 26);
+	}
+	return label;
+}
+//#endregion
+//#region src/composables/useWellPlateAdapter.ts
+/** Convert domain rows into WellPlate's wells prop without hand-written adapters. */
+function useWellPlateAdapter(options) {
+	return { wells: computed(() => createWellPlateWells(toValue(options.entries), options)) };
+}
+function createWellPlateWells(entries, options) {
+	return Object.fromEntries(entries.map((entry) => {
+		const wellId = options.getWellId(entry);
+		const coord = parseWellId(wellId);
+		return [wellId, {
+			id: wellId,
+			row: coord.row,
+			col: coord.col,
+			state: options.getState?.(entry) ?? "filled",
+			sampleType: options.getSampleType?.(entry),
+			value: options.getValue?.(entry),
+			metadata: options.getMetadata?.(entry)
+		}];
+	}));
+}
+function createColumnConditions(entries) {
+	return entries.map((entry) => {
+		const startCol = typeof entry.start === "number" ? entry.start : Number.parseInt(entry.start, 10);
+		const cols = [];
+		const concentrations = [];
+		for (const concentration of entry.concentrations) {
+			const replicates = concentration.replicates ?? 1;
+			for (let index = 0; index < replicates; index++) {
+				cols.push(startCol + cols.length);
+				concentrations.push(concentration.value);
+			}
+		}
+		return {
+			label: entry.label,
+			color: entry.color,
+			unit: entry.unit,
+			cols,
+			concentrations
+		};
+	});
+}
+function createRowConditions(entries) {
+	return entries.map((entry) => {
+		const startRow = typeof entry.start === "number" ? entry.start : rowLabelToIndex(entry.start);
+		const rows = [];
+		const concentrations = [];
+		for (const concentration of entry.concentrations) {
+			const replicates = concentration.replicates ?? 1;
+			for (let index = 0; index < replicates; index++) {
+				rows.push(indexToRowLabel(startRow + rows.length));
+				concentrations.push(concentration.value);
+			}
+		}
+		return {
+			label: entry.label,
+			color: entry.color,
+			unit: entry.unit,
+			rows,
+			concentrations
+		};
+	});
+}
+function parseWellId(wellId) {
+	const match = /^([A-Z]+)(\d+)$/i.exec(wellId.trim());
+	if (!match) throw new Error(`[MINT SDK] Invalid well id "${wellId}".`);
+	return {
+		row: rowLabelToIndex(match[1].toUpperCase()),
+		col: Number(match[2]) - 1
+	};
+}
+function rowLabelToIndex(label) {
+	let result = 0;
+	for (const char of label.toUpperCase()) result = result * 26 + (char.charCodeAt(0) - 64);
+	return result - 1;
+}
+function indexToRowLabel(index) {
+	let value = index + 1;
+	let label = "";
+	while (value > 0) {
+		value--;
+		label = String.fromCharCode(65 + value % 26) + label;
+		value = Math.floor(value / 26);
+	}
+	return label;
+}
+//#endregion
+//#region src/composables/useWellPlateValidation.ts
+/** Rule-driven validation state for WellPlate layout/design screens. */
+function useWellPlateValidation(options) {
+	const warnings = computed(() => runWellPlateValidation(toValue(options.context), toValue(options.rules)));
+	return {
+		warnings,
+		hasBlockingIssues: computed(() => warnings.value.some((warning) => warning.severity === "error")),
+		warningCount: computed(() => warnings.value.length),
+		errorCount: computed(() => warnings.value.filter((warning) => warning.severity === "error").length)
+	};
+}
+function runWellPlateValidation(context, rules) {
+	const warnings = [];
+	for (const rule of rules) {
+		const result = rule.validate(context);
+		if (!result) continue;
+		warnings.push(normalizeWarning(rule, result));
+	}
+	return warnings;
+}
+function normalizeWarning(rule, result) {
+	if (typeof result === "string") return {
+		type: rule.type,
+		severity: rule.severity,
+		message: result
+	};
+	return {
+		type: rule.type,
+		severity: rule.severity,
+		...result
+	};
+}
+//#endregion
 //#region src/composables/pluginEndpointBuilder.ts
 function normalizeApiBaseUrl(baseUrl) {
 	if (!baseUrl) return void 0;
@@ -987,6 +1650,6 @@ function useCurrentExperiment(options = {}) {
 	};
 }
 //#endregion
-export { pluginFormDataFromPayload as a, usePluginClient as c, resolvePluginBaseUrl as d, usePluginConfig as f, useAuth as g, usePasskey as h, getPluginPageSelectorItems as i, usePluginSettings as l, useAsyncBatch as m, downloadBlob as n, uploadPluginEndpoint as o, useAsync as p, downloadPluginEndpoint as r, useCurrentExperiment as s, createPluginClient as t, buildPluginEndpointUrl as u };
+export { useCommandHistory as A, parseDelimitedText as C, createPluginResourceClient as D, validateImportFile as E, useAuth as F, useAsync as M, useAsyncBatch as N, useResourceCrud as O, usePasskey as P, detectDelimiter as S, useFileImport as T, useWellPlateAdapter as _, pluginFormDataFromPayload as a, wellIdToCoordinate as b, usePluginClient as c, resolvePluginBaseUrl as d, runWellPlateValidation as f, createWellPlateWells as g, createRowConditions as h, getPluginPageSelectorItems as i, usePluginConfig as j, useOptimisticMutation as k, usePluginSettings as l, createColumnConditions as m, downloadBlob as n, uploadPluginEndpoint as o, useWellPlateValidation as p, downloadPluginEndpoint as r, useCurrentExperiment as s, createPluginClient as t, buildPluginEndpointUrl as u, coordinateToWellId as v, readFileAsText as w, wellIdsInRectangle as x, useWellPainting as y };
 
-//# sourceMappingURL=composables-BWh0MpcK.js.map
+//# sourceMappingURL=composables-D9mexHSW.js.map