@morscherlab/mint-sdk 1.2.10 → 1.3.0-beta.10

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

@@ -1,497 +0,0 @@
-/**
- * Tests for usePluginConfig.
- *
- * Covers the plugin settings life-cycle used by every plugin's
- * settings pane:
- *
- * - resolvedName prefers explicit pluginName, falls back to platform plugin
- * - load() populates config + savedConfig from /plugins/{name}/config
- * - save() PATCHes the endpoint, updates savedConfig, returns true
- * - isDirty reflects user edits vs last saved state
- * - reset() restores config to savedConfig and clears error
- * - lastLoadedAt / lastSavedAt track successful syncs
- * - error messages bubble up from network failures
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { createPinia, setActivePinia } from 'pinia'
-import axios, { type AxiosRequestConfig } from 'axios'
-import { nextTick } from 'vue'
-
-// usePluginConfig calls onMounted(load); happy-dom doesn't run Vue's
-// lifecycle outside a component, so we stub onMounted to call the
-// callback synchronously if and only if the test opts in.
-let autoLoadOnMount = false
-vi.mock('vue', async () => {
-  const actual = await vi.importActual<typeof import('vue')>('vue')
-  return {
-    ...actual,
-    onMounted: vi.fn((cb: () => void) => {
-      if (autoLoadOnMount) cb()
-    }),
-  }
-})
-
-import { usePluginConfig } from '../../composables/usePluginConfig'
-
-type FakeResponse = Record<string, unknown>
-
-let getResponse: FakeResponse = { plugin_name: 'drp', config: {} }
-let patchResponse: FakeResponse = { plugin_name: 'drp', config: {} }
-let putResponse: FakeResponse = { plugin_name: 'drp', config: {} }
-let getError: Error | null = null
-let patchError: Error | null = null
-let recordedBaseUrls: Array<string | undefined> = []
-let recordedCalls: {
-  method: string
-  url: string
-  data?: unknown
-  headers?: AxiosRequestConfig['headers']
-}[] = []
-
-function mockAxios() {
-  vi.spyOn(axios.Axios.prototype, 'get').mockImplementation(async function (
-    this: unknown,
-    url: string,
-    config?: AxiosRequestConfig,
-  ) {
-    recordedBaseUrls.push(config?.baseURL)
-    recordedCalls.push({ method: 'GET', url })
-    if (getError) throw getError
-    return { data: getResponse }
-  })
-  vi.spyOn(axios.Axios.prototype, 'patch').mockImplementation(async function (
-    this: unknown,
-    url: string,
-    data?: unknown,
-    config?: AxiosRequestConfig,
-  ) {
-    recordedBaseUrls.push(config?.baseURL)
-    recordedCalls.push({ method: 'PATCH', url, data })
-    if (patchError) throw patchError
-    return { data: patchResponse }
-  })
-  vi.spyOn(axios.Axios.prototype, 'put').mockImplementation(async function (
-    this: unknown,
-    url: string,
-    data?: unknown,
-    config?: AxiosRequestConfig,
-  ) {
-    recordedBaseUrls.push(config?.baseURL)
-    recordedCalls.push({ method: 'PUT', url, data, headers: config?.headers })
-    return { data: putResponse }
-  })
-}
-
-describe('usePluginConfig', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    autoLoadOnMount = false
-    getResponse = { plugin_name: 'drp', config: {} }
-    patchResponse = { plugin_name: 'drp', config: {} }
-    putResponse = { plugin_name: 'drp', config: {} }
-    getError = null
-    patchError = null
-    recordedCalls = []
-    recordedBaseUrls = []
-    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
-    mockAxios()
-  })
-
-  afterEach(() => {
-    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
-    vi.restoreAllMocks()
-  })
-
-  it('load fetches config from correct endpoint and populates state', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: { raw_files_path: '/data/rfa', threshold: 0.5 },
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-
-    expect(recordedCalls).toEqual([
-      { method: 'GET', url: '/plugins/drp/config' },
-    ])
-    expect(hook.config.value).toEqual({
-      raw_files_path: '/data/rfa',
-      threshold: 0.5,
-    })
-    expect(hook.isDirty.value).toBe(false)
-    expect(hook.error.value).toBeNull()
-    expect(hook.lastLoadedAt.value).toBeInstanceOf(Date)
-  })
-
-  it('encodes special characters in plugin name', async () => {
-    const hook = usePluginConfig('my/plugin')
-    await hook.load()
-    expect(recordedCalls[0]!.url).toBe('/plugins/my%2Fplugin/config')
-  })
-
-  it.each([
-    'platform',
-    undefined,
-  ] as const)(
-    'should use the platform config facade when settings_api is %s',
-    async (settingsApi) => {
-      ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-        isIntegrated: true,
-        theme: 'light',
-        platformApiUrl: '/api',
-        plugin: {
-          id: 'drp',
-          name: 'drp',
-          version: '1.0.0',
-          route_prefix: '/drp',
-          api_prefix: '/api/drp',
-          ...(settingsApi ? { settings_api: settingsApi } : {}),
-        },
-      }
-      getResponse = {
-        plugin_name: 'drp',
-        config: { n: 1 },
-        revision: 'revision-1',
-      }
-      const hook = usePluginConfig('drp')
-
-      await hook.load()
-
-      expect(recordedCalls).toEqual([
-        { method: 'GET', url: '/plugins/drp/config' },
-      ])
-    },
-  )
-
-  it('should use the plugin settings router for an integrated plugin capability', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      platformApiUrl: '/api',
-      plugin: {
-        id: 'drp',
-        name: 'drp',
-        version: '1.0.0',
-        route_prefix: '/drp',
-        api_prefix: '/api/drp',
-        settings_api: 'plugin',
-      },
-    }
-    getResponse = {
-      settings: { n: 1 },
-      mode: 'integrated',
-      revision: 'revision-1',
-    }
-    putResponse = {
-      settings: { n: 2 },
-      mode: 'integrated',
-      revision: 'revision-2',
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = { n: 2 }
-
-    const saved = await hook.save()
-
-    expect({
-      saved,
-      calls: recordedCalls,
-      baseUrls: recordedBaseUrls,
-      config: hook.config.value,
-    }).toEqual({
-      saved: true,
-      baseUrls: ['/api/drp', '/api/drp'],
-      calls: [
-        { method: 'GET', url: '/settings' },
-        {
-          method: 'PUT',
-          url: '/settings',
-          data: { n: 2 },
-          headers: { 'If-Match': '"revision-1"' },
-        },
-      ],
-      config: { n: 2 },
-    })
-  })
-
-  it('should use the platform facade for an explicit different plugin name', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      platformApiUrl: '/api',
-      plugin: {
-        id: 'current-plugin',
-        name: 'current-plugin',
-        version: '1.0.0',
-        route_prefix: '/current-plugin',
-        api_prefix: '/api/current-plugin',
-        settings_api: 'plugin',
-      },
-    }
-    getResponse = {
-      plugin_name: 'other-plugin',
-      config: { n: 1 },
-      revision: 'revision-1',
-    }
-
-    const hook = usePluginConfig('other-plugin')
-    await hook.load()
-
-    expect({
-      calls: recordedCalls,
-      config: hook.config.value,
-    }).toEqual({
-      calls: [
-        { method: 'GET', url: '/plugins/other-plugin/config' },
-      ],
-      config: { n: 1 },
-    })
-  })
-
-  it('should PATCH only dirty typed fields through a versioned platform facade', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 1,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-1',
-    }
-    patchResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 2,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-2',
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = {
-      n: 2,
-      allowed_experiment_types: ['metabolomics'],
-    }
-    await nextTick()
-    expect(hook.isDirty.value).toBe(true)
-
-    const ok = await hook.save()
-    expect(ok).toBe(true)
-    const patchCall = recordedCalls.find((c) => c.method === 'PATCH')!
-    expect(patchCall.url).toBe('/plugins/drp/config')
-    expect(patchCall.data).toEqual({ config: { n: 2 } })
-    expect(patchCall.headers).toBeUndefined()
-    expect(hook.config.value).toEqual({
-      n: 2,
-      allowed_experiment_types: ['metabolomics'],
-    })
-    expect(hook.isDirty.value).toBe(false)
-    expect(hook.lastSavedAt.value).toBeInstanceOf(Date)
-  })
-
-  it('should split changed platform-owned config from a versioned typed save', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 1,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-1',
-    }
-    patchResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 2,
-        allowed_experiment_types: ['proteomics'],
-      },
-      revision: 'untrusted-platform-revision',
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = {
-      n: 2,
-      allowed_experiment_types: ['proteomics'],
-    }
-
-    const saved = await hook.save()
-    patchResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 3,
-        allowed_experiment_types: ['proteomics'],
-      },
-      revision: 'revision-3',
-    }
-    hook.config.value = {
-      n: 3,
-      allowed_experiment_types: ['proteomics'],
-    }
-    const savedAgain = await hook.save()
-
-    expect({
-      saved,
-      savedAgain,
-      calls: recordedCalls,
-      config: hook.config.value,
-      isDirty: hook.isDirty.value,
-    }).toEqual({
-      saved: true,
-      savedAgain: true,
-      calls: [
-        { method: 'GET', url: '/plugins/drp/config' },
-        {
-          method: 'PATCH',
-          url: '/plugins/drp/config',
-          data: { config: { n: 2 } },
-        },
-        {
-          method: 'PATCH',
-          url: '/plugins/drp/config',
-          data: { config: { allowed_experiment_types: ['proteomics'] } },
-        },
-        {
-          method: 'PATCH',
-          url: '/plugins/drp/config',
-          data: { config: { n: 3 } },
-        },
-      ],
-      config: {
-        n: 3,
-        allowed_experiment_types: ['proteomics'],
-      },
-      isDirty: false,
-    })
-  })
-
-  it('should avoid a typed PUT when only the platform-owned config changes', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 1,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-1',
-    }
-    patchResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 1,
-        allowed_experiment_types: ['proteomics'],
-      },
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = {
-      n: 1,
-      allowed_experiment_types: ['proteomics'],
-    }
-
-    const saved = await hook.save()
-
-    expect({
-      saved,
-      calls: recordedCalls,
-      config: hook.config.value,
-    }).toEqual({
-      saved: true,
-      calls: [
-        { method: 'GET', url: '/plugins/drp/config' },
-        {
-          method: 'PATCH',
-          url: '/plugins/drp/config',
-          data: { config: { allowed_experiment_types: ['proteomics'] } },
-        },
-      ],
-      config: {
-        n: 1,
-        allowed_experiment_types: ['proteomics'],
-      },
-    })
-  })
-
-  it('should detect nested config edits and restore the saved JSON snapshot', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: {
-        rules: {
-          thresholds: [1, 2],
-        },
-      },
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    const rules = hook.config.value.rules as { thresholds: number[] }
-    rules.thresholds[0] = 9
-    await nextTick()
-
-    const dirtyAfterMutation = hook.isDirty.value
-    hook.reset()
-
-    expect({
-      dirtyAfterMutation,
-      config: hook.config.value,
-      isDirty: hook.isDirty.value,
-    }).toEqual({
-      dirtyAfterMutation: true,
-      config: {
-        rules: {
-          thresholds: [1, 2],
-        },
-      },
-      isDirty: false,
-    })
-  })
-
-  it('isDirty reflects edits vs last saved snapshot', async () => {
-    getResponse = { plugin_name: 'drp', config: { k: 'v' } }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    expect(hook.isDirty.value).toBe(false)
-
-    hook.config.value = { k: 'changed' }
-    await nextTick()
-    expect(hook.isDirty.value).toBe(true)
-
-    hook.config.value = { k: 'v' }
-    await nextTick()
-    expect(hook.isDirty.value).toBe(false)
-  })
-
-  it('reset restores saved config and clears error', async () => {
-    getResponse = { plugin_name: 'drp', config: { k: 'v' } }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = { k: 'edited' }
-    hook.error.value = 'something'
-
-    hook.reset()
-    expect(hook.config.value).toEqual({ k: 'v' })
-    expect(hook.error.value).toBeNull()
-  })
-
-  it('load surfaces network error message', async () => {
-    getError = new Error('network down')
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    expect(hook.error.value).toBe('network down')
-    expect(hook.isLoading.value).toBe(false)
-    expect(hook.lastLoadedAt.value).toBeNull()
-  })
-
-  it('save returns false and records error on failure', async () => {
-    patchError = new Error('403')
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = { x: 1 }
-    const ok = await hook.save()
-    expect(ok).toBe(false)
-    expect(hook.error.value).toBe('403')
-    expect(hook.lastSavedAt.value).toBeNull()
-  })
-
-  it('empty plugin name produces a noop load', async () => {
-    const hook = usePluginConfig('')
-    await hook.load()
-    expect(recordedCalls).toEqual([])
-    expect(hook.error.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/useWellPainting.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-  coordinateToWellId,
-  useWellPainting,
-  wellIdToCoordinate,
-  wellIdsInRectangle,
-} from '../../composables/useWellPainting'
-
-describe('useWellPainting', () => {
-  it('converts well coordinates and computes rectangle selections', () => {
-    expect(wellIdToCoordinate('B2')).toEqual({ row: 1, col: 1 })
-    expect(coordinateToWellId({ row: 0, col: 0 })).toBe('A1')
-    expect(wellIdsInRectangle({ row: 0, col: 0 }, { row: 1, col: 1 }, 96)).toEqual([
-      'A1',
-      'A2',
-      'B1',
-      'B2',
-    ])
-  })
-
-  it('emits rectangle selections in select mode', () => {
-    const completed: string[][] = []
-    const painting = useWellPainting({
-      format: 96,
-      initialMode: 'select',
-      onComplete: result => completed.push(result.wellIds),
-    })
-
-    painting.onWellMouseDown('A1')
-    painting.onWellMouseMove('B2')
-    expect(painting.previewWellIds.value).toEqual(['A1', 'A2', 'B1', 'B2'])
-    painting.onWellMouseUp()
-
-    expect(completed).toEqual([['A1', 'A2', 'B1', 'B2']])
-  })
-
-  it('tracks paint trails for non-select modes', () => {
-    const completed: { mode: string; wells: string[] }[] = []
-    const painting = useWellPainting({
-      format: 96,
-      initialMode: 'paint',
-      onComplete: result => completed.push({ mode: result.mode, wells: result.wellIds }),
-    })
-
-    painting.onWellMouseDown('A1')
-    painting.onWellMouseMove('A3')
-    painting.onWellMouseUp()
-
-    expect(completed).toEqual([{ mode: 'paint', wells: ['A1', 'A3'] }])
-  })
-})

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

@@ -1,50 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-  createColumnConditions,
-  createRowConditions,
-  createWellPlateWells,
-} from '../../composables/useWellPlateAdapter'
-
-describe('well plate adapter helpers', () => {
-  it('maps domain entries to WellPlate wells', () => {
-    const wells = createWellPlateWells(
-      [{ id: 'B3', type: 'sample', signal: 42 }],
-      {
-        getWellId: entry => entry.id,
-        getSampleType: entry => entry.type,
-        getValue: entry => entry.signal,
-        getMetadata: () => ({ source: 'analysis' }),
-      },
-    )
-
-    expect(wells.B3).toEqual({
-      id: 'B3',
-      row: 1,
-      col: 2,
-      state: 'filled',
-      sampleType: 'sample',
-      value: 42,
-      metadata: { source: 'analysis' },
-    })
-  })
-
-  it('builds row and column condition spans from axis entries', () => {
-    const entry = {
-      label: 'Drug A',
-      color: '#123456',
-      start: 2,
-      unit: 'uM',
-      concentrations: [{ value: 1, replicates: 2 }, { value: 10 }],
-    }
-
-    expect(createColumnConditions([entry])[0]).toMatchObject({
-      cols: [2, 3, 4],
-      concentrations: [1, 1, 10],
-    })
-    expect(createRowConditions([{ ...entry, start: 'B' }])[0]).toMatchObject({
-      rows: ['B', 'C', 'D'],
-      concentrations: [1, 1, 10],
-    })
-  })
-})

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

@@ -1,42 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { runWellPlateValidation, useWellPlateValidation } from '../../composables/useWellPlateValidation'
-
-describe('well plate validation helpers', () => {
-  it('runs rule-driven validation', () => {
-    const warnings = runWellPlateValidation(
-      { assigned: 0 },
-      [
-        {
-          type: 'empty',
-          severity: 'warning',
-          validate: context => context.assigned === 0 && 'No wells assigned',
-        },
-      ],
-    )
-
-    expect(warnings).toEqual([
-      { type: 'empty', severity: 'warning', message: 'No wells assigned' },
-    ])
-  })
-
-  it('derives blocking state and counts', () => {
-    const validation = useWellPlateValidation({
-      context: { overlaps: ['A1'] },
-      rules: [
-        {
-          type: 'overlap',
-          severity: 'error',
-          validate: context => ({
-            message: `${context.overlaps.length} overlap`,
-            affectedWells: context.overlaps,
-          }),
-        },
-      ],
-    })
-
-    expect(validation.hasBlockingIssues.value).toBe(true)
-    expect(validation.errorCount.value).toBe(1)
-    expect(validation.warningCount.value).toBe(1)
-  })
-})