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

package/src/composables/useScheduleDrag.ts

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

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

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

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