@morscherlab/mint-sdk 1.2.0-beta.3 → 1.2.0-beta.4

package/src/composables/useAutoGroupInputSources.ts

@@ -0,0 +1,147 @@
+import { computed, nextTick, ref, type Ref } from 'vue'
+import { parseCSV, type useAutoGroup } from './useAutoGroup'
+import { useApi, type UseApiReturn } from './useApi'
+import type { WizardStep } from '../types/components'
+
+type AutoGroupController = ReturnType<typeof useAutoGroup>
+type ReadableRef<T> = Readonly<Ref<T>>
+type AutoGroupApi = Pick<UseApiReturn, 'get'>
+
+export interface UseAutoGroupInputSourcesOptions {
+  autoGroup: AutoGroupController
+  samples: ReadableRef<readonly string[]>
+  experimentId: ReadableRef<number | undefined>
+  designData: ReadableRef<Record<string, unknown> | undefined>
+  currentStep: Ref<number>
+  dynamicSteps: ReadableRef<readonly WizardStep[]>
+  api?: AutoGroupApi
+}
+
+/** Manages AutoGroupModal input sources: pasted samples, CSV/TSV files, and experiment metadata. */
+export function useAutoGroupInputSources(options: UseAutoGroupInputSourcesOptions) {
+  const api = options.api ?? useApi()
+  const isDragOver = ref(false)
+  const csvFileName = ref('')
+  const experimentLoading = ref(false)
+  const experimentError = ref<string | null>(null)
+  const csvError = ref<string | null>(null)
+
+  const experimentFieldNames = computed(() =>
+    options.autoGroup.csvData.value?.columns.filter(c => c !== 'sample_name') ?? [],
+  )
+
+  async function initializeInputSources() {
+    options.autoGroup.reset()
+    options.currentStep.value = 0
+    resetInputSourceState()
+
+    if (options.experimentId.value || options.designData.value) {
+      await fetchExperimentData()
+    } else if (options.samples.value.length > 0) {
+      options.autoGroup.rawText.value = options.samples.value.join('\n')
+    }
+  }
+
+  function resetInputSourceState() {
+    csvFileName.value = ''
+    experimentError.value = null
+    csvError.value = null
+    isDragOver.value = false
+  }
+
+  async function fetchExperimentData() {
+    if (!options.experimentId.value && !options.designData.value) return
+
+    options.autoGroup.inputMode.value = 'experiment'
+    experimentLoading.value = true
+    experimentError.value = null
+
+    try {
+      const pluginData = await loadExperimentPluginData()
+
+      if (!pluginData || typeof pluginData !== 'object') {
+        experimentError.value = 'No design data found for this experiment'
+        return
+      }
+
+      const success = options.autoGroup.loadExperimentData(pluginData, { samples: options.samples.value })
+      if (!success) {
+        experimentError.value = 'No sample metadata found in this experiment'
+        return
+      }
+
+      await nextTick()
+      const fieldsIdx = options.dynamicSteps.value.findIndex(s => s.id === 'fields')
+      if (fieldsIdx >= 0) {
+        options.currentStep.value = fieldsIdx
+      }
+    } catch (e) {
+      experimentError.value = e instanceof Error ? e.message : 'Failed to fetch experiment data'
+    } finally {
+      experimentLoading.value = false
+    }
+  }
+
+  async function loadExperimentPluginData(): Promise<Record<string, unknown> | undefined> {
+    if (options.designData.value) {
+      return options.designData.value
+    }
+
+    const result = await api.get<Record<string, unknown>>(
+      `/experiments/${options.experimentId.value}/data`,
+    )
+    return result.data as Record<string, unknown> | undefined
+  }
+
+  function handleFileDrop(event: DragEvent) {
+    event.preventDefault()
+    isDragOver.value = false
+    const files = event.dataTransfer?.files
+    if (files && files.length > 0) {
+      void processFile(files[0])
+    }
+  }
+
+  function handleFileInput(event: Event) {
+    const target = event.target as HTMLInputElement
+    if (target.files && target.files.length > 0) {
+      void processFile(target.files[0])
+    }
+  }
+
+  async function processFile(file: File) {
+    if (!file.name.endsWith('.csv') && !file.name.endsWith('.tsv')) return
+
+    csvError.value = null
+    try {
+      const text = await file.text()
+      const parsed = parseCSV(text)
+      options.autoGroup.inputMode.value = 'csv'
+      options.autoGroup.csvData.value = parsed
+      csvFileName.value = file.name
+    } catch (e) {
+      csvError.value = e instanceof Error ? e.message : 'Failed to parse file'
+    }
+  }
+
+  function clearCsvFile() {
+    options.autoGroup.csvData.value = null
+    options.autoGroup.inputMode.value = 'paste'
+    csvFileName.value = ''
+  }
+
+  return {
+    isDragOver,
+    csvFileName,
+    experimentLoading,
+    experimentError,
+    csvError,
+    experimentFieldNames,
+    initializeInputSources,
+    fetchExperimentData,
+    handleFileDrop,
+    handleFileInput,
+    processFile,
+    clearCsvFile,
+  }
+}

package/src/composables/useBioTemplateComponents.ts

@@ -0,0 +1,105 @@
+import {
+  getBioTemplateComponentBindings,
+  getBioTemplateComponentProps as getTemplateComponentProps,
+  toBioTemplateComponentImports,
+  toBioTemplateComponentBindings,
+  toBioTemplateComponentBindingsById,
+  toBioTemplateComponentProps,
+  toBioTemplateComponentPropsByComponent as toTemplateComponentPropsByComponent,
+  toBioTemplateComponentPropsById,
+  toBioTemplateComponentSnippets,
+  toBioTemplateComponentUsage,
+  type BioTemplateComponentBinding,
+  type BioTemplateComponentBindingsById,
+  type BioTemplateComponentImport,
+  type BioTemplateComponentPropsByComponent,
+  type BioTemplateComponentPropsBinding,
+  type BioTemplateComponentPropsById,
+  type BioTemplateComponentPropsLookupOptions,
+  type BioTemplateResolvedComponentBinding,
+  type BioTemplateComponentSnippet,
+  type BioTemplateComponentTarget,
+  type BioTemplateComponentUsage,
+} from '../templates/componentBindings'
+import type {
+  BioTemplateEnvelope,
+  TemplateCollectionEnvelope,
+} from '../templates/types'
+
+export {
+  getBioTemplateComponentBindings,
+  toBioTemplateComponentBindings,
+  toBioTemplateComponentBindingsById,
+  toBioTemplateComponentImports,
+  toBioTemplateComponentProps,
+  toBioTemplateComponentPropsById,
+  toBioTemplateComponentSnippets,
+  toBioTemplateComponentUsage,
+}
+
+export type {
+  BioTemplateComponentBinding,
+  BioTemplateComponentBindingsById,
+  BioTemplateComponentImport,
+  BioTemplateComponentPropsByComponent,
+  BioTemplateComponentPropsBinding,
+  BioTemplateComponentPropsById,
+  BioTemplateComponentPropsLookupOptions,
+  BioTemplateResolvedComponentBinding,
+  BioTemplateComponentSnippet,
+  BioTemplateComponentTarget,
+  BioTemplateComponentUsage,
+}
+
+export interface UseBioTemplateComponentsReturn {
+  bindings: BioTemplateComponentBinding[]
+  imports: BioTemplateComponentImport[]
+  componentBindings: BioTemplateResolvedComponentBinding[]
+  componentBindingsById: BioTemplateComponentBindingsById
+  componentProps: BioTemplateComponentPropsBinding[]
+  componentPropsById: BioTemplateComponentPropsById
+  componentPropsByComponent: BioTemplateComponentPropsByComponent
+  snippets: BioTemplateComponentSnippet[]
+  usage: BioTemplateComponentUsage | null
+  getComponentProps: (
+    component: string,
+    options?: BioTemplateComponentPropsLookupOptions,
+  ) => Record<string, unknown> | undefined
+}
+
+/** Return component props grouped by SDK component name for direct WellPlate/DoseCalculator binding. */
+export function toBioTemplateComponentPropsByComponent(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
+): BioTemplateComponentPropsByComponent {
+  return toTemplateComponentPropsByComponent(target)
+}
+
+/** Return the first props object for an SDK component, optionally restricted by template id or binding id. */
+export function getBioTemplateComponentProps(
+  target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope,
+  component: string,
+  options: BioTemplateComponentPropsLookupOptions = {},
+): Record<string, unknown> | undefined {
+  return getTemplateComponentProps(target, component, options)
+}
+
+/** Map built-in biology templates to SDK components such as WellPlate, DataFrame, DoseCalculator, and PlateMapEditor. */
+export function useBioTemplateComponents(
+  target: BioTemplateComponentTarget
+): UseBioTemplateComponentsReturn {
+  return {
+    bindings: getBioTemplateComponentBindings(target),
+    imports: toBioTemplateComponentImports(target),
+    componentBindings: typeof target === 'string' ? [] : toBioTemplateComponentBindings(target),
+    componentBindingsById: typeof target === 'string' ? {} : toBioTemplateComponentBindingsById(target),
+    componentProps: typeof target === 'string' ? [] : toBioTemplateComponentProps(target),
+    componentPropsById: typeof target === 'string' ? {} : toBioTemplateComponentPropsById(target),
+    componentPropsByComponent: typeof target === 'string' ? {} : toBioTemplateComponentPropsByComponent(target),
+    snippets: typeof target === 'string' ? [] : toBioTemplateComponentSnippets(target),
+    usage: typeof target === 'string' ? null : toBioTemplateComponentUsage(target),
+    getComponentProps: (component, options) =>
+      typeof target === 'string'
+        ? undefined
+        : getBioTemplateComponentProps(target, component, options),
+  }
+}

package/src/composables/useBioTemplateControls.ts

@@ -0,0 +1,41 @@
+import {
+  createBioTemplateControlToolkit,
+  getBioTemplateControlSchema,
+  requireBioTemplateControlSchema,
+  type BioTemplateControlSchema,
+  type BioTemplateControlTarget,
+} from '../templates/controlSchemas'
+import type {
+  ControlSchemaOptions,
+  ControlWorkspaceOptions,
+  UseControlSchemaReturn,
+} from './controlSchemaTypes'
+
+export {
+  getBioTemplateControlSchema,
+  requireBioTemplateControlSchema,
+}
+
+export type {
+  BioTemplateControlSchema,
+  BioTemplateControlTarget,
+}
+
+/** Build FormBuilder schema, AppSidebar panels, and defaults for a built-in biology template or preset. */
+export function useBioTemplateControls(
+  target: BioTemplateControlTarget,
+  options: ControlWorkspaceOptions = {},
+): UseControlSchemaReturn<BioTemplateControlSchema> {
+  const { initialValues, topBarSettings: _topBarSettings, ...schemaOptions } = options
+  const controls = createBioTemplateControlToolkit(target, schemaOptions as ControlSchemaOptions)
+
+  if (initialValues === undefined) return controls
+
+  return {
+    ...controls,
+    initialValues: {
+      ...controls.initialValues,
+      ...initialValues,
+    },
+  }
+}

package/src/composables/useBioTemplatePackWorkspace.ts

@@ -0,0 +1,193 @@
+import {
+  computed,
+  effectScope,
+  getCurrentScope,
+  onScopeDispose,
+  shallowRef,
+  watch,
+  type ComputedRef,
+  type EffectScope,
+  type Ref,
+} from 'vue'
+import {
+  createBioTemplatePackCollection,
+  getBioTemplatePackInfo,
+  type BioTemplatePackEntry,
+  type TemplateCollectionEnvelope,
+  type TemplatePackId,
+} from '../templates'
+import {
+  useTemplateCollection,
+  type UseTemplateCollectionOptions,
+  type UseTemplateCollectionReturn,
+} from './useTemplateCollection'
+import {
+  useBioTemplateWorkspace,
+  type BioTemplateRendererBinding,
+  type BioTemplateWorkspaceBindings,
+  type UseBioTemplateWorkspaceReturn,
+} from './useBioTemplateWorkspace'
+import type {
+  BioTemplateComponentBinding,
+  BioTemplateComponentBindingsById,
+  BioTemplateComponentImport,
+  BioTemplateComponentPropsByComponent,
+  BioTemplateComponentPropsBinding,
+  BioTemplateComponentPropsById,
+  BioTemplateComponentSnippet,
+  BioTemplateComponentUsage,
+} from './useBioTemplateComponents'
+
+export type UseBioTemplatePackWorkspaceOptions = UseTemplateCollectionOptions
+
+export interface UseBioTemplatePackWorkspaceReturn {
+  packId: TemplatePackId
+  pack: BioTemplatePackEntry
+  collection: Ref<TemplateCollectionEnvelope>
+  templates: UseTemplateCollectionReturn['templates']
+  templateIds: UseTemplateCollectionReturn['templateIds']
+  currentExperimentId: UseTemplateCollectionReturn['currentExperimentId']
+  hasCurrentExperiment: UseTemplateCollectionReturn['hasCurrentExperiment']
+  loading: UseTemplateCollectionReturn['isLoading']
+  saving: UseTemplateCollectionReturn['isSaving']
+  error: UseTemplateCollectionReturn['error']
+  lastLoadedAt: UseTemplateCollectionReturn['lastLoadedAt']
+  lastSavedAt: UseTemplateCollectionReturn['lastSavedAt']
+  renderer: ComputedRef<BioTemplateRendererBinding>
+  workspace: ComputedRef<UseBioTemplateWorkspaceReturn>
+  form: ComputedRef<UseBioTemplateWorkspaceReturn['form']>
+  sidebar: ComputedRef<UseBioTemplateWorkspaceReturn['sidebar']>
+  topBar: ComputedRef<UseBioTemplateWorkspaceReturn['topBar']['value']>
+  pillNav: ComputedRef<UseBioTemplateWorkspaceReturn['pillNav']>
+  topBarSettings: ComputedRef<UseBioTemplateWorkspaceReturn['topBarSettings']>
+  bindings: ComputedRef<BioTemplateWorkspaceBindings>
+  componentBindings: ComputedRef<BioTemplateComponentBinding[]>
+  componentBindingsById: ComputedRef<BioTemplateComponentBindingsById>
+  componentImports: ComputedRef<BioTemplateComponentImport[]>
+  componentProps: ComputedRef<BioTemplateComponentPropsBinding[]>
+  componentPropsById: ComputedRef<BioTemplateComponentPropsById>
+  componentPropsByComponent: ComputedRef<BioTemplateComponentPropsByComponent>
+  componentSnippets: ComputedRef<BioTemplateComponentSnippet[]>
+  componentUsage: ComputedRef<BioTemplateComponentUsage | null>
+  getComponentProps: UseBioTemplateWorkspaceReturn['getComponentProps']
+  applyCollection: (value: unknown, metadata?: Record<string, unknown>) => TemplateCollectionEnvelope
+  resetToDefaultCollection: () => TemplateCollectionEnvelope
+  save: UseTemplateCollectionReturn['save']
+  saveCurrent: UseTemplateCollectionReturn['saveCurrent']
+  load: UseTemplateCollectionReturn['load']
+  loadCurrent: UseTemplateCollectionReturn['loadCurrent']
+  requireCurrentExperimentId: UseTemplateCollectionReturn['requireCurrentExperimentId']
+}
+
+/**
+ * Create a complete workspace for a curated biology template pack from a single pack id.
+ *
+ * @example Recommended
+ * ```ts
+ * const pack = useBioTemplatePackWorkspace('cell-culture-screen')
+ * await pack.loadCurrent()
+ * ```
+ */
+export function useBioTemplatePackWorkspace(
+  packId: TemplatePackId | string,
+  options: UseBioTemplatePackWorkspaceOptions = {},
+): UseBioTemplatePackWorkspaceReturn {
+  const pack = getBioTemplatePackInfo(packId)
+  if (!pack) {
+    throw new Error(`Unknown template pack '${packId}'.`)
+  }
+  const resolvedPack = pack
+
+  const templateCollection = useTemplateCollection({
+    ...options,
+    initial: createDefaultCollection,
+  })
+  const collection = templateCollection.templateCollection
+  let workspaceScope: EffectScope | undefined
+
+  function createWorkspace(value: TemplateCollectionEnvelope): UseBioTemplateWorkspaceReturn {
+    workspaceScope?.stop()
+    workspaceScope = effectScope()
+    return workspaceScope.run(() => useBioTemplateWorkspace(value))!
+  }
+
+  const workspaceRef = shallowRef<UseBioTemplateWorkspaceReturn>(createWorkspace(collection.value))
+  const workspace = computed(() => workspaceRef.value)
+  const renderer = computed<BioTemplateRendererBinding>(() => ({ target: collection.value }))
+  const form = computed(() => workspace.value.form)
+  const sidebar = computed(() => workspace.value.sidebar)
+  const topBar = computed(() => workspace.value.topBar.value)
+  const pillNav = computed(() => workspace.value.pillNav)
+  const topBarSettings = computed(() => workspace.value.topBarSettings)
+  const bindings = computed(() => workspace.value.bindings)
+  const componentBindings = computed(() => workspace.value.componentBindings)
+  const componentBindingsById = computed(() => workspace.value.componentBindingsById)
+  const componentImports = computed(() => workspace.value.componentImports)
+  const componentProps = computed(() => workspace.value.componentProps)
+  const componentPropsById = computed(() => workspace.value.componentPropsById)
+  const componentPropsByComponent = computed(() => workspace.value.componentPropsByComponent)
+  const componentSnippets = computed(() => workspace.value.componentSnippets)
+  const componentUsage = computed(() => workspace.value.componentUsage)
+
+  watch(collection, value => {
+    workspaceRef.value = createWorkspace(value)
+  })
+
+  if (getCurrentScope()) {
+    onScopeDispose(() => workspaceScope?.stop())
+  }
+
+  function createDefaultCollection(): TemplateCollectionEnvelope {
+    return createBioTemplatePackCollection(resolvedPack.name)
+  }
+
+  function applyCollection(
+    value: unknown,
+    metadata?: Record<string, unknown>,
+  ): TemplateCollectionEnvelope {
+    return templateCollection.apply(value, metadata)
+  }
+
+  function resetToDefaultCollection(): TemplateCollectionEnvelope {
+    return templateCollection.apply(createDefaultCollection())
+  }
+
+  return {
+    packId: resolvedPack.name,
+    pack: resolvedPack,
+    collection,
+    templates: templateCollection.templates,
+    templateIds: templateCollection.templateIds,
+    currentExperimentId: templateCollection.currentExperimentId,
+    hasCurrentExperiment: templateCollection.hasCurrentExperiment,
+    loading: templateCollection.isLoading,
+    saving: templateCollection.isSaving,
+    error: templateCollection.error,
+    lastLoadedAt: templateCollection.lastLoadedAt,
+    lastSavedAt: templateCollection.lastSavedAt,
+    renderer,
+    workspace,
+    form,
+    sidebar,
+    topBar,
+    pillNav,
+    topBarSettings,
+    bindings,
+    componentBindings,
+    componentBindingsById,
+    componentImports,
+    componentProps,
+    componentPropsById,
+    componentPropsByComponent,
+    componentSnippets,
+    componentUsage,
+    getComponentProps: (component, options) => workspace.value.getComponentProps(component, options),
+    applyCollection,
+    resetToDefaultCollection,
+    save: templateCollection.save,
+    saveCurrent: templateCollection.saveCurrent,
+    load: templateCollection.load,
+    loadCurrent: templateCollection.loadCurrent,
+    requireCurrentExperimentId: templateCollection.requireCurrentExperimentId,
+  }
+}