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

package/src/composables/useAutoGroupInputSources.ts

@@ -1,147 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,193 +0,0 @@
-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,
-  }
-}