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

package/src/composables/controlSchemaModel.ts

@@ -1,172 +0,0 @@
-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.
- *
- * @example Recommended
- * ```ts
- * const workspaceModel = defineControlModel({
- *   controls: { threshold: { type: 'number', default: 0.05 } },
- * })
- * ```
- */
-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

@@ -1,101 +0,0 @@
-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

@@ -1,372 +0,0 @@
-import type {
-  ComputedRef,
-  Ref,
-} from 'vue'
-import type {
-  PillNavItem,
-  SidebarBadgeTone,
-  SidebarToolSection,
-  SidebarToolSectionAction,
-  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
-  badge?: string | number
-  badgeTone?: SidebarBadgeTone
-  actions?: SidebarToolSectionAction[]
-  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
-  icon?: string | string[]
-  iconColor?: string
-  iconBg?: 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

package/src/composables/controlSchemaUtils.ts

@@ -1,36 +0,0 @@
-export function recordValue(value: unknown): Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-    ? value as Record<string, unknown>
-    : {}
-}
-
-export function numericValue(value: number | { value: number; message: string }): number {
-  return typeof value === 'number' ? value : value.value
-}
-
-export function orderedUnique(values: string[]): string[] {
-  return [...new Set(values)]
-}
-
-export function replaceRecord(target: Record<string, unknown>, values: Record<string, unknown>) {
-  for (const key of Object.keys(target)) {
-    delete target[key]
-  }
-  Object.assign(target, values)
-}
-
-export 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
-}
-
-export 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))
-}

package/src/composables/controlWorkspaceOptions.ts

@@ -1,21 +0,0 @@
-import type {
-  ControlWorkspaceOptions,
-} from './controlSchemaTypes'
-
-export function mergeControlWorkspaceOptions(
-  base?: ControlWorkspaceOptions,
-  override?: ControlWorkspaceOptions,
-): ControlWorkspaceOptions {
-  return {
-    ...(base ?? {}),
-    ...(override ?? {}),
-    initialValues: {
-      ...(base?.initialValues ?? {}),
-      ...(override?.initialValues ?? {}),
-    },
-    topBarSettings: {
-      ...(base?.topBarSettings ?? {}),
-      ...(override?.topBarSettings ?? {}),
-    },
-  }
-}