@morscherlab/mint-sdk 1.2.0-beta.2 → 1.2.0-beta.20

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

@@ -0,0 +1,145 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import { defineComponent, nextTick, ref } from 'vue'
+import {
+  reorderList,
+  useListReorder,
+  useReorderAnnouncer,
+  type ListReorderMove,
+} from '../../composables/useListReorder'
+
+interface Row { id: string; name: string }
+
+function mountHarness(onReorder: (move: ListReorderMove<Row>) => void, disabled = false) {
+  const items = ref<Row[]>([
+    { id: 'a', name: 'Alpha' },
+    { id: 'b', name: 'Beta' },
+    { id: 'c', name: 'Gamma' },
+  ])
+
+  const wrapper = mount(defineComponent({
+    setup() {
+      const reorder = useListReorder<Row>({
+        items: () => items.value,
+        getId: (row) => row.id,
+        getLabel: (row) => row.name,
+        disabled: () => disabled,
+        itemNoun: 'Row',
+        onReorder,
+      })
+      return { items, ...reorder }
+    },
+    template: `
+      <ul>
+        <li v-for="(row, index) in items" :key="row.id" :data-id="row.id"
+            @keydown="onKeydown($event, row, index)"
+            @dragstart="onDragStart($event, row, index)"
+            @dragover="onDragOver($event, row, index)"
+            @drop="onDrop($event, row, index)">{{ row.name }}</li>
+      </ul>
+      <p class="announcement">{{ announcement }}</p>
+    `,
+  }), { attachTo: document.body })
+
+  return { wrapper, items }
+}
+
+describe('reorderList', () => {
+  it('returns a copy with the item moved, leaving the source untouched', () => {
+    const source = ['a', 'b', 'c']
+
+    expect(reorderList(source, 0, 2)).toEqual(['b', 'c', 'a'])
+    expect(source).toEqual(['a', 'b', 'c'])
+  })
+})
+
+describe('useReorderAnnouncer', () => {
+  it('publishes messages and re-announces an identical message', async () => {
+    const { announcement, announce } = useReorderAnnouncer()
+
+    announce('Alpha moved.')
+    await nextTick()
+    expect(announcement.value).toBe('Alpha moved.')
+
+    announce('Alpha moved.')
+    expect(announcement.value).toBe('')
+    await nextTick()
+    expect(announcement.value).toBe('Alpha moved.')
+  })
+})
+
+describe('useListReorder', () => {
+  it('moves an item one position later on Alt+ArrowDown and announces it', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder)
+
+    await wrapper.get('[data-id="a"]').trigger('keydown', { key: 'ArrowDown', altKey: true })
+
+    expect(onReorder).toHaveBeenCalledTimes(1)
+    const move = onReorder.mock.calls[0][0] as ListReorderMove<Row>
+    expect(move.fromIndex).toBe(0)
+    expect(move.toIndex).toBe(1)
+    expect(move.source).toBe('keyboard')
+    expect(move.items.map(row => row.id)).toEqual(['b', 'a', 'c'])
+
+    await nextTick()
+    expect(wrapper.get('.announcement').text()).toBe('Alpha moved to position 2 of 3.')
+
+    wrapper.unmount()
+  })
+
+  it('moves an item one position earlier on Alt+ArrowUp and Alt+ArrowLeft', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder)
+
+    await wrapper.get('[data-id="c"]').trigger('keydown', { key: 'ArrowUp', altKey: true })
+    await wrapper.get('[data-id="c"]').trigger('keydown', { key: 'ArrowLeft', altKey: true })
+
+    expect(onReorder.mock.calls.map(call => (call[0] as ListReorderMove<Row>).toIndex)).toEqual([1, 1])
+
+    wrapper.unmount()
+  })
+
+  it('ignores arrow keys without Alt and moves past either end', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder)
+
+    await wrapper.get('[data-id="a"]').trigger('keydown', { key: 'ArrowDown' })
+    await wrapper.get('[data-id="a"]').trigger('keydown', { key: 'ArrowUp', altKey: true })
+    await wrapper.get('[data-id="c"]').trigger('keydown', { key: 'ArrowDown', altKey: true })
+
+    expect(onReorder).not.toHaveBeenCalled()
+
+    wrapper.unmount()
+  })
+
+  it('reorders through a drag and clears its drag state', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder)
+
+    const dataTransfer = { effectAllowed: '', dropEffect: '', setData: vi.fn() }
+    await wrapper.get('[data-id="a"]').trigger('dragstart', { dataTransfer })
+    await wrapper.get('[data-id="c"]').trigger('dragover', { dataTransfer })
+    await wrapper.get('[data-id="c"]').trigger('drop', { dataTransfer })
+
+    const move = onReorder.mock.calls[0][0] as ListReorderMove<Row>
+    expect(move).toMatchObject({ fromIndex: 0, toIndex: 2, source: 'drag' })
+    expect(move.items.map(row => row.id)).toEqual(['b', 'c', 'a'])
+    expect(dataTransfer.setData).toHaveBeenCalledWith('text/plain', 'a')
+
+    wrapper.unmount()
+  })
+
+  it('blocks every reorder while disabled', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder, true)
+
+    await wrapper.get('[data-id="a"]').trigger('keydown', { key: 'ArrowDown', altKey: true })
+    await wrapper.get('[data-id="a"]').trigger('dragstart', { dataTransfer: { setData: vi.fn() } })
+    await wrapper.get('[data-id="b"]').trigger('drop', { dataTransfer: { setData: vi.fn() } })
+
+    expect(onReorder).not.toHaveBeenCalled()
+
+    wrapper.unmount()
+  })
+})

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

@@ -0,0 +1,67 @@
+import { beforeEach, expect, it, vi } from 'vitest'
+const { get } = vi.hoisted(() => ({ get: vi.fn() }))
+vi.mock('../../composables/useApi', () => ({ useApi: () => ({ get }) }))
+import {
+  decodePlatformPickerPath,
+  encodePlatformPickerPath,
+  usePlatformFilePickerAdapter,
+} from '../../composables/usePlatformFilePickerAdapter'
+
+beforeEach(() => get.mockReset())
+it('preserves mount and relative path identities with punctuation and Unicode', () => {
+  const path = '测试/one, [2] # ?.raw'
+  expect(decodePlatformPickerPath(encodePlatformPickerPath('instrument', path))).toEqual({
+    mountId: 'instrument',
+    path,
+  })
+  expect(() => decodePlatformPickerPath('["mount"]')).toThrow()
+  expect(() => decodePlatformPickerPath('["", "file"]')).toThrow()
+})
+it('passes cancellation, marks offline mounts, and maps compound extensions', async () => {
+  get
+    .mockResolvedValueOnce({
+      mounts: [
+        { id: 'online', label: 'Instrument', available: true },
+        { id: 'offline', label: 'NAS', available: false },
+      ],
+    })
+    .mockResolvedValueOnce({
+      entries: [{ kind: 'file', path: 'run.mzML.gz', name: 'run.mzML.gz', size_bytes: 7 }],
+    })
+  const adapter = usePlatformFilePickerAdapter({ apiBaseUrl: '/api' })
+  const signal = new AbortController().signal
+  const roots = await adapter.listRoot({ signal })
+  expect(roots[1]?.unavailableReason).toContain('offline')
+  const files = await adapter.listChildren(roots[0]!.path, { signal })
+  expect(files[0]).toMatchObject({
+    kind: 'file',
+    format: 'mzML.gz',
+    bytes: 7,
+    parentPath: roots[0]!.path,
+  })
+  expect(get.mock.calls.every((call) => call[1].signal === signal)).toBe(true)
+})
+it('refuses truncated listings rather than returning a partial folder selection', async () => {
+  get.mockResolvedValue({ truncated: true, entries: [] })
+  await expect(
+    usePlatformFilePickerAdapter({ apiBaseUrl: '/api' }).listChildren(
+      encodePlatformPickerPath('a'),
+    ),
+  ).rejects.toThrow('listing limit')
+})
+it('scopes shallow search to one level and recursive search skips offline mounts', async () => {
+  get.mockImplementation(async (url: string) =>
+    url === '/filesystem/mounts'
+      ? {
+          mounts: [
+            { id: 'a', label: 'Instrument', available: true },
+            { id: 'b', label: 'NAS', available: false },
+          ],
+        }
+      : { entries: [{ kind: 'file', path: 'run.raw', name: 'run.raw', size_bytes: 1 }] },
+  )
+  const adapter = usePlatformFilePickerAdapter({ apiBaseUrl: '/api' })
+  expect(await adapter.search('run', { path: '', recursive: false })).toEqual([])
+  expect(await adapter.search('run', { path: '', recursive: true })).toHaveLength(1)
+  expect(get.mock.calls.filter((call) => call[0].includes('/browse'))).toHaveLength(1)
+})

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

@@ -184,6 +184,7 @@ describe('usePluginClient', () => {
 
     expect(requestConfigs[0]!.baseURL).toBe('/api/drp')
     expect(requestConfigs[0]!.url).toBe('/health')
+    expect(requestConfigs[0]).toMatchObject({ _mintTypedErrors: true })
   })
 
   it('omits MINT auth transport for a public generated endpoint', async () => {
@@ -396,6 +397,7 @@ describe('usePluginClient', () => {
     expect(requestConfigs[0]!.url).toBe('/schedule/import')
     expect(requestConfigs[0]!.params).toEqual({ instrument_id: 'orbitrap', mode: 'replace' })
     expect(requestConfigs[0]!.headers).toEqual({ 'Content-Type': undefined })
+    expect(requestConfigs[0]).toMatchObject({ _mintTypedErrors: true })
     expect(requestBodies[0]).toBeInstanceOf(FormData)
     const form = requestBodies[0] as FormData
     expect(form.get('file')).toBeInstanceOf(Blob)
@@ -462,6 +464,7 @@ describe('usePluginClient', () => {
     expect(requestConfigs[0]!.url).toBe('/schedule/export')
     expect(requestConfigs[0]!.params).toEqual({ instrument_id: 'orbitrap', start: '2026-05-27' })
     expect(requestConfigs[0]!.responseType).toBe('blob')
+    expect(requestConfigs[0]).toMatchObject({ _mintTypedErrors: true })
   })
 
   it('downloads generated POST endpoint blobs with the contract body and request options', async () => {
@@ -848,6 +851,146 @@ describe('usePluginClient', () => {
     })
   })
 
+  describe('secret settings references', () => {
+    const secretRef = { $secret: 'sec_0f2a4c6e8a0c2e4a6c8e0a2c4e6a8c0e', set: true }
+
+    function integratedPluginSettingsHost(): void {
+      ;(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',
+        },
+      }
+      nextGetData = {
+        settings: { apiKey: secretRef, method: 'first' },
+        secret_format: 'ref',
+        mode: 'integrated',
+        revision: 'revision-1',
+      }
+      nextPutData = {
+        settings: { apiKey: secretRef, method: 'second' },
+        secret_format: 'ref',
+        mode: 'integrated',
+        revision: 'revision-2',
+      }
+    }
+
+    it('should round-trip an untouched secret reference unchanged', async () => {
+      integratedPluginSettingsHost()
+
+      const settings = usePluginSettings<{ apiKey?: unknown; method?: string }>({
+        pluginName: 'drp',
+      })
+      await settings.load()
+      const saved = await settings.save({ ...settings.values.value, method: 'second' })
+
+      expect({ saved, body: requestBodies[0] }).toEqual({
+        saved: true,
+        body: { apiKey: secretRef, method: 'second', secret_format: 'ref' },
+      })
+    })
+
+    it('should submit a typed string when the user enters a new secret', async () => {
+      integratedPluginSettingsHost()
+
+      const settings = usePluginSettings<{ apiKey?: unknown; method?: string }>({
+        pluginName: 'drp',
+      })
+      await settings.load()
+      await settings.save({ apiKey: 'typed-secret', method: 'first' })
+
+      expect(requestBodies[0]).toEqual({
+        apiKey: 'typed-secret',
+        method: 'first',
+        secret_format: 'ref',
+      })
+    })
+
+    it('should submit null when the user clears a secret', async () => {
+      integratedPluginSettingsHost()
+
+      const settings = usePluginSettings<{ apiKey?: unknown; method?: string }>({
+        pluginName: 'drp',
+      })
+      await settings.load()
+      await settings.save({ apiKey: null, method: 'first' })
+
+      expect(requestBodies[0]).toEqual({
+        apiKey: null,
+        method: 'first',
+        secret_format: 'ref',
+      })
+    })
+
+    it('should declare the reference format on platform config patches', 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',
+        },
+      }
+      nextGetData = {
+        plugin_name: 'drp',
+        config: { apiKey: secretRef, method: 'first' },
+        secret_format: 'ref',
+        revision: 'revision-1',
+      }
+      nextPatchData = {
+        plugin_name: 'drp',
+        config: { apiKey: secretRef, method: 'second' },
+        secret_format: 'ref',
+        revision: 'revision-2',
+      }
+
+      const settings = usePluginSettings<{ apiKey?: unknown; method?: string }>({
+        pluginName: 'drp',
+      })
+      await settings.load()
+      await settings.save({ apiKey: secretRef, method: 'second' })
+
+      expect(requestBodies[0]).toEqual({
+        config: { method: 'second', secret_format: 'ref' },
+      })
+    })
+
+    it('should omit the format marker for a host that does not publish one', 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',
+        },
+      }
+      nextGetData = { settings: { method: 'first' }, mode: 'integrated', revision: 'revision-1' }
+      nextPutData = { settings: { method: 'second' }, mode: 'integrated', revision: 'revision-2' }
+
+      const settings = usePluginSettings<{ method?: string }>({ pluginName: 'drp' })
+      await settings.load()
+      await settings.save({ method: 'second' })
+
+      expect(requestBodies[0]).toEqual({ method: 'second' })
+    })
+  })
+
   it('should preserve the contract v2 form schema in settingsConfig', () => {
     const settings = usePluginSettings({
       apiBaseUrl: '/api/drp',