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

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

@@ -1,164 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { defineComponent, nextTick } from 'vue'
-import { mount } from '@vue/test-utils'
-
-import { usePresenceHeartbeat } from '../../composables/usePresenceHeartbeat'
-
-class MemoryStorage implements Pick<Storage, 'getItem' | 'setItem'> {
-  private readonly values = new Map<string, string>()
-
-  getItem(key: string): string | null {
-    return this.values.get(key) ?? null
-  }
-
-  setItem(key: string, value: string): void {
-    this.values.set(key, value)
-  }
-}
-
-function mountHeartbeat(options: Parameters<typeof usePresenceHeartbeat>[0]) {
-  let heartbeat: ReturnType<typeof usePresenceHeartbeat> | undefined
-  const wrapper = mount(defineComponent({
-    setup() {
-      heartbeat = usePresenceHeartbeat(options)
-      return () => null
-    },
-  }))
-  return { wrapper, get heartbeat() { return heartbeat! } }
-}
-
-describe('usePresenceHeartbeat', () => {
-  afterEach(() => {
-    vi.useRealTimers()
-    vi.restoreAllMocks()
-  })
-
-  it('should reuse one sessionStorage client id and send the integrated scope immediately', async () => {
-    const storage = new MemoryStorage()
-    const send = vi.fn().mockResolvedValue(undefined)
-    const first = mountHeartbeat({
-      scope: 'LEAF',
-      enabled: true,
-      storage,
-      createClientId: () => 'tab-1',
-      send,
-    })
-    await nextTick()
-
-    expect(send).toHaveBeenCalledWith({ client_id: 'tab-1', scope: 'LEAF' })
-
-    first.wrapper.unmount()
-    send.mockClear()
-    const second = mountHeartbeat({
-      scope: 'HMDB',
-      enabled: true,
-      storage,
-      createClientId: () => 'tab-2',
-      send,
-    })
-    await nextTick()
-
-    expect({ clientId: second.heartbeat.clientId, payload: send.mock.calls[0]?.[0] }).toEqual({
-      clientId: 'tab-1',
-      payload: { client_id: 'tab-1', scope: 'HMDB' },
-    })
-    second.wrapper.unmount()
-  })
-
-  it('should heartbeat every 30 seconds only while the page is visible', async () => {
-    vi.useFakeTimers()
-    const send = vi.fn().mockResolvedValue(undefined)
-    const visibility = { value: 'visible' }
-    vi.spyOn(document, 'visibilityState', 'get').mockImplementation(
-      () => visibility.value as DocumentVisibilityState,
-    )
-    const { wrapper } = mountHeartbeat({
-      scope: 'platform',
-      enabled: true,
-      storage: new MemoryStorage(),
-      createClientId: () => 'platform-tab',
-      send,
-    })
-    await nextTick()
-    expect(send).toHaveBeenCalledTimes(1)
-
-    await vi.advanceTimersByTimeAsync(30_000)
-    expect(send).toHaveBeenCalledTimes(2)
-
-    visibility.value = 'hidden'
-    document.dispatchEvent(new Event('visibilitychange'))
-    await vi.advanceTimersByTimeAsync(60_000)
-    expect(send).toHaveBeenCalledTimes(2)
-
-    visibility.value = 'visible'
-    document.dispatchEvent(new Event('visibilitychange'))
-    await nextTick()
-    expect(send).toHaveBeenCalledTimes(3)
-
-    wrapper.unmount()
-    await vi.advanceTimersByTimeAsync(60_000)
-    expect(send).toHaveBeenCalledTimes(3)
-  })
-
-  it('should make no request when the caller is standalone', async () => {
-    vi.useFakeTimers()
-    const send = vi.fn().mockResolvedValue(undefined)
-    const { wrapper } = mountHeartbeat({
-      scope: 'LEAF',
-      enabled: false,
-      storage: new MemoryStorage(),
-      createClientId: () => 'standalone-tab',
-      send,
-    })
-    await nextTick()
-    await vi.advanceTimersByTimeAsync(90_000)
-
-    expect(send).not.toHaveBeenCalled()
-    wrapper.unmount()
-  })
-
-  it('should forward the platform revision response to the runtime observer', async () => {
-    const onResponse = vi.fn()
-    const response = { frontend_revision: 'sha256:new' }
-    const { wrapper } = mountHeartbeat({
-      scope: 'LEAF',
-      enabled: true,
-      storage: new MemoryStorage(),
-      createClientId: () => 'leaf-tab',
-      send: vi.fn().mockResolvedValue(response),
-      onResponse,
-    })
-    await nextTick()
-
-    expect(onResponse).toHaveBeenCalledWith(response)
-    wrapper.unmount()
-  })
-
-  it('should keep a page-local id when sessionStorage is unavailable', async () => {
-    const storage = {
-      getItem: vi.fn(() => { throw new Error('blocked') }),
-      setItem: vi.fn(() => { throw new Error('blocked') }),
-    }
-    const send = vi.fn().mockResolvedValue(undefined)
-    const first = mountHeartbeat({
-      scope: 'LEAF',
-      enabled: true,
-      storage,
-      createClientId: () => 'fallback-tab',
-      send,
-    })
-    await nextTick()
-    first.wrapper.unmount()
-    const second = mountHeartbeat({
-      scope: 'HMDB',
-      enabled: true,
-      storage,
-      createClientId: () => 'different-tab',
-      send,
-    })
-    await nextTick()
-
-    expect(second.heartbeat.clientId).toBe('fallback-tab')
-    second.wrapper.unmount()
-  })
-})

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

@@ -1,64 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { useProtocolTemplates } from '../../composables/useProtocolTemplates'
-
-const STORAGE_KEY = 'mint-custom-protocol-templates'
-
-function installLocalStorage() {
-  const storage: Record<string, string> = {}
-  vi.stubGlobal('localStorage', {
-    get length() {
-      return Object.keys(storage).length
-    },
-    key: vi.fn((index: number) => Object.keys(storage)[index] ?? null),
-    getItem: vi.fn((key: string) => storage[key] ?? null),
-    setItem: vi.fn((key: string, value: string) => {
-      storage[key] = value
-    }),
-    removeItem: vi.fn((key: string) => {
-      delete storage[key]
-    }),
-    clear: vi.fn(() => {
-      for (const key of Object.keys(storage)) delete storage[key]
-    }),
-  } as unknown as Storage)
-}
-
-describe('useProtocolTemplates', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks()
-    vi.unstubAllGlobals()
-    installLocalStorage()
-  })
-
-  it('ignores corrupted custom template storage', () => {
-    localStorage.setItem(STORAGE_KEY, JSON.stringify({ invalid: true }))
-
-    const templates = useProtocolTemplates()
-
-    expect(templates.customTemplates.value).toEqual([])
-    expect(templates.allTemplates.value.length).toBeGreaterThan(0)
-  })
-
-  it('filters invalid custom template entries', () => {
-    localStorage.setItem(STORAGE_KEY, JSON.stringify([
-      { id: 'bad', name: 'Missing parameters', type: 'custom' },
-      {
-        id: 'custom-valid',
-        name: 'Valid custom step',
-        type: 'custom',
-        parameters: [],
-      },
-    ]))
-
-    const templates = useProtocolTemplates()
-
-    expect(templates.customTemplates.value).toEqual([
-      {
-        id: 'custom-valid',
-        name: 'Valid custom step',
-        type: 'custom',
-        parameters: [],
-      },
-    ])
-  })
-})

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

@@ -1,92 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { useRequestSyncState } from '../../composables/useRequestSyncState'
-
-describe('useRequestSyncState', () => {
-  it('starts with idle request state', () => {
-    const state = useRequestSyncState()
-
-    expect(state.loading.value).toBe(false)
-    expect(state.error.value).toBeNull()
-    expect(state.lastLoadedAt.value).toBeNull()
-    expect(state.lastSavedAt.value).toBeNull()
-    expect(state.lastRunAt.value).toBeNull()
-  })
-
-  it('normalizes errors and supports explicit clearing', () => {
-    const state = useRequestSyncState('Default failure')
-
-    expect(state.setError(new Error('Backend rejected request'))).toBe(
-      'Backend rejected request',
-    )
-    expect(state.error.value).toBe('Backend rejected request')
-
-    expect(state.setError('String failure')).toBe('String failure')
-    expect(state.error.value).toBe('String failure')
-
-    expect(state.setError({ message: 'Validation failed' })).toBe('Validation failed')
-    expect(state.error.value).toBe('Validation failed')
-
-    expect(state.setError({ reason: 'unknown' })).toBe('Default failure')
-    state.clearError()
-    expect(state.error.value).toBeNull()
-  })
-
-  it('marks load, save, and run timestamps', () => {
-    const state = useRequestSyncState()
-    const loadedAt = new Date('2026-05-07T09:00:00Z')
-    const savedAt = new Date('2026-05-07T09:01:00Z')
-    const runAt = new Date('2026-05-07T09:02:00Z')
-
-    state.markLoaded(loadedAt)
-    state.markSaved(savedAt)
-    state.markRun(runAt)
-
-    expect(state.lastLoadedAt.value).toBe(loadedAt)
-    expect(state.lastSavedAt.value).toBe(savedAt)
-    expect(state.lastRunAt.value).toBe(runAt)
-  })
-
-  it('wraps successful operations and marks requested sync timestamps', async () => {
-    const state = useRequestSyncState()
-
-    const result = await state.run(async () => {
-      expect(state.loading.value).toBe(true)
-      return { ok: true }
-    }, { success: 'load' })
-
-    expect(result).toEqual({ ok: true })
-    expect(state.loading.value).toBe(false)
-    expect(state.error.value).toBeNull()
-    expect(state.lastLoadedAt.value).toBeInstanceOf(Date)
-    expect(state.lastSavedAt.value).toBeNull()
-    expect(state.lastRunAt.value).toBeNull()
-  })
-
-  it('wraps successful run operations and marks lastRunAt', async () => {
-    const state = useRequestSyncState()
-
-    const result = await state.run(async () => 'done', { success: 'run' })
-
-    expect(result).toBe('done')
-    expect(state.lastLoadedAt.value).toBeNull()
-    expect(state.lastSavedAt.value).toBeNull()
-    expect(state.lastRunAt.value).toBeInstanceOf(Date)
-  })
-
-  it('wraps failed operations, sets error, and rethrows', async () => {
-    const state = useRequestSyncState()
-    const failure = new Error('Network down')
-
-    await expect(state.run(async () => {
-      expect(state.loading.value).toBe(true)
-      throw failure
-    }, { success: 'save' })).rejects.toThrow('Network down')
-
-    expect(state.loading.value).toBe(false)
-    expect(state.error.value).toBe('Network down')
-    expect(state.lastLoadedAt.value).toBeNull()
-    expect(state.lastSavedAt.value).toBeNull()
-    expect(state.lastRunAt.value).toBeNull()
-  })
-})

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

@@ -1,56 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { useResourceCrud } from '../../composables/useResourceCrud'
-
-interface Item {
-  id: string
-  name: string
-}
-
-describe('useResourceCrud', () => {
-  it('loads and mutates local resource state through an adapter', async () => {
-    const remote: Item[] = [{ id: 'a', name: 'Alpha' }]
-    const resource = useResourceCrud<Item, Pick<Item, 'name'>, Partial<Item>, string>({
-      adapter: {
-        list: async () => [...remote],
-        create: async payload => {
-          const item = { id: payload.name.toLowerCase(), name: payload.name }
-          remote.push(item)
-          return item
-        },
-        update: async (id, payload) => {
-          const item = { id, name: payload.name ?? 'Untitled' }
-          remote.splice(remote.findIndex(candidate => candidate.id === id), 1, item)
-          return item
-        },
-        remove: async id => {
-          remote.splice(remote.findIndex(candidate => candidate.id === id), 1)
-        },
-      },
-    })
-
-    await resource.load()
-    expect(resource.items.value).toEqual([{ id: 'a', name: 'Alpha' }])
-
-    await resource.createItem({ name: 'Beta' })
-    expect(resource.items.value.map(item => item.name)).toEqual(['Alpha', 'Beta'])
-
-    await resource.updateItem('beta', { name: 'Bravo' })
-    expect(resource.items.value.find(item => item.id === 'beta')?.name).toBe('Bravo')
-
-    await resource.deleteItem('a')
-    expect(resource.items.value.map(item => item.id)).toEqual(['beta'])
-  })
-
-  it('normalizes adapter errors', async () => {
-    const resource = useResourceCrud<Item>({
-      adapter: {
-        list: async () => { throw new Error('nope') },
-      },
-    })
-
-    await expect(resource.load()).rejects.toThrow('nope')
-    expect(resource.error.value).toBe('nope')
-    expect(resource.loading.value).toBe(false)
-  })
-})

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

@@ -1,145 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { defineComponent, nextTick } from 'vue'
-import { mount } from '@vue/test-utils'
-
-import { useRuntimeAlignment } from '../../composables/useRuntimeAlignment'
-
-class MemoryStorage implements Pick<Storage, 'getItem' | 'setItem'> {
-  private readonly values = new Map<string, string>()
-
-  getItem(key: string): string | null {
-    return this.values.get(key) ?? null
-  }
-
-  setItem(key: string, value: string): void {
-    this.values.set(key, value)
-  }
-}
-
-function mountRuntime(options: Parameters<typeof useRuntimeAlignment>[0]) {
-  let runtime: ReturnType<typeof useRuntimeAlignment> | undefined
-  const wrapper = mount(defineComponent({
-    setup() {
-      runtime = useRuntimeAlignment(options)
-      return () => null
-    },
-  }))
-  return { wrapper, get runtime() { return runtime! } }
-}
-
-describe('useRuntimeAlignment', () => {
-  afterEach(() => vi.restoreAllMocks())
-
-  it('should offer a reload when a visible tab observes a different revision', async () => {
-    const replace = vi.fn()
-    const { runtime } = mountRuntime({
-      currentRevision: 'sha256:old',
-      visibility: () => 'visible',
-      replace,
-      storage: new MemoryStorage(),
-    })
-
-    runtime.observe({ frontend_revision: 'sha256:new' })
-    await nextTick()
-
-    expect(runtime.updateAvailable.value).toBe(true)
-  })
-
-  it('should reload a hidden stale tab automatically', () => {
-    const replace = vi.fn()
-    const { runtime } = mountRuntime({
-      currentRevision: 'sha256:old',
-      visibility: () => 'hidden',
-      replace,
-      storage: new MemoryStorage(),
-      currentUrl: () => 'https://mint.example/leaf/analysis',
-    })
-
-    runtime.observe({ frontend_revision: 'sha256:new' })
-
-    expect(replace).toHaveBeenCalledWith(
-      'https://mint.example/leaf/analysis?__mint_revision=sha256%3Anew',
-    )
-  })
-
-  it('should reload before reuse when a tab became stale while hidden', () => {
-    const replace = vi.fn()
-    let state: DocumentVisibilityState = 'visible'
-    let visibilityListener: EventListener | undefined
-    const runtime = mountRuntime({
-      currentRevision: 'sha256:before-hide',
-      visibility: () => state,
-      replace,
-      storage: new MemoryStorage(),
-      currentUrl: () => 'https://mint.example/leaf/analysis',
-      visibilityTarget: {
-        addEventListener: (_type, listener) => { visibilityListener = listener },
-        removeEventListener: () => {},
-      },
-    }).runtime
-    state = 'hidden'
-    visibilityListener?.(new Event('visibilitychange'))
-    state = 'visible'
-
-    runtime.observe({ frontend_revision: 'sha256:after-hide' })
-
-    expect(replace).toHaveBeenCalledTimes(1)
-  })
-
-  it('should make only one recovery reload for the same missing chunk', () => {
-    const replace = vi.fn()
-    const storage = new MemoryStorage()
-    const first = mountRuntime({
-      currentRevision: 'sha256:old',
-      visibility: () => 'visible',
-      replace,
-      storage,
-      currentUrl: () => 'https://mint.example/',
-    })
-    const second = mountRuntime({
-      currentRevision: 'sha256:old',
-      visibility: () => 'visible',
-      replace,
-      storage,
-      currentUrl: () => 'https://mint.example/',
-    })
-
-    first.runtime.recoverMissingChunk()
-    second.runtime.recoverMissingChunk()
-
-    expect(replace).toHaveBeenCalledTimes(1)
-  })
-
-  it('should make only one recovery reload when session storage is unavailable', () => {
-    const replace = vi.fn()
-    const runtime = mountRuntime({
-      currentRevision: 'sha256:no-storage',
-      visibility: () => 'visible',
-      replace,
-      storage: null,
-      currentUrl: () => 'https://mint.example/',
-    }).runtime
-
-    runtime.recoverMissingChunk()
-    runtime.recoverMissingChunk()
-
-    expect(replace).toHaveBeenCalledTimes(1)
-  })
-
-  it('should not repeat chunk recovery after the cache-busted page reloads', () => {
-    const replace = vi.fn()
-    const runtime = mountRuntime({
-      currentRevision: 'sha256:already-reloaded',
-      visibility: () => 'visible',
-      replace,
-      storage: null,
-      currentUrl: () => (
-        'https://mint.example/?__mint_revision=sha256%3Aalready-reloaded'
-      ),
-    }).runtime
-
-    runtime.recoverMissingChunk()
-
-    expect(replace).not.toHaveBeenCalled()
-  })
-})

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

@@ -1,66 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { ref } from 'vue'
-import { useSampleGroups } from '../../composables/useSampleGroups'
-import type { SampleGroup } from '../../types'
-
-const groups: SampleGroup[] = [
-  { name: 'Control/A', color: '#3B82F6', samples: ['S1', 'S2'] },
-  { name: 'Control/B', color: '#06B6D4', samples: ['S3'] },
-  { name: 'Treatment/A', color: '#F43F5E', samples: ['S4'] },
-]
-
-describe('useSampleGroups', () => {
-  it('derives major groups, display colors, hierarchy state, and ungrouped samples', () => {
-    const sampleGroups = useSampleGroups({
-      samples: ['S1', 'S2', 'S3', 'S4', 'S5'],
-      groups,
-    })
-
-    expect(sampleGroups.separator.value).toBe('/')
-    expect(sampleGroups.showHierarchy.value).toBe(true)
-    expect(sampleGroups.ungroupedSamples.value).toEqual(['S5'])
-    expect(sampleGroups.hierarchicalGroups.value.map(group => group.name)).toEqual(['Control', 'Treatment'])
-    expect(sampleGroups.hierarchicalGroups.value[0].allSamples).toEqual(['S1', 'S2', 'S3'])
-    expect(sampleGroups.hierarchicalGroups.value[0].subGroups[0]).toMatchObject({
-      name: 'Control/A',
-      displayBg: expect.stringMatching(/20$/),
-      displayBorder: expect.stringMatching(/40$/),
-    })
-  })
-
-  it('keeps flat groups flat when major names do not introduce hierarchy', () => {
-    const sampleGroups = useSampleGroups({
-      samples: ['S1'],
-      groups: [
-        { name: 'Control', color: '#3B82F6', samples: ['S1'] },
-      ],
-    })
-
-    expect(sampleGroups.separator.value).toBe('_')
-    expect(sampleGroups.showHierarchy.value).toBe(false)
-    expect(sampleGroups.hierarchicalGroups.value[0].name).toBe('Control')
-  })
-
-  it('supports explicit separators, fallback colors, and reactive group sources', () => {
-    const reactiveGroups = ref<SampleGroup[]>([
-      { name: 'Vehicle_DMSO', color: '', samples: ['S1'] },
-    ])
-    const sampleGroups = useSampleGroups({
-      samples: () => ['S1', 'S2'],
-      groups: reactiveGroups,
-      separator: '_',
-      fallbackColor: '#111111',
-    })
-
-    expect(sampleGroups.hierarchicalGroups.value[0].name).toBe('Vehicle')
-    expect(sampleGroups.getGroupColor('Vehicle_DMSO')).toBe('#111111')
-
-    reactiveGroups.value = [
-      ...reactiveGroups.value,
-      { name: 'Drug_1uM', color: '#F43F5E', samples: ['S2'] },
-    ]
-
-    expect(sampleGroups.ungroupedSamples.value).toEqual([])
-    expect(sampleGroups.findGroup('Drug_1uM')?.samples).toEqual(['S2'])
-  })
-})