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

package/src/__tests__/composables/useGroupAssignment.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest'
+import { ref } from 'vue'
+import { useGroupAssignment } from '../../composables/useGroupAssignment'
+import type { GroupItem } from '../../types'
+
+const groups: GroupItem[] = [
+  { name: 'control-a', color: '#3B82F6', count: 3 },
+  { name: 'control-b', color: '#06B6D4', count: 2 },
+  { name: 'treatment-a', color: '#F43F5E', count: 4 },
+]
+
+describe('useGroupAssignment', () => {
+  it('derives zone groups, unassigned groups, counts, and validation state', () => {
+    const assignment = useGroupAssignment({
+      groups,
+      group1: ['control-a'],
+      group2: [],
+      label1: 'Control',
+      label2: 'Treatment',
+      minPerGroup: 1,
+    })
+
+    expect(assignment.zone1Groups.value.map(group => group.name)).toEqual(['control-a'])
+    expect(assignment.zone2Groups.value).toEqual([])
+    expect(assignment.unassignedGroups.value.map(group => group.name)).toEqual(['control-b', 'treatment-a'])
+    expect(assignment.zone1Count.value).toBe(3)
+    expect(assignment.zone2Count.value).toBe(0)
+    expect(assignment.isValid.value).toBe(false)
+    expect(assignment.validationMessage.value).toBe('Add 1 more to Treatment')
+  })
+
+  it('moves assignments between zones without mutating the input arrays', () => {
+    const group1 = ['control-a']
+    const group2 = ['treatment-a']
+    const assignment = useGroupAssignment({ groups, group1, group2 })
+
+    expect(assignment.getZoneForGroup('control-a')).toBe('zone1')
+    expect(assignment.assignToZone('control-a', 'zone2')).toEqual({
+      group1: [],
+      group2: ['treatment-a', 'control-a'],
+    })
+    expect(assignment.removeFromZone('treatment-a', 'zone2')).toEqual({
+      group1: ['control-a'],
+      group2: [],
+    })
+    expect(assignment.clearAll()).toEqual({ group1: [], group2: [] })
+    expect(group1).toEqual(['control-a'])
+    expect(group2).toEqual(['treatment-a'])
+  })
+
+  it('updates from reactive sources and normalizes minimum group counts', () => {
+    const group1 = ref<string[]>([])
+    const group2 = ref<string[]>(['treatment-a'])
+    const minPerGroup = ref(2.8)
+    const assignment = useGroupAssignment({
+      groups: () => groups,
+      group1,
+      group2,
+      minPerGroup,
+    })
+
+    expect(assignment.isValid.value).toBe(false)
+    expect(assignment.validationMessage.value).toBe('Add 2 more to Control and 1 more to Treatment')
+
+    group1.value = ['control-a', 'control-b']
+    group2.value = ['treatment-a', 'control-a']
+    minPerGroup.value = 0
+
+    expect(assignment.isValid.value).toBe(true)
+    expect(assignment.validationMessage.value).toBeNull()
+    expect(assignment.unassignedGroups.value).toEqual([])
+  })
+})

package/src/__tests__/composables/useJobsStatusTray.test.ts

@@ -0,0 +1,283 @@
+import { mount } from '@vue/test-utils'
+import { defineComponent, nextTick, shallowRef } from 'vue'
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+  combinePluginJobSources,
+  usePluginJobCenter,
+  type UsePluginJobCenterOptions,
+} from '../../composables/useJobsStatusTray'
+import type { JobStateInput, JobStatus } from '../../types/jobs'
+
+function job(status: JobStatus, id: string = status): JobStateInput {
+  return {
+    id,
+    job_id: id,
+    kind: 'analysis',
+    name: id,
+    status,
+    progress: {
+      current_file: 0,
+      total_files: 0,
+      current_filename: null,
+      percent: status === 'running' ? 42 : 0,
+      message: '',
+      stage: status,
+    },
+    queue_position: 0,
+    warnings: [],
+    error: null,
+    output_path: null,
+    save_path: null,
+    session_id: null,
+    folders: [],
+    folder_path: null,
+    user_id: '1',
+    owner_user_id: '1',
+    experiment_id: null,
+    extraction_result_id: null,
+    metadata: {},
+    created_at: '2026-07-14T10:00:00+00:00',
+    started_at: null,
+    completed_at: null,
+  }
+}
+
+function mountComposable(options: UsePluginJobCenterOptions) {
+  let tray!: ReturnType<typeof usePluginJobCenter>
+  const wrapper = mount(defineComponent({
+    setup() {
+      tray = usePluginJobCenter(options)
+      return () => null
+    },
+  }))
+  return { tray, wrapper }
+}
+
+describe('usePluginJobCenter', () => {
+  it('combines live source jobs and fans out or routes source actions', async () => {
+    const firstJobs = shallowRef([job('running', 'first')])
+    const secondJobs = shallowRef([job('completed', 'second')])
+    const firstRefresh = vi.fn(async () => firstJobs.value)
+    const secondRefresh = vi.fn(async () => secondJobs.value)
+    const secondCancel = vi.fn(async (jobId: string) => job('cancelled', jobId))
+    const firstClear = vi.fn(async () => 1)
+    const secondClear = vi.fn(async () => 2)
+    const firstDispose = vi.fn()
+    const secondDispose = vi.fn()
+    const combined = combinePluginJobSources([
+      {
+        jobs: firstJobs,
+        refreshJobs: firstRefresh,
+        clearFinishedJobs: firstClear,
+        dispose: firstDispose,
+      },
+      {
+        jobs: secondJobs,
+        refreshJobs: secondRefresh,
+        cancelJob: secondCancel,
+        clearFinishedJobs: secondClear,
+        dispose: secondDispose,
+      },
+    ])
+
+    expect(combined.jobs.value.map(item => item.job_id)).toEqual(['first', 'second'])
+    secondJobs.value = [job('running', 'replacement')]
+    await nextTick()
+    expect(combined.jobs.value.map(item => item.job_id)).toEqual(['first', 'replacement'])
+
+    await combined.refreshJobs?.()
+    await combined.cancelJob?.('replacement')
+    await expect(combined.clearFinishedJobs?.()).resolves.toBe(3)
+    combined.dispose?.()
+
+    expect({
+      refreshes: [firstRefresh.mock.calls.length, secondRefresh.mock.calls.length],
+      cancelled: secondCancel.mock.calls[0]?.[0],
+      disposed: [firstDispose.mock.calls.length, secondDispose.mock.calls.length],
+    }).toEqual({
+      refreshes: [1, 1],
+      cancelled: 'replacement',
+      disposed: [1, 1],
+    })
+  })
+
+  it('retains every failure when disposing combined sources', () => {
+    const firstFailure = new Error('first dispose failed')
+    const secondFailure = { source: 'second', reason: 'dispose failed' }
+    const finalDispose = vi.fn()
+    const combined = combinePluginJobSources([
+      {
+        jobs: [],
+        dispose: () => {
+          throw firstFailure
+        },
+      },
+      {
+        jobs: [],
+        dispose: () => {
+          throw secondFailure
+        },
+      },
+      { jobs: [], dispose: finalDispose },
+    ])
+
+    let failure: unknown
+    try {
+      combined.dispose?.()
+    } catch (cause) {
+      failure = cause
+    }
+
+    expect(failure).toMatchObject({
+      name: 'PluginJobSourceDisposeError',
+      message: 'Failed to dispose plugin job sources',
+      cause: firstFailure,
+      errors: [firstFailure, secondFailure],
+    })
+    expect(finalDispose).toHaveBeenCalledOnce()
+  })
+
+  it('rejects duplicate ids instead of routing to an arbitrary combined source', async () => {
+    const firstCancel = vi.fn(async () => undefined)
+    const secondCancel = vi.fn(async () => undefined)
+    const combined = combinePluginJobSources([
+      { jobs: [job('running', 'duplicate')], cancelJob: firstCancel },
+      { jobs: [job('queued', 'duplicate')], cancelJob: secondCancel },
+    ])
+
+    expect(() => combined.jobs.value).toThrow('Duplicate plugin job id')
+    await expect(combined.cancelJob?.('duplicate')).rejects.toThrow('Duplicate plugin job id')
+    expect([firstCancel.mock.calls.length, secondCancel.mock.calls.length]).toEqual([0, 0])
+  })
+
+  it('does not expose a partial bulk clear across combined sources', () => {
+    const combined = combinePluginJobSources([
+      { jobs: [job('completed', 'first')], clearFinishedJobs: async () => 1 },
+      { jobs: [job('completed', 'second')] },
+    ])
+
+    expect(combined.clearFinishedJobs).toBeUndefined()
+  })
+
+  it('does not partially delete finished jobs when one combined source cannot delete', async () => {
+    const firstDelete = vi.fn(async () => true)
+    const combined = combinePluginJobSources([
+      { jobs: [job('completed', 'first')], deleteJob: firstDelete },
+      { jobs: [job('completed', 'second')] },
+    ])
+    let center!: ReturnType<typeof usePluginJobCenter>
+    const wrapper = mount(defineComponent({
+      setup() {
+        center = usePluginJobCenter({ source: combined, loadOnMount: false })
+        return () => null
+      },
+    }))
+
+    expect(combined.deleteJob).toBeUndefined()
+    expect(center.canClearFinished.value).toBe(false)
+    await expect(center.clearFinished()).resolves.toBe(false)
+    expect(firstDelete).not.toHaveBeenCalled()
+
+    wrapper.unmount()
+  })
+
+  it('derives jobs directly from a canonical source ref', async () => {
+    const sourceJobs = shallowRef([job('queued', 'first')])
+    let center!: ReturnType<typeof usePluginJobCenter>
+    const wrapper = mount(defineComponent({
+      setup() {
+        center = usePluginJobCenter({
+          source: { jobs: sourceJobs },
+          loadOnMount: false,
+        })
+        return () => null
+      },
+    }))
+
+    sourceJobs.value = [job('running', 'replacement')]
+    await nextTick()
+
+    expect(center.jobs.value.map(item => item.job_id)).toEqual(['replacement'])
+    wrapper.unmount()
+  })
+
+  it('delegates actions by id and leaves source mutation with the source', async () => {
+    const sourceJobs = shallowRef([job('running', 'fit')])
+    const cancelJob = vi.fn(async (jobId: string) => {
+      sourceJobs.value = [job('cancelled', jobId)]
+      return sourceJobs.value[0]
+    })
+    let center!: ReturnType<typeof usePluginJobCenter>
+    const wrapper = mount(defineComponent({
+      setup() {
+        center = usePluginJobCenter({
+          source: { jobs: sourceJobs, cancelJob },
+          loadOnMount: false,
+        })
+        return () => null
+      },
+    }))
+
+    await center.cancelJob(center.jobs.value[0]!)
+
+    expect([cancelJob.mock.calls[0]?.[0], center.jobs.value[0]?.status]).toEqual([
+      'fit',
+      'cancelled',
+    ])
+    wrapper.unmount()
+  })
+
+  it('keeps awaiting input jobs in the active group', () => {
+    const { tray } = mountComposable({
+      source: { jobs: [job('awaiting_input')] },
+      loadOnMount: false,
+    })
+
+    expect(tray.activeJobs.value.map(item => item.job_id)).toEqual(['awaiting_input'])
+  })
+
+  it('does not call a source cancel action when the capability is disabled', async () => {
+    const cancelJob = vi.fn()
+    const { tray } = mountComposable({
+      source: {
+        jobs: [{ ...job('running'), can_cancel: false }],
+        cancelJob,
+      },
+      loadOnMount: false,
+    })
+
+    await tray.cancelJob(tray.jobs.value[0]!)
+
+    expect(cancelJob).not.toHaveBeenCalled()
+  })
+
+  it('refreshes through the source without mirroring its jobs', async () => {
+    const sourceJobs = shallowRef([job('running', 'old')])
+    const refreshJobs = vi.fn(async () => {
+      sourceJobs.value = [job('queued', 'new')]
+      return sourceJobs.value
+    })
+    const { tray } = mountComposable({
+      source: { jobs: sourceJobs, refreshJobs },
+      loadOnMount: false,
+    })
+
+    await tray.refresh()
+    await nextTick()
+
+    expect([refreshJobs.mock.calls.length, tray.jobs.value.map(item => item.job_id)]).toEqual([
+      1,
+      ['new'],
+    ])
+  })
+
+  it('does not include active deletable jobs in bulk clear targets', () => {
+    const { tray } = mountComposable({
+      source: { jobs: [{ ...job('awaiting_input'), can_delete: true }] },
+      loadOnMount: false,
+    })
+
+    expect(tray.deletableJobs.value).toEqual([])
+  })
+})

package/src/__tests__/composables/useListSelection.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest'
+import { computed, ref } from 'vue'
+import { useListSelection } from '../../composables/useListSelection'
+
+describe('useListSelection', () => {
+  it('toggles single values and all configured items', () => {
+    const selected = ref<string[]>(['A'])
+    const selection = useListSelection({
+      selected,
+      items: ['A', 'B', 'C'],
+    })
+
+    expect(selection.isSelected('A')).toBe(true)
+    expect(selection.toggleValue('A')).toEqual([])
+    expect(selection.toggleValue('B')).toEqual(['A', 'B'])
+    expect(selection.isAllSelected.value).toBe(false)
+
+    selected.value = ['A', 'B', 'C']
+    expect(selection.isAllSelected.value).toBe(true)
+    expect(selection.toggleAll()).toEqual([])
+  })
+
+  it('reports full and partial batch selection', () => {
+    const selection = useListSelection({
+      selected: ['A', 'B'],
+    })
+
+    expect(selection.isFullySelected(['A', 'B'])).toBe(true)
+    expect(selection.isPartiallySelected(['A', 'C'])).toBe(true)
+    expect(selection.isPartiallySelected(['C', 'D'])).toBe(false)
+    expect(selection.toggleValues(['A', 'B'])).toEqual([])
+    expect(selection.toggleValues(['B', 'C'])).toEqual(['A', 'B', 'C'])
+  })
+
+  it('uses item value adapters for object lists', () => {
+    const selection = useListSelection({
+      selected: computed(() => [2]),
+      items: [
+        { id: 1, label: 'Control' },
+        { id: 2, label: 'Treatment' },
+      ],
+      getValue: item => item.id,
+    })
+
+    expect(selection.itemValues.value).toEqual([1, 2])
+    expect(selection.isAllSelected.value).toBe(false)
+    expect(selection.selectAll()).toEqual([2, 1])
+  })
+
+  it('respects disabled and max-selection constraints', () => {
+    const disabledSelection = useListSelection({
+      selected: ['A'],
+      disabled: true,
+    })
+    expect(disabledSelection.toggleValue('B')).toEqual(['A'])
+    expect(disabledSelection.clear()).toEqual(['A'])
+
+    const limitedSelection = useListSelection({
+      selected: ['A'],
+      max: 1,
+    })
+    expect(limitedSelection.canAddMore.value).toBe(false)
+    expect(limitedSelection.toggleValue('B')).toEqual(['A'])
+    expect(limitedSelection.toggleValue('A')).toEqual([])
+  })
+})

package/src/__tests__/composables/useMobileSupportGate.test.ts

@@ -0,0 +1,74 @@
+import { mount } from '@vue/test-utils'
+import { computed, defineComponent, nextTick, ref } from 'vue'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { useMobileSupportGate } from '../../composables/useMobileSupportGate'
+
+function mockMatchMedia(initialMatches: boolean) {
+  const listeners = new Set<(event: MediaQueryListEvent) => void>()
+  const queryList = {
+    matches: initialMatches,
+    media: '',
+    onchange: null,
+    addEventListener: vi.fn((_event: string, listener: (event: MediaQueryListEvent) => void) => {
+      listeners.add(listener)
+    }),
+    removeEventListener: vi.fn((_event: string, listener: (event: MediaQueryListEvent) => void) => {
+      listeners.delete(listener)
+    }),
+    addListener: vi.fn((listener: (event: MediaQueryListEvent) => void) => {
+      listeners.add(listener)
+    }),
+    removeListener: vi.fn((listener: (event: MediaQueryListEvent) => void) => {
+      listeners.delete(listener)
+    }),
+    dispatchEvent: vi.fn(),
+  } as unknown as MediaQueryList
+
+  Object.defineProperty(window, 'matchMedia', {
+    configurable: true,
+    value: vi.fn(() => queryList),
+  })
+
+  return {
+    setMatches(matches: boolean) {
+      Object.defineProperty(queryList, 'matches', {
+        configurable: true,
+        value: matches,
+      })
+      listeners.forEach(listener => listener({ matches } as MediaQueryListEvent))
+    },
+  }
+}
+
+describe('useMobileSupportGate', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('computes the unsupported state from viewport and supported sources', async () => {
+    const media = mockMatchMedia(true)
+    const supported = ref(false)
+
+    const wrapper = mount(defineComponent({
+      setup() {
+        const gate = useMobileSupportGate({
+          supported: computed(() => supported.value),
+        })
+        return gate
+      },
+      template: '<div>{{ shouldShowUnsupported }}</div>',
+    }))
+    await nextTick()
+
+    expect(wrapper.text()).toBe('true')
+
+    supported.value = true
+    await nextTick()
+    expect(wrapper.text()).toBe('false')
+
+    supported.value = false
+    media.setMatches(false)
+    await nextTick()
+    expect(wrapper.text()).toBe('false')
+  })
+})

package/src/__tests__/composables/useOptimisticMutation.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+
+import { useOptimisticMutation } from '../../composables/useOptimisticMutation'
+
+describe('useOptimisticMutation', () => {
+  it('applies optimistic state and commits server data', async () => {
+    const items = ['A']
+    const mutation = useOptimisticMutation<string, string, string[]>({
+      snapshot: () => [...items],
+      apply: value => { items.push(value) },
+      mutation: async (value: string) => value.toLowerCase(),
+      commit: result => { items[items.length - 1] = result },
+    })
+
+    const result = await mutation.run('B')
+
+    expect(result).toBe('b')
+    expect(items).toEqual(['A', 'b'])
+    expect(mutation.loading.value).toBe(false)
+    expect(mutation.error.value).toBeNull()
+  })
+
+  it('rolls back and rethrows failed mutations', async () => {
+    const items = ['A']
+    const failure = new Error('backend rejected')
+    const mutation = useOptimisticMutation<string, never, string[]>({
+      snapshot: () => [...items],
+      apply: value => { items.push(value) },
+      mutation: async () => { throw failure },
+      rollback: snapshot => {
+        items.splice(0, items.length, ...(snapshot ?? []))
+      },
+    })
+
+    await expect(mutation.run('B')).rejects.toThrow('backend rejected')
+
+    expect(items).toEqual(['A'])
+    expect(mutation.error.value).toBe('backend rejected')
+  })
+})

package/src/__tests__/composables/usePlatformContext.test.ts

@@ -0,0 +1,148 @@
+import { beforeEach, afterEach, describe, expect, expectTypeOf, it, vi } from 'vitest'
+
+const unmountedCallbacks: Array<() => void> = []
+
+type MessageHandler = (event: MessageEvent) => void
+let messageHandler: MessageHandler | null = null
+
+vi.mock('vue', async () => {
+  const actual = await vi.importActual<typeof import('vue')>('vue')
+  return {
+    ...actual,
+    onMounted: vi.fn((cb: () => void) => cb()),
+    onUnmounted: vi.fn((cb: () => void) => {
+      unmountedCallbacks.push(cb)
+    }),
+  }
+})
+
+import { usePlatformContext } from '../../composables/usePlatformContext'
+import type { PlatformContext } from '../../types'
+
+type InjectedPlatformWindow = Window & {
+  __MINT_PLATFORM__?: PlatformContext
+}
+
+function sendThemeMessage(origin: string, theme: 'light' | 'dark' | 'system'): void {
+  if (!messageHandler) {
+    throw new Error('Message handler was not registered')
+  }
+
+  messageHandler({
+    source: window.parent,
+    origin,
+    data: {
+      type: 'mint:theme-changed',
+      payload: theme,
+    },
+  } as MessageEvent)
+}
+
+describe('usePlatformContext', () => {
+  it('uses integer IDs for injected users', () => {
+    expectTypeOf<NonNullable<PlatformContext['user']>['id']>().toEqualTypeOf<number>()
+  })
+
+  beforeEach(() => {
+    unmountedCallbacks.length = 0
+    messageHandler = null
+    delete (window as InjectedPlatformWindow).__MINT_PLATFORM__
+
+    vi.spyOn(window, 'addEventListener').mockImplementation((type, listener) => {
+      if (type === 'message') {
+        messageHandler = listener as MessageHandler
+      }
+    })
+    vi.spyOn(window, 'removeEventListener').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    while (unmountedCallbacks.length > 0) {
+      const callback = unmountedCallbacks.pop()
+      callback?.()
+    }
+    delete (window as InjectedPlatformWindow).__MINT_PLATFORM__
+    vi.restoreAllMocks()
+  })
+
+  it('preserves the injected plugin settings API capability', () => {
+    const injectedContext: PlatformContext = {
+      isIntegrated: true,
+      theme: 'light',
+      platformApiUrl: '/api',
+      plugin: {
+        id: 'test-plugin',
+        name: 'test-plugin',
+        version: '1.0.0',
+        route_prefix: '/test-plugin',
+        api_prefix: '/api/test-plugin',
+        settings_api: 'plugin',
+      },
+    }
+    ;(window as InjectedPlatformWindow).__MINT_PLATFORM__ = injectedContext
+
+    const context = usePlatformContext()
+
+    expect(context.plugin.value?.settings_api).toBe('plugin')
+  })
+
+  it('clears allowAnyOrigin policy after last consumer unmounts', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const first = usePlatformContext({ allowAnyOrigin: true })
+    sendThemeMessage('https://evil.example', 'dark')
+    expect(first.theme.value).toBe('dark')
+
+    expect(unmountedCallbacks).toHaveLength(1)
+    unmountedCallbacks[0]!()
+    unmountedCallbacks.length = 0
+
+    const second = usePlatformContext()
+    sendThemeMessage('https://evil.example', 'light')
+    expect(second.theme.value).toBe('system')
+    expect(
+      warnSpy.mock.calls.some(([msg]) => String(msg).includes('Rejected postMessage')),
+    ).toBe(true)
+  })
+
+  it('does not leak explicit allowed origins to new consumers', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const first = usePlatformContext({ allowedOrigins: ['https://trusted.example'] })
+    sendThemeMessage('https://trusted.example', 'dark')
+    expect(first.theme.value).toBe('dark')
+
+    expect(unmountedCallbacks).toHaveLength(1)
+    unmountedCallbacks[0]!()
+    unmountedCallbacks.length = 0
+
+    const second = usePlatformContext()
+    sendThemeMessage('https://trusted.example', 'light')
+    expect(second.theme.value).toBe('system')
+    expect(
+      warnSpy.mock.calls.some(([msg]) => String(msg).includes('Rejected postMessage')),
+    ).toBe(true)
+  })
+
+  it('removes allowAnyOrigin scope when that consumer unmounts while others remain', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    usePlatformContext({ allowAnyOrigin: true })
+    const second = usePlatformContext()
+
+    sendThemeMessage('https://evil.example', 'dark')
+    expect(second.theme.value).toBe('dark')
+
+    expect(unmountedCallbacks).toHaveLength(2)
+    unmountedCallbacks[0]!()
+
+    sendThemeMessage('https://evil.example', 'light')
+    expect(second.theme.value).toBe('dark')
+    expect(
+      warnSpy.mock.calls.some(([msg]) => String(msg).includes('Rejected postMessage')),
+    ).toBe(true)
+
+    unmountedCallbacks[1]!()
+    unmountedCallbacks.length = 0
+  })
+})