@morscherlab/mint-sdk 1.0.0-rc.2 → 1.0.0-rc.5

package/src/composables/autoGroupGrouping.ts

@@ -0,0 +1,148 @@
+import type {
+  AutoGroupResult,
+  ColumnInfo,
+  MetadataRow,
+  OutlierAction,
+  ParsedCsvData,
+} from '../types/auto-group'
+import type { SampleGroup } from '../types/components'
+import { DEFAULT_COLORS } from './autoGroupConstants'
+
+export function computeGroups(
+  allSamples: string[],
+  columns: ColumnInfo[],
+  enabledFields: Set<number>,
+  outlierActions: Map<number, OutlierAction>,
+  delimiter: string,
+  minFieldCount: number,
+): AutoGroupResult {
+  const excludedSamples: string[] = []
+  const qcSamples: string[] = []
+  const conformingSamples: string[] = []
+
+  for (let i = 0; i < allSamples.length; i++) {
+    const action = outlierActions.get(i)
+    if (action === 'exclude') {
+      excludedSamples.push(allSamples[i])
+    } else if (action === 'qc') {
+      qcSamples.push(allSamples[i])
+    } else {
+      conformingSamples.push(allSamples[i])
+    }
+  }
+
+  // Build group map
+  const groupMap = new Map<string, string[]>()
+  const metadata: MetadataRow[] = []
+  const enabledIndices = [...enabledFields].sort((a, b) => a - b)
+  const suffixCount = minFieldCount - 1
+
+  for (const sample of conformingSamples) {
+    const parts = sample.split(delimiter)
+    const splitAt = Math.max(1, parts.length - suffixCount)
+    const row = [
+      parts.slice(0, splitAt).join(delimiter),
+      ...parts.slice(splitAt),
+    ]
+
+    // Build group key from enabled columns
+    const keyParts: string[] = []
+    for (const idx of enabledIndices) {
+      if (idx < row.length && idx < columns.length) {
+        keyParts.push(row[idx])
+      }
+    }
+    const groupKey = keyParts.join(' / ')
+
+    const group = groupMap.get(groupKey)
+    if (group) {
+      group.push(sample)
+    } else {
+      groupMap.set(groupKey, [sample])
+    }
+
+    // Build metadata row with ALL columns
+    const fields: Record<string, string> = {}
+    for (const col of columns) {
+      if (col.index < row.length) {
+        fields[col.name] = row[col.index]
+      }
+    }
+    metadata.push({ sampleName: sample, fields, group: groupKey })
+  }
+
+  // Convert to SampleGroup[]
+  const groups: SampleGroup[] = []
+  let colorIdx = 0
+  for (const [name, samples] of groupMap) {
+    groups.push({
+      name,
+      color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
+      samples,
+    })
+    colorIdx++
+  }
+
+  // QC group
+  if (qcSamples.length > 0) {
+    groups.push({
+      name: 'QC',
+      color: '#6B7280',
+      samples: qcSamples,
+    })
+    for (const sample of qcSamples) {
+      metadata.push({ sampleName: sample, fields: {}, group: 'QC' })
+    }
+  }
+
+  return { groups, metadata, excludedSamples }
+}
+
+export function computeGroupsFromCsv(
+  csvData: ParsedCsvData,
+  columns: ColumnInfo[],
+  enabledFields: Set<number>,
+): AutoGroupResult {
+  const groupMap = new Map<string, string[]>()
+  const metadata: MetadataRow[] = []
+  const enabledCols = columns
+    .filter(c => enabledFields.has(c.index))
+    .sort((a, b) => a.index - b.index)
+
+  for (const row of csvData.rows) {
+    const sampleName = row[csvData.sampleColumn]
+
+    // Build group key from enabled CSV column values
+    // Use originalName for CSV row lookup (survives user renames), display name for group key
+    const keyParts = enabledCols.map(col => row[col.originalName ?? col.name])
+    const groupKey = keyParts.join(' / ')
+
+    const group = groupMap.get(groupKey)
+    if (group) {
+      group.push(sampleName)
+    } else {
+      groupMap.set(groupKey, [sampleName])
+    }
+
+    // Build metadata row with ALL columns - use display name as key, original for lookup
+    const fields: Record<string, string> = {}
+    for (const col of columns) {
+      fields[col.name] = row[col.originalName ?? col.name]
+    }
+    metadata.push({ sampleName, fields, group: groupKey })
+  }
+
+  // Convert to SampleGroup[]
+  const groups: SampleGroup[] = []
+  let colorIdx = 0
+  for (const [name, samples] of groupMap) {
+    groups.push({
+      name,
+      color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
+      samples,
+    })
+    colorIdx++
+  }
+
+  return { groups, metadata, excludedSamples: [] }
+}

package/src/composables/controlComponentBindings.ts

@@ -0,0 +1,80 @@
+import type {
+  ControlComponentBinding,
+  ControlComponentBindingConfig,
+  ControlComponentBindingRecordConfig,
+  ControlComponentBindingsById,
+  ControlComponentBindingsConfig,
+  ControlComponentPropsMap,
+  ControlComponentPropSource,
+} from './controlSchemaTypes'
+
+/** Map control workspace values into component props for direct `v-bind` usage. */
+export function controlValuesToComponentProps<TValues extends Record<string, unknown>>(
+  values: TValues,
+  mapping?: ControlComponentPropsMap<TValues>,
+): Record<string, unknown> {
+  if (mapping === undefined) return { ...values }
+
+  if (Array.isArray(mapping)) {
+    const props: Record<string, unknown> = {}
+    for (const key of mapping) {
+      props[key] = values[key]
+    }
+    return props
+  }
+
+  const props: Record<string, unknown> = {}
+  for (const [prop, source] of Object.entries(mapping) as Array<[string, ControlComponentPropSource<TValues>]>) {
+    props[prop] = typeof source === 'function' ? source(values) : values[source]
+  }
+  return props
+}
+
+/** Map control workspace values into named SDK component bindings for direct slot rendering. */
+export function controlValuesToComponentBindings<TValues extends Record<string, unknown>>(
+  values: TValues,
+  bindings?: ControlComponentBindingsConfig<TValues>,
+): ControlComponentBinding[] {
+  if (bindings === undefined) return []
+
+  return normalizeControlComponentBindingConfigs(bindings).map(binding => ({
+    id: binding.id,
+    component: binding.component,
+    props: controlValuesToComponentProps(values, binding.props),
+  }))
+}
+
+/** Map control workspace values into SDK component bindings keyed by binding id. */
+export function controlValuesToComponentBindingsById<TValues extends Record<string, unknown>>(
+  values: TValues,
+  bindings?: ControlComponentBindingsConfig<TValues>,
+): ControlComponentBindingsById {
+  return Object.fromEntries(
+    controlValuesToComponentBindings(values, bindings).map(binding => [binding.id, binding]),
+  )
+}
+
+function normalizeControlComponentBindingConfigs<TValues extends Record<string, unknown>>(
+  bindings: ControlComponentBindingsConfig<TValues>,
+): Array<Required<Pick<ControlComponentBindingConfig<TValues>, 'id' | 'component'>> & Pick<ControlComponentBindingConfig<TValues>, 'props'>> {
+  if (Array.isArray(bindings)) {
+    const usedIds = new Map<string, number>()
+    return bindings.map(binding => ({
+      id: uniqueComponentBindingId(binding.id ?? binding.component, usedIds),
+      component: binding.component,
+      props: binding.props,
+    }))
+  }
+
+  return Object.entries(bindings).map(([id, binding]: [string, ControlComponentBindingRecordConfig<TValues>]) => ({
+    id,
+    component: binding.component,
+    props: binding.props,
+  }))
+}
+
+function uniqueComponentBindingId(id: string, usedIds: Map<string, number>): string {
+  const count = usedIds.get(id) ?? 0
+  usedIds.set(id, count + 1)
+  return count === 0 ? id : `${id}-${count + 1}`
+}

package/src/composables/controlSchemaAdapters.ts

@@ -0,0 +1,196 @@
+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,
+        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,215 @@
+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. */
+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,61 @@
+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,
+    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
+}