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

package/src/composables/useControlSchema.ts

@@ -1,135 +0,0 @@
-import {
-  defaultValueForControl,
-  normalizeControls,
-} from './controlSchemaNormalize'
-import {
-  controlToFormField,
-} from './controlSchemaFormFields'
-import {
-  controlsToFormSchema,
-  controlsToSectionFormSchema,
-  controlsToSectionFormSchemas,
-  controlsToSettingsSchema,
-  controlsToSidebarPanels,
-  controlsToTopBarSettingsConfig,
-  controlsToViewItems,
-} from './controlSchemaAdapters'
-import type {
-  ControlComponentBindingsConfig,
-  ControlSchema,
-  ControlSchemaOptions,
-  ControlValues,
-  UseControlSchemaReturn,
-} from './controlSchemaTypes'
-
-export type * from './controlSchemaTypes'
-
-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 {
-  defineControlModel,
-  isControlModelBinding,
-  resolveControlModel,
-} from './controlSchemaModel'
-
-export {
-  defineDoseCalculatorControlProps,
-  defineDoseDesignControlModel,
-  defineWellPlateControlProps,
-  defineWellPlateDoseComponentBindings,
-  defineWellPlateDoseControlProps,
-} from './controlSchemaDoseDesign'
-
-/** Preserve literal control keys while marking an object as a MINT control schema. */
-export function defineControls<TControls extends ControlSchema>(controls: TControls): TControls {
-  return controls
-}
-
-/** Preserve literal SDK component binding ids while marking an object as generated workspace component bindings. */
-export function defineControlComponentBindings<TBindings extends ControlComponentBindingsConfig>(
-  bindings: TBindings,
-): TBindings {
-  return bindings
-}
-
-/** Build default values for a control schema, matching FormBuilder field defaults. */
-export function getControlDefaults<TControls extends ControlSchema>(
-  controls: TControls,
-): ControlValues<TControls> {
-  const values: Record<string, unknown> = {}
-  for (const control of normalizeControls(controls)) {
-    values[control.name] = defaultValueForControl(control.definition, control.type)
-  }
-  return values as ControlValues<TControls>
-}
-
-/** Prepare FormBuilder, SettingsModal, AppTopBar settings, AppSidebar, and initial values from one compact control model. */
-export function useControlSchema<TControls extends ControlSchema>(
-  controls: TControls,
-  options: ControlSchemaOptions = {},
-): UseControlSchemaReturn<TControls> {
-  const formSchema = controlsToFormSchema(controls, options)
-  const settingsSchema = controlsToSettingsSchema(controls, options)
-  const topBarSettingsConfig = controlsToTopBarSettingsConfig(controls, options)
-  const sidebarPanels = controlsToSidebarPanels(controls, options)
-  const viewItems = controlsToViewItems(controls, options)
-  const viewIds = viewItems.map(item => item.id)
-  const defaultView = viewIds[0] ?? ''
-  const sectionSchemas = controlsToSectionFormSchemas(controls, options)
-
-  return {
-    controls,
-    fields: normalizeControls(controls, options).map(controlToFormField),
-    formSchema,
-    form: {
-      schema: formSchema,
-    },
-    settingsSchema,
-    settings: {
-      schema: settingsSchema,
-    },
-    topBarSettingsConfig,
-    topBarSettings: {
-      showSettings: true,
-      settingsConfig: topBarSettingsConfig,
-    },
-    sidebarPanels,
-    viewIds,
-    viewItems,
-    defaultView,
-    sectionSchemas,
-    sidebar: {
-      panels: sidebarPanels,
-      forms: sectionSchemas,
-      viewIds,
-      viewItems,
-      defaultView,
-    },
-    initialValues: getControlDefaults(controls),
-    sectionSchema: (sectionId: string) => controlsToSectionFormSchema(controls, sectionId, options),
-  }
-}

package/src/composables/useControlWorkspace.ts

@@ -1,209 +0,0 @@
-import {
-  computed,
-  reactive,
-  ref,
-  watch,
-} from 'vue'
-import type {
-  PillNavItem,
-  TopBarSettingsConfig,
-} from '../types'
-import {
-  replaceRecord,
-} from './controlSchemaUtils'
-import {
-  mergeControlWorkspaceOptions,
-} from './controlWorkspaceOptions'
-import {
-  controlValuesToComponentBindings,
-  controlValuesToComponentBindingsById,
-  controlValuesToComponentProps,
-} from './controlComponentBindings'
-import {
-  isControlModelBinding,
-} from './controlSchemaModel'
-import {
-  useControlSchema,
-} from './useControlSchema'
-import type {
-  ControlComponentBinding,
-  ControlComponentBindingsById,
-  ControlComponentBindingsConfig,
-  ControlComponentPropsByIdMap,
-  ControlComponentPropsMap,
-  ControlModelBinding,
-  ControlSchema,
-  ControlValues,
-  ControlWorkspaceComponentBindings,
-  ControlWorkspaceFormBinding,
-  ControlWorkspaceOptions,
-  ControlWorkspacePillNavBinding,
-  ControlWorkspaceSidebarBinding,
-  ControlWorkspaceTopBarBinding,
-  ControlWorkspaceTopBarSettingsBinding,
-  UseControlWorkspaceReturn,
-} from './controlSchemaTypes'
-
-/**
- * Prepare shared reactive values plus AppTopBar/AppSidebar/FormBuilder bindings from one simple controls data model.
- *
- * @example Recommended
- * ```ts
- * const workspace = useControlWorkspace(workspaceModel)
- * const { form, sidebar, topBar } = workspace.bindings
- * ```
- */
-export function useControlWorkspace<TControls extends ControlSchema>(
-  controlsOrModel: TControls | (ControlModelBinding & { controls: TControls }),
-  options: ControlWorkspaceOptions = {},
-): UseControlWorkspaceReturn<TControls> {
-  const model = isControlModelBinding<ControlModelBinding & { controls: 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,
-  }
-}

package/src/composables/useDebouncedWatch.ts

@@ -1,119 +0,0 @@
-import {
-  onScopeDispose,
-  ref,
-  watch,
-  type Ref,
-  type WatchOptions,
-  type WatchSource,
-  type WatchStopHandle,
-} from 'vue'
-
-export type DebouncedWatchCleanup = () => void
-export type DebouncedWatchSource<T> = WatchSource<T> | WatchSource<unknown>[] | (() => T)
-export type DebouncedWatchCallback<T> = (
-  value: T,
-  oldValue: T | undefined,
-  onCleanup: (cleanup: DebouncedWatchCleanup) => void,
-) => void | Promise<void>
-
-export interface UseDebouncedWatchOptions extends WatchOptions {
-  /** Debounce interval in milliseconds. */
-  delay?: number
-}
-
-export interface UseDebouncedWatchReturn {
-  /** Whether a callback is currently scheduled. */
-  isPending: Ref<boolean>
-  /** Cancel the pending callback without stopping the watcher. */
-  cancel: () => void
-  /** Run the pending callback immediately, if one is scheduled. */
-  flush: () => void
-  /** Stop the watcher and clear pending callbacks. */
-  stop: WatchStopHandle
-}
-
-/** Watch a Vue source with debounced callback execution and explicit cancel/flush controls. */
-export function useDebouncedWatch<T>(
-  source: DebouncedWatchSource<T>,
-  callback: DebouncedWatchCallback<T>,
-  options: UseDebouncedWatchOptions = {},
-): UseDebouncedWatchReturn {
-  const { delay = 300, ...watchOptions } = options
-  const isPending = ref(false)
-
-  let timer: ReturnType<typeof setTimeout> | null = null
-  let hasLatestValue = false
-  let latestValue: T
-  let latestOldValue: T | undefined
-  let callbackCleanup: DebouncedWatchCleanup | null = null
-  let stopped = false
-
-  function clearTimer(): void {
-    if (timer) {
-      clearTimeout(timer)
-      timer = null
-    }
-    isPending.value = false
-  }
-
-  function runCallbackCleanup(): void {
-    if (!callbackCleanup) return
-    callbackCleanup()
-    callbackCleanup = null
-  }
-
-  function cancel(): void {
-    clearTimer()
-    hasLatestValue = false
-    latestOldValue = undefined
-  }
-
-  function flush(): void {
-    if (!hasLatestValue) return
-    const value = latestValue
-    const oldValue = latestOldValue
-    cancel()
-    runCallbackCleanup()
-    void callback(value, oldValue, (cleanup) => {
-      callbackCleanup = cleanup
-    })
-  }
-
-  function schedule(value: T, oldValue: T | undefined): void {
-    cancel()
-    hasLatestValue = true
-    latestValue = value
-    latestOldValue = oldValue
-    isPending.value = true
-    timer = setTimeout(flush, delay)
-  }
-
-  const stopWatch = watch(
-    source as WatchSource<unknown> | WatchSource<unknown>[],
-    (value, oldValue, onCleanup) => {
-      schedule(value as T, oldValue as T | undefined)
-      onCleanup(() => {
-        cancel()
-        runCallbackCleanup()
-      })
-    },
-    watchOptions,
-  )
-
-  function stop(): void {
-    if (stopped) return
-    stopped = true
-    stopWatch()
-    cancel()
-    runCallbackCleanup()
-  }
-
-  onScopeDispose(stop)
-
-  return {
-    isPending,
-    cancel,
-    flush,
-    stop,
-  }
-}