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

package/src/composables/controlSchemaAdapters.ts

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

package/src/composables/controlSchemaDoseDesign.ts

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

package/src/composables/controlSchemaFormFields.ts

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

package/src/composables/controlSchemaLayout.ts

@@ -1,59 +0,0 @@
-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 } : {}),
-  }
-}