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

package/src/composables/useScheduleDrag.ts

@@ -0,0 +1,245 @@
+import { ref, computed, onUnmounted, type Ref } from 'vue'
+import type { ScheduleEvent } from '../types/components'
+
+export type DragType = 'create' | 'resize-top' | 'resize-bottom' | 'move'
+
+export interface DragState {
+  type: DragType
+  event?: ScheduleEvent
+  startDate: Date
+  startY: number
+  currentY: number
+  dayIndex: number
+  currentDayIndex: number
+}
+
+export interface GhostEvent {
+  start: Date
+  end: Date
+  dayIndex: number
+  style: Record<string, string>
+}
+
+export interface UseScheduleDragOptions {
+  slotDuration: Ref<number>
+  dayStartHour: Ref<number>
+  dayEndHour: Ref<number>
+  readonly: Ref<boolean>
+  slotHeight: Ref<number>
+  blockedSlots?: Ref<{ start: string; end: string; label?: string }[]>
+  onCreateComplete?: (start: Date, end: Date) => void
+  onMoveComplete?: (event: ScheduleEvent, newStart: Date, newEnd: Date) => void
+  onResizeComplete?: (event: ScheduleEvent, newStart: Date, newEnd: Date) => void
+}
+
+/** Handles pointer-driven create, move, and resize drag interactions for the ScheduleCalendar grid. */
+export function useScheduleDrag(options: UseScheduleDragOptions) {
+  const isDragging = ref(false)
+  const dragState = ref<DragState | null>(null)
+
+  const ghost = computed<GhostEvent | null>(() => {
+    if (!dragState.value) return null
+    const state = dragState.value
+    const slotH = options.slotHeight.value
+    const slotMin = options.slotDuration.value
+    const dayStart = options.dayStartHour.value * 60
+
+    if (state.type === 'create') {
+      const deltaY = state.currentY - state.startY
+      const startOffset = state.startY
+      const endOffset = startOffset + deltaY
+
+      const topPx = Math.min(startOffset, endOffset)
+      const bottomPx = Math.max(startOffset, endOffset)
+
+      const startMinutes = dayStart + Math.round((topPx / slotH) * slotMin)
+      const endMinutes = dayStart + Math.round((bottomPx / slotH) * slotMin)
+
+      const snappedStart = snapMinutes(startMinutes, slotMin)
+      const snappedEnd = Math.max(snapMinutes(endMinutes, slotMin), snappedStart + slotMin)
+
+      const snappedTopPx = ((snappedStart - dayStart) / slotMin) * slotH
+      const snappedHeightPx = ((snappedEnd - snappedStart) / slotMin) * slotH
+
+      return {
+        start: minutesToDate(state.startDate, snappedStart),
+        end: minutesToDate(state.startDate, snappedEnd),
+        dayIndex: state.dayIndex,
+        style: {
+          top: `${snappedTopPx}px`,
+          height: `${snappedHeightPx}px`,
+        },
+      }
+    }
+
+    if (state.type === 'move' && state.event) {
+      const deltaY = state.currentY - state.startY
+      const eventStart = dateToMinutes(new Date(state.event.start))
+      const eventEnd = dateToMinutes(new Date(state.event.end))
+      const duration = eventEnd - eventStart
+      const pixelDelta = Math.round((deltaY / slotH) * slotMin)
+      const newStart = snapMinutes(eventStart + pixelDelta, slotMin)
+      const newEnd = newStart + duration
+
+      const clamped = clampRange(newStart, newEnd, dayStart, options.dayEndHour.value * 60)
+      const topPx = ((clamped.start - dayStart) / slotMin) * slotH
+      const heightPx = ((clamped.end - clamped.start) / slotMin) * slotH
+
+      return {
+        start: minutesToDate(state.startDate, clamped.start),
+        end: minutesToDate(state.startDate, clamped.end),
+        dayIndex: state.currentDayIndex,
+        style: {
+          top: `${topPx}px`,
+          height: `${heightPx}px`,
+        },
+      }
+    }
+
+    if ((state.type === 'resize-top' || state.type === 'resize-bottom') && state.event) {
+      const eventStart = dateToMinutes(new Date(state.event.start))
+      const eventEnd = dateToMinutes(new Date(state.event.end))
+      const deltaY = state.currentY - state.startY
+      const pixelDelta = Math.round((deltaY / slotH) * slotMin)
+
+      let newStart = eventStart
+      let newEnd = eventEnd
+
+      if (state.type === 'resize-top') {
+        newStart = snapMinutes(eventStart + pixelDelta, slotMin)
+        newStart = Math.min(newStart, newEnd - slotMin)
+      } else {
+        newEnd = snapMinutes(eventEnd + pixelDelta, slotMin)
+        newEnd = Math.max(newEnd, newStart + slotMin)
+      }
+
+      const clamped = clampRange(newStart, newEnd, dayStart, options.dayEndHour.value * 60)
+      const topPx = ((clamped.start - dayStart) / slotMin) * slotH
+      const heightPx = ((clamped.end - clamped.start) / slotMin) * slotH
+
+      return {
+        start: minutesToDate(state.startDate, clamped.start),
+        end: minutesToDate(state.startDate, clamped.end),
+        dayIndex: state.dayIndex,
+        style: {
+          top: `${topPx}px`,
+          height: `${heightPx}px`,
+        },
+      }
+    }
+
+    return null
+  })
+
+  function startCreate(date: Date, y: number, dayIndex: number) {
+    if (options.readonly.value) return
+    isDragging.value = true
+    dragState.value = {
+      type: 'create',
+      startDate: date,
+      startY: y,
+      currentY: y,
+      dayIndex,
+      currentDayIndex: dayIndex,
+    }
+    addListeners()
+  }
+
+  function startMove(event: ScheduleEvent, y: number, dayIndex: number) {
+    if (options.readonly.value || event.draggable === false) return
+    isDragging.value = true
+    dragState.value = {
+      type: 'move',
+      event,
+      startDate: new Date(event.start),
+      startY: y,
+      currentY: y,
+      dayIndex,
+      currentDayIndex: dayIndex,
+    }
+    addListeners()
+  }
+
+  function startResize(event: ScheduleEvent, edge: 'top' | 'bottom', y: number, dayIndex: number) {
+    if (options.readonly.value || event.resizable === false) return
+    isDragging.value = true
+    dragState.value = {
+      type: edge === 'top' ? 'resize-top' : 'resize-bottom',
+      event,
+      startDate: new Date(event.start),
+      startY: y,
+      currentY: y,
+      dayIndex,
+      currentDayIndex: dayIndex,
+    }
+    addListeners()
+  }
+
+  function onPointerMove(e: PointerEvent) {
+    if (!dragState.value) return
+    dragState.value = { ...dragState.value, currentY: e.clientY }
+  }
+
+  function onPointerUp() {
+    if (!dragState.value || !ghost.value) {
+      cleanup()
+      return
+    }
+
+    const g = ghost.value
+    const state = dragState.value
+
+    if (state.type === 'create' && options.onCreateComplete) {
+      options.onCreateComplete(g.start, g.end)
+    } else if (state.type === 'move' && state.event && options.onMoveComplete) {
+      options.onMoveComplete(state.event, g.start, g.end)
+    } else if ((state.type === 'resize-top' || state.type === 'resize-bottom') && state.event && options.onResizeComplete) {
+      options.onResizeComplete(state.event, g.start, g.end)
+    }
+
+    cleanup()
+  }
+
+  function addListeners() {
+    document.addEventListener('pointermove', onPointerMove)
+    document.addEventListener('pointerup', onPointerUp)
+  }
+
+  function cleanup() {
+    isDragging.value = false
+    dragState.value = null
+    document.removeEventListener('pointermove', onPointerMove)
+    document.removeEventListener('pointerup', onPointerUp)
+  }
+
+  onUnmounted(cleanup)
+
+  return {
+    isDragging,
+    dragState,
+    ghost,
+    startCreate,
+    startMove,
+    startResize,
+  }
+}
+
+function snapMinutes(minutes: number, step: number): number {
+  return Math.round(minutes / step) * step
+}
+
+function dateToMinutes(date: Date): number {
+  return date.getHours() * 60 + date.getMinutes()
+}
+
+function minutesToDate(baseDate: Date, minutes: number): Date {
+  const d = new Date(baseDate)
+  d.setHours(Math.floor(minutes / 60), minutes % 60, 0, 0)
+  return d
+}
+
+function clampRange(start: number, end: number, min: number, max: number) {
+  const s = Math.max(start, min)
+  const e = Math.min(end, max)
+  return { start: s, end: Math.max(e, s) }
+}

package/src/composables/useSelectionLimit.ts

@@ -0,0 +1,57 @@
+import { computed, toValue, type ComputedRef, type Ref } from 'vue'
+
+export type SelectionLimitSource<T> =
+  | T
+  | Ref<T>
+  | ComputedRef<T>
+  | (() => T)
+
+export interface UseSelectionLimitOptions {
+  count: SelectionLimitSource<number>
+  max?: SelectionLimitSource<number | null | undefined>
+}
+
+export interface UseSelectionLimitReturn {
+  count: ComputedRef<number>
+  max: ComputedRef<number | undefined>
+  isLimited: ComputedRef<boolean>
+  isAtLimit: ComputedRef<boolean>
+  canAddMore: ComputedRef<boolean>
+  remaining: ComputedRef<number | undefined>
+  canAdd: (amount?: number, fromCount?: number) => boolean
+}
+
+/** Shared cap logic for chip, tag, and multi-select controls. */
+export function useSelectionLimit(options: UseSelectionLimitOptions): UseSelectionLimitReturn {
+  const count = computed(() => Math.max(0, Math.floor(toValue(options.count) || 0)))
+  const max = computed(() => normalizeMax(toValue(options.max)))
+  const isLimited = computed(() => max.value !== undefined)
+  const remaining = computed(() => {
+    if (max.value === undefined) return undefined
+    return Math.max(0, max.value - count.value)
+  })
+  const isAtLimit = computed(() => remaining.value === 0)
+  const canAddMore = computed(() => canAdd(1))
+
+  function canAdd(amount = 1, fromCount = count.value): boolean {
+    const normalizedAmount = Math.max(0, Math.floor(amount))
+    const normalizedCount = Math.max(0, Math.floor(fromCount))
+    if (max.value === undefined) return true
+    return normalizedCount + normalizedAmount <= max.value
+  }
+
+  return {
+    count,
+    max,
+    isLimited,
+    isAtLimit,
+    canAddMore,
+    remaining,
+    canAdd,
+  }
+}
+
+function normalizeMax(value: number | null | undefined): number | undefined {
+  if (value === null || value === undefined || !Number.isFinite(value)) return undefined
+  return Math.max(0, Math.floor(value))
+}

package/src/composables/useSequenceUtils.ts

@@ -0,0 +1,105 @@
+export type SequenceType = 'dna' | 'rna' | 'protein' | 'auto'
+
+export interface SequenceStats {
+  length: number
+  gcPercent?: number
+  molecularWeight?: number
+}
+
+const DNA_CHARS = /[^ATCGNatcgn]/g
+const RNA_CHARS = /[^AUCGNaucgn]/g
+const PROTEIN_CHARS = /[^ACDEFGHIKLMNPQRSTVWYacdefghiklmnpqrstvwy]/g
+
+const DNA_COMPLEMENT: Record<string, string> = {
+  A: 'T', T: 'A', C: 'G', G: 'C', N: 'N',
+  a: 't', t: 'a', c: 'g', g: 'c', n: 'n',
+}
+
+const RNA_COMPLEMENT: Record<string, string> = {
+  A: 'U', U: 'A', C: 'G', G: 'C', N: 'N',
+  a: 'u', u: 'a', c: 'g', g: 'c', n: 'n',
+}
+
+// Average molecular weights per residue
+const MW_DNA_NT = 330 // Da per nucleotide (average)
+const MW_RNA_NT = 340 // Da per nucleotide (average)
+const MW_PROTEIN_AA = 110 // Da per amino acid (average)
+
+/** Detects, validates, cleans, and computes stats (GC%, MW) for DNA, RNA, and protein sequences. */
+export function useSequenceUtils() {
+  function detectSequenceType(seq: string): 'dna' | 'rna' | 'protein' {
+    const upper = seq.toUpperCase()
+
+    // If contains U but not T, it's RNA
+    if (upper.includes('U') && !upper.includes('T')) {
+      return 'rna'
+    }
+
+    // If only contains ATCGN characters, it's DNA
+    if (/^[ATCGN]+$/i.test(seq)) {
+      return 'dna'
+    }
+
+    return 'protein'
+  }
+
+  function validateSequence(seq: string, type: SequenceType): string {
+    const effectiveType = type === 'auto' ? detectSequenceType(seq) : type
+
+    switch (effectiveType) {
+      case 'dna':
+        return seq.replace(DNA_CHARS, '')
+      case 'rna':
+        return seq.replace(RNA_CHARS, '')
+      case 'protein':
+        return seq.replace(PROTEIN_CHARS, '')
+      default:
+        return seq
+    }
+  }
+
+  function reverseComplement(seq: string, type: 'dna' | 'rna'): string {
+    const complementMap = type === 'dna' ? DNA_COMPLEMENT : RNA_COMPLEMENT
+
+    return seq
+      .split('')
+      .reverse()
+      .map(ch => complementMap[ch] ?? ch)
+      .join('')
+  }
+
+  function calculateStats(seq: string, type: 'dna' | 'rna' | 'protein'): SequenceStats {
+    const length = seq.length
+    const stats: SequenceStats = { length }
+
+    if (type === 'dna' || type === 'rna') {
+      const upper = seq.toUpperCase()
+      let gcCount = 0
+      for (const ch of upper) {
+        if (ch === 'G' || ch === 'C') gcCount++
+      }
+      stats.gcPercent = length > 0 ? Math.round((gcCount / length) * 10000) / 100 : 0
+      stats.molecularWeight = length * (type === 'dna' ? MW_DNA_NT : MW_RNA_NT)
+    } else {
+      stats.molecularWeight = length * MW_PROTEIN_AA
+    }
+
+    return stats
+  }
+
+  function formatFasta(seq: string, lineWidth: number = 60): string {
+    const lines: string[] = []
+    for (let i = 0; i < seq.length; i += lineWidth) {
+      lines.push(seq.slice(i, i + lineWidth))
+    }
+    return lines.join('\n')
+  }
+
+  return {
+    detectSequenceType,
+    validateSequence,
+    reverseComplement,
+    calculateStats,
+    formatFasta,
+  }
+}

package/src/composables/useSortedItems.ts

@@ -0,0 +1,118 @@
+import { computed, toValue, type ComputedRef, type Ref } from 'vue'
+
+export type SortedItemsSource<T> =
+  | T
+  | Ref<T>
+  | ComputedRef<T>
+  | (() => T)
+
+export type SortOrder = 'asc' | 'desc'
+
+export interface SortDescriptor<TKey extends string = string> {
+  key: TKey
+  direction?: SortOrder | null
+}
+
+export interface CompareSortValuesOptions {
+  caseSensitive?: boolean
+}
+
+export interface SortComparatorContext<TItem, TKey extends string = string> {
+  key: TKey
+  direction: SortOrder
+  a: TItem
+  b: TItem
+}
+
+export type SortComparator<TItem, TKey extends string = string> = (
+  aValue: unknown,
+  bValue: unknown,
+  context: SortComparatorContext<TItem, TKey>,
+) => number
+
+export interface UseSortedItemsOptions<TItem, TKey extends string = string> {
+  items: SortedItemsSource<readonly TItem[]>
+  sort: SortedItemsSource<SortDescriptor<TKey> | null | undefined>
+  enabled?: SortedItemsSource<boolean | null | undefined>
+  caseSensitive?: SortedItemsSource<boolean | null | undefined>
+  getValue: (item: TItem, key: TKey) => unknown
+  compare?: SortComparator<TItem, TKey>
+}
+
+export interface UseSortedItemsReturn<TItem, TKey extends string = string> {
+  sort: ComputedRef<SortDescriptor<TKey> | null | undefined>
+  sortedItems: ComputedRef<TItem[]>
+}
+
+/** Shared sorting for SDK tables and lists with stable empty-value handling. */
+export function useSortedItems<TItem, TKey extends string = string>(
+  options: UseSortedItemsOptions<TItem, TKey>,
+): UseSortedItemsReturn<TItem, TKey> {
+  const sort = computed(() => toValue(options.sort))
+  const enabled = computed(() => toValue(options.enabled) ?? true)
+
+  const sortedItems = computed(() => {
+    const items = [...toValue(options.items)]
+    const activeSort = sort.value
+
+    if (!enabled.value || !activeSort?.key || !activeSort.direction) return items
+
+    const direction = activeSort.direction
+    const caseSensitive = toValue(options.caseSensitive) ?? true
+
+    return items.sort((a, b) => {
+      const aValue = options.getValue(a, activeSort.key)
+      const bValue = options.getValue(b, activeSort.key)
+
+      if (options.compare) {
+        return options.compare(aValue, bValue, {
+          key: activeSort.key,
+          direction,
+          a,
+          b,
+        })
+      }
+
+      return compareSortValues(aValue, bValue, direction, { caseSensitive })
+    })
+  })
+
+  return {
+    sort,
+    sortedItems,
+  }
+}
+
+export function compareSortValues(
+  aValue: unknown,
+  bValue: unknown,
+  direction: SortOrder = 'asc',
+  options: CompareSortValuesOptions = {},
+): number {
+  const aEmpty = aValue === null || aValue === undefined
+  const bEmpty = bValue === null || bValue === undefined
+
+  if (aEmpty && bEmpty) return 0
+  if (aEmpty) return 1
+  if (bEmpty) return -1
+
+  const aComparable = toComparableSortValue(aValue, options)
+  const bComparable = toComparableSortValue(bValue, options)
+
+  let comparison = 0
+  if (typeof aComparable === 'number' && typeof bComparable === 'number') {
+    comparison = aComparable - bComparable
+  } else {
+    comparison = String(aComparable).localeCompare(String(bComparable))
+  }
+
+  return direction === 'asc' ? comparison : -comparison
+}
+
+function toComparableSortValue(value: unknown, options: CompareSortValuesOptions): unknown {
+  if (value instanceof Date) return value.getTime()
+  if (typeof value === 'string' && options.caseSensitive === false) {
+    return value.toLowerCase()
+  }
+  return value
+}