@morscherlab/mint-sdk 1.1.8 → 1.1.10

package/dist/types/platform.d.ts

@@ -3,6 +3,7 @@ export interface PluginInfo {
     id: string;
     name: string;
     version: string;
+    plugin_type?: string;
     description?: string;
     icon?: string;
     color?: string;

package/dist/{useProtocolTemplates-BMt0LlXf.js → useProtocolTemplates-D3IZKLqr.js}

@@ -1657,6 +1657,19 @@ function composeGroups(input) {
 	const excludedSamples = [];
 	const metadata = [];
 	let colorIdx = 0;
+	const experimentalClasses = input.classes.filter((c) => c.disposition === "group" && input.schemas[classKey(c)]);
+	const classPrefix = /* @__PURE__ */ new Map();
+	if (input.prefixClassLabels !== false && experimentalClasses.length > 1) {
+		const shortCounts = /* @__PURE__ */ new Map();
+		for (const c of experimentalClasses) {
+			const short = c.subKind ?? c.label;
+			shortCounts.set(short, (shortCounts.get(short) ?? 0) + 1);
+		}
+		for (const c of experimentalClasses) {
+			const short = c.subKind ?? c.label;
+			classPrefix.set(c, (shortCounts.get(short) ?? 0) > 1 ? c.label : short);
+		}
+	}
 	const PATH_SEP = String.fromCharCode(1);
 	const groupTree = [];
 	const treeIndex = /* @__PURE__ */ new Map();
@@ -1696,8 +1709,8 @@ function composeGroups(input) {
 				return fieldValues[col.displayName ?? col.name];
 			}) : [cls.label];
 			const hasMissingGroupPart = input.missingGroupName && cls.disposition === "group" && keyParts.some((part) => part.trim().length === 0);
-			const useClassPrefix = input.prefixClassLabels !== false && cls.disposition === "group" && cls.kind !== "unknown" && keyParts.length > 0;
-			const groupKey = hasMissingGroupPart ? input.missingGroupName : useClassPrefix ? `${cls.label} / ${keyParts.join(" / ")}` : keyParts.length > 0 ? keyParts.join(" / ") : cls.label;
+			const prefix = cls.kind !== "unknown" && keyParts.length > 0 ? classPrefix.get(cls) : void 0;
+			const groupKey = hasMissingGroupPart ? input.missingGroupName : prefix ? `${prefix} / ${keyParts.join(" / ")}` : keyParts.length > 0 ? keyParts.join(" / ") : cls.label;
 			const bucket = groupMap.get(groupKey);
 			if (bucket) bucket.samples.push(rowName);
 			else groupMap.set(groupKey, {
@@ -2357,17 +2370,108 @@ function useAutoGroup() {
 	function toggleGroupBy(key, idx) {
 		const schema = schemas.value[key];
 		if (!schema) return;
-		const set = new Set(schema.groupBy);
-		if (set.has(idx)) set.delete(idx);
-		else set.add(idx);
+		const groupBy = schema.groupBy.includes(idx) ? schema.groupBy.filter((i) => i !== idx) : [...schema.groupBy, idx];
 		schemas.value = {
 			...schemas.value,
 			[key]: {
 				...schema,
-				groupBy: [...set].sort((a, b) => a - b)
+				groupBy
 			}
 		};
 	}
+	/** Move an enabled column one step up (toward layer 1) or down in the layer order. */
+	function moveGroupBy(key, idx, direction) {
+		const schema = schemas.value[key];
+		if (!schema) return;
+		const from = schema.groupBy.indexOf(idx);
+		if (from === -1) return;
+		const to = direction === "up" ? from - 1 : from + 1;
+		if (to < 0 || to >= schema.groupBy.length) return;
+		const groupBy = [...schema.groupBy];
+		[groupBy[from], groupBy[to]] = [groupBy[to], groupBy[from]];
+		schemas.value = {
+			...schemas.value,
+			[key]: {
+				...schema,
+				groupBy
+			}
+		};
+	}
+	function schemasExposing(fieldKey) {
+		return Object.entries(schemas.value).flatMap(([key, schema]) => {
+			const col = schema.columns.find((c) => (c.displayName ?? c.name) === fieldKey && (c.role === "factor" || c.role === "replicate" || schema.groupBy.includes(c.index)));
+			return col ? [{
+				key,
+				index: col.index
+			}] : [];
+		});
+	}
+	function fieldIdentity(schema, index) {
+		const column = schema.columns.find((candidate) => candidate.index === index);
+		return column ? column.displayName ?? column.name : void 0;
+	}
+	/**
+	* Toggle a grouping field across every class exposing it. The batch card is
+	* on when any schema groups by the field, so clicking it disables all such
+	* schemas; only a fully disabled field is enabled across the batch.
+	*/
+	function toggleGroupByField(fieldKey) {
+		const targets = schemasExposing(fieldKey);
+		if (targets.length === 0) return;
+		const enable = !targets.some(({ key, index }) => schemas.value[key]?.groupBy.includes(index));
+		for (const { key, index } of targets) {
+			const schema = schemas.value[key];
+			if (!schema || schema.groupBy.includes(index) === enable) continue;
+			toggleGroupBy(key, index);
+		}
+	}
+	/**
+	* Move a grouping field in the active schema, then project that visible field
+	* order across every class. Class-only fields keep their relative order after
+	* the shared fields because the Field Recipe has no card with which to place
+	* them explicitly.
+	*/
+	function moveGroupByField(fieldKey, direction) {
+		const targets = schemasExposing(fieldKey);
+		if (targets.length === 0) return;
+		const active = targets.find((target) => target.key === activeClassKey.value && schemas.value[target.key]?.groupBy.includes(target.index)) ?? targets.find((target) => schemas.value[target.key]?.groupBy.includes(target.index)) ?? targets[0];
+		const activeSchema = schemas.value[active.key];
+		if (!activeSchema) return;
+		const from = activeSchema.groupBy.indexOf(active.index);
+		if (from === -1) return;
+		const to = direction === "up" ? from - 1 : from + 1;
+		if (to < 0 || to >= activeSchema.groupBy.length) return;
+		const activeOrder = [...activeSchema.groupBy];
+		[activeOrder[from], activeOrder[to]] = [activeOrder[to], activeOrder[from]];
+		const desiredRank = new Map(activeOrder.flatMap((index, rank) => {
+			const identity = fieldIdentity(activeSchema, index);
+			return identity === void 0 ? [] : [[identity, rank]];
+		}));
+		let changed = false;
+		const nextSchemas = { ...schemas.value };
+		for (const [key, schema] of Object.entries(schemas.value)) {
+			const shared = [];
+			const classOnly = [];
+			for (const index of schema.groupBy) {
+				const identity = fieldIdentity(schema, index);
+				const rank = identity === void 0 ? void 0 : desiredRank.get(identity);
+				if (rank === void 0) classOnly.push(index);
+				else shared.push({
+					index,
+					rank
+				});
+			}
+			shared.sort((left, right) => left.rank - right.rank);
+			const groupBy = [...shared.map((entry) => entry.index), ...classOnly];
+			if (groupBy.every((index, position) => index === schema.groupBy[position])) continue;
+			nextSchemas[key] = {
+				...schema,
+				groupBy
+			};
+			changed = true;
+		}
+		if (changed) schemas.value = nextSchemas;
+	}
 	function updateColumn(key, idx, patch) {
 		const schema = schemas.value[key];
 		if (!schema) return;
@@ -2552,6 +2656,9 @@ function useAutoGroup() {
 		setClassDisposition,
 		setClassDispositions,
 		toggleGroupBy,
+		moveGroupBy,
+		toggleGroupByField,
+		moveGroupByField,
 		setRole,
 		setColumnName,
 		setValueOps,
@@ -2882,6 +2989,22 @@ function deriveShade(parentHex, index, total) {
 	return hslToHex(h, clamp(s, 35, 100), childL);
 }
 //#endregion
+//#region src/utils/sampleGroupPath.ts
+/** Split a group name into normalized hierarchy segments. */
+function splitSampleGroupPath(groupName, separator) {
+	const parts = groupName.split(separator).map((part) => part.trim()).filter((part) => part.length > 0);
+	return parts.length > 0 ? parts : [groupName];
+}
+/** First normalized hierarchy segment, used as the reorderable family key. */
+function getSampleGroupMajorPrefix(groupName, separator) {
+	return splitSampleGroupPath(groupName, separator)[0];
+}
+/** Normalized path above a concrete leaf group. */
+function getSampleGroupParentPath(groupName, separator) {
+	const parts = splitSampleGroupPath(groupName, separator);
+	return parts.length > 1 ? parts.slice(0, -1).join(separator) : "";
+}
+//#endregion
 //#region src/composables/useSampleGroups.ts
 /** Shared sample-group hierarchy, color, and ungrouped-sample derivation for lab selectors. */
 function useSampleGroups(options) {
@@ -2893,34 +3016,84 @@ function useSampleGroups(options) {
 		if (explicit) return explicit;
 		return groups.value.some((group) => group.name.includes("/")) ? "/" : "_";
 	});
-	const hierarchicalGroups = computed(() => {
-		if (groups.value.length === 0) return [];
-		const groupedByMajor = /* @__PURE__ */ new Map();
+	const families = computed(() => {
+		const byMajor = /* @__PURE__ */ new Map();
 		for (const group of groups.value) {
 			const majorName = getMajorGroupName(group.name, separator.value);
-			const existing = groupedByMajor.get(majorName);
+			const existing = byMajor.get(majorName);
 			if (existing) existing.push(group);
-			else groupedByMajor.set(majorName, [group]);
+			else byMajor.set(majorName, [group]);
 		}
-		return [...groupedByMajor.entries()].map(([majorName, subGroups]) => {
-			const color = subGroups[0]?.color || fallbackColor.value;
+		return [...byMajor.entries()].map(([name, members]) => {
+			const color = members[0]?.color || fallbackColor.value;
 			return {
-				name: majorName,
+				name,
 				color,
-				subGroups: subGroups.map((subGroup, index) => {
-					const displayColor = deriveShade(color, index, subGroups.length);
+				subGroups: members.map((group, index) => {
+					const displayColor = deriveShade(color, index, members.length);
 					return {
-						...subGroup,
+						...group,
 						displayColor,
 						displayBg: displayColor + "20",
 						displayBorder: displayColor + "40"
 					};
-				}),
-				allSamples: subGroups.flatMap((group) => group.samples)
+				})
 			};
 		});
 	});
-	const showHierarchy = computed(() => hierarchicalGroups.value.some((major) => major.subGroups.length > 1 || major.subGroups.length === 1 && major.name !== major.subGroups[0].name));
+	const groupTree = computed(() => {
+		const roots = [];
+		for (const family of families.value) {
+			const interior = /* @__PURE__ */ new Map();
+			for (const subGroup of family.subGroups) {
+				const segments = splitSampleGroupPath(subGroup.name, separator.value);
+				const leafLabel = segments[segments.length - 1] ?? subGroup.name;
+				let siblings = roots;
+				let path = "";
+				for (const segment of segments.slice(0, -1)) {
+					path = path ? `${path}/${segment}` : segment;
+					let node = interior.get(path);
+					if (!node) {
+						node = {
+							key: `node:${family.name}/${path}`,
+							label: segment,
+							color: family.color,
+							displayBg: family.color + "20",
+							displayBorder: family.color + "40",
+							allSamples: [],
+							children: []
+						};
+						interior.set(path, node);
+						siblings.push(node);
+					}
+					node.allSamples.push(...subGroup.samples);
+					siblings = node.children;
+				}
+				siblings.push({
+					key: `leaf:${subGroup.name}`,
+					label: leafLabel,
+					color: subGroup.displayColor,
+					displayBg: subGroup.displayBg,
+					displayBorder: subGroup.displayBorder,
+					allSamples: [...subGroup.samples],
+					children: [],
+					group: subGroup
+				});
+			}
+		}
+		return roots;
+	});
+	const maxDepth = computed(() => {
+		const depthOf = (nodes) => nodes.reduce((deepest, node) => Math.max(deepest, 1 + depthOf(node.children)), 0);
+		return depthOf(groupTree.value);
+	});
+	const hierarchicalGroups = computed(() => families.value.map((family) => ({
+		name: family.name,
+		color: family.color,
+		subGroups: family.subGroups,
+		allSamples: family.subGroups.flatMap((group) => group.samples)
+	})));
+	const showHierarchy = computed(() => maxDepth.value > 1);
 	const groupedSamples = computed(() => new Set(groups.value.flatMap((group) => group.samples)));
 	const ungroupedSamples = computed(() => samples.value.filter((sample) => !groupedSamples.value.has(sample)));
 	function findGroup(groupName) {
@@ -2932,6 +3105,8 @@ function useSampleGroups(options) {
 	return {
 		groups,
 		separator,
+		groupTree,
+		maxDepth,
 		hierarchicalGroups,
 		showHierarchy,
 		groupedSamples,
@@ -2941,8 +3116,7 @@ function useSampleGroups(options) {
 	};
 }
 function getMajorGroupName(groupName, separator) {
-	const parts = groupName.split(separator);
-	return parts.length > 1 ? parts[0] : groupName;
+	return splitSampleGroupPath(groupName, separator)[0];
 }
 //#endregion
 //#region src/composables/useExpansionSet.ts
@@ -4760,6 +4934,6 @@ function useProtocolTemplates() {
 	};
 }
 //#endregion
-export { extractSamplesFromDesignData as A, useJobsStatusTray as B, hexToHsl as C, readFileAsText as D, parseDelimitedText as E, unwrapExperimentDesignData as F, useAppExperiment as G, DEFAULT_MOBILE_VIEWPORT_QUERY as H, DEFAULT_COLORS as I, candidateMatchesSearch as J, useTheme as K, useWellPlateEditor as L, parseCSV as M, extractSampleNamesFromDesignData as N, useFileImport as O, extractSampleOptionsFromDesignData as P, useSortedItems as Q, useDoseCalculator as R, deriveShade as S, detectDelimiter as T, useMobileSupportGate as U, usePluginJobCenter as V, APP_EXPERIMENT_KEY as W, useTextSearch as X, normalizeSearchQuery as Y, compareSortValues as Z, useScheduleDrag as _, useReagentSeries as a, useExpansionSet as b, useBioTemplatePresetWorkspace as c, getBioTemplateComponentProps as d, toBioTemplateComponentPropsByComponent as f, useExperimentSave as g, useTemplateCollection as h, generateDilutionSeries as i, useAutoGroup as j, validateImportFile as k, useBioTemplatePackWorkspace as l, useBioTemplateControls as m, DEFAULT_PRESETS as n, useGroupAssignment as o, useBioTemplateComponents as p, useToast as q, DEFAULT_UNITS as r, useRackEditor as s, useProtocolTemplates as t, useBioTemplateWorkspace as u, useExperimentSamples as v, hslToHex as w, useSampleGroups as x, useExperimentData as y, combinePluginJobSources as z };
+export { compareSortValues as $, useFileImport as A, useDoseCalculator as B, getSampleGroupParentPath as C, detectDelimiter as D, hslToHex as E, extractSampleNamesFromDesignData as F, useMobileSupportGate as G, useJobsStatusTray as H, extractSampleOptionsFromDesignData as I, useTheme as J, APP_EXPERIMENT_KEY as K, unwrapExperimentDesignData as L, extractSamplesFromDesignData as M, useAutoGroup as N, parseDelimitedText as O, parseCSV as P, useTextSearch as Q, DEFAULT_COLORS as R, getSampleGroupMajorPrefix as S, hexToHsl as T, usePluginJobCenter as U, combinePluginJobSources as V, DEFAULT_MOBILE_VIEWPORT_QUERY as W, candidateMatchesSearch as X, useToast as Y, normalizeSearchQuery as Z, useScheduleDrag as _, useReagentSeries as a, useExpansionSet as b, useBioTemplatePresetWorkspace as c, getBioTemplateComponentProps as d, useSortedItems as et, toBioTemplateComponentPropsByComponent as f, useExperimentSave as g, useTemplateCollection as h, generateDilutionSeries as i, validateImportFile as j, readFileAsText as k, useBioTemplatePackWorkspace as l, useBioTemplateControls as m, DEFAULT_PRESETS as n, useGroupAssignment as o, useBioTemplateComponents as p, useAppExperiment as q, DEFAULT_UNITS as r, useRackEditor as s, useProtocolTemplates as t, useBioTemplateWorkspace as u, useExperimentSamples as v, deriveShade as w, useSampleGroups as x, useExperimentData as y, useWellPlateEditor as z };
 
-//# sourceMappingURL=useProtocolTemplates-BMt0LlXf.js.map
+//# sourceMappingURL=useProtocolTemplates-D3IZKLqr.js.map