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

package/src/composables/controlSchemaAdapters.ts

@@ -0,0 +1,199 @@
+import type {
+  PillNavItem,
+  SidebarToolSection,
+  SettingsModalSchema,
+  TopBarSettingsConfig,
+} from '../types'
+import type {
+  FormSectionSchema,
+} from '../types/form-builder'
+import {
+  controlToFormField,
+} from './controlSchemaFormFields'
+import {
+  controlViewItem,
+  firstSidebarConfig,
+  isSidebarEnabled,
+  sectionConfig,
+} from './controlSchemaLayout'
+import {
+  normalizeControls,
+} from './controlSchemaNormalize'
+import {
+  humanize,
+  orderedUnique,
+} from './controlSchemaUtils'
+import type {
+  ControlFormSchema,
+  ControlSchema,
+  ControlSchemaOptions,
+} from './controlSchemaTypes'
+
+/** Convert a compact control schema into a FormBuilder schema. */
+export function controlsToFormSchema(
+  controls: ControlSchema,
+  options: ControlSchemaOptions = {},
+): ControlFormSchema {
+  const normalized = normalizeControls(controls, options)
+  const sectionIds = orderedUnique(normalized.map(control => control.sectionId))
+  const sections = sectionIds.map((sectionId): FormSectionSchema => {
+    const sectionControls = normalized.filter(control => control.sectionId === sectionId)
+    const config = sectionConfig(sectionId, sectionControls, options)
+    return {
+      id: sectionId,
+      title: config.title ?? config.label ?? humanize(sectionId),
+      description: config.description,
+      columns: config.columns ?? options.columns ?? 1,
+      defaultOpen: config.defaultOpen,
+      condition: config.condition,
+      fields: sectionControls.map(controlToFormField),
+    }
+  })
+
+  return {
+    sections,
+    submitLabel: options.submitLabel,
+    cancelLabel: options.cancelLabel,
+    showCancel: options.showCancel,
+  }
+}
+
+/** Convert controls into AppSidebar panels grouped by view and section. */
+export function controlsToSidebarPanels(
+  controls: ControlSchema,
+  options: ControlSchemaOptions = {},
+): Record<string, SidebarToolSection[]> {
+  const normalized = normalizeControls(controls, options)
+    .filter(control => isSidebarEnabled(control.definition.sidebar))
+  const viewIds = orderedUnique(normalized.map(control => control.viewId))
+  const panels: Record<string, SidebarToolSection[]> = {}
+
+  for (const viewId of viewIds) {
+    const viewControls = normalized.filter(control => control.viewId === viewId)
+    const sectionIds = orderedUnique(viewControls.map(control => control.sectionId))
+    panels[viewId] = sectionIds.map((sectionId): SidebarToolSection => {
+      const sectionControls = viewControls.filter(control => control.sectionId === sectionId)
+      const config = sectionConfig(sectionId, sectionControls, options)
+      const sidebarConfig = firstSidebarConfig(sectionControls)
+      return {
+        id: sectionId,
+        label: sidebarConfig?.label ?? config.label ?? config.title ?? humanize(sectionId),
+        subtitle: sidebarConfig?.subtitle ?? config.subtitle,
+        icon: sidebarConfig?.icon ?? config.icon,
+        iconColor: sidebarConfig?.iconColor ?? config.iconColor,
+        iconBg: sidebarConfig?.iconBg ?? config.iconBg,
+        badge: sidebarConfig?.badge ?? config.badge,
+        badgeTone: sidebarConfig?.badgeTone ?? config.badgeTone,
+        actions: sidebarConfig?.actions ?? config.actions,
+        defaultOpen: sidebarConfig?.defaultOpen ?? config.defaultOpen,
+        showToggle: sidebarConfig?.showToggle ?? config.showToggle,
+      }
+    })
+  }
+
+  return panels
+}
+
+/** Convert controls into a SettingsModal schema grouped by the same sections. */
+export function controlsToSettingsSchema(
+  controls: ControlSchema,
+  options: ControlSchemaOptions = {},
+): SettingsModalSchema {
+  const normalized = normalizeControls(controls, options)
+  const sectionIds = orderedUnique(normalized.map(control => control.sectionId))
+
+  return {
+    groups: sectionIds.map((sectionId) => {
+      const sectionControls = normalized.filter(control => control.sectionId === sectionId)
+      const config = sectionConfig(sectionId, sectionControls, options)
+      return {
+        id: sectionId,
+        label: config.label ?? config.title ?? humanize(sectionId),
+        description: config.description ?? config.subtitle,
+        icon: typeof config.icon === 'string' ? config.icon : undefined,
+        fields: sectionControls.map(controlToFormField),
+        columns: config.columns ?? options.columns ?? 1,
+        condition: config.condition,
+        access: config.access,
+        visibleFor: config.visibleFor,
+        requiresAdmin: config.requiresAdmin,
+        permissions: config.permissions,
+        anyPermissions: config.anyPermissions,
+      }
+    }),
+  }
+}
+
+/** Convert controls into an AppTopBar settingsConfig object that passes compact controls through to SettingsModal. */
+export function controlsToTopBarSettingsConfig(
+  controls: ControlSchema,
+  options: ControlSchemaOptions = {},
+  config: Omit<TopBarSettingsConfig, 'schema' | 'controls' | 'controlOptions'> = {},
+): TopBarSettingsConfig {
+  return {
+    ...config,
+    controls,
+    controlOptions: options,
+  }
+}
+
+/** Return generated control view IDs that have at least one sidebar panel. */
+export function controlsToViewIds(
+  controls: ControlSchema,
+  options: ControlSchemaOptions = {},
+): string[] {
+  return controlsToViewItems(controls, options).map(item => item.id)
+}
+
+/** Return AppTopBar pillNav-compatible view items for switching generated control sidebars. */
+export function controlsToViewItems(
+  controls: ControlSchema,
+  options: ControlSchemaOptions = {},
+): PillNavItem[] {
+  return Object.entries(controlsToSidebarPanels(controls, options))
+    .filter(([, sections]) => sections.length > 0)
+    .map(([id]) => controlViewItem(id, options))
+}
+
+/** Return the first generated sidebar view ID, or an empty string when controls render no sidebar panels. */
+export function getDefaultControlView(
+  controls: ControlSchema,
+  options: ControlSchemaOptions = {},
+): string {
+  return controlsToViewIds(controls, options)[0] ?? ''
+}
+
+/** Return a headerless single-section FormBuilder schema for rendering inside an AppSidebar section slot. */
+export function controlsToSectionFormSchema(
+  controls: ControlSchema,
+  sectionId: string,
+  options: ControlSchemaOptions = {},
+): ControlFormSchema {
+  const schema = controlsToFormSchema(controls, options)
+  return {
+    sections: schema.sections
+      .filter(section => section.id === sectionId)
+      .map(section => ({ ...section, title: '', description: undefined })),
+    submitLabel: schema.submitLabel,
+    cancelLabel: schema.cancelLabel,
+    showCancel: schema.showCancel,
+  }
+}
+
+/** Return headerless FormBuilder schemas keyed by section ID for AppSidebar auto-rendering. */
+export function controlsToSectionFormSchemas(
+  controls: ControlSchema,
+  options: ControlSchemaOptions = {},
+): Record<string, ControlFormSchema> {
+  const schema = controlsToFormSchema(controls, options)
+  const schemas: Record<string, ControlFormSchema> = {}
+  for (const section of schema.sections) {
+    schemas[section.id] = {
+      sections: [{ ...section, title: '', description: undefined }],
+      submitLabel: schema.submitLabel,
+      cancelLabel: schema.cancelLabel,
+      showCancel: schema.showCancel,
+    }
+  }
+  return schemas
+}

package/src/composables/controlSchemaDoseDesign.ts

@@ -0,0 +1,222 @@
+import type {
+  ControlComponentBindingsConfig,
+  ControlComponentPropSource,
+  ControlComponentPropsByIdMap,
+  ControlComponentPropsMap,
+  ControlModelBinding,
+  ControlSchema,
+  DoseCalculatorControlPropsOptions,
+  DoseDesignControlModelOptions,
+  WellPlateControlPropsOptions,
+  WellPlateDoseControlPropsOptions,
+} from './controlSchemaTypes'
+import type { WellConcentration } from './useDoseCalculator'
+import {
+  defineControlModel,
+} from './controlSchemaModel'
+import {
+  recordValue,
+} from './controlSchemaUtils'
+
+/** Return a default WellPlate prop mapping for generated control workspaces. */
+export function defineWellPlateControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(
+  options: WellPlateControlPropsOptions<TValues> = {},
+): ControlComponentPropsMap<TValues> {
+  const selectedWells = options.selectedWells ?? sourceKey<TValues>('selectedWells')
+  const onUpdateModelValue = options.onUpdateModelValue === false
+    ? undefined
+    : options.onUpdateModelValue ?? updateControlValueSource(selectedWells)
+
+  return compactComponentPropsMap<TValues>({
+    modelValue: selectedWells,
+    'onUpdate:modelValue': onUpdateModelValue,
+    format: options.format ?? sourceKey<TValues>('plateFormat'),
+    wells: options.wells ?? sourceKey<TValues>('wells'),
+    disabled: options.disabled ?? sourceKey<TValues>('disabled'),
+    readonly: options.readonly ?? sourceKey<TValues>('readonly'),
+    showLegend: options.showLegend,
+    showSampleTypeIndicator: options.showSampleTypeIndicator,
+  })
+}
+
+/** Return a default DoseCalculator prop mapping for generated control workspaces. */
+export function defineDoseCalculatorControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(
+  options: DoseCalculatorControlPropsOptions<TValues> = {},
+): ControlComponentPropsMap<TValues> {
+  const targetWells = options.targetWells ?? sourceKey<TValues>('selectedWells')
+  const wells = options.wells ?? sourceKey<TValues>('wells')
+  const onApplyToWells = options.onApplyToWells === false
+    ? undefined
+    : options.onApplyToWells ?? defaultDoseApplyHandler(wells, targetWells)
+
+  return compactComponentPropsMap<TValues>({
+    mode: options.mode ?? sourceKey<TValues>('doseMode'),
+    targetWells,
+    disabled: options.disabled ?? sourceKey<TValues>('disabled'),
+    molecularWeight: options.molecularWeight,
+    onApplyToWells,
+  })
+}
+
+/** Return named WellPlate + DoseCalculator prop mappings for one dose-design control model. */
+export function defineWellPlateDoseControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(
+  options: WellPlateDoseControlPropsOptions<TValues> = {},
+): ControlComponentPropsByIdMap<TValues> {
+  return {
+    [options.plateId ?? 'plate']: defineWellPlateControlProps(options.plate),
+    [options.doseId ?? 'dose']: defineDoseCalculatorControlProps(options.dose),
+  }
+}
+
+/** Return named WellPlate + DoseCalculator component bindings for one dose-design control model. */
+export function defineWellPlateDoseComponentBindings<TValues extends Record<string, unknown> = Record<string, unknown>>(
+  options: WellPlateDoseControlPropsOptions<TValues> = {},
+): ControlComponentBindingsConfig<TValues> {
+  return [
+    {
+      id: options.plateId ?? 'plate',
+      component: 'WellPlate',
+      props: defineWellPlateControlProps(options.plate),
+    },
+    {
+      id: options.doseId ?? 'dose',
+      component: 'DoseCalculator',
+      props: defineDoseCalculatorControlProps(options.dose),
+    },
+  ]
+}
+
+/**
+ * Return a complete ControlWorkspaceView model for WellPlate + DoseCalculator dose design.
+ *
+ * @example Recommended
+ * ```ts
+ * const workspaceModel = defineDoseDesignControlModel({ selectedWells: ['A1', 'A2'] })
+ * ```
+ */
+export function defineDoseDesignControlModel(
+  options: DoseDesignControlModelOptions = {},
+): ControlModelBinding {
+  const viewId = options.viewId ?? 'design'
+  const sectionId = options.sectionId ?? 'dose'
+  const doseControls: ControlSchema = {
+    selectedWells: {
+      type: 'tags',
+      label: 'Selected wells',
+      default: [...(options.selectedWells ?? ['A1', 'A2'])],
+    },
+    plateFormat: {
+      label: 'Plate format',
+      default: options.plateFormat ?? 96,
+      options: options.plateFormats ?? [96, 384],
+    },
+    doseMode: {
+      label: 'Dose mode',
+      default: options.doseMode ?? 'serial',
+      options: options.doseModes ?? ['serial', 'dilution', 'conversion'],
+    },
+    disabled: {
+      label: 'Disable tools',
+      default: options.disabled ?? false,
+    },
+  }
+
+  if (options.includeMolecularWeight) {
+    doseControls.molecularWeight = {
+      type: 'number',
+      label: 'Molecular weight',
+      default: options.molecularWeight ?? 300,
+      min: 0,
+    }
+  }
+
+  const componentProps: WellPlateDoseControlPropsOptions = {
+    ...options.componentProps,
+    dose: {
+      ...(options.componentProps?.dose ?? {}),
+      ...(options.includeMolecularWeight && options.componentProps?.dose?.molecularWeight === undefined
+        ? { molecularWeight: 'molecularWeight' }
+        : {}),
+    },
+  }
+
+  return defineControlModel({
+    componentBindings: defineWellPlateDoseComponentBindings(componentProps),
+    componentPropsById: defineWellPlateDoseControlProps(componentProps),
+    views: {
+      [viewId]: {
+        label: options.viewLabel ?? 'Design',
+        sections: {
+          [sectionId]: {
+            label: options.sectionLabel ?? 'Dose design',
+            description: options.sectionDescription ?? 'Well selection and dose calculator controls',
+            controls: doseControls,
+          },
+        },
+      },
+    },
+  })
+}
+
+function compactComponentPropsMap<TValues extends Record<string, unknown>>(
+  mapping: Record<string, ControlComponentPropSource<TValues> | undefined>,
+): ControlComponentPropsMap<TValues> {
+  return Object.fromEntries(
+    Object.entries(mapping).filter((entry): entry is [string, ControlComponentPropSource<TValues>] =>
+      entry[1] !== undefined
+    ),
+  )
+}
+
+function sourceKey<TValues extends Record<string, unknown>>(key: string): keyof TValues & string {
+  return key as keyof TValues & string
+}
+
+function updateControlValueSource<TValues extends Record<string, unknown>>(
+  source: ControlComponentPropSource<TValues>,
+): ((values: TValues) => (value: string[]) => void) | undefined {
+  if (typeof source !== 'string') return undefined
+  return values => (value: string[]) => {
+    const writableValues = values as Record<string, unknown>
+    writableValues[source] = value
+  }
+}
+
+function defaultDoseApplyHandler<TValues extends Record<string, unknown>>(
+  wells: ControlComponentPropSource<TValues>,
+  targetWells: ControlComponentPropSource<TValues>,
+): ((values: TValues) => (results: WellConcentration[]) => void) | undefined {
+  if (wells === targetWells) return undefined
+  return updateWellsFromDoseResults(wells)
+}
+
+function updateWellsFromDoseResults<TValues extends Record<string, unknown>>(
+  source: ControlComponentPropSource<TValues>,
+): ((values: TValues) => (results: WellConcentration[]) => void) | undefined {
+  if (typeof source !== 'string') return undefined
+  return values => (results: WellConcentration[]) => {
+    const writableValues = values as Record<string, unknown>
+    const currentWells = recordValue(writableValues[source])
+    const nextWells: Record<string, Record<string, unknown>> = {}
+    for (const [wellId, well] of Object.entries(currentWells)) {
+      nextWells[wellId] = recordValue(well)
+    }
+
+    for (const result of results) {
+      const existing = recordValue(nextWells[result.wellId])
+      const metadata = recordValue(existing.metadata)
+      nextWells[result.wellId] = {
+        ...existing,
+        state: 'filled',
+        value: result.concentration.value,
+        metadata: {
+          ...metadata,
+          concentration: result.concentration,
+          ...(result.volume === undefined ? {} : { volume: result.volume }),
+        },
+      }
+    }
+
+    writableValues[source] = nextWells
+  }
+}

package/src/composables/controlSchemaFormFields.ts

@@ -0,0 +1,64 @@
+import type {
+  FieldValidation,
+  FormFieldSchema,
+} from '../types/form-builder'
+import {
+  defaultValueForControl,
+  normalizeOption,
+  type NormalizedControl,
+} from './controlSchemaNormalize'
+import {
+  humanize,
+  numericValue,
+} from './controlSchemaUtils'
+import type {
+  ControlDefinition,
+} from './controlSchemaTypes'
+
+export function controlToFormField(control: NormalizedControl): FormFieldSchema {
+  const { name, definition, type } = control
+  const props = fieldProps(definition)
+  return {
+    name,
+    label: definition.label ?? humanize(name),
+    type,
+    defaultValue: defaultValueForControl(definition, type),
+    placeholder: definition.placeholder,
+    hint: definition.hint,
+    icon: definition.icon,
+    iconColor: definition.iconColor,
+    iconBg: definition.iconBg,
+    size: definition.size,
+    disabled: definition.disabled,
+    readonly: definition.readonly,
+    validation: validationForControl(definition),
+    condition: definition.condition,
+    access: definition.access,
+    visibleFor: definition.visibleFor,
+    requiresAdmin: definition.requiresAdmin,
+    permissions: definition.permissions,
+    anyPermissions: definition.anyPermissions,
+    colSpan: definition.colSpan,
+    props,
+  }
+}
+
+function fieldProps(definition: ControlDefinition): Record<string, unknown> {
+  const props: Record<string, unknown> = {}
+  if (definition.min !== undefined) props.min = numericValue(definition.min)
+  if (definition.max !== undefined) props.max = numericValue(definition.max)
+  if (definition.options) props.options = definition.options.map(normalizeOption)
+  return { ...props, ...(definition.props ?? {}) }
+}
+
+function validationForControl(definition: ControlDefinition): FieldValidation | undefined {
+  const validation: FieldValidation = { ...(definition.validation ?? {}) }
+  if (definition.required !== undefined) validation.required = definition.required
+  if (definition.min !== undefined) validation.min = definition.min
+  if (definition.max !== undefined) validation.max = definition.max
+  if (definition.minLength !== undefined) validation.minLength = definition.minLength
+  if (definition.maxLength !== undefined) validation.maxLength = definition.maxLength
+  if (definition.email !== undefined) validation.email = definition.email
+  if (definition.pattern !== undefined) validation.pattern = definition.pattern
+  return Object.keys(validation).length > 0 ? validation : undefined
+}

package/src/composables/controlSchemaLayout.ts

@@ -0,0 +1,59 @@
+import type {
+  PillNavItem,
+} from '../types'
+import type {
+  NormalizedControl,
+} from './controlSchemaNormalize'
+import {
+  humanize,
+} from './controlSchemaUtils'
+import type {
+  ControlDefinition,
+  ControlSchemaOptions,
+  ControlSectionConfig,
+  ControlSidebarConfig,
+} from './controlSchemaTypes'
+
+export function sectionConfig(
+  sectionId: string,
+  controls: NormalizedControl[],
+  options: ControlSchemaOptions,
+): ControlSectionConfig {
+  const configured = options.sections?.[sectionId]
+  const first = controls[0]?.definition
+  return {
+    ...configured,
+    id: sectionId,
+    label: configured?.label ?? first?.sectionLabel,
+    title: configured?.title ?? first?.sectionLabel,
+    description: configured?.description ?? first?.sectionDescription,
+    subtitle: configured?.subtitle ?? first?.sectionSubtitle,
+  }
+}
+
+export function firstSidebarConfig(controls: NormalizedControl[]): ControlSidebarConfig | undefined {
+  for (const control of controls) {
+    const sidebar = control.definition.sidebar
+    if (sidebar && typeof sidebar === 'object' && sidebar.enabled !== false) return sidebar
+  }
+  return undefined
+}
+
+export function isSidebarEnabled(sidebar: ControlDefinition['sidebar']): boolean {
+  if (sidebar === false) return false
+  if (sidebar && typeof sidebar === 'object') return sidebar.enabled !== false
+  return true
+}
+
+export function controlViewItem(viewId: string, options: ControlSchemaOptions): PillNavItem {
+  const config = options.views?.[viewId]
+  return {
+    id: viewId,
+    label: config?.label ?? humanize(viewId),
+    ...(config?.icon !== undefined ? { icon: config.icon } : {}),
+    ...(config?.to !== undefined ? { to: config.to } : {}),
+    ...(config?.href !== undefined ? { href: config.href } : {}),
+    ...(config?.disabled !== undefined ? { disabled: config.disabled } : {}),
+    ...(config?.children !== undefined ? { children: config.children } : {}),
+  }
+}