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

package/src/composables/useControlSchema.ts

@@ -1,4 +1,7 @@
-import { computed, reactive, ref, watch, type ComputedRef, type Ref } from 'vue'
+import type {
+  ComputedRef,
+  Ref,
+} from 'vue'
 import type {
   PillNavItem,
   SidebarToolSection,
@@ -15,9 +18,55 @@ import type {
   FormSchema,
   FormSectionSchema,
 } from '../types/form-builder'
-import { getTypeDefault } from './formBuilderRegistry'
+import {
+  defaultValueForControl,
+  normalizeControls,
+  normalizeControlDefinition,
+} from './controlSchemaNormalize'
+import {
+  controlToFormField,
+} from './controlSchemaFormFields'
+import {
+  controlsToFormSchema,
+  controlsToSectionFormSchema,
+  controlsToSectionFormSchemas,
+  controlsToSettingsSchema,
+  controlsToSidebarPanels,
+  controlsToTopBarSettingsConfig,
+  controlsToViewItems,
+} from './controlSchemaAdapters'
+import {
+  omitUndefined,
+  recordValue,
+} from './controlSchemaUtils'
 import type { WellConcentration } from './useDoseCalculator'
 
+export {
+  mergeControlWorkspaceOptions,
+} from './controlWorkspaceOptions'
+
+export {
+  useControlWorkspace,
+} from './useControlWorkspace'
+
+export {
+  controlValuesToComponentBindings,
+  controlValuesToComponentBindingsById,
+  controlValuesToComponentProps,
+} from './controlComponentBindings'
+
+export {
+  controlsToFormSchema,
+  controlsToSectionFormSchema,
+  controlsToSectionFormSchemas,
+  controlsToSettingsSchema,
+  controlsToSidebarPanels,
+  controlsToTopBarSettingsConfig,
+  controlsToViewIds,
+  controlsToViewItems,
+  getDefaultControlView,
+} from './controlSchemaAdapters'
+
 export type ControlOptionValue = string | number | boolean
 export type ControlOption = ControlOptionValue | SelectOption<unknown>
 export type ControlPrimitive = string | number | boolean
@@ -361,15 +410,6 @@ type ControlValue<TControl> =
 
 type OptionValue<TOption> = TOption extends SelectOption<infer TValue> ? TValue : TOption
 
-interface NormalizedControl {
-  name: string
-  definition: ControlDefinition
-  type: FormFieldType
-  sectionId: string
-  viewId: string
-  order: number
-}
-
 /** Preserve literal control keys while marking an object as a MINT control schema. */
 export function defineControls<TControls extends ControlSchema>(controls: TControls): TControls {
   return controls
@@ -481,52 +521,6 @@ export function getControlDefaults<TControls extends ControlSchema>(
   return values as ControlValues<TControls>
 }
 
-/** 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]),
-  )
-}
-
 /** Return a default WellPlate prop mapping for generated control workspaces. */
 export function defineWellPlateControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(
   options: WellPlateControlPropsOptions<TValues> = {},
@@ -660,201 +654,6 @@ export function defineDoseDesignControlModel(
   })
 }
 
-function isControlModelBindingInput<TControls extends ControlSchema>(
-  value: TControls | (ControlModelBinding & { controls: TControls }),
-): value is ControlModelBinding & { controls: TControls } {
-  return (
-    typeof value === 'object'
-    && value !== null
-    && 'controls' in value
-    && 'controlOptions' in value
-  )
-}
-
-export function mergeControlWorkspaceOptions(
-  base?: ControlWorkspaceOptions,
-  override?: ControlWorkspaceOptions,
-): ControlWorkspaceOptions {
-  return {
-    ...(base ?? {}),
-    ...(override ?? {}),
-    initialValues: {
-      ...(base?.initialValues ?? {}),
-      ...(override?.initialValues ?? {}),
-    },
-    topBarSettings: {
-      ...(base?.topBarSettings ?? {}),
-      ...(override?.topBarSettings ?? {}),
-    },
-  }
-}
-
-/** 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
-}
-
 /** Prepare FormBuilder, SettingsModal, AppTopBar settings, AppSidebar, and initial values from one compact control model. */
 export function useControlSchema<TControls extends ControlSchema>(
   controls: TControls,
@@ -902,195 +701,6 @@ export function useControlSchema<TControls extends ControlSchema>(
   }
 }
 
-/** Prepare shared reactive values plus AppTopBar/AppSidebar/FormBuilder bindings from one simple controls data model. */
-export function useControlWorkspace<TControls extends ControlSchema>(
-  controlsOrModel: TControls | (ControlModelBinding & { controls: TControls }),
-  options: ControlWorkspaceOptions = {},
-): UseControlWorkspaceReturn<TControls> {
-  const model = isControlModelBindingInput<TControls>(controlsOrModel) ? controlsOrModel : undefined
-  const controls: TControls = model ? model.controls : controlsOrModel as TControls
-  const workspaceOptions = model
-    ? mergeControlWorkspaceOptions(model.controlOptions, options)
-    : options
-  const { initialValues, topBarSettings, ...schemaOptions } = workspaceOptions
-  const schema = useControlSchema(controls, schemaOptions)
-  const activeView = ref(schema.defaultView)
-  const values = reactive({
-    ...schema.initialValues,
-    ...(initialValues ?? {}),
-  }) as ControlValues<TControls> & Record<string, unknown>
-
-  function setActiveView(viewId: string) {
-    syncActiveView(viewId)
-  }
-
-  function syncActiveView(viewId: string) {
-    if (!schema.viewIds.includes(viewId)) return
-    if (activeView.value !== viewId) activeView.value = viewId
-    if (sidebar.activeView !== viewId) sidebar.activeView = viewId
-    if (pillNav.currentItemId !== viewId) pillNav.currentItemId = viewId
-  }
-
-  function setValues(nextValues: Record<string, unknown>) {
-    Object.assign(values, nextValues)
-  }
-
-  function resetValues(nextValues: Record<string, unknown> = {}) {
-    replaceRecord(values, {
-      ...schema.initialValues,
-      ...nextValues,
-    })
-  }
-
-  function getComponentProps(
-    mapping?: ControlComponentPropsMap<ControlValues<TControls> & Record<string, unknown>>,
-  ): Record<string, unknown> {
-    return controlValuesToComponentProps(values, mapping)
-  }
-
-  function getComponentPropsById(
-    mappings?: ControlComponentPropsByIdMap<ControlValues<TControls> & Record<string, unknown>>,
-  ): Record<string, Record<string, unknown>> {
-    if (mappings === undefined) return {}
-
-    return Object.fromEntries(
-      Object.entries(mappings).map(([id, mapping]) => [
-        id,
-        controlValuesToComponentProps(values, mapping),
-      ]),
-    )
-  }
-
-  function getComponentBindings(
-    bindings?: ControlComponentBindingsConfig<ControlValues<TControls> & Record<string, unknown>>,
-  ): ControlComponentBinding[] {
-    return controlValuesToComponentBindings(values, bindings)
-  }
-
-  function getComponentBindingsById(
-    bindings?: ControlComponentBindingsConfig<ControlValues<TControls> & Record<string, unknown>>,
-  ): ControlComponentBindingsById {
-    return controlValuesToComponentBindingsById(values, bindings)
-  }
-  const componentProps = computed(() => (
-    model?.componentProps === undefined ? {} : getComponentProps(model.componentProps)
-  ))
-  const componentPropsById = computed(() => getComponentPropsById(model?.componentPropsById))
-  const componentBindings = computed(() => getComponentBindings(model?.componentBindings))
-  const componentBindingsById = computed(() => getComponentBindingsById(model?.componentBindings))
-  const form = {
-    ...schema.form,
-    modelValue: values,
-    'onUpdate:modelValue': setValues,
-  } as ControlWorkspaceFormBinding
-
-  const topBarSettingsConfig: TopBarSettingsConfig = {
-    ...schema.topBarSettingsConfig,
-    ...(topBarSettings ?? {}),
-    values,
-  }
-  const sidebar = reactive({
-    ...schema.sidebar,
-    activeView: activeView.value,
-    modelValue: values,
-    'onUpdate:modelValue': setValues,
-    values,
-    'onUpdate:values': setValues,
-  }) as ControlWorkspaceSidebarBinding
-  const pillNav = reactive({
-    items: schema.viewItems,
-    currentItemId: activeView.value,
-    onSelect: (item: PillNavItem) => setActiveView(item.id),
-  }) as ControlWorkspacePillNavBinding
-  const topBarSettingsBinding = {
-    showSettings: true,
-    settingsConfig: topBarSettingsConfig,
-    onSettingsValuesChange: setValues,
-  } as ControlWorkspaceTopBarSettingsBinding
-  const topBarProps = computed<ControlWorkspaceTopBarBinding>(() => ({
-    pillNav: pillNav.items,
-    currentPillId: pillNav.currentItemId,
-    onPillSelect: pillNav.onSelect,
-    ...topBarSettingsBinding,
-  }))
-  const bindings: ControlWorkspaceComponentBindings = {
-    form,
-    sidebar,
-    topBar: topBarProps,
-    topBarSettings: topBarSettingsBinding,
-    pillNav,
-    componentBindings,
-    componentBindingsById,
-    componentProps,
-    componentPropsById,
-  }
-
-  watch(activeView, syncActiveView, { flush: 'sync' })
-  watch(() => sidebar.activeView, syncActiveView, { flush: 'sync' })
-  watch(() => pillNav.currentItemId, syncActiveView, { flush: 'sync' })
-
-  return {
-    ...schema,
-    schema,
-    values,
-    activeView,
-    topBarSettingsConfig,
-    form,
-    sidebar,
-    topBar: topBarProps,
-    pillNav,
-    topBarSettings: topBarSettingsBinding,
-    bindings,
-    componentBindings,
-    componentBindingsById,
-    componentProps,
-    componentPropsById,
-    setActiveView,
-    setValues,
-    resetValues,
-    getComponentProps,
-    getComponentPropsById,
-    getComponentBindings,
-    getComponentBindingsById,
-  }
-}
-
-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)
-}
-
-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
-}
-
 function appendModelControls(
   target: ControlSchema,
   source: ControlSchema,
@@ -1132,118 +742,6 @@ function registerSectionOptions(
   })
 }
 
-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 defaultValueForControl(definition: ControlDefinition, type: FormFieldType): unknown {
-  if (definition.default !== undefined) return definition.default
-  if (definition.defaultValue !== undefined) return definition.defaultValue
-  return getTypeDefault(type)
-}
-
-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
-}
-
-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,
-  }
-}
-
-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
-}
-
-function isSidebarEnabled(sidebar: ControlDefinition['sidebar']): boolean {
-  if (sidebar === false) return false
-  if (sidebar && typeof sidebar === 'object') return sidebar.enabled !== false
-  return true
-}
-
-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 optionValue(option: ControlOption): ControlOptionValue | unknown {
-  if (typeof option === 'object' && option !== null && 'value' in option) {
-    return option.value
-  }
-  return option
-}
-
 function compactComponentPropsMap<TValues extends Record<string, unknown>>(
   mapping: Record<string, ControlComponentPropSource<TValues> | undefined>,
 ): ControlComponentPropsMap<TValues> {
@@ -1254,31 +752,6 @@ function compactComponentPropsMap<TValues extends Record<string, unknown>>(
   )
 }
 
-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]) => ({
-    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}`
-}
-
 function sourceKey<TValues extends Record<string, unknown>>(key: string): keyof TValues & string {
   return key as keyof TValues & string
 }
@@ -1331,53 +804,3 @@ function updateWellsFromDoseResults<TValues extends Record<string, unknown>>(
     writableValues[source] = nextWells
   }
 }
-
-function recordValue(value: unknown): Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-    ? value as Record<string, unknown>
-    : {}
-}
-
-function numericValue(value: number | { value: number; message: string }): number {
-  return typeof value === 'number' ? value : value.value
-}
-
-function orderedUnique(values: string[]): string[] {
-  return [...new Set(values)]
-}
-
-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 } : {}),
-  }
-}
-
-function replaceRecord(target: Record<string, unknown>, values: Record<string, unknown>) {
-  for (const key of Object.keys(target)) {
-    delete target[key]
-  }
-  Object.assign(target, values)
-}
-
-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
-}
-
-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))
-}