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

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

package/src/composables/controlWorkspaceOptions.ts

@@ -1,6 +1,6 @@
 import type {
   ControlWorkspaceOptions,
-} from './useControlSchema'
+} from './controlSchemaTypes'
 
 export function mergeControlWorkspaceOptions(
   base?: ControlWorkspaceOptions,

package/src/composables/formBuilderSchema.ts

@@ -0,0 +1,153 @@
+import { getTypeDefault } from './formBuilderRegistry'
+import type { FieldRules } from './useForm'
+import type {
+  FieldCondition,
+  FieldValidation,
+  FormEnhancements,
+  FormFieldSchema,
+  FormSchema,
+  FormSectionSchema,
+} from '../types/form-builder'
+
+/**
+ * Evaluate a JSON-serializable field condition against the current form data.
+ *
+ * Supports logical operators (`and`, `or`, `not`) and comparison operators
+ * (`eq`, `neq`, `gt`, `lt`, `gte`, `lte`, `in`, `notIn`, `truthy`, `falsy`,
+ * `contains`). Returns `true` if the condition passes.
+ */
+export function evaluateCondition(
+  condition: FieldCondition,
+  data: Record<string, unknown>,
+): boolean {
+  if ('and' in condition) {
+    return condition.and.every((c) => evaluateCondition(c, data))
+  }
+  if ('or' in condition) {
+    return condition.or.some((c) => evaluateCondition(c, data))
+  }
+  if ('not' in condition) {
+    return !evaluateCondition(condition.not, data)
+  }
+
+  const value = data[condition.field]
+
+  if ('eq' in condition) return value === condition.eq
+  if ('neq' in condition) return value !== condition.neq
+  if ('gt' in condition) return typeof value === 'number' && value > condition.gt
+  if ('lt' in condition) return typeof value === 'number' && value < condition.lt
+  if ('gte' in condition) return typeof value === 'number' && value >= condition.gte
+  if ('lte' in condition) return typeof value === 'number' && value <= condition.lte
+  if ('in' in condition) return condition.in.includes(value)
+  if ('notIn' in condition) return !condition.notIn.includes(value)
+  if ('truthy' in condition) return !!value
+  if ('falsy' in condition) return !value
+  if ('contains' in condition) {
+    if (typeof value === 'string') return value.includes(condition.contains)
+    if (Array.isArray(value)) return value.includes(condition.contains)
+    return false
+  }
+
+  return true
+}
+
+/** Return all sections across steps (wizard) or directly from a flat schema. */
+export function collectSections(schema: FormSchema): FormSectionSchema[] {
+  return schema.steps ? schema.steps.flatMap((step) => step.sections) : schema.sections
+}
+
+/** Return all field schemas in schema order, flattening sections and steps. */
+export function flattenFields(schema: FormSchema): FormFieldSchema[] {
+  return collectSections(schema).flatMap((section) => section.fields)
+}
+
+/** Convert a JSON-safe `FieldValidation` descriptor to a runtime `FieldRules` object. */
+function convertValidation(v: FieldValidation): FieldRules {
+  const rules: FieldRules = {}
+
+  if (v.required !== undefined) rules.required = v.required
+  if (v.minLength !== undefined) rules.minLength = v.minLength
+  if (v.maxLength !== undefined) rules.maxLength = v.maxLength
+  if (v.min !== undefined) rules.min = v.min
+  if (v.max !== undefined) rules.max = v.max
+  if (v.email !== undefined) rules.email = v.email
+
+  if (v.pattern !== undefined) {
+    rules.pattern =
+      typeof v.pattern === 'string'
+        ? new RegExp(v.pattern)
+        : { value: new RegExp(v.pattern.value), message: v.pattern.message }
+  }
+
+  return rules
+}
+
+export function buildInitialValues<T extends Record<string, unknown>>(
+  fields: readonly FormFieldSchema[],
+  initialData?: Partial<T>,
+): Record<string, unknown> {
+  const initialValues = {} as Record<string, unknown>
+
+  for (const field of fields) {
+    const key = field.name
+    if (initialData && hasOwnKey(initialData, key)) {
+      initialValues[key] = (initialData as Record<string, unknown>)[key]
+    } else if (field.defaultValue !== undefined) {
+      initialValues[key] = field.defaultValue
+    } else {
+      initialValues[key] = getTypeDefault(field.type)
+    }
+  }
+
+  return initialValues
+}
+
+export function buildRules<T extends Record<string, unknown>>(
+  fields: readonly FormFieldSchema[],
+  enhancements?: FormEnhancements<T>,
+): Partial<Record<string, FieldRules>> {
+  const rules: Partial<Record<string, FieldRules>> = {}
+
+  for (const field of fields) {
+    const base: FieldRules = field.validation ? convertValidation(field.validation) : {}
+    const enhancement = enhancements?.fields?.[field.name as keyof T]
+
+    const customValidators: Array<(
+      value: unknown,
+      formData: Record<string, unknown>,
+    ) => string | undefined | null> = []
+
+    if (enhancement?.validate) {
+      const fn = enhancement.validate
+      customValidators.push((value, formData) => fn(value, formData as T))
+    }
+
+    if (customValidators.length > 0) {
+      base.custom = customValidators
+    }
+
+    if (Object.keys(base).length > 0) {
+      rules[field.name] = base
+    }
+  }
+
+  return rules
+}
+
+export function replaceArray<T>(target: T[], values: readonly T[]): void {
+  target.splice(0, target.length, ...values)
+}
+
+export function replaceRecord<TValue>(
+  target: Partial<Record<string, TValue>>,
+  source: Partial<Record<string, TValue>>,
+): void {
+  for (const key of Object.keys(target)) {
+    delete target[key]
+  }
+  Object.assign(target, source)
+}
+
+function hasOwnKey(source: object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(source, key)
+}