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

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 } : {}),
+  }
+}

package/src/composables/controlSchemaModel.ts

@@ -0,0 +1,163 @@
+import type {
+  ControlModel,
+  ControlModelBinding,
+  ControlModelSectionConfig,
+  ControlSchema,
+  ControlSectionConfig,
+  ControlSidebarConfig,
+  ControlViewConfig,
+  ControlWorkspaceOptions,
+} from './controlSchemaTypes'
+import {
+  normalizeControlDefinition,
+} from './controlSchemaNormalize'
+import {
+  omitUndefined,
+} from './controlSchemaUtils'
+
+export function isControlModelBinding<TBinding extends ControlModelBinding = ControlModelBinding>(
+  model: unknown,
+): model is TBinding {
+  return (
+    typeof model === 'object'
+    && model !== null
+    && 'controls' in model
+    && 'controlOptions' in model
+  )
+}
+
+export function resolveControlModel(
+  model: ControlModel | ControlModelBinding | undefined,
+): ControlModelBinding | undefined {
+  if (model === undefined) return undefined
+  return isControlModelBinding(model) ? model : defineControlModel(model)
+}
+
+/** Create a complete workspace component binding from a simple controls data model for ControlWorkspaceView, generated forms, and sidebars. */
+export function defineControlModel(model: ControlModel): ControlModelBinding {
+  const {
+    controls: rootControls,
+    sections: rootSections,
+    views: modelViews,
+    components,
+    componentBindings,
+    componentProps,
+    componentPropsById,
+    ...baseOptions
+  } = model
+  const resolvedComponentBindings = componentBindings ?? components
+  const controls: ControlSchema = {}
+  const views: Record<string, ControlViewConfig> = {}
+  const sections: Record<string, ControlSectionConfig> = {}
+
+  const defaultViewId = model.view ?? 'default'
+  const defaultSectionId = model.section ?? 'controls'
+
+  if (rootControls) {
+    registerSectionOptions(sections, defaultSectionId, {
+      id: defaultSectionId,
+      label: model.sectionLabel,
+      title: model.sectionLabel,
+      columns: model.columns,
+    })
+    appendModelControls(controls, rootControls, defaultViewId, defaultSectionId)
+  }
+
+  for (const [sectionId, section] of Object.entries(rootSections ?? {})) {
+    registerSectionOptions(sections, sectionId, controlModelSectionOptions(section))
+    appendModelControls(controls, section.controls, defaultViewId, sectionId, section.sidebar)
+  }
+
+  for (const [viewId, view] of Object.entries(modelViews ?? {})) {
+    const {
+      controls: viewControls,
+      sections: viewSections,
+      section,
+      sectionLabel,
+      sectionDescription,
+      ...viewConfig
+    } = view
+
+    views[viewId] = omitUndefined(viewConfig)
+
+    if (viewControls) {
+      const sectionId = section ?? `${viewId}-controls`
+      const label = sectionLabel ?? view.label
+      registerSectionOptions(sections, sectionId, {
+        id: sectionId,
+        label,
+        title: label,
+        description: sectionDescription,
+        columns: model.columns,
+      })
+      appendModelControls(controls, viewControls, viewId, sectionId)
+    }
+
+    for (const [sectionKey, sectionConfig] of Object.entries(viewSections ?? {})) {
+      const sectionId = sectionConfig.id ?? `${viewId}-${sectionKey}`
+      registerSectionOptions(sections, sectionId, controlModelSectionOptions(sectionConfig))
+      appendModelControls(controls, sectionConfig.controls, viewId, sectionId, sectionConfig.sidebar)
+    }
+  }
+
+  const controlOptions: ControlWorkspaceOptions = {
+    ...baseOptions,
+  }
+
+  if (Object.keys(views).length > 0) {
+    controlOptions.views = views
+  }
+
+  if (Object.keys(sections).length > 0) {
+    controlOptions.sections = sections
+  }
+
+  return {
+    controls,
+    controlOptions,
+    ...(resolvedComponentBindings === undefined ? {} : { componentBindings: resolvedComponentBindings }),
+    ...(componentProps === undefined ? {} : { componentProps }),
+    ...(componentPropsById === undefined ? {} : { componentPropsById }),
+  }
+}
+
+function appendModelControls(
+  target: ControlSchema,
+  source: ControlSchema,
+  viewId: string,
+  sectionId: string,
+  sidebar?: boolean | ControlSidebarConfig,
+): void {
+  for (const [name, input] of Object.entries(source)) {
+    if (Object.prototype.hasOwnProperty.call(target, name)) {
+      throw new Error(
+        `Duplicate control "${name}" in defineControlModel(). Control names must be unique across views and sections.`,
+      )
+    }
+
+    const definition = normalizeControlDefinition(input)
+    target[name] = omitUndefined({
+      ...definition,
+      view: definition.view ?? viewId,
+      section: definition.section ?? sectionId,
+      sidebar: definition.sidebar ?? sidebar,
+    })
+  }
+}
+
+function controlModelSectionOptions(section: ControlModelSectionConfig): ControlSectionConfig {
+  const { controls: _controls, sidebar: _sidebar, ...options } = section
+  return omitUndefined(options)
+}
+
+function registerSectionOptions(
+  target: Record<string, ControlSectionConfig>,
+  sectionId: string,
+  options: ControlSectionConfig,
+): void {
+  target[sectionId] = omitUndefined({
+    ...(target[sectionId] ?? {}),
+    ...options,
+    id: sectionId,
+  })
+}

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 './controlSchemaTypes'
+
+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/controlSchemaTypes.ts

@@ -0,0 +1,364 @@
+import type {
+  ComputedRef,
+  Ref,
+} from 'vue'
+import type {
+  PillNavItem,
+  SidebarToolSection,
+  SelectOption,
+  SettingsModalSchema,
+  TopBarSettingsConfig,
+} from '../types'
+import type { AccessPolicy, AccessAudienceInput } from '../permissions'
+import type {
+  FieldCondition,
+  FieldValidation,
+  FormFieldSchema,
+  FormFieldType,
+  FormSchema,
+  FormSectionSchema,
+} from '../types/form-builder'
+import type { WellConcentration } from './useDoseCalculator'
+
+export type ControlOptionValue = string | number | boolean
+export type ControlOption = ControlOptionValue | SelectOption<unknown>
+export type ControlPrimitive = string | number | boolean
+export type ControlShorthand = ControlPrimitive | readonly ControlOption[]
+export type ControlInput = ControlDefinition | ControlShorthand
+
+export interface ControlSectionConfig {
+  id?: string
+  label?: string
+  title?: string
+  description?: string
+  subtitle?: string
+  icon?: string | string[]
+  iconColor?: string
+  iconBg?: string
+  columns?: 1 | 2 | 3
+  condition?: FieldCondition
+  access?: AccessPolicy
+  visibleFor?: AccessAudienceInput
+  requiresAdmin?: boolean
+  permissions?: readonly string[]
+  anyPermissions?: readonly string[]
+  defaultOpen?: boolean
+  showToggle?: boolean
+}
+
+export interface ControlViewConfig {
+  label?: string
+  icon?: string
+  to?: string
+  href?: string
+  disabled?: boolean
+  children?: PillNavItem['children']
+}
+
+export interface ControlSidebarConfig extends Omit<ControlSectionConfig, 'id' | 'title' | 'description' | 'columns'> {
+  enabled?: boolean
+}
+
+export interface ControlDefinition {
+  type?: FormFieldType
+  label?: string
+  default?: unknown
+  defaultValue?: unknown
+  placeholder?: string
+  hint?: string
+  size?: 'sm' | 'md' | 'lg'
+  disabled?: boolean
+  readonly?: boolean
+  required?: boolean | string
+  min?: number | { value: number; message: string }
+  max?: number | { value: number; message: string }
+  minLength?: number | { value: number; message: string }
+  maxLength?: number | { value: number; message: string }
+  email?: boolean | string
+  pattern?: string | { value: string; message: string }
+  validation?: FieldValidation
+  condition?: FieldCondition
+  access?: AccessPolicy
+  visibleFor?: AccessAudienceInput
+  requiresAdmin?: boolean
+  permissions?: readonly string[]
+  anyPermissions?: readonly string[]
+  options?: readonly ControlOption[]
+  section?: string
+  sectionLabel?: string
+  sectionDescription?: string
+  sectionSubtitle?: string
+  view?: string
+  order?: number
+  colSpan?: number
+  props?: Record<string, unknown>
+  sidebar?: boolean | ControlSidebarConfig
+}
+
+export type ControlSchema = Record<string, ControlInput>
+export type ControlFormSchema = Extract<FormSchema, { sections: FormSectionSchema[] }>
+
+export interface ControlSchemaOptions {
+  view?: string
+  views?: Record<string, ControlViewConfig>
+  section?: string
+  sectionLabel?: string
+  sections?: Record<string, ControlSectionConfig>
+  columns?: 1 | 2 | 3
+  submitLabel?: string
+  cancelLabel?: string
+  showCancel?: boolean
+}
+
+export interface ControlWorkspaceOptions extends ControlSchemaOptions {
+  initialValues?: Record<string, unknown>
+  topBarSettings?: Omit<TopBarSettingsConfig, 'schema' | 'controls' | 'controlOptions' | 'values'>
+}
+
+export interface ControlModelSectionConfig extends ControlSectionConfig {
+  controls: ControlSchema
+  sidebar?: boolean | ControlSidebarConfig
+}
+
+export interface ControlModelViewConfig extends ControlViewConfig {
+  controls?: ControlSchema
+  section?: string
+  sectionLabel?: string
+  sectionDescription?: string
+  sections?: Record<string, ControlModelSectionConfig>
+}
+
+export interface ControlModel extends Omit<ControlWorkspaceOptions, 'sections' | 'views'> {
+  controls?: ControlSchema
+  sections?: Record<string, ControlModelSectionConfig>
+  views?: Record<string, ControlModelViewConfig>
+  /** Optional SDK component bindings returned with generated component props for custom workspace slots. */
+  componentBindings?: ControlComponentBindingsConfig
+  /** Alias for componentBindings in raw control models. */
+  components?: ControlComponentBindingsConfig
+  /** Optional ControlWorkspaceView componentProps mapping returned with the generated controls/options. */
+  componentProps?: ControlComponentPropsMap
+  /** Optional named componentProps mappings returned for multiple SDK components. */
+  componentPropsById?: ControlComponentPropsByIdMap
+}
+
+export interface ControlModelBinding {
+  controls: ControlSchema
+  controlOptions: ControlWorkspaceOptions
+  componentBindings?: ControlComponentBindingsConfig
+  componentProps?: ControlComponentPropsMap
+  componentPropsById?: ControlComponentPropsByIdMap
+}
+
+export interface ControlSidebarBinding {
+  panels: Record<string, SidebarToolSection[]>
+  forms: Record<string, ControlFormSchema>
+  viewIds: string[]
+  viewItems: PillNavItem[]
+  defaultView: string
+}
+
+export interface ControlFormBinding {
+  schema: ControlFormSchema
+}
+
+export interface ControlSettingsBinding {
+  schema: SettingsModalSchema
+}
+
+export interface ControlTopBarSettingsBinding {
+  showSettings: true
+  settingsConfig: TopBarSettingsConfig
+}
+
+export interface ControlWorkspaceFormBinding extends ControlFormBinding {
+  modelValue: Record<string, unknown>
+  'onUpdate:modelValue': (values: Record<string, unknown>) => void
+}
+
+export interface ControlWorkspaceSidebarBinding extends ControlSidebarBinding {
+  activeView: string
+  modelValue: Record<string, unknown>
+  'onUpdate:modelValue': (values: Record<string, unknown>) => void
+  values: Record<string, unknown>
+  'onUpdate:values': (values: Record<string, unknown>) => void
+}
+
+export interface ControlWorkspaceTopBarSettingsBinding extends ControlTopBarSettingsBinding {
+  onSettingsValuesChange: (values: Record<string, unknown>) => void
+}
+
+export interface ControlWorkspacePillNavBinding {
+  items: PillNavItem[]
+  currentItemId: string
+  onSelect: (item: PillNavItem) => void
+}
+
+export interface ControlWorkspaceTopBarBinding extends ControlWorkspaceTopBarSettingsBinding {
+  pillNav: PillNavItem[]
+  currentPillId: string
+  onPillSelect: (item: PillNavItem) => void
+}
+
+export type ControlWorkspaceAppTopBarPillBinding = ControlWorkspaceTopBarBinding
+
+export interface ControlWorkspaceComponentBindings {
+  form: ControlWorkspaceFormBinding
+  sidebar: ControlWorkspaceSidebarBinding
+  topBar: ComputedRef<ControlWorkspaceTopBarBinding>
+  topBarSettings: ControlWorkspaceTopBarSettingsBinding
+  pillNav: ControlWorkspacePillNavBinding
+  componentBindings: ComputedRef<ControlComponentBinding[]>
+  componentBindingsById: ComputedRef<ControlComponentBindingsById>
+  componentProps: ComputedRef<Record<string, unknown>>
+  componentPropsById: ComputedRef<Record<string, Record<string, unknown>>>
+}
+
+export type ControlComponentPropSource<TValues extends Record<string, unknown> = Record<string, unknown>> =
+  | (keyof TValues & string)
+  | ((values: TValues) => unknown)
+
+export type ControlComponentPropsMap<TValues extends Record<string, unknown> = Record<string, unknown>> =
+  | readonly (keyof TValues & string)[]
+  | Record<string, ControlComponentPropSource<TValues>>
+
+export type ControlComponentPropsByIdMap<TValues extends Record<string, unknown> = Record<string, unknown>> =
+  Record<string, ControlComponentPropsMap<TValues>>
+
+export interface ControlComponentBindingConfig<TValues extends Record<string, unknown> = Record<string, unknown>> {
+  id?: string
+  component: string
+  props?: ControlComponentPropsMap<TValues>
+}
+
+export interface ControlComponentBindingRecordConfig<TValues extends Record<string, unknown> = Record<string, unknown>> {
+  component: string
+  props?: ControlComponentPropsMap<TValues>
+}
+
+export type ControlComponentBindingsConfig<TValues extends Record<string, unknown> = Record<string, unknown>> =
+  | readonly ControlComponentBindingConfig<TValues>[]
+  | Record<string, ControlComponentBindingRecordConfig<TValues>>
+
+export interface ControlComponentBinding {
+  id: string
+  component: string
+  props: Record<string, unknown>
+}
+
+export type ControlComponentBindingsById = Record<string, ControlComponentBinding>
+
+export interface WellPlateControlPropsOptions<TValues extends Record<string, unknown> = Record<string, unknown>> {
+  selectedWells?: ControlComponentPropSource<TValues>
+  format?: ControlComponentPropSource<TValues>
+  wells?: ControlComponentPropSource<TValues>
+  disabled?: ControlComponentPropSource<TValues>
+  readonly?: ControlComponentPropSource<TValues>
+  showLegend?: ControlComponentPropSource<TValues>
+  showSampleTypeIndicator?: ControlComponentPropSource<TValues>
+  /** Listener for WellPlate v-model updates. Set false to keep generated props one-way. */
+  onUpdateModelValue?: ((values: TValues) => (wellIds: string[]) => void) | false
+}
+
+export interface DoseCalculatorControlPropsOptions<TValues extends Record<string, unknown> = Record<string, unknown>> {
+  mode?: ControlComponentPropSource<TValues>
+  targetWells?: ControlComponentPropSource<TValues>
+  /** Control value key used by the default apply-to-wells handler. */
+  wells?: ControlComponentPropSource<TValues>
+  disabled?: ControlComponentPropSource<TValues>
+  molecularWeight?: ControlComponentPropSource<TValues>
+  /** Listener for DoseCalculator apply-to-wells. Set false to keep generated props one-way. */
+  onApplyToWells?: ((values: TValues) => (results: WellConcentration[]) => void) | false
+}
+
+export interface WellPlateDoseControlPropsOptions<TValues extends Record<string, unknown> = Record<string, unknown>> {
+  plateId?: string
+  doseId?: string
+  plate?: WellPlateControlPropsOptions<TValues>
+  dose?: DoseCalculatorControlPropsOptions<TValues>
+}
+
+export interface DoseDesignControlModelOptions {
+  viewId?: string
+  viewLabel?: string
+  sectionId?: string
+  sectionLabel?: string
+  sectionDescription?: string
+  selectedWells?: readonly string[]
+  plateFormat?: number
+  plateFormats?: readonly number[]
+  doseMode?: 'serial' | 'dilution' | 'conversion'
+  doseModes?: readonly ('serial' | 'dilution' | 'conversion')[]
+  disabled?: boolean
+  includeMolecularWeight?: boolean
+  molecularWeight?: number
+  componentProps?: WellPlateDoseControlPropsOptions
+}
+
+export interface UseControlSchemaReturn<TControls extends ControlSchema> {
+  controls: TControls
+  fields: FormFieldSchema[]
+  formSchema: ControlFormSchema
+  form: ControlFormBinding
+  settingsSchema: SettingsModalSchema
+  settings: ControlSettingsBinding
+  topBarSettingsConfig: TopBarSettingsConfig
+  topBarSettings: ControlTopBarSettingsBinding
+  sidebarPanels: Record<string, SidebarToolSection[]>
+  viewIds: string[]
+  viewItems: PillNavItem[]
+  defaultView: string
+  sectionSchemas: Record<string, ControlFormSchema>
+  sidebar: ControlSidebarBinding
+  initialValues: ControlValues<TControls>
+  sectionSchema: (sectionId: string) => ControlFormSchema
+}
+
+export interface UseControlWorkspaceReturn<TControls extends ControlSchema>
+  extends Omit<UseControlSchemaReturn<TControls>, 'form' | 'sidebar' | 'topBarSettings'> {
+  schema: UseControlSchemaReturn<TControls>
+  values: ControlValues<TControls> & Record<string, unknown>
+  activeView: Ref<string>
+  form: ControlWorkspaceFormBinding
+  sidebar: ControlWorkspaceSidebarBinding
+  topBar: ComputedRef<ControlWorkspaceTopBarBinding>
+  pillNav: ControlWorkspacePillNavBinding
+  topBarSettings: ControlWorkspaceTopBarSettingsBinding
+  bindings: ControlWorkspaceComponentBindings
+  componentBindings: ComputedRef<ControlComponentBinding[]>
+  componentBindingsById: ComputedRef<ControlComponentBindingsById>
+  componentProps: ComputedRef<Record<string, unknown>>
+  componentPropsById: ComputedRef<Record<string, Record<string, unknown>>>
+  setActiveView: (viewId: string) => void
+  setValues: (values: Record<string, unknown>) => void
+  resetValues: (values?: Record<string, unknown>) => void
+  getComponentProps: (
+    mapping?: ControlComponentPropsMap<ControlValues<TControls> & Record<string, unknown>>
+  ) => Record<string, unknown>
+  getComponentPropsById: (
+    mappings?: ControlComponentPropsByIdMap<ControlValues<TControls> & Record<string, unknown>>
+  ) => Record<string, Record<string, unknown>>
+  getComponentBindings: (
+    bindings?: ControlComponentBindingsConfig<ControlValues<TControls> & Record<string, unknown>>
+  ) => ControlComponentBinding[]
+  getComponentBindingsById: (
+    bindings?: ControlComponentBindingsConfig<ControlValues<TControls> & Record<string, unknown>>
+  ) => ControlComponentBindingsById
+}
+
+export type ControlValues<TControls extends ControlSchema> = {
+  [K in keyof TControls]: ControlValue<TControls[K]>
+}
+
+type ControlValue<TControl> =
+  TControl extends { default: infer TDefault }
+    ? TDefault
+    : TControl extends { defaultValue: infer TDefaultValue }
+      ? TDefaultValue
+      : TControl extends readonly [infer First, ...unknown[]]
+        ? OptionValue<First>
+        : TControl extends ControlPrimitive
+          ? TControl
+          : unknown
+
+type OptionValue<TOption> = TOption extends SelectOption<infer TValue> ? TValue : TOption