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

package/src/composables/controlSchemaFormFields.ts

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

@@ -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,172 @@
+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

@@ -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
+}