@morscherlab/mint-sdk 1.0.0-rc.1 → 1.0.0-rc.4

package/src/composables/controlSchemaNormalize.ts

@@ -0,0 +1,101 @@
+import type {
+  SelectOption,
+} from '../types'
+import type {
+  FormFieldType,
+} from '../types/form-builder'
+import {
+  getTypeDefault,
+} from './formBuilderRegistry'
+import {
+  humanize,
+} from './controlSchemaUtils'
+import type {
+  ControlDefinition,
+  ControlInput,
+  ControlOption,
+  ControlOptionValue,
+  ControlSchema,
+  ControlSchemaOptions,
+} from './useControlSchema'
+
+export interface NormalizedControl {
+  name: string
+  definition: ControlDefinition
+  type: FormFieldType
+  sectionId: string
+  viewId: string
+  order: number
+}
+
+export function normalizeControls(
+  controls: ControlSchema,
+  options: ControlSchemaOptions = {},
+): NormalizedControl[] {
+  return Object.entries(controls)
+    .map(([name, input], index): NormalizedControl => {
+      const definition = normalizeControlDefinition(input)
+      const type = definition.type ?? inferControlType(definition)
+      return {
+        name,
+        definition,
+        type,
+        sectionId: definition.section ?? options.section ?? 'controls',
+        viewId: definition.view ?? options.view ?? 'default',
+        order: definition.order ?? index,
+      }
+    })
+    .sort((a, b) => a.order - b.order)
+}
+
+export function normalizeControlDefinition(input: ControlInput): ControlDefinition {
+  if (isControlOptionArray(input)) {
+    if (input.length === 0) return { type: 'tags', default: [] }
+    return {
+      default: optionValue(input[0]),
+      options: input,
+    }
+  }
+
+  if (typeof input === 'string' || typeof input === 'number' || typeof input === 'boolean') {
+    return { default: input }
+  }
+
+  return input
+}
+
+export function defaultValueForControl(definition: ControlDefinition, type: FormFieldType): unknown {
+  if (definition.default !== undefined) return definition.default
+  if (definition.defaultValue !== undefined) return definition.defaultValue
+  return getTypeDefault(type)
+}
+
+export function normalizeOption(option: ControlOption): SelectOption<unknown> {
+  if (typeof option === 'object' && option !== null && 'label' in option) {
+    return option
+  }
+  return {
+    value: option,
+    label: humanize(String(option)),
+  }
+}
+
+function isControlOptionArray(input: ControlInput): input is readonly ControlOption[] {
+  return Array.isArray(input)
+}
+
+function inferControlType(definition: ControlDefinition): FormFieldType {
+  const value = definition.default ?? definition.defaultValue
+  if (definition.options?.length) return Array.isArray(value) ? 'multiselect' : 'select'
+  if (typeof value === 'boolean') return 'toggle'
+  if (typeof value === 'number') return 'number'
+  if (Array.isArray(value)) return 'tags'
+  return 'text'
+}
+
+function optionValue(option: ControlOption): ControlOptionValue | unknown {
+  if (typeof option === 'object' && option !== null && 'value' in option) {
+    return option.value
+  }
+  return option
+}

package/src/composables/controlSchemaUtils.ts

@@ -0,0 +1,36 @@
+export function recordValue(value: unknown): Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {}
+}
+
+export function numericValue(value: number | { value: number; message: string }): number {
+  return typeof value === 'number' ? value : value.value
+}
+
+export function orderedUnique(values: string[]): string[] {
+  return [...new Set(values)]
+}
+
+export function replaceRecord(target: Record<string, unknown>, values: Record<string, unknown>) {
+  for (const key of Object.keys(target)) {
+    delete target[key]
+  }
+  Object.assign(target, values)
+}
+
+export function omitUndefined<T extends object>(record: T): T {
+  const next: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(record as Record<string, unknown>)) {
+    if (value !== undefined) next[key] = value
+  }
+  return next as T
+}
+
+export function humanize(value: string): string {
+  return value
+    .replace(/[_-]+/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .trim()
+    .replace(/\w\S*/g, word => word.charAt(0).toUpperCase() + word.slice(1))
+}

package/src/composables/controlWorkspaceOptions.ts

@@ -0,0 +1,21 @@
+import type {
+  ControlWorkspaceOptions,
+} from './useControlSchema'
+
+export function mergeControlWorkspaceOptions(
+  base?: ControlWorkspaceOptions,
+  override?: ControlWorkspaceOptions,
+): ControlWorkspaceOptions {
+  return {
+    ...(base ?? {}),
+    ...(override ?? {}),
+    initialValues: {
+      ...(base?.initialValues ?? {}),
+      ...(override?.initialValues ?? {}),
+    },
+    topBarSettings: {
+      ...(base?.topBarSettings ?? {}),
+      ...(override?.topBarSettings ?? {}),
+    },
+  }
+}

package/src/composables/experimentDesignData.ts

@@ -0,0 +1,182 @@
+import type { SelectOption } from '../types'
+
+export interface ExperimentDesignDataResponse {
+  experiment_id?: number
+  plugin_id?: string
+  data?: Record<string, unknown>
+  schema_version?: string
+  updated_at?: string | null
+}
+
+export interface ExtractExperimentSamplesOptions {
+  includeControls?: boolean
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function isPlatformDesignDataResponse(value: Record<string, unknown>): boolean {
+  return (
+    'data' in value
+    && (
+      'experiment_id' in value
+      || 'plugin_id' in value
+      || 'schema_version' in value
+      || 'updated_at' in value
+    )
+  )
+}
+
+/** Return the plugin-defined design_data payload from common platform and plugin response shapes. */
+export function unwrapExperimentDesignData(
+  rawData: Record<string, unknown> | null | undefined,
+): Record<string, unknown> | null {
+  if (!rawData) return null
+
+  if (isRecord(rawData.data) && isPlatformDesignDataResponse(rawData)) {
+    return rawData.data
+  }
+
+  if (isRecord(rawData.design_data)) {
+    return rawData.design_data
+  }
+
+  if (isRecord(rawData.designData)) {
+    return rawData.designData
+  }
+
+  return rawData
+}
+
+function shouldIncludeSample(record: Record<string, unknown>, options: ExtractExperimentSamplesOptions): boolean {
+  if (options.includeControls) return true
+  const rawType = record.sample_type ?? record.sampleType ?? record.type ?? record.well_type ?? record.wellType
+  const type = typeof rawType === 'string' ? rawType.toLowerCase() : ''
+  return !['blank', 'qc'].includes(type)
+}
+
+function readSampleValue(record: Record<string, unknown>): string | null {
+  const candidates = [
+    record.sample_name,
+    record.sampleName,
+    record.sample_id,
+    record.sampleId,
+    record.name,
+    record.id,
+    record.label,
+  ]
+
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim()) {
+      return candidate
+    }
+    if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+      return String(candidate)
+    }
+  }
+
+  return null
+}
+
+function readSampleLabel(record: Record<string, unknown>, fallback: string): string {
+  const label = record.name ?? record.label ?? record.sample_name ?? record.sampleName
+  return typeof label === 'string' && label.trim() ? label : fallback
+}
+
+function readSampleDescription(record: Record<string, unknown>): string | undefined {
+  const parts = [
+    record.group,
+    record.batch,
+    record.batch_id,
+    record.batchId,
+    record.plate_id,
+    record.plateId,
+    record.well_id,
+    record.wellId,
+  ].filter((value): value is string | number =>
+    (typeof value === 'string' && value.trim().length > 0)
+    || typeof value === 'number',
+  )
+
+  return parts.length > 0 ? parts.map(String).join(' / ') : undefined
+}
+
+function addSampleRecord(
+  options: SelectOption<string>[],
+  seen: Set<string>,
+  value: unknown,
+  extractOptions: ExtractExperimentSamplesOptions,
+): void {
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (trimmed && !seen.has(trimmed)) {
+      seen.add(trimmed)
+      options.push({ value: trimmed, label: trimmed })
+    }
+    return
+  }
+
+  if (!isRecord(value) || !shouldIncludeSample(value, extractOptions)) return
+
+  const sampleValue = readSampleValue(value)
+  if (!sampleValue || seen.has(sampleValue)) return
+
+  seen.add(sampleValue)
+  options.push({
+    value: sampleValue,
+    label: readSampleLabel(value, sampleValue),
+    description: readSampleDescription(value),
+  })
+}
+
+function addSampleArray(
+  options: SelectOption<string>[],
+  seen: Set<string>,
+  value: unknown,
+  extractOptions: ExtractExperimentSamplesOptions,
+): void {
+  if (!Array.isArray(value)) return
+  for (const sample of value) {
+    addSampleRecord(options, seen, sample, extractOptions)
+  }
+}
+
+/** Extract selectable sample options from raw or wrapped experiment design_data. */
+export function extractSampleOptionsFromDesignData(
+  rawData: Record<string, unknown> | null | undefined,
+  options: ExtractExperimentSamplesOptions = {},
+): SelectOption<string>[] {
+  const designData = unwrapExperimentDesignData(rawData)
+  if (!designData) return []
+
+  const sampleOptions: SelectOption<string>[] = []
+  const seen = new Set<string>()
+
+  addSampleArray(sampleOptions, seen, designData.samples, options)
+
+  if (isRecord(designData.templates)) {
+    for (const template of Object.values(designData.templates)) {
+      if (!isRecord(template)) continue
+      const templateData = isRecord(template.data) ? template.data : template
+      addSampleArray(sampleOptions, seen, templateData.samples, options)
+    }
+  }
+
+  if (Array.isArray(designData.plates)) {
+    for (const plate of designData.plates) {
+      if (!isRecord(plate)) continue
+      addSampleArray(sampleOptions, seen, plate.samples, options)
+    }
+  }
+
+  return sampleOptions
+}
+
+/** Extract SampleSelector-compatible string values from raw or wrapped experiment design_data. */
+export function extractSampleNamesFromDesignData(
+  rawData: Record<string, unknown> | null | undefined,
+  options: ExtractExperimentSamplesOptions = {},
+): string[] {
+  return extractSampleOptionsFromDesignData(rawData, options).map(sample => sample.value)
+}

package/src/composables/index.ts

@@ -144,6 +144,20 @@ export {
   type UseExperimentDataOptions,
   type UseExperimentDataReturn,
 } from './useExperimentData'
+export {
+  extractSampleNamesFromDesignData,
+  extractSampleOptionsFromDesignData,
+  unwrapExperimentDesignData,
+  type ExperimentDesignDataResponse,
+  type ExtractExperimentSamplesOptions,
+} from './experimentDesignData'
+export {
+  useExperimentSamples,
+  type ExperimentDesignDataSource,
+  type ExperimentIdSource,
+  type UseExperimentSamplesOptions,
+  type UseExperimentSamplesReturn,
+} from './useExperimentSamples'
 export {
   getFieldRegistryEntry,
   getTypeDefault,

package/src/composables/useAuth.ts

@@ -3,6 +3,7 @@ import { ref, onMounted, onUnmounted, watch, getCurrentInstance, type Ref } from
 import { useAuthStore } from '../stores/auth'
 import { useSettingsStore } from '../stores/settings'
 import type { AuthConfig, UserInfo, LoginResponse, TokenVerifyResponse, UpdateProfileRequest } from '../types'
+import type { RoleInfo } from '../permissions'
 
 interface UserResponse {
   id: string
@@ -10,6 +11,7 @@ interface UserResponse {
   shortname: string | null
   email: string | null
   role: string
+  role_obj?: RoleInfo | null
   is_active: boolean
 }
 
@@ -187,6 +189,7 @@ export function useAuth(): UseAuthReturn {
         shortname: response.data.shortname,
         email: response.data.email,
         role: response.data.role,
+        roleObj: response.data.role_obj ?? null,
         isActive: response.data.is_active,
       }
 
@@ -379,6 +382,7 @@ export function useAuth(): UseAuthReturn {
         shortname: response.data.shortname,
         email: response.data.email,
         role: response.data.role,
+        roleObj: response.data.role_obj ?? null,
         isActive: response.data.is_active,
       }
       authStore.setUserInfo(userInfo)

package/src/composables/useAutoGroup.ts

@@ -9,6 +9,7 @@ import type {
   ParsedCsvData,
 } from '../types/auto-group'
 import type { SampleGroup } from '../types/components'
+import { unwrapExperimentDesignData } from './experimentDesignData'
 
 export const DEFAULT_COLORS = [
   '#3B82F6', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6',
@@ -311,7 +312,10 @@ export function computeGroups(
 export function extractSamplesFromDesignData(
   rawData: Record<string, unknown>,
 ): ParsedCsvData | null {
-  const samples = rawData.samples
+  const designData = unwrapExperimentDesignData(rawData)
+  if (!designData) return null
+
+  const samples = designData.samples
   if (!Array.isArray(samples) || samples.length === 0) return null
 
   // Single pass: filter QC/blank and collect all condition keys