@morscherlab/mint-sdk 1.3.9 → 1.4.0-beta.2

package/src/composables/useExperimentSave.ts

@@ -1,348 +0,0 @@
-import { computed, ref, type ComputedRef, type Ref } from 'vue'
-import { useApi } from './useApi'
-import { useRequestSyncState } from './useRequestSyncState'
-import { createBioTemplatePresetCollection } from '../templates'
-import type {
-  CreateLcmsBatchCollectionOptions,
-  CreateQpcrExpressionCollectionOptions,
-  CreateWellPlateScreenCollectionOptions,
-  TemplatePresetId,
-} from '../templates'
-import {
-  getInjectedPlatformContext,
-  resolveCurrentExperimentId,
-} from './platformContextHelpers'
-
-type TemplatePresetCollectionOptions =
-  | CreateWellPlateScreenCollectionOptions
-  | CreateQpcrExpressionCollectionOptions
-  | CreateLcmsBatchCollectionOptions
-
-export interface UseExperimentSaveOptions {
-  /** Default plugin_id for all save/load calls. */
-  pluginId?: string
-  /** Default schema version for design saves (defaults to "1.0"). */
-  schemaVersion?: string
-  /** Override API base URL. */
-  apiBaseUrl?: string
-}
-
-export interface UseExperimentSaveReturn {
-  /** Current experiment id from platform injection, URL query, or URL path. */
-  currentExperimentId: ComputedRef<number | undefined>
-  /** Whether a current experiment id is available. */
-  hasCurrentExperiment: ComputedRef<boolean>
-  /** Whether a save operation is in progress. */
-  isSaving: Ref<boolean>
-  /** Whether a load or delete operation is in progress. */
-  isLoading: Ref<boolean>
-  /** Error message from the last failed operation, or null. */
-  error: Ref<string | null>
-  /** Timestamp of the last successful load, or null. */
-  lastLoadedAt: Ref<Date | null>
-  /** Timestamp of the last successful save, or null. */
-  lastSavedAt: Ref<Date | null>
-  /** Save design data for an experiment. */
-  saveDesign: (experimentId: number, data: Record<string, unknown>) => Promise<boolean>
-  /** Save design data for the current experiment. */
-  saveCurrentDesign: (data: Record<string, unknown>) => Promise<boolean>
-  /** Create and save a built-in biology template preset as experiment design data. */
-  saveTemplatePreset: (
-    experimentId: number,
-    name: TemplatePresetId | string,
-    options?: TemplatePresetCollectionOptions,
-  ) => Promise<boolean>
-  /** Create and save a built-in biology template preset for the current experiment. */
-  saveCurrentTemplatePreset: (
-    name: TemplatePresetId | string,
-    options?: TemplatePresetCollectionOptions,
-  ) => Promise<boolean>
-  /** Save analysis result for an experiment. */
-  saveAnalysis: (experimentId: number, result: Record<string, unknown>) => Promise<boolean>
-  /** Save analysis result for the current experiment. */
-  saveCurrentAnalysis: (result: Record<string, unknown>) => Promise<boolean>
-  /** Save design and/or analysis in one call. */
-  save: (experimentId: number, opts: {
-    design?: Record<string, unknown>
-    analysis?: Record<string, unknown>
-  }) => Promise<boolean>
-  /** Load design data for an experiment. */
-  loadDesign: (experimentId: number) => Promise<Record<string, unknown> | null>
-  /** Load design data for the current experiment. */
-  loadCurrentDesign: () => Promise<Record<string, unknown> | null>
-  /** Load analysis result for an experiment. */
-  loadAnalysis: (experimentId: number) => Promise<Record<string, unknown> | null>
-  /** Load analysis result for the current experiment. */
-  loadCurrentAnalysis: () => Promise<Record<string, unknown> | null>
-  /** Delete design data for an experiment. */
-  deleteDesign: (experimentId: number) => Promise<boolean>
-  /** Delete design data for the current experiment. */
-  deleteCurrentDesign: () => Promise<boolean>
-  /** Delete analysis result for an experiment. */
-  deleteAnalysis: (experimentId: number) => Promise<boolean>
-  /** Delete analysis result for the current experiment. */
-  deleteCurrentAnalysis: () => Promise<boolean>
-  /** Require and return the current experiment id, or throw when missing. */
-  requireCurrentExperimentId: () => number
-}
-
-/**
- * Persists experiment design, analysis, and built-in template preset data through the platform API.
- *
- * @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
- */
-export function useExperimentSave(
-  options: UseExperimentSaveOptions = {},
-): UseExperimentSaveReturn {
-  const injectedContext = getInjectedPlatformContext()
-  const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl })
-  const pluginId = options.pluginId ?? injectedContext?.plugin?.id
-  const schemaVersion = options.schemaVersion ?? '1.0'
-  const currentExperimentId = computed<number | undefined>(() => {
-    return resolveCurrentExperimentId(injectedContext)
-  })
-  const hasCurrentExperiment = computed(() => currentExperimentId.value !== undefined)
-
-  const request = useRequestSyncState('Experiment request failed.')
-  const isSaving = ref(false)
-  const isLoading = ref(false)
-  const error = request.error
-  const lastLoadedAt = request.lastLoadedAt
-  const lastSavedAt = request.lastSavedAt
-
-  function requireCurrentExperimentId(): number {
-    const id = currentExperimentId.value
-    if (id === undefined) {
-      throw new Error('[MINT SDK] No current experiment is selected.')
-    }
-    return id
-  }
-
-  function currentExperimentIdOrError(action: string): number | undefined {
-    const id = currentExperimentId.value
-    if (id === undefined) {
-      request.setError(`No current experiment is selected for ${action}`)
-      return undefined
-    }
-    return id
-  }
-
-  async function saveDesign(
-    experimentId: number,
-    data: Record<string, unknown>,
-  ): Promise<boolean> {
-    if (!pluginId) {
-      request.setError('pluginId is required for saveDesign')
-      return false
-    }
-    isSaving.value = true
-    try {
-      await request.run(async () => {
-        await api.put(`/experiments/${experimentId}/data`, {
-          plugin_id: pluginId,
-          data,
-          schema_version: schemaVersion,
-        })
-      }, { success: 'save' })
-      return true
-    } catch {
-      return false
-    } finally {
-      isSaving.value = false
-    }
-  }
-
-  async function saveCurrentDesign(data: Record<string, unknown>): Promise<boolean> {
-    const experimentId = currentExperimentIdOrError('saveDesign')
-    return experimentId === undefined ? false : saveDesign(experimentId, data)
-  }
-
-  async function saveTemplatePreset(
-    experimentId: number,
-    name: TemplatePresetId | string,
-    presetOptions: TemplatePresetCollectionOptions = {},
-  ): Promise<boolean> {
-    const collection = createBioTemplatePresetCollection(name, presetOptions)
-    return saveDesign(experimentId, collection as unknown as Record<string, unknown>)
-  }
-
-  async function saveCurrentTemplatePreset(
-    name: TemplatePresetId | string,
-    presetOptions: TemplatePresetCollectionOptions = {},
-  ): Promise<boolean> {
-    const experimentId = currentExperimentIdOrError('saveTemplatePreset')
-    return experimentId === undefined ? false : saveTemplatePreset(experimentId, name, presetOptions)
-  }
-
-  async function saveAnalysis(
-    experimentId: number,
-    result: Record<string, unknown>,
-  ): Promise<boolean> {
-    if (!pluginId) {
-      request.setError('pluginId is required for saveAnalysis')
-      return false
-    }
-    isSaving.value = true
-    try {
-      await request.run(async () => {
-        await api.put(`/experiments/${experimentId}/results/${pluginId}`, {
-          result,
-        })
-      }, { success: 'save' })
-      return true
-    } catch {
-      return false
-    } finally {
-      isSaving.value = false
-    }
-  }
-
-  async function saveCurrentAnalysis(result: Record<string, unknown>): Promise<boolean> {
-    const experimentId = currentExperimentIdOrError('saveAnalysis')
-    return experimentId === undefined ? false : saveAnalysis(experimentId, result)
-  }
-
-  async function save(
-    experimentId: number,
-    opts: { design?: Record<string, unknown>; analysis?: Record<string, unknown> },
-  ): Promise<boolean> {
-    if ((opts.design || opts.analysis) && !pluginId) {
-      request.setError('pluginId is required for save')
-      return false
-    }
-    isSaving.value = true
-    try {
-      await request.run(async () => {
-        if (opts.design) {
-          await api.put(`/experiments/${experimentId}/data`, {
-            plugin_id: pluginId,
-            data: opts.design,
-            schema_version: schemaVersion,
-          })
-        }
-        if (opts.analysis) {
-          await api.put(`/experiments/${experimentId}/results/${pluginId}`, {
-            result: opts.analysis,
-          })
-        }
-      }, { success: 'save' })
-      return true
-    } catch {
-      return false
-    } finally {
-      isSaving.value = false
-    }
-  }
-
-  async function loadDesign(
-    experimentId: number,
-  ): Promise<Record<string, unknown> | null> {
-    isLoading.value = true
-    try {
-      return await request.run(
-        () => api.get<Record<string, unknown>>(`/experiments/${experimentId}/data`),
-        { success: 'load' },
-      )
-    } catch {
-      return null
-    } finally {
-      isLoading.value = false
-    }
-  }
-
-  async function loadCurrentDesign(): Promise<Record<string, unknown> | null> {
-    const experimentId = currentExperimentIdOrError('loadDesign')
-    return experimentId === undefined ? null : loadDesign(experimentId)
-  }
-
-  async function loadAnalysis(
-    experimentId: number,
-  ): Promise<Record<string, unknown> | null> {
-    if (!pluginId) {
-      request.setError('pluginId is required for loadAnalysis')
-      return null
-    }
-    isLoading.value = true
-    try {
-      return await request.run(
-        () => api.get<Record<string, unknown>>(
-          `/experiments/${experimentId}/results/${pluginId}`,
-        ),
-        { success: 'load' },
-      )
-    } catch {
-      return null
-    } finally {
-      isLoading.value = false
-    }
-  }
-
-  async function loadCurrentAnalysis(): Promise<Record<string, unknown> | null> {
-    const experimentId = currentExperimentIdOrError('loadAnalysis')
-    return experimentId === undefined ? null : loadAnalysis(experimentId)
-  }
-
-  async function deleteDesign(experimentId: number): Promise<boolean> {
-    isLoading.value = true
-    try {
-      await request.run(() => api.delete(`/experiments/${experimentId}/data`))
-      return true
-    } catch {
-      return false
-    } finally {
-      isLoading.value = false
-    }
-  }
-
-  async function deleteCurrentDesign(): Promise<boolean> {
-    const experimentId = currentExperimentIdOrError('deleteDesign')
-    return experimentId === undefined ? false : deleteDesign(experimentId)
-  }
-
-  async function deleteAnalysis(experimentId: number): Promise<boolean> {
-    if (!pluginId) {
-      request.setError('pluginId is required for deleteAnalysis')
-      return false
-    }
-    isLoading.value = true
-    try {
-      await request.run(() => api.delete(`/experiments/${experimentId}/results/${pluginId}`))
-      return true
-    } catch {
-      return false
-    } finally {
-      isLoading.value = false
-    }
-  }
-
-  async function deleteCurrentAnalysis(): Promise<boolean> {
-    const experimentId = currentExperimentIdOrError('deleteAnalysis')
-    return experimentId === undefined ? false : deleteAnalysis(experimentId)
-  }
-
-  return {
-    currentExperimentId,
-    hasCurrentExperiment,
-    isSaving,
-    isLoading,
-    error,
-    lastLoadedAt,
-    lastSavedAt,
-    saveDesign,
-    saveCurrentDesign,
-    saveTemplatePreset,
-    saveCurrentTemplatePreset,
-    saveAnalysis,
-    saveCurrentAnalysis,
-    save,
-    loadDesign,
-    loadCurrentDesign,
-    loadAnalysis,
-    loadCurrentAnalysis,
-    deleteDesign,
-    deleteCurrentDesign,
-    deleteAnalysis,
-    deleteCurrentAnalysis,
-    requireCurrentExperimentId,
-  }
-}

package/src/composables/useGroupAssignment.ts

@@ -1,152 +0,0 @@
-import { computed, toValue, type ComputedRef, type Ref } from 'vue'
-import type { GroupItem } from '../types'
-
-export type GroupAssignmentZone = 'zone1' | 'zone2'
-
-export type GroupAssignmentSource<T> =
-  | T
-  | Ref<T>
-  | ComputedRef<T>
-  | (() => T)
-
-export interface GroupAssignmentState {
-  group1: string[]
-  group2: string[]
-}
-
-export interface UseGroupAssignmentOptions {
-  groups: GroupAssignmentSource<readonly GroupItem[]>
-  group1: GroupAssignmentSource<readonly string[]>
-  group2: GroupAssignmentSource<readonly string[]>
-  label1?: GroupAssignmentSource<string | null | undefined>
-  label2?: GroupAssignmentSource<string | null | undefined>
-  minPerGroup?: GroupAssignmentSource<number | null | undefined>
-}
-
-export interface UseGroupAssignmentReturn {
-  unassignedGroups: ComputedRef<GroupItem[]>
-  zone1Groups: ComputedRef<GroupItem[]>
-  zone2Groups: ComputedRef<GroupItem[]>
-  zone1Count: ComputedRef<number>
-  zone2Count: ComputedRef<number>
-  isValid: ComputedRef<boolean>
-  validationMessage: ComputedRef<string | null>
-  getZoneForGroup: (groupName: string) => GroupAssignmentZone | null
-  assignToZone: (groupName: string, zone: GroupAssignmentZone) => GroupAssignmentState
-  removeFromZone: (groupName: string, zone: GroupAssignmentZone) => GroupAssignmentState
-  clearAll: () => GroupAssignmentState
-}
-
-/**
- * Shared two-zone group assignment model for control/treatment style workflows.
- *
- * @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
- */
-export function useGroupAssignment(options: UseGroupAssignmentOptions): UseGroupAssignmentReturn {
-  const groups = computed(() => [...toValue(options.groups)])
-  const group1 = computed(() => [...toValue(options.group1)])
-  const group2 = computed(() => [...toValue(options.group2)])
-  const label1 = computed(() => toValue(options.label1) || 'Control')
-  const label2 = computed(() => toValue(options.label2) || 'Treatment')
-  const minPerGroup = computed(() => normalizeMinimum(toValue(options.minPerGroup)))
-  const group1Set = computed(() => new Set(group1.value))
-  const group2Set = computed(() => new Set(group2.value))
-
-  const unassignedGroups = computed(() =>
-    groups.value.filter(group => !group1Set.value.has(group.name) && !group2Set.value.has(group.name))
-  )
-
-  const zone1Groups = computed(() =>
-    groups.value.filter(group => group1Set.value.has(group.name))
-  )
-
-  const zone2Groups = computed(() =>
-    groups.value.filter(group => group2Set.value.has(group.name))
-  )
-
-  const zone1Count = computed(() =>
-    zone1Groups.value.reduce((sum, group) => sum + group.count, 0)
-  )
-
-  const zone2Count = computed(() =>
-    zone2Groups.value.reduce((sum, group) => sum + group.count, 0)
-  )
-
-  const isValid = computed(() =>
-    group1.value.length >= minPerGroup.value &&
-    group2.value.length >= minPerGroup.value
-  )
-
-  const validationMessage = computed(() => {
-    if (isValid.value) return null
-    const missing1 = Math.max(0, minPerGroup.value - group1.value.length)
-    const missing2 = Math.max(0, minPerGroup.value - group2.value.length)
-    const parts: string[] = []
-    if (missing1 > 0) parts.push(`${missing1} more to ${label1.value}`)
-    if (missing2 > 0) parts.push(`${missing2} more to ${label2.value}`)
-    return `Add ${parts.join(' and ')}`
-  })
-
-  function getZoneForGroup(groupName: string): GroupAssignmentZone | null {
-    if (group1Set.value.has(groupName)) return 'zone1'
-    if (group2Set.value.has(groupName)) return 'zone2'
-    return null
-  }
-
-  function assignToZone(groupName: string, zone: GroupAssignmentZone): GroupAssignmentState {
-    const next = removeFromBoth(groupName)
-    if (zone === 'zone1') {
-      return {
-        group1: [...next.group1, groupName],
-        group2: next.group2,
-      }
-    }
-    return {
-      group1: next.group1,
-      group2: [...next.group2, groupName],
-    }
-  }
-
-  function removeFromZone(groupName: string, zone: GroupAssignmentZone): GroupAssignmentState {
-    if (zone === 'zone1') {
-      return {
-        group1: group1.value.filter(name => name !== groupName),
-        group2: group2.value,
-      }
-    }
-    return {
-      group1: group1.value,
-      group2: group2.value.filter(name => name !== groupName),
-    }
-  }
-
-  function clearAll(): GroupAssignmentState {
-    return { group1: [], group2: [] }
-  }
-
-  function removeFromBoth(groupName: string): GroupAssignmentState {
-    return {
-      group1: group1.value.filter(name => name !== groupName),
-      group2: group2.value.filter(name => name !== groupName),
-    }
-  }
-
-  return {
-    unassignedGroups,
-    zone1Groups,
-    zone2Groups,
-    zone1Count,
-    zone2Count,
-    isValid,
-    validationMessage,
-    getZoneForGroup,
-    assignToZone,
-    removeFromZone,
-    clearAll,
-  }
-}
-
-function normalizeMinimum(value: number | null | undefined): number {
-  if (value === null || value === undefined || !Number.isFinite(value)) return 1
-  return Math.max(0, Math.floor(value))
-}