@morscherlab/mint-sdk 1.3.8 → 1.4.0-beta.1

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

@@ -1,73 +0,0 @@
-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/useMobileSupportGate.test.ts

@@ -1,74 +0,0 @@
-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/usePlatformContext.test.ts

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

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/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()
-  })
-})