@morscherlab/mint-sdk 1.2.10 → 1.3.0-beta.10

package/dist/composables-D6uqp0UF.js

@@ -0,0 +1,591 @@
+import { ar as getInjectedPlatformContext } from "./templates-BU1pet28.js";
+import { n as pickerFormat, st as useRequestSyncState } from "./validation-Dmp9Q5W0.js";
+import { a as useApi } from "./experiment-DgllIc3I.js";
+import { computed, getCurrentScope, onBeforeUnmount, onScopeDispose, ref, shallowRef, toValue, watch } from "vue";
+//#region src/composables/pluginFrontendBase.ts
+function normalizePluginRoutePrefix(prefix) {
+	const candidate = prefix?.trim();
+	if (!candidate) return void 0;
+	const path = candidate.split("/").filter(Boolean).join("/");
+	return path ? `/${path}/` : "/";
+}
+/**
+* Resolve the Vue Router base for a plugin frontend.
+*
+* Integrated plugins use the platform-injected mount prefix. Standalone and
+* development builds retain the caller's Vite base unchanged.
+*/
+function resolvePluginFrontendBase(fallbackBase = "/") {
+	const context = getInjectedPlatformContext();
+	if (!context?.isIntegrated) return fallbackBase;
+	return normalizePluginRoutePrefix(context.plugin?.route_prefix) ?? fallbackBase;
+}
+//#endregion
+//#region src/composables/useManualLayoutResize.ts
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function availablePanelWidth(containerWidth, constraints) {
+	return Math.min(constraints.maxWidth, containerWidth - (constraints.mainMinWidth ?? 0) - (constraints.layoutGap ?? 0));
+}
+function resizedLeadingPanelWidth(startWidth, deltaX, containerWidth, constraints) {
+	return Math.round(clamp(startWidth + deltaX, constraints.minWidth, Math.max(constraints.minWidth, availablePanelWidth(containerWidth, constraints))));
+}
+function resizedTrailingPanelWidth(startWidth, deltaX, containerWidth, constraints) {
+	return resizedLeadingPanelWidth(startWidth, -deltaX, containerWidth, constraints);
+}
+function resizedVerticalSplitPercent(startPercent, deltaY, containerHeight, constraints) {
+	if (containerHeight <= 0) return startPercent;
+	return Math.round(clamp(startPercent + deltaY / containerHeight * 100, constraints.minPercent, constraints.maxPercent));
+}
+/** Coordinates pointer-driven resizing for one or more layout splitters. */
+function useManualLayoutResize(options) {
+	const activeResize = shallowRef(null);
+	const isResizing = computed(() => activeResize.value !== null);
+	let previousBodyCursor = "";
+	let previousBodyUserSelect = "";
+	function stopResize() {
+		if (!activeResize.value) return;
+		activeResize.value = null;
+		window.removeEventListener("pointermove", handlePointerMove);
+		window.removeEventListener("pointerup", stopResize);
+		window.removeEventListener("pointercancel", stopResize);
+		if (typeof document !== "undefined") {
+			document.body.style.cursor = previousBodyCursor;
+			document.body.style.userSelect = previousBodyUserSelect;
+		}
+	}
+	function handlePointerMove(event) {
+		const state = activeResize.value;
+		if (!state) return;
+		options.resolveTarget(state.kind)?.onResize({
+			kind: state.kind,
+			startValue: state.startValue,
+			deltaX: event.clientX - state.startClientX,
+			deltaY: event.clientY - state.startClientY,
+			containerRect: state.containerRect,
+			secondaryRect: state.secondaryRect
+		});
+	}
+	function startResize(kind, event) {
+		if (!toValue(options.enabled) || event.button !== 0) return;
+		const target = options.resolveTarget(kind);
+		const containerRect = target?.getContainerElement()?.getBoundingClientRect();
+		if (!target || !containerRect) return;
+		event.preventDefault();
+		if (event.currentTarget instanceof HTMLElement) event.currentTarget.setPointerCapture(event.pointerId);
+		const secondary = target.getSecondaryElement?.() ?? null;
+		activeResize.value = {
+			kind,
+			startClientX: event.clientX,
+			startClientY: event.clientY,
+			startValue: target.getStartValue(),
+			containerRect,
+			secondaryRect: secondary?.getBoundingClientRect() ?? null,
+			cursor: target.cursor ?? "col-resize"
+		};
+		if (typeof document !== "undefined") {
+			previousBodyCursor = document.body.style.cursor;
+			previousBodyUserSelect = document.body.style.userSelect;
+			document.body.style.cursor = activeResize.value.cursor;
+			document.body.style.userSelect = "none";
+		}
+		window.addEventListener("pointermove", handlePointerMove);
+		window.addEventListener("pointerup", stopResize);
+		window.addEventListener("pointercancel", stopResize);
+	}
+	function isResizingKind(kind) {
+		return activeResize.value?.kind === kind;
+	}
+	watch(() => toValue(options.enabled), (enabled) => {
+		if (!enabled) stopResize();
+	});
+	onBeforeUnmount(stopResize);
+	return {
+		activeResize,
+		isResizing,
+		isResizingKind,
+		startResize,
+		stopResize
+	};
+}
+//#endregion
+//#region src/composables/useFileBrowser.ts
+/**
+* Browses the platform's `/api/filesystem` routes for a custom file UI. For the
+* ready-made dialog, use `FilePicker` with `usePlatformFilePickerAdapter()`.
+*
+* Requires the `filesystem.browse` permission and a deployment that declares
+* mounts; with none configured the routes are absent and `mounts` stays empty.
+*/
+function useFileBrowser(options = {}) {
+	const injectedContext = getInjectedPlatformContext();
+	const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl });
+	const sync = useRequestSyncState("Could not read the server mounts.");
+	const mounts = ref([]);
+	const mountId = shallowRef("");
+	const path = shallowRef("");
+	const parent = ref(null);
+	const entries = ref([]);
+	const breadcrumbs = ref([]);
+	const totalCount = ref(null);
+	const matchCount = ref(null);
+	const shownCount = ref(null);
+	const truncated = ref(false);
+	const search = shallowRef("");
+	const sort = shallowRef("name");
+	const selected = ref([]);
+	const mountsLoading = shallowRef(false);
+	const listingLoading = shallowRef(false);
+	const listingReady = shallowRef(false);
+	const isLoading = computed(() => mountsLoading.value || listingLoading.value);
+	let listToken = 0;
+	let mountsToken = 0;
+	let disposed = false;
+	let listingController;
+	let mountsController;
+	let searchTimer;
+	function resetListing() {
+		listingReady.value = false;
+		entries.value = [];
+		breadcrumbs.value = [];
+		parent.value = null;
+		totalCount.value = null;
+		matchCount.value = null;
+		shownCount.value = null;
+		truncated.value = false;
+	}
+	function typeRuleParams() {
+		return (toValue(options.typeRules) ?? []).map((rule) => `&type_rules=${encodeURIComponent(rule)}`).join("");
+	}
+	/** Prefer the API's own `detail` over axios's "Request failed with status N". */
+	function describe(cause, fallback) {
+		const detail = cause?.response?.data?.detail;
+		return typeof detail === "string" && detail ? detail : sync.readErrorMessage(cause, fallback);
+	}
+	function fail(cause, fallback) {
+		sync.setError(new Error(describe(cause, fallback)), fallback);
+	}
+	function statusOf(cause) {
+		return cause?.response?.status;
+	}
+	async function loadMounts() {
+		const token = ++mountsToken;
+		mountsController?.abort();
+		mountsController = new AbortController();
+		mountsLoading.value = true;
+		try {
+			const data = await api.get("/filesystem/mounts", { signal: mountsController.signal });
+			if (disposed || token !== mountsToken) return false;
+			mounts.value = data.mounts ?? [];
+			sync.clearError();
+			sync.markLoaded();
+			return true;
+		} catch (cause) {
+			if (disposed || token !== mountsToken) return false;
+			if (statusOf(cause) === 404) {
+				mounts.value = [];
+				sync.clearError();
+				sync.markLoaded();
+				return true;
+			}
+			mounts.value = [];
+			fail(cause, "Could not read the server mounts.");
+			return false;
+		} finally {
+			if (token === mountsToken) mountsLoading.value = false;
+		}
+	}
+	async function navigate(location, refresh = false) {
+		if (disposed || !location.mount_id) return;
+		clearTimeout(searchTimer);
+		const token = ++listToken;
+		listingController?.abort();
+		listingController = new AbortController();
+		listingLoading.value = true;
+		mountId.value = location.mount_id;
+		path.value = location.path;
+		resetListing();
+		sync.clearError();
+		try {
+			const query = `mount_id=${encodeURIComponent(location.mount_id)}&path=${encodeURIComponent(location.path)}&sort=${sort.value}` + (refresh ? "&refresh=true" : "") + (search.value ? `&search=${encodeURIComponent(search.value)}` : "") + typeRuleParams();
+			const listing = await api.get(`/filesystem/browse?${query}`, { signal: listingController.signal });
+			if (disposed || token !== listToken) return;
+			mountId.value = listing.mount_id;
+			path.value = listing.path;
+			parent.value = listing.parent ?? null;
+			entries.value = listing.entries ?? [];
+			breadcrumbs.value = listing.breadcrumbs ?? [];
+			totalCount.value = listing.total_count ?? null;
+			matchCount.value = listing.match_count ?? null;
+			shownCount.value = listing.shown_count ?? listing.entries?.length ?? null;
+			truncated.value = listing.truncated ?? false;
+			listingReady.value = true;
+			sync.clearError();
+			sync.markLoaded();
+		} catch (cause) {
+			if (disposed || token !== listToken) return;
+			entries.value = [];
+			fail(cause, "Could not read that folder.");
+		} finally {
+			if (token === listToken) listingLoading.value = false;
+		}
+	}
+	async function init() {
+		if (disposed) return;
+		const navigationToken = listToken;
+		if (!await loadMounts() || disposed || navigationToken !== listToken) return;
+		const preferred = toValue(options.initialMountId);
+		const reachable = (mount) => mount.available !== false;
+		const target = mounts.value.find((mount) => mount.id === preferred && reachable(mount)) ?? mounts.value.find(reachable);
+		if (target) await navigate({
+			mount_id: target.id,
+			path: ""
+		});
+		else {
+			mountId.value = "";
+			path.value = "";
+			resetListing();
+		}
+	}
+	async function refresh() {
+		if (disposed) return;
+		if (mountId.value) await navigate({
+			mount_id: mountId.value,
+			path: path.value
+		}, true);
+		else await init();
+	}
+	function selectCurrentFolder() {
+		if (!mountId.value || !listingReady.value || isLoading.value || sync.error.value) return;
+		const crumb = breadcrumbs.value[breadcrumbs.value.length - 1];
+		const key = JSON.stringify([mountId.value, path.value]);
+		if (selected.value.some((item) => JSON.stringify([item.mount_id, item.path]) === key)) return;
+		selected.value = [...selected.value, {
+			mount_id: mountId.value,
+			path: path.value,
+			name: crumb?.label ?? path.value,
+			kind: "directory",
+			child_count: totalCount.value
+		}];
+	}
+	function clear() {
+		selected.value = [];
+	}
+	watch(search, () => {
+		if (!mountId.value) return;
+		clearTimeout(searchTimer);
+		searchTimer = setTimeout(() => {
+			navigate({
+				mount_id: mountId.value,
+				path: path.value
+			});
+		}, 250);
+	});
+	watch(sort, () => {
+		if (mountId.value) navigate({
+			mount_id: mountId.value,
+			path: path.value
+		});
+	});
+	watch(() => toValue(options.typeRules), () => {
+		if (mountId.value) navigate({
+			mount_id: mountId.value,
+			path: path.value
+		});
+	}, { deep: true });
+	if (getCurrentScope()) onScopeDispose(() => {
+		disposed = true;
+		++listToken;
+		++mountsToken;
+		clearTimeout(searchTimer);
+		listingController?.abort();
+		mountsController?.abort();
+	});
+	return {
+		mounts,
+		mountId,
+		path,
+		parent,
+		entries,
+		breadcrumbs,
+		totalCount,
+		matchCount,
+		shownCount,
+		truncated,
+		search,
+		sort,
+		selected,
+		isLoading,
+		error: sync.error,
+		init,
+		navigate,
+		refresh,
+		selectCurrentFolder,
+		clear
+	};
+}
+//#endregion
+//#region src/composables/analysisArtifactTarget.ts
+var EXPERIMENT_ID = "experiment_id";
+var ARTIFACT_PLUGIN_ID = "artifact_plugin_id";
+var ARTIFACT_KEY = "artifact_key";
+var ARTIFACT_ID = "artifact_id";
+function parsePositiveInteger(value) {
+	if (value === null || !/^\d+$/.test(value)) return void 0;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+/** Build the canonical query used to open one analysis artifact in a plugin. */
+function buildAnalysisArtifactTargetQuery(target) {
+	const query = new URLSearchParams();
+	query.set(EXPERIMENT_ID, String(target.experimentId));
+	query.set(ARTIFACT_PLUGIN_ID, target.artifactPluginId);
+	query.set(ARTIFACT_KEY, target.artifactKey);
+	if (target.artifactId !== void 0) query.set(ARTIFACT_ID, String(target.artifactId));
+	return query;
+}
+/** Parse a complete canonical target. Incomplete or invalid input is not guessed. */
+function parseAnalysisArtifactTarget(query) {
+	const experimentId = parsePositiveInteger(query.get(EXPERIMENT_ID));
+	const artifactPluginId = query.get(ARTIFACT_PLUGIN_ID)?.trim();
+	const artifactKey = query.get(ARTIFACT_KEY)?.trim();
+	const rawArtifactId = query.get(ARTIFACT_ID);
+	const artifactId = parsePositiveInteger(rawArtifactId);
+	if (experimentId === void 0 || !artifactPluginId || !artifactKey || rawArtifactId !== null && artifactId === void 0) return null;
+	return {
+		experimentId,
+		artifactPluginId,
+		artifactKey,
+		...artifactId === void 0 ? {} : { artifactId }
+	};
+}
+//#endregion
+//#region src/composables/createFilePickerAdapter.ts
+/** Opaque picker identity; decode before passing a selection to a mount-scoped API. */
+function encodePlatformPickerPath(mountId, path = "") {
+	return JSON.stringify([mountId, path]);
+}
+function decodePlatformPickerPath(path) {
+	const decoded = JSON.parse(path);
+	if (!Array.isArray(decoded) || decoded.length !== 2 || !decoded.every((item) => typeof item === "string") || !decoded[0]) throw new Error("Invalid platform picker path.");
+	return {
+		mountId: decoded[0],
+		path: decoded[1]
+	};
+}
+function isRelativePath(path) {
+	return path === "" || !/^[a-z]:/i.test(path) && !/[\\\x00-\x1f\x7f]/.test(path) && path.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+/** Mount browsing and search shared by platform and generated plugin clients. */
+function createFilePickerAdapter(transport, options = {}) {
+	const root = options.rootLocation && { ...options.rootLocation };
+	const mountLabels = /* @__PURE__ */ new Map();
+	const listings = /* @__PURE__ */ new Map();
+	let generation = 0;
+	function invalidate() {
+		generation++;
+		listings.clear();
+		mountLabels.clear();
+	}
+	function validateLocation(location) {
+		if (!location.mount_id || !isRelativePath(location.path) || root && (location.mount_id !== root.mount_id || root.path !== "" && location.path !== root.path && !location.path.startsWith(`${root.path}/`))) throw new Error("Invalid file picker location.");
+	}
+	if (root) validateLocation(root);
+	function begin(request) {
+		request?.signal?.throwIfAborted();
+		if (request?.refresh) invalidate();
+		return generation;
+	}
+	function check(request, token) {
+		request?.signal?.throwIfAborted();
+		if (token !== generation) throw new DOMException("Cancelled", "AbortError");
+	}
+	async function read(path, request, token) {
+		check(request, token);
+		const decoded = path ? decodePlatformPickerPath(path) : void 0;
+		const location = decoded ? {
+			mount_id: decoded.mountId,
+			path: decoded.path
+		} : root;
+		if (location) validateLocation(location);
+		const key = location ? encodePlatformPickerPath(location.mount_id, location.path) : "";
+		const cached = listings.get(key);
+		if (cached) return cached;
+		let nodes;
+		if (!location) {
+			const mounts = await transport.listMounts(request);
+			check(request, token);
+			nodes = mounts.map((mount) => {
+				mountLabels.set(mount.id, mount.label);
+				return {
+					kind: "folder",
+					path: encodePlatformPickerPath(mount.id),
+					name: mount.label,
+					parentPath: null,
+					parentName: "Server mounts",
+					unavailableReason: mount.available === false ? "This mount is offline." : void 0
+				};
+			});
+		} else if (transport.tree) {
+			const tree = await transport.tree(location, request);
+			check(request, token);
+			for (const listing of tree.listings ?? []) {
+				const at = {
+					mount_id: listing.mount_id,
+					path: listing.path
+				};
+				validateLocation(at);
+				if (at.mount_id !== location.mount_id) throw new Error("Invalid file picker directory entry.");
+				if (!listing.truncated) listings.set(encodePlatformPickerPath(at.mount_id, at.path), toNodes(at, listing));
+			}
+			const cached = listings.get(key);
+			if (!cached) throw new Error("This directory exceeds the server listing limit. Choose a smaller data directory.");
+			return cached;
+		} else {
+			const listing = await transport.browse(location, request);
+			check(request, token);
+			if (listing.truncated) throw new Error("This directory exceeds the server listing limit. Choose a smaller data directory.");
+			nodes = toNodes(location, listing);
+		}
+		listings.set(key, nodes);
+		return nodes;
+	}
+	function toNodes(location, listing) {
+		return (listing.entries ?? []).map((entry) => {
+			if (entry.path !== `${location.path ? `${location.path}/` : ""}${entry.name}`) throw new Error("Invalid file picker directory entry.");
+			return toNode(location.mount_id, entry);
+		});
+	}
+	/** One entry, parented on the folder its mount-relative path names. */
+	function toNode(mountId, entry) {
+		if (!isRelativePath(entry.path) || !entry.name || entry.name.includes("/") || entry.path !== entry.name && !entry.path.endsWith(`/${entry.name}`)) throw new Error("Invalid file picker directory entry.");
+		const parent = entry.path.slice(0, Math.max(0, entry.path.length - entry.name.length - 1));
+		const atRoot = root && mountId === root.mount_id && parent === root.path;
+		const common = {
+			path: encodePlatformPickerPath(mountId, entry.path),
+			parentPath: atRoot ? null : encodePlatformPickerPath(mountId, parent),
+			parentName: `${mountLabels.get(mountId) ?? mountId}${parent ? ` / ${parent}` : ""}`,
+			name: entry.name,
+			bytes: entry.size_bytes,
+			modifiedAt: entry.modified_at
+		};
+		return entry.kind === "directory" ? {
+			...common,
+			kind: "folder"
+		} : {
+			...common,
+			kind: "file",
+			format: pickerFormat(entry.name)
+		};
+	}
+	async function serverSearch(query, scope, request) {
+		const token = begin(request);
+		const decoded = scope.path ? decodePlatformPickerPath(scope.path) : void 0;
+		const location = decoded ? {
+			mount_id: decoded.mountId,
+			path: decoded.path
+		} : root;
+		validateLocation(location);
+		const result = await transport.search(location, query, scope.recursive, request);
+		check(request, token);
+		const prefix = location.path ? `${location.path}/` : "";
+		const nodes = (result.entries ?? []).map((entry) => {
+			if (!entry.path.startsWith(prefix) || !scope.recursive && entry.path.slice(prefix.length).includes("/")) throw new Error("Invalid file picker directory entry.");
+			return toNode(location.mount_id, entry);
+		});
+		return result.truncated ? {
+			nodes,
+			truncated: true
+		} : nodes;
+	}
+	return {
+		mounts: !root,
+		mountOf(path) {
+			try {
+				return encodePlatformPickerPath(decodePlatformPickerPath(path).mountId);
+			} catch {
+				return;
+			}
+		},
+		invalidate,
+		listRoot: async (request) => read("", request, begin(request)),
+		listChildren: async (path, request) => read(path, request, begin(request)),
+		async search(query, scope, request) {
+			if (transport.search && (scope.path || root)) return serverSearch(query, scope, request);
+			const token = begin(request);
+			const matches = [];
+			const queue = [scope.path];
+			const visited = /* @__PURE__ */ new Set();
+			const needle = query.toLowerCase();
+			let currentRequest = request;
+			while (queue.length) {
+				check(request, token);
+				const path = queue.shift();
+				if (visited.has(path)) continue;
+				visited.add(path);
+				if (visited.size > 500) return {
+					nodes: matches,
+					truncated: true
+				};
+				const nodes = await read(path, currentRequest, token);
+				check(request, token);
+				if (currentRequest?.refresh) {
+					currentRequest = { ...currentRequest };
+					delete currentRequest.refresh;
+				}
+				for (const node of nodes) {
+					if (node.name.toLowerCase().includes(needle)) matches.push(node);
+					if (scope.recursive && node.kind === "folder" && !node.unavailableReason) queue.push(node.path);
+				}
+				if (matches.length > 1e4) return {
+					nodes: matches.slice(0, 1e4),
+					truncated: true
+				};
+			}
+			return matches;
+		}
+	};
+}
+//#endregion
+//#region src/composables/usePlatformFilePickerAdapter.ts
+function query(location, request) {
+	const params = new URLSearchParams({
+		mount_id: location.mount_id,
+		path: location.path
+	});
+	if (request?.refresh) params.set("refresh", "true");
+	return params;
+}
+/** Adapt the authenticated MINT mount API without exposing absolute host paths. */
+function usePlatformFilePickerAdapter(options = {}) {
+	const api = useApi({ baseUrl: options.apiBaseUrl ?? getInjectedPlatformContext()?.platformApiUrl });
+	return createFilePickerAdapter({
+		async listMounts(request) {
+			try {
+				const url = `/filesystem/mounts${request?.refresh ? "?refresh=true" : ""}`;
+				const { mounts } = await api.get(url, { signal: request?.signal });
+				return mounts;
+			} catch (cause) {
+				if (cause.response?.status === 404) return [];
+				throw cause;
+			}
+		},
+		browse(location, request) {
+			return api.get(`/filesystem/browse?${query(location, request)}`, { signal: request?.signal });
+		},
+		tree(location, request) {
+			return api.get(`/filesystem/tree?${query(location, request)}`, { signal: request?.signal });
+		},
+		search(location, text, recursive, request) {
+			const params = query(location, request);
+			params.set("q", text);
+			params.set("recursive", String(recursive));
+			return api.get(`/filesystem/search?${params}`, { signal: request?.signal });
+		}
+	}, options);
+}
+//#endregion
+export { buildAnalysisArtifactTargetQuery as a, resizedLeadingPanelWidth as c, useManualLayoutResize as d, resolvePluginFrontendBase as f, encodePlatformPickerPath as i, resizedTrailingPanelWidth as l, createFilePickerAdapter as n, parseAnalysisArtifactTarget as o, decodePlatformPickerPath as r, useFileBrowser as s, usePlatformFilePickerAdapter as t, resizedVerticalSplitPercent as u };
+
+//# sourceMappingURL=composables-D6uqp0UF.js.map