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

package/src/composables/experiment-utils.ts

@@ -1,105 +0,0 @@
-import type { DatePreset, ExperimentStatus, SelectOption, PillVariant } from '../types'
-
-interface ExperimentCodeSource {
-  id?: number | null
-  experiment_code?: string | null
-}
-
-export function formatExperimentDate(dateStr: string): string {
-  try {
-    return new Date(dateStr).toLocaleDateString(undefined, {
-      year: 'numeric',
-      month: 'short',
-      day: 'numeric',
-    })
-  } catch {
-    return dateStr
-  }
-}
-
-export function datePresetToISO(preset: DatePreset): string {
-  const now = new Date()
-  const days = preset === 'last_7_days' ? 7 : preset === 'last_30_days' ? 30 : 90
-  const d = new Date(now.getTime() - days * 86_400_000)
-  return d.toISOString()
-}
-
-export const EXPERIMENT_STATUS_OPTIONS: SelectOption<string>[] = [
-  { value: '', label: 'All statuses' },
-  { value: 'planned', label: 'Planned' },
-  { value: 'ongoing', label: 'Ongoing' },
-  { value: 'completed', label: 'Completed' },
-  { value: 'cancelled', label: 'Cancelled' },
-]
-
-export const EXPERIMENT_STATUS_VARIANT_MAP: Record<ExperimentStatus, PillVariant> = {
-  planned: 'default',
-  ongoing: 'primary',
-  completed: 'success',
-  cancelled: 'error',
-}
-
-export const EXPERIMENT_STATUS_LABELS: Record<ExperimentStatus, string> = {
-  planned: 'Planned',
-  ongoing: 'Ongoing',
-  completed: 'Completed',
-  cancelled: 'Cancelled',
-}
-
-export function formatExperimentStatus(status?: ExperimentStatus | string | null): string {
-  if (!status) return ''
-  if (status in EXPERIMENT_STATUS_LABELS) {
-    return EXPERIMENT_STATUS_LABELS[status as ExperimentStatus]
-  }
-  const label = String(status).replace(/[-_]+/g, ' ').trim()
-  return label ? label.replace(/^\w/, c => c.toUpperCase()) : ''
-}
-
-export function getExperimentStatusVariant(status?: ExperimentStatus | string | null): PillVariant {
-  if (status && status in EXPERIMENT_STATUS_VARIANT_MAP) {
-    return EXPERIMENT_STATUS_VARIANT_MAP[status as ExperimentStatus]
-  }
-  return 'default'
-}
-
-export function resolveExperimentCode(experiment: ExperimentCodeSource): string | undefined {
-  if (experiment.experiment_code) return experiment.experiment_code
-  return undefined
-}
-
-// Mirrors vue-router's LocationQuery, whose array members are `string | null`.
-// Declaring `string[]` here made the helper reject the very type every caller
-// passes it, so keep this assignable from LocationQuery without importing
-// vue-router (the SDK does not depend on it).
-type RouteQueryValue = string | null | undefined | readonly (string | null | undefined)[]
-type RouteQueryLike = Record<string, RouteQueryValue>
-
-/**
- * Reads the experiment id a deep link was opened with.
- *
- * Returns an id and never a label: a display name belongs to the platform, so
- * callers must resolve it (see `useExperimentStore().selectById`) rather than
- * derive one from the query or the id itself.
- */
-export function experimentIdFromRoute(query: RouteQueryLike): number | null {
-  const raw = query.experiment_id ?? query.experimentId
-  const value = Array.isArray(raw) ? raw.find(item => typeof item === 'string') : raw
-  if (typeof value !== 'string' || !value) return null
-  const id = Number(value)
-  return Number.isInteger(id) && id > 0 ? id : null
-}
-
-export const DATE_PRESET_OPTIONS: SelectOption<string>[] = [
-  { value: '', label: 'Any time' },
-  { value: 'last_7_days', label: 'Last 7 days' },
-  { value: 'last_30_days', label: 'Last 30 days' },
-  { value: 'last_90_days', label: 'Last 90 days' },
-]
-
-export const SORT_OPTIONS: SelectOption<string>[] = [
-  { value: 'created_at:desc', label: 'Newest first' },
-  { value: 'created_at:asc', label: 'Oldest first' },
-  { value: 'updated_at:desc', label: 'Recently updated' },
-  { value: 'name:asc', label: 'Name A\u2013Z' },
-  { value: 'name:desc', label: 'Name Z\u2013A' },
-]

package/src/composables/experimentDesignData.ts

@@ -1,182 +0,0 @@
-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/formBuilderRegistry.ts

@@ -1,81 +0,0 @@
-import type { Component } from 'vue'
-import type { FormFieldType } from '../types/form-builder'
-
-import BaseInput from '../components/BaseInput.vue'
-import BaseTextarea from '../components/BaseTextarea.vue'
-import BaseSelect from '../components/BaseSelect.vue'
-import MultiSelect from '../components/MultiSelect.vue'
-import BaseCheckbox from '../components/BaseCheckbox.vue'
-import BaseToggle from '../components/BaseToggle.vue'
-import BaseRadioGroup from '../components/BaseRadioGroup.vue'
-import BaseSlider from '../components/BaseSlider.vue'
-import TagsInput from '../components/TagsInput.vue'
-import NumberInput from '../components/NumberInput.vue'
-import DatePicker from '../components/DatePicker.vue'
-import TimePicker from '../components/TimePicker.vue'
-import DateTimePicker from '../components/DateTimePicker.vue'
-import FileUploader from '../components/FileUploader.vue'
-import GeneratedPathInput from '../components/GeneratedPathInput.vue'
-import FormulaInput from '../components/FormulaInput.vue'
-import SequenceInput from '../components/SequenceInput.vue'
-import MoleculeInput from '../components/MoleculeInput.vue'
-import ConcentrationInput from '../components/ConcentrationInput.vue'
-import UnitInput from '../components/UnitInput.vue'
-
-export interface RegistryEntry {
-  component: Component
-  /** Default props applied to the component. */
-  defaults: Record<string, unknown>
-  /** Whether the component uses v-model (false for event-only components like FileUploader). */
-  vModel: boolean
-}
-
-const registry: Record<FormFieldType, RegistryEntry> = {
-  text: { component: BaseInput, defaults: { type: 'text' }, vModel: true },
-  email: { component: BaseInput, defaults: { type: 'email' }, vModel: true },
-  password: { component: BaseInput, defaults: { type: 'password' }, vModel: true },
-  tel: { component: BaseInput, defaults: { type: 'tel' }, vModel: true },
-  url: { component: BaseInput, defaults: { type: 'url' }, vModel: true },
-  search: { component: BaseInput, defaults: { type: 'search' }, vModel: true },
-  number: { component: NumberInput, defaults: {}, vModel: true },
-  textarea: { component: BaseTextarea, defaults: {}, vModel: true },
-  select: { component: BaseSelect, defaults: {}, vModel: true },
-  multiselect: { component: MultiSelect, defaults: {}, vModel: true },
-  checkbox: { component: BaseCheckbox, defaults: {}, vModel: true },
-  toggle: { component: BaseToggle, defaults: {}, vModel: true },
-  radio: { component: BaseRadioGroup, defaults: {}, vModel: true },
-  slider: { component: BaseSlider, defaults: {}, vModel: true },
-  tags: { component: TagsInput, defaults: {}, vModel: true },
-  date: { component: DatePicker, defaults: {}, vModel: true },
-  time: { component: TimePicker, defaults: {}, vModel: true },
-  datetime: { component: DateTimePicker, defaults: {}, vModel: true },
-  file: { component: FileUploader, defaults: {}, vModel: false },
-  path: { component: GeneratedPathInput, defaults: {}, vModel: true },
-  formula: { component: FormulaInput, defaults: {}, vModel: true },
-  sequence: { component: SequenceInput, defaults: {}, vModel: true },
-  molecule: { component: MoleculeInput, defaults: {}, vModel: true },
-  concentration: { component: ConcentrationInput, defaults: {}, vModel: true },
-  unit: { component: UnitInput, defaults: {}, vModel: true },
-}
-
-/** Return the registry entry for a given field type. Throws if the type is unregistered. */
-export function getFieldRegistryEntry(type: FormFieldType): RegistryEntry {
-  return registry[type]
-}
-
-/** Get the default empty value for a given field type. */
-export function getTypeDefault(type: FormFieldType): unknown {
-  switch (type) {
-    case 'checkbox':
-    case 'toggle':
-      return false
-    case 'number':
-    case 'slider':
-      return undefined
-    case 'multiselect':
-    case 'tags':
-      return []
-    default:
-      return ''
-  }
-}

package/src/composables/formBuilderSchema.ts

@@ -1,153 +0,0 @@
-import { getTypeDefault } from './formBuilderRegistry'
-import type { FieldRules } from './useForm'
-import type {
-  FieldCondition,
-  FieldValidation,
-  FormEnhancements,
-  FormFieldSchema,
-  FormSchema,
-  FormSectionSchema,
-} from '../types/form-builder'
-
-/**
- * Evaluate a JSON-serializable field condition against the current form data.
- *
- * Supports logical operators (`and`, `or`, `not`) and comparison operators
- * (`eq`, `neq`, `gt`, `lt`, `gte`, `lte`, `in`, `notIn`, `truthy`, `falsy`,
- * `contains`). Returns `true` if the condition passes.
- */
-export function evaluateCondition(
-  condition: FieldCondition,
-  data: Record<string, unknown>,
-): boolean {
-  if ('and' in condition) {
-    return condition.and.every((c) => evaluateCondition(c, data))
-  }
-  if ('or' in condition) {
-    return condition.or.some((c) => evaluateCondition(c, data))
-  }
-  if ('not' in condition) {
-    return !evaluateCondition(condition.not, data)
-  }
-
-  const value = data[condition.field]
-
-  if ('eq' in condition) return value === condition.eq
-  if ('neq' in condition) return value !== condition.neq
-  if ('gt' in condition) return typeof value === 'number' && value > condition.gt
-  if ('lt' in condition) return typeof value === 'number' && value < condition.lt
-  if ('gte' in condition) return typeof value === 'number' && value >= condition.gte
-  if ('lte' in condition) return typeof value === 'number' && value <= condition.lte
-  if ('in' in condition) return condition.in.includes(value)
-  if ('notIn' in condition) return !condition.notIn.includes(value)
-  if ('truthy' in condition) return !!value
-  if ('falsy' in condition) return !value
-  if ('contains' in condition) {
-    if (typeof value === 'string') return value.includes(condition.contains)
-    if (Array.isArray(value)) return value.includes(condition.contains)
-    return false
-  }
-
-  return true
-}
-
-/** Return all sections across steps (wizard) or directly from a flat schema. */
-export function collectSections(schema: FormSchema): FormSectionSchema[] {
-  return schema.steps ? schema.steps.flatMap((step) => step.sections) : schema.sections
-}
-
-/** Return all field schemas in schema order, flattening sections and steps. */
-export function flattenFields(schema: FormSchema): FormFieldSchema[] {
-  return collectSections(schema).flatMap((section) => section.fields)
-}
-
-/** Convert a JSON-safe `FieldValidation` descriptor to a runtime `FieldRules` object. */
-function convertValidation(v: FieldValidation): FieldRules {
-  const rules: FieldRules = {}
-
-  if (v.required !== undefined) rules.required = v.required
-  if (v.minLength !== undefined) rules.minLength = v.minLength
-  if (v.maxLength !== undefined) rules.maxLength = v.maxLength
-  if (v.min !== undefined) rules.min = v.min
-  if (v.max !== undefined) rules.max = v.max
-  if (v.email !== undefined) rules.email = v.email
-
-  if (v.pattern !== undefined) {
-    rules.pattern =
-      typeof v.pattern === 'string'
-        ? new RegExp(v.pattern)
-        : { value: new RegExp(v.pattern.value), message: v.pattern.message }
-  }
-
-  return rules
-}
-
-export function buildInitialValues<T extends Record<string, unknown>>(
-  fields: readonly FormFieldSchema[],
-  initialData?: Partial<T>,
-): Record<string, unknown> {
-  const initialValues = {} as Record<string, unknown>
-
-  for (const field of fields) {
-    const key = field.name
-    if (initialData && hasOwnKey(initialData, key)) {
-      initialValues[key] = (initialData as Record<string, unknown>)[key]
-    } else if (field.defaultValue !== undefined) {
-      initialValues[key] = field.defaultValue
-    } else {
-      initialValues[key] = getTypeDefault(field.type)
-    }
-  }
-
-  return initialValues
-}
-
-export function buildRules<T extends Record<string, unknown>>(
-  fields: readonly FormFieldSchema[],
-  enhancements?: FormEnhancements<T>,
-): Partial<Record<string, FieldRules>> {
-  const rules: Partial<Record<string, FieldRules>> = {}
-
-  for (const field of fields) {
-    const base: FieldRules = field.validation ? convertValidation(field.validation) : {}
-    const enhancement = enhancements?.fields?.[field.name as keyof T]
-
-    const customValidators: Array<(
-      value: unknown,
-      formData: Record<string, unknown>,
-    ) => string | undefined | null> = []
-
-    if (enhancement?.validate) {
-      const fn = enhancement.validate
-      customValidators.push((value, formData) => fn(value, formData as T))
-    }
-
-    if (customValidators.length > 0) {
-      base.custom = customValidators
-    }
-
-    if (Object.keys(base).length > 0) {
-      rules[field.name] = base
-    }
-  }
-
-  return rules
-}
-
-export function replaceArray<T>(target: T[], values: readonly T[]): void {
-  target.splice(0, target.length, ...values)
-}
-
-export function replaceRecord<TValue>(
-  target: Partial<Record<string, TValue>>,
-  source: Partial<Record<string, TValue>>,
-): void {
-  for (const key of Object.keys(target)) {
-    delete target[key]
-  }
-  Object.assign(target, source)
-}
-
-function hasOwnKey(source: object, key: string): boolean {
-  return Object.prototype.hasOwnProperty.call(source, key)
-}