@morscherlab/mint-sdk 1.2.0 → 1.2.2

package/src/composables/useManualLayoutResize.ts

@@ -0,0 +1,165 @@
+import { computed, onBeforeUnmount, shallowRef, toValue, watch, type MaybeRefOrGetter } from 'vue'
+
+export interface ResizePanelWidthConstraints {
+  minWidth: number
+  maxWidth: number
+  mainMinWidth?: number
+  layoutGap?: number
+}
+
+export interface ResizePercentConstraints {
+  minPercent: number
+  maxPercent: number
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value))
+}
+
+function availablePanelWidth(
+  containerWidth: number,
+  constraints: ResizePanelWidthConstraints,
+): number {
+  return Math.min(
+    constraints.maxWidth,
+    containerWidth - (constraints.mainMinWidth ?? 0) - (constraints.layoutGap ?? 0),
+  )
+}
+
+export function resizedLeadingPanelWidth(
+  startWidth: number,
+  deltaX: number,
+  containerWidth: number,
+  constraints: ResizePanelWidthConstraints,
+): number {
+  return Math.round(clamp(
+    startWidth + deltaX,
+    constraints.minWidth,
+    Math.max(constraints.minWidth, availablePanelWidth(containerWidth, constraints)),
+  ))
+}
+
+export function resizedTrailingPanelWidth(
+  startWidth: number,
+  deltaX: number,
+  containerWidth: number,
+  constraints: ResizePanelWidthConstraints,
+): number {
+  return resizedLeadingPanelWidth(startWidth, -deltaX, containerWidth, constraints)
+}
+
+export function resizedVerticalSplitPercent(
+  startPercent: number,
+  deltaY: number,
+  containerHeight: number,
+  constraints: ResizePercentConstraints,
+): number {
+  if (containerHeight <= 0) return startPercent
+  return Math.round(clamp(
+    startPercent + (deltaY / containerHeight) * 100,
+    constraints.minPercent,
+    constraints.maxPercent,
+  ))
+}
+
+export interface ManualLayoutResizeContext<TKind extends string> {
+  kind: TKind
+  startValue: number
+  deltaX: number
+  deltaY: number
+  containerRect: DOMRectReadOnly
+  secondaryRect: DOMRectReadOnly | null
+}
+
+export interface ManualLayoutResizeTarget<TKind extends string> {
+  cursor?: string
+  getContainerElement: () => HTMLElement | null
+  getSecondaryElement?: () => HTMLElement | null
+  getStartValue: () => number
+  onResize: (context: ManualLayoutResizeContext<TKind>) => void
+}
+
+/** Coordinates pointer-driven resizing for one or more layout splitters. */
+export function useManualLayoutResize<TKind extends string>(options: {
+  enabled: MaybeRefOrGetter<boolean>
+  resolveTarget: (kind: TKind) => ManualLayoutResizeTarget<TKind> | null
+}) {
+  const activeResize = shallowRef<{
+    kind: TKind
+    startClientX: number
+    startClientY: number
+    startValue: number
+    containerRect: DOMRectReadOnly
+    secondaryRect: DOMRectReadOnly | null
+    cursor: string
+  } | null>(null)
+  const isResizing = computed(() => activeResize.value !== null)
+  let previousBodyCursor = ''
+  let previousBodyUserSelect = ''
+
+  function stopResize(): void {
+    if (!activeResize.value) return
+    activeResize.value = null
+    window.removeEventListener('pointermove', handlePointerMove)
+    window.removeEventListener('pointerup', stopResize)
+    window.removeEventListener('pointercancel', stopResize)
+    if (typeof document !== 'undefined') {
+      document.body.style.cursor = previousBodyCursor
+      document.body.style.userSelect = previousBodyUserSelect
+    }
+  }
+
+  function handlePointerMove(event: PointerEvent): void {
+    const state = activeResize.value
+    if (!state) return
+    options.resolveTarget(state.kind)?.onResize({
+      kind: state.kind,
+      startValue: state.startValue,
+      deltaX: event.clientX - state.startClientX,
+      deltaY: event.clientY - state.startClientY,
+      containerRect: state.containerRect,
+      secondaryRect: state.secondaryRect,
+    })
+  }
+
+  function startResize(kind: TKind, event: PointerEvent): void {
+    if (!toValue(options.enabled) || event.button !== 0) return
+    const target = options.resolveTarget(kind)
+    const containerRect = target?.getContainerElement()?.getBoundingClientRect()
+    if (!target || !containerRect) return
+
+    event.preventDefault()
+    if (event.currentTarget instanceof HTMLElement) {
+      event.currentTarget.setPointerCapture(event.pointerId)
+    }
+    const secondary = target.getSecondaryElement?.() ?? null
+    activeResize.value = {
+      kind,
+      startClientX: event.clientX,
+      startClientY: event.clientY,
+      startValue: target.getStartValue(),
+      containerRect,
+      secondaryRect: secondary?.getBoundingClientRect() ?? null,
+      cursor: target.cursor ?? 'col-resize',
+    }
+
+    if (typeof document !== 'undefined') {
+      previousBodyCursor = document.body.style.cursor
+      previousBodyUserSelect = document.body.style.userSelect
+      document.body.style.cursor = activeResize.value.cursor
+      document.body.style.userSelect = 'none'
+    }
+    window.addEventListener('pointermove', handlePointerMove)
+    window.addEventListener('pointerup', stopResize)
+    window.addEventListener('pointercancel', stopResize)
+  }
+
+  function isResizingKind(kind: TKind): boolean {
+    return activeResize.value?.kind === kind
+  }
+
+  watch(() => toValue(options.enabled), enabled => { if (!enabled) stopResize() })
+  onBeforeUnmount(stopResize)
+
+  return { activeResize, isResizing, isResizingKind, startResize, stopResize }
+}

package/src/composables/usePluginWorkspace.ts

@@ -167,7 +167,6 @@ export function usePluginWorkspace(options: UsePluginWorkspaceOptions): UsePlugi
     title: props.sidebarTitle,
     subtitle: props.sidebarSubtitle,
     badge: props.sidebarBadge,
-    variant: props.sidebarVariant ?? 'analysis',
     panels: props.panels ?? {},
     activeView: navigationState.resolvedActiveView.value,
     floating: false,
@@ -187,7 +186,7 @@ export function usePluginWorkspace(options: UsePluginWorkspaceOptions): UsePlugi
     formDisabled: props.formDisabled ?? false,
     formReadonly: props.formReadonly ?? false,
     formSize: props.formSize ?? 'sm',
-    collapsible: props.sidebarCollapsible,
+    collapsible: props.sidebarCollapsible ?? true,
     collapsed: props.sidebarCollapsed,
     defaultCollapsed: props.defaultSidebarCollapsed ?? false,
     collapsedWidth: props.sidebarCollapsedWidth ?? '3rem',

package/src/composables/useToast.ts

@@ -1,15 +1,31 @@
 import { ref } from 'vue'
-import type { Toast } from '../types'
+import type { Toast, ToastOptions } from '../types'
 
 const toasts = ref<Toast[]>([])
 let nextId = 0
 
 /** Reactive global toast queue with success/error/warning/info variants and auto-dismiss timers. */
 export function useToast() {
-  function show(message: string, type: Toast['type'] = 'success', duration = 3500) {
+  /** Push a structured toast. `progress: 'indeterminate'` is the in-progress form and never auto-dismisses. */
+  function push(options: ToastOptions): number {
     const id = nextId++
-    toasts.value.push({ id, message, type, duration })
-    setTimeout(() => dismiss(id), duration)
+    const duration = options.duration ?? 3500
+    toasts.value.push({
+      id,
+      type: 'success',
+      ...options,
+      message: options.message ?? options.title,
+      duration,
+      actions: options.actions?.slice(0, 2),
+    })
+    if (options.progress !== 'indeterminate') {
+      setTimeout(() => dismiss(id), duration)
+    }
+    return id
+  }
+
+  function show(message: string, type: Toast['type'] = 'success', duration = 3500) {
+    push({ title: message, type, duration })
   }
 
   function success(message: string, duration = 3500) {
@@ -36,5 +52,5 @@ export function useToast() {
     toasts.value = []
   }
 
-  return { toasts, show, success, error, warning, info, dismiss, clear }
+  return { toasts, push, show, success, error, warning, info, dismiss, clear }
 }

package/src/generated/schema.ts

@@ -38,8 +38,9 @@ export function generatedJobFormSchema(definition: GeneratedJobDefinition): Form
 export function generatedJobDefaults(definition: GeneratedJobDefinition): Record<string, unknown> {
   return Object.fromEntries(
     Object.entries(definition.input_schema.properties ?? {})
-      .filter(([, schema]) => hasOwnDefault(schema))
-      .map(([name, schema]) => [name, structuredClone(schema.default)]),
+      .map(([name, schema]) => [name, resolveGeneratedField(definition.input_schema, schema)] as const)
+      .filter(([, field]) => field.hasDefault)
+      .map(([name, field]) => [name, structuredClone(field.defaultValue)]),
   )
 }
 
@@ -51,7 +52,17 @@ export function normalizeGeneratedJobInput(
   for (const [name, value] of Object.entries(values)) {
     const field = definition.input_schema.properties?.[name]
     if (!field) continue
-    normalized[name] = value
+    const { schema, reference } = resolveGeneratedField(definition.input_schema, field)
+    if (reference !== 'path' && Array.isArray(value) && ['integer', 'number'].includes(String(schema.items?.type))) {
+      normalized[name] = value.map(item => {
+        const numeric = typeof item === 'string' && item.trim() !== '' ? Number(item) : item
+        return typeof numeric === 'number' && Number.isFinite(numeric) ? numeric : item
+      })
+    } else if (reference !== 'path' && Array.isArray(value) && schema.items?.type === 'boolean') {
+      normalized[name] = value.map(item => item === 'true' ? true : item === 'false' ? false : item)
+    } else {
+      normalized[name] = value === undefined && allowsNull(schema) ? null : value
+    }
   }
   return normalized
 }
@@ -63,7 +74,12 @@ function toFormField(
 ): FormFieldSchema {
   const { schema, reference } = resolved
   const validation: NonNullable<FormFieldSchema['validation']> = {}
-  if (required) validation.required = true
+  const allowsEmpty = schema.type === 'array' || (
+    schema.type === 'string' && reference !== 'path'
+    && !(schema.minLength && schema.minLength > 0)
+    && (!schema.enum || schema.enum.includes(''))
+  )
+  if (required && !allowsNull(schema) && !allowsEmpty) validation.required = true
   if (schema.minimum !== undefined) validation.min = schema.minimum
   if (schema.maximum !== undefined) validation.max = schema.maximum
   if (schema.minLength !== undefined) validation.minLength = schema.minLength
@@ -71,15 +87,37 @@ function toFormField(
 
   const props: Record<string, unknown> = {}
   if (schema.enum) props.options = [...schema.enum]
+  if (schema.type === 'integer') {
+    if (schema.exclusiveMinimum !== undefined) validation.min = Math.max(Number(validation.min ?? -Infinity), Math.floor(schema.exclusiveMinimum) + 1)
+    if (schema.exclusiveMaximum !== undefined) validation.max = Math.min(Number(validation.max ?? Infinity), Math.ceil(schema.exclusiveMaximum) - 1)
+    if (validation.min !== undefined) validation.min = Math.ceil(Number(validation.min))
+    if (validation.max !== undefined) validation.max = Math.floor(Number(validation.max))
+    if (schema.multipleOf && Number.isInteger(schema.multipleOf)) {
+      if (validation.min !== undefined) validation.min = Math.ceil(Number(validation.min) / schema.multipleOf) * schema.multipleOf
+      if (validation.max !== undefined) validation.max = Math.floor(Number(validation.max) / schema.multipleOf) * schema.multipleOf
+    }
+    props.step = 1
+  }
+  if (schema.type === 'integer' || schema.type === 'number') {
+    if (validation.min !== undefined) props.min = validation.min
+    if (validation.max !== undefined) props.max = validation.max
+    if (schema.multipleOf !== undefined) props.step = schema.multipleOf
+  }
+  if (schema.type === 'array' && reference !== 'path') {
+    if (schema.items?.enum) props.options = [...schema.items.enum]
+    else props.allowDuplicates = true
+  }
   if (reference === 'path' && schema.type === 'array') props.multiple = true
   return {
     name,
     label: schema.title || humanize(name),
     type: fieldType(schema, reference),
     defaultValue: resolved.hasDefault ? structuredClone(resolved.defaultValue) : undefined,
+    disabled: Object.prototype.hasOwnProperty.call(schema, 'const') || undefined,
     hint: schema.description,
     validation,
     props,
+    itemType: schema.items?.type === 'number' || schema.items?.type === 'integer' ? 'number' : undefined,
   }
 }
 
@@ -87,27 +125,24 @@ function resolveGeneratedField(
   root: GeneratedJsonSchema,
   field: GeneratedJsonSchema,
 ): ResolvedGeneratedField {
-  const hasDefault = hasOwnDefault(field)
   const candidate = field.anyOf?.find(item => item.type !== 'null')
     ?? field.allOf?.[0]
     ?? field
+  let schema = { ...candidate, ...field }
   if (candidate.$ref) {
     const referenceParts = candidate.$ref.split('/')
     const key = referenceParts[referenceParts.length - 1]
-    const schema = key ? root.$defs?.[key] : undefined
-    if (!schema) throw new Error(`Generated field reference is missing: ${candidate.$ref}`)
-    return {
-      schema: { ...schema, title: field.title ?? schema.title },
-      reference: field['x-mint-component'] ?? schema['x-mint-component'],
-      hasDefault,
-      defaultValue: field.default,
-    }
+    const referenced = key ? root.$defs?.[key] : undefined
+    if (!referenced) throw new Error(`Generated field reference is missing: ${candidate.$ref}`)
+    schema = { ...referenced, ...candidate, ...field }
   }
+  if (schema.items) schema.items = resolveGeneratedField(root, schema.items).schema
+  const constant = Object.prototype.hasOwnProperty.call(schema, 'const')
   return {
-    schema: candidate,
-    reference: field['x-mint-component'] ?? candidate['x-mint-component'],
-    hasDefault,
-    defaultValue: field.default,
+    schema,
+    reference: schema['x-mint-component'],
+    hasDefault: constant || hasOwnDefault(field) || allowsNull(schema),
+    defaultValue: constant ? schema.const : hasOwnDefault(field) ? field.default : null,
   }
 }
 
@@ -117,7 +152,7 @@ function fieldType(schema: GeneratedJsonSchema, reference?: GeneratedReference):
   const type = Array.isArray(schema.type) ? schema.type.find(value => value !== 'null') : schema.type
   if (type === 'boolean') return 'toggle'
   if (type === 'number' || type === 'integer') return 'number'
-  if (type === 'array') return 'tags'
+  if (type === 'array') return schema.items?.enum ? 'multiselect' : 'tags'
   return 'text'
 }
 
@@ -125,6 +160,11 @@ function hasOwnDefault(schema: GeneratedJsonSchema): boolean {
   return Object.prototype.hasOwnProperty.call(schema, 'default')
 }
 
+function allowsNull(schema: GeneratedJsonSchema): boolean {
+  return schema.type === 'null' || (Array.isArray(schema.type) && schema.type.includes('null'))
+    || !!schema.anyOf?.some(item => item.type === 'null')
+}
+
 function humanize(value: string): string {
   return value.replace(/[_-]+/g, ' ').replace(/^\w/, character => character.toUpperCase())
 }

package/src/styles/components/adduct-text.css

@@ -0,0 +1,45 @@
+.mint-adduct-text {
+  display: inline-flex;
+  align-items: center;
+  flex-shrink: 0;
+  max-width: 100%;
+  overflow: hidden;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+  font-weight: 600;
+  letter-spacing: 0;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.mint-adduct-text--mono { font-family: var(--font-mono); font-feature-settings: 'liga' 0, 'calt' 0; }
+.mint-adduct-text--sans { font-family: var(--font-sans); font-feature-settings: 'liga' 1, 'calt' 1; font-weight: 650; }
+
+.mint-adduct-text--xs {
+  font-size: 0.625rem;
+  line-height: 1rem;
+}
+
+.mint-adduct-text--inherit {
+  font-size: inherit;
+  line-height: inherit;
+}
+
+.mint-adduct-text--badge {
+  padding: 0.125rem 0.25rem;
+  border-radius: var(--radius-sm);
+  background: var(--bg-tertiary);
+}
+
+.mint-adduct-text--on-primary {
+  color: rgb(255 255 255 / 0.82);
+}
+
+.mint-adduct-text--badge.mint-adduct-text--on-primary {
+  background: rgb(255 255 255 / 0.2);
+}
+
+.mint-adduct-text--muted,
+.mint-adduct-text--empty {
+  color: var(--text-muted);
+}