@morscherlab/mint-sdk 1.2.0-beta.14 → 1.2.0-beta.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morscherlab/mint-sdk",
-  "version": "1.2.0-beta.14",
+  "version": "1.2.0-beta.16",
   "description": "MINT Platform SDK — Vue 3 components, composables, and types for plugin development. MINT = Mass-spec INtegrated Toolkit.",
   "type": "module",
   "main": "./dist/index.js",

package/src/__tests__/apiErrors.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest'
+
+import { MintApiError, mintApiErrorFromResponse } from '../apiErrors'
+
+describe('MintApiError', () => {
+  it('should expose a typed server envelope', () => {
+    const error = mintApiErrorFromResponse(404, {
+      code: 'leaf.ARTIFACT_NOT_FOUND',
+      message: 'Artifact is not available',
+      status: 404,
+      request_id: 'req-typed',
+      details: { artifact_id: 67 },
+      detail: 'Artifact is not available',
+    })
+
+    expect({
+      type: error.constructor,
+      code: error.code,
+      status: error.status,
+      requestId: error.requestId,
+      details: error.details,
+    }).toEqual({
+      type: MintApiError,
+      code: 'leaf.ARTIFACT_NOT_FOUND',
+      status: 404,
+      requestId: 'req-typed',
+      details: { artifact_id: 67 },
+    })
+  })
+
+  it('should retain a legacy FastAPI validation detail list', () => {
+    const detail = [{ type: 'int_parsing', loc: ['body', 'count'] }]
+
+    const error = mintApiErrorFromResponse(422, { detail })
+
+    expect(error.detail).toBe(detail)
+    expect({ message: error.message, code: error.code, details: error.details }).toEqual({
+      message: 'Validation error',
+      code: 'unknown',
+      details: null,
+    })
+  })
+
+  it('preserves nested SDK errors and outer platform metadata', () => {
+    const detail = { error: 'NOT_FOUND', message: 'Missing artifact', details: { id: 67 }, request_id: 'inner' }
+    const body = { code: 'resource.not_found', message: 'Resource not found', request_id: 'outer', detail }
+    const error = mintApiErrorFromResponse(404, body)
+
+    expect(error).toMatchObject({
+      code: 'NOT_FOUND', message: 'Missing artifact', status: 404,
+      requestId: 'outer', details: { id: 67 }, detail, body,
+    })
+    expect(mintApiErrorFromResponse(404, { ...body, details: [] }).details).toEqual([])
+    expect(mintApiErrorFromResponse(404, detail).code).toBe('NOT_FOUND')
+  })
+
+  it('prefers canonical envelopes over legacy nested SDK error metadata', () => {
+    const body = {
+      status: 426, code: 'plugin.api_version_mismatch', message: 'Plugin API version mismatch',
+      detail: { error: 'PLATFORM_API_VERSION_MISMATCH', message: 'Legacy version mismatch' },
+    }
+    expect(mintApiErrorFromResponse(426, body)).toMatchObject({
+      status: 426, code: body.code, message: body.message, detail: body.detail,
+    })
+    expect(mintApiErrorFromResponse(502, body).status).toBe(502)
+    expect(mintApiErrorFromResponse(426, { ...body, status: '426' }).code)
+      .toBe('PLATFORM_API_VERSION_MISMATCH')
+  })
+
+  it('retains platform codes and falls back to legacy detail and header request IDs', () => {
+    expect(mintApiErrorFromResponse(403, {
+      code: 'auth.forbidden', message: '', detail: 'Restricted', request_id: '',
+    }, { requestId: 'header-id' })).toMatchObject({
+      code: 'auth.forbidden', message: 'Restricted', requestId: 'header-id',
+    })
+    expect(mintApiErrorFromResponse(502, '<html>Bad gateway</html>')).toMatchObject({
+      code: 'unknown', message: 'Bad gateway', body: '<html>Bad gateway</html>',
+    })
+  })
+
+})

package/src/__tests__/components/FilePicker.state.test.ts

@@ -1,6 +1,8 @@
 import { enableAutoUnmount, flushPromises, mount } from '@vue/test-utils'
 import { afterEach, expect, it, vi } from 'vitest'
+import { ref } from 'vue'
 import FilePicker from '../../components/FilePicker.vue'
+import FileUploader from '../../components/FileUploader.vue'
 import type { PickerAdapter, PickerNode, PickerSelection } from '../../types/filePicker'
 
 enableAutoUnmount(afterEach)
@@ -83,6 +85,24 @@ it('refresh removes deleted descendants from a selected folder', async () => {
   expect(wrapper.get('.mint-picker__receipt').text()).not.toContain('7 B')
 })
 
+it('marks only an explicit refresh so adapters can bypass their caches', async () => {
+  const data = adapter()
+  const wrapper = await setup(data)
+  await row(wrapper, folder.path).trigger('dblclick')
+  await flushPromises()
+  expect(vi.mocked(data.listRoot).mock.calls[0]![0]).not.toHaveProperty('refresh')
+  expect(vi.mocked(data.listChildren).mock.calls[0]![1]).not.toHaveProperty('refresh')
+  await wrapper.get('[aria-label="Refresh location"]').trigger('click')
+  await flushPromises()
+  expect(vi.mocked(data.listChildren).mock.calls.at(-1)![1]).toMatchObject({ refresh: true })
+  await wrapper.get('[aria-label="Breadcrumb"] button').trigger('click')
+  await flushPromises()
+  expect(vi.mocked(data.listRoot).mock.calls.at(-1)![0]).not.toHaveProperty('refresh')
+  await wrapper.get('[aria-label="Refresh location"]').trigger('click')
+  await flushPromises()
+  expect(vi.mocked(data.listRoot).mock.calls.at(-1)![0]).toMatchObject({ refresh: true })
+})
+
 it('late server responses cannot overwrite browser source metadata', async () => {
   const data = adapter()
   let release!: (nodes: PickerNode[]) => void
@@ -97,7 +117,7 @@ it('late server responses cannot overwrite browser source metadata', async () =>
   release([folder])
   await flushPromises()
   expect(wrapper.findAll('[role="treeitem"]')).toHaveLength(0)
-  expect(wrapper.text()).toContain('No files chosen')
+  expect(wrapper.text()).toContain('No selection')
 })
 
 it('browser source confirms original File objects without reading or uploading them', async () => {
@@ -113,6 +133,26 @@ it('browser source confirms original File objects without reading or uploading t
   expect(read).not.toHaveBeenCalled()
 })
 
+it('restores dropped folder paths after remounting with the confirmed local selection', async () => {
+  const options = { sources: ['localFile'], selectionMode: 'folder' }
+  const wrapper = await setup(adapter(), options)
+  const file = new File(['data'], 'run.raw')
+  wrapper.getComponent(FileUploader).vm.$emit('upload', [file], 'batch', ['batch/run.raw'])
+  await flushPromises()
+  await confirm(wrapper).trigger('click')
+  const result = wrapper.emitted('select')![0]![0] as PickerSelection
+  expect(result).toEqual({ source: 'localFile', files: [file], relativePaths: ['batch/run.raw'] })
+  expect(result.files[0]).toBe(file)
+  wrapper.unmount()
+
+  const restored = await setup(adapter(), { ...options, initialSelection: result })
+  expect(confirm(restored).attributes('disabled')).toBeUndefined()
+  await confirm(restored).trigger('click')
+  const confirmed = restored.emitted('select')![0]![0] as PickerSelection
+  expect(confirmed).toEqual(result)
+  expect(confirmed.files[0]).toBe(file)
+})
+
 it('restores a nested selected folder display name without exposing its opaque identity', async () => {
   const wrapper = await setup()
   await row(wrapper, folder.path).trigger('dblclick')
@@ -158,3 +198,90 @@ it('does not confirm a folder after the host switches the same picker to single-
   await confirm(wrapper).trigger('click')
   expect(wrapper.emitted('select')).toBeUndefined()
 })
+
+it('system filter hides denied folders and skips their contents during folder selection', async () => {
+  const allowed: PickerNode = { ...file, path: 'allowed', name: 'allowed.raw', parentPath: folder.path }
+  const data = adapter()
+  vi.mocked(data.listChildren).mockImplementation(async (path) =>
+    path === folder.path ? [child, allowed] : [file],
+  )
+  const filter = vi.fn((node: PickerNode) => node.path !== child.path)
+  const wrapper = await setup(data, { systemFilter: filter })
+  await row(wrapper, folder.path).trigger('click')
+  await flushPromises()
+  expect(data.listChildren).not.toHaveBeenCalledWith(child.path, expect.anything())
+  await row(wrapper, folder.path).trigger('dblclick')
+  await flushPromises()
+  expect(row(wrapper, child.path)).toBeUndefined()
+  await confirm(wrapper).trigger('click')
+  expect(wrapper.emitted('select')?.[0]?.[0]).toMatchObject({ files: [allowed], excluded: [] })
+  expect(filter).toHaveBeenCalledWith(expect.objectContaining({ path: child.path }), 'server')
+})
+
+it('system filter applies to search results and restored or already selected files', async () => {
+  const data = adapter()
+  vi.mocked(data.listRoot).mockResolvedValue([file])
+  vi.mocked(data.search).mockResolvedValue([file])
+  const wrapper = await setup(data, { selectionMode: 'multi-file' })
+  await row(wrapper, file.path).trigger('click')
+  await flushPromises()
+  const deny = (node: PickerNode) => node.path !== file.path
+  await wrapper.setProps({ systemFilter: deny })
+  expect(row(wrapper, file.path)).toBeUndefined()
+  expect(confirm(wrapper).attributes('disabled')).toBeDefined()
+  await wrapper.get('input[aria-label="Search folders and files"]').setValue('run')
+  await new Promise((resolve) => setTimeout(resolve, 250))
+  await flushPromises()
+  expect(data.search).toHaveBeenCalled()
+  expect(row(wrapper, file.path)).toBeUndefined()
+  await wrapper.setProps({ open: false, initialSelection: {
+    source: 'server', folders: [], files: [file], excluded: [],
+  } })
+  await wrapper.setProps({ open: true })
+  await flushPromises()
+  expect(confirm(wrapper).attributes('disabled')).toBeDefined()
+  await confirm(wrapper).trigger('click')
+  expect(wrapper.emitted('select')).toBeUndefined()
+})
+
+it('system filter receives local source and prevents denied browser files from being confirmed', async () => {
+  const filter = vi.fn((node: PickerNode) => node.name !== 'private.raw')
+  const wrapper = await setup(adapter(), {
+    sources: ['localFile'], selectionMode: 'multi-file', systemFilter: filter,
+  })
+  const allowed = new File(['public'], 'public.raw')
+  const denied = new File(['private'], 'private.raw')
+  const input = wrapper.get('input[type="file"]')
+  Object.defineProperty(input.element, 'files', { value: [allowed, denied], configurable: true })
+  await input.trigger('change')
+  await flushPromises()
+  expect(wrapper.get('.mint-picker__receipt').text()).toContain('1 file')
+  expect(wrapper.text()).not.toContain('private.raw')
+  await confirm(wrapper).trigger('click')
+  expect(wrapper.emitted('select')?.[0]?.[0]).toEqual({ source: 'localFile', files: [allowed] })
+  expect(filter).toHaveBeenCalledWith(expect.objectContaining({ name: denied.name }), 'localFile')
+})
+
+it('reactive permission changes restore visible rows and resolve newly allowed selected subfolders', async () => {
+  const allowed = ref(false)
+  const data = adapter()
+  const wrapper = await setup(data, {
+    systemFilter: (node: PickerNode) => node.path !== child.path || allowed.value,
+  })
+  await row(wrapper, folder.path).trigger('click')
+  await flushPromises()
+  await row(wrapper, folder.path).trigger('dblclick')
+  await flushPromises()
+  expect(row(wrapper, child.path)).toBeUndefined()
+  expect(confirm(wrapper).attributes('disabled')).toBeDefined()
+  allowed.value = true
+  await flushPromises()
+  expect(row(wrapper, child.path)).toBeDefined()
+  expect(confirm(wrapper).attributes('disabled')).toBeUndefined()
+  await confirm(wrapper).trigger('click')
+  expect(wrapper.emitted('select')?.[0]?.[0]).toMatchObject({ files: [file] })
+  allowed.value = false
+  await flushPromises()
+  expect(row(wrapper, child.path)).toBeUndefined()
+  expect(confirm(wrapper).attributes('disabled')).toBeDefined()
+})

package/src/__tests__/components/FilePicker.test.ts

@@ -1,6 +1,7 @@
 import { enableAutoUnmount, flushPromises, mount } from '@vue/test-utils'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import FilePicker from '../../components/FilePicker.vue'
+import FileUploader from '../../components/FileUploader.vue'
 import type { PickerAdapter, PickerNode, PickerSelection } from '../../types/filePicker'
 import { localFilesAdapter } from '../../composables/filePicker/localFiles'
 import { pickerExclusion } from '../../composables/filePicker/validation'
@@ -272,7 +273,151 @@ describe('FilePicker', () => {
     await flushPromises()
     expect(wrapper.get('[aria-label="Local files"]').attributes('aria-pressed')).toBe('true')
     expect(wrapper.find('[aria-label="Absolute path"]').exists()).toBe(false)
-    expect(wrapper.text()).toContain('Choose files…')
+    expect(wrapper.text()).toContain('Drop files or a folder')
+  })
+
+  it.each(['single-file', 'multi-file', 'folder', 'folder+files'] as const)(
+    'uses one upload panel without a lower workspace and preserves %s selection limits',
+    async (selectionMode) => {
+      const wrapper = await setup({ sources: ['localFile'], selectionMode })
+      const uploaders = wrapper.findAllComponents(FileUploader)
+      expect(uploaders.map((uploader) => uploader.props('mode'))).toEqual(
+        selectionMode === 'single-file'
+          ? ['file']
+          : selectionMode === 'folder'
+            ? ['folder']
+            : ['file+folder'],
+      )
+      expect(wrapper.find('.mint-picker__workspace').exists()).toBe(false)
+      expect(wrapper.find('.mint-file-uploader__actions').exists()).toBe(false)
+      expect(wrapper.text()).not.toContain('Files stay in this browser.')
+      expect(wrapper.find('.mint-picker__pathbar').exists()).toBe(false)
+      expect(wrapper.find('[aria-label="Search folders and files"]').exists()).toBe(false)
+      const files = [new File(['a'], 'one.raw'), new File(['b'], 'two.raw')]
+      const input = uploaders[0]!.get('input[type="file"]')
+      if (selectionMode === 'folder') {
+        files.forEach((file) =>
+          Object.defineProperty(file, 'webkitRelativePath', { value: `batch/${file.name}` }),
+        )
+      }
+      Object.defineProperty(input.element, 'files', { value: files })
+      await input.trigger('change')
+      await flushPromises()
+      expect(wrapper.find('.mint-file-uploader__list').exists()).toBe(false)
+      expect(wrapper.find('.mint-file-uploader__folder-summary').exists()).toBe(false)
+      await confirm(wrapper).trigger('click')
+      const result = wrapper.emitted('select')?.[0]?.[0] as Extract<
+        PickerSelection,
+        { source: 'localFile' }
+      >
+      expect(result.files).toEqual(selectionMode === 'single-file' ? [files[0]] : files)
+      expect(result.files[0]).toBe(files[0])
+    },
+  )
+
+  it.each(['folder+files', 'multi-file'] as const)('accepts dropped directories in %s mode and validates without a workspace', async (selectionMode) => {
+    const wrapper = await setup({
+      sources: ['localFile'],
+      selectionMode,
+      capabilities: { localFile: { formats: ['mzML.gz'], maxBytes: 10 } },
+    })
+    const valid = new File(['data'], 'run.mzML.gz')
+    const unsupported = new File(['notes'], 'notes.txt')
+    const oversized = new File(['too much data'], 'large.mzML.gz')
+    const directory = (name: string, entries: unknown[]) => ({
+      name,
+      isDirectory: true,
+      createReader: () => {
+        let pending = entries
+        return {
+          readEntries: (resolve: (entries: unknown[]) => void) => {
+            resolve(pending)
+            pending = []
+          },
+        }
+      },
+    })
+    const nested = directory('batch', [
+      directory('nested', [valid, unsupported, oversized].map((file) => ({
+        name: file.name,
+        isFile: true,
+        file: (resolve: (file: File) => void) => resolve(file),
+      }))),
+    ])
+    const uploader = wrapper.getComponent(FileUploader)
+    await uploader.get('[role="button"]').trigger('drop', {
+      dataTransfer: { items: [{ webkitGetAsEntry: () => nested }] },
+    })
+    await flushPromises()
+    expect(wrapper.get('.mint-picker__receipt').text()).toContain('1 file')
+    if (selectionMode === 'folder+files') expect(wrapper.text()).toContain('2 skipped')
+    expect(wrapper.find('.mint-picker__workspace').exists()).toBe(false)
+    await confirm(wrapper).trigger('click')
+    const result = wrapper.emitted('select')?.[0]?.[0] as Extract<
+      PickerSelection,
+      { source: 'localFile' }
+    >
+    expect(result.files).toEqual([valid])
+    expect(result.files[0]).toBe(valid)
+    await wrapper.setProps({ open: false })
+    await wrapper.setProps({ open: true })
+    await flushPromises()
+    expect(wrapper.get('.mint-picker__receipt').text()).toContain('1 file')
+    expect(confirm(wrapper).attributes('disabled')).toBeUndefined()
+  })
+
+  it.each(['entry', 'file'] as const)(
+    'captures dropped %s handles before the drag data becomes protected',
+    async (secondHandle) => {
+      const wrapper = await setup({ sources: ['localFile'], selectionMode: 'multi-file' })
+      const files = [new File(['a'], 'one.raw'), new File(['b'], 'two.raw')]
+      let protectedMode = false
+      const secondEntry = {
+        isFile: true,
+        file: (resolve: (file: File) => void) => resolve(files[1]!),
+      }
+      await wrapper.getComponent(FileUploader).get('[role="button"]').trigger('drop', {
+        dataTransfer: {
+          items: [
+            { webkitGetAsEntry: () => ({
+              isFile: true,
+              file: (resolve: (file: File) => void) => queueMicrotask(() => {
+                protectedMode = true
+                resolve(files[0]!)
+              }),
+            }) },
+            {
+              webkitGetAsEntry: () =>
+                !protectedMode && secondHandle === 'entry' ? secondEntry : null,
+              getAsFile: () =>
+                !protectedMode && secondHandle === 'file' ? files[1] : null,
+            },
+          ],
+        },
+      })
+      await flushPromises()
+      await confirm(wrapper).trigger('click')
+      const result = wrapper.emitted('select')?.[0]?.[0] as Extract<
+        PickerSelection,
+        { source: 'localFile' }
+      >
+      expect(result.files).toHaveLength(2)
+      expect(result.files[0]).toBe(files[0])
+      expect(result.files[1]).toBe(files[1])
+    },
+  )
+
+  it('shows folder drop errors without a preview panel', async () => {
+    const wrapper = await setup({ sources: ['localFile'] })
+    await wrapper.getComponent(FileUploader).get('[role="button"]').trigger('drop', {
+      dataTransfer: { items: [{ webkitGetAsEntry: () => ({
+        name: 'unreadable', isDirectory: true,
+        createReader: () => ({ readEntries: (_resolve: unknown, reject: (error: Error) => void) => reject(new Error('Folder cannot be read')) }),
+      }) }] },
+    })
+    await flushPromises()
+    expect(wrapper.get('[role="alert"]').text()).toBe('Folder cannot be read')
+    expect(confirm(wrapper).attributes('disabled')).toBeDefined()
   })
 
   it('does not render sources the host did not supply', async () => {

package/src/__tests__/components/GeneratedPlotlyResult.test.ts

@@ -1,15 +1,17 @@
-import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
-import { nextTick } from 'vue'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { enableAutoUnmount, flushPromises, mount, type VueWrapper } from '@vue/test-utils'
+import { nextTick, reactive } from 'vue'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import GeneratedPlotlyResult from '../../components/GeneratedPlotlyResult.vue'
 
 const plotly = vi.hoisted(() => ({
+  Plots: { resize: vi.fn() },
   purge: vi.fn(),
   react: vi.fn(),
 }))
 
 vi.mock('plotly.js-dist-min', () => ({ default: plotly }))
+enableAutoUnmount(afterEach)
 
 async function mountAndRecover(
   fallback?: { media_type: string; data: string },
@@ -58,6 +60,18 @@ describe('GeneratedPlotlyResult', () => {
     expect(wrapper.get('img').attributes('src')).toBe('data:image/png;base64,cG5n')
   })
 
+  it('should render a static fallback without the error presentation', async () => {
+    const wrapper = mount(GeneratedPlotlyResult, {
+      props: {
+        spec: { data: [] },
+        fallback: { media_type: 'image/png', data: 'cG5n' },
+      },
+    })
+    await flushPromises()
+
+    expect(wrapper.find('.mint-plotly-chart__error').exists()).toBe(false)
+  })
+
   it('should not redraw an immutable result for nested spec mutations', async () => {
     plotly.react.mockResolvedValue(undefined)
     const wrapper = mount(GeneratedPlotlyResult, {
@@ -73,6 +87,21 @@ describe('GeneratedPlotlyResult', () => {
     expect(plotly.react).toHaveBeenCalledTimes(1)
   })
 
+  it('should redraw a replaced spec even when its native arrays are reused', async () => {
+    plotly.react.mockResolvedValue(undefined)
+    const spec = reactive({ data: [{ x: [1], y: [2] }], layout: {}, config: { displayModeBar: true } })
+    const wrapper = mount(GeneratedPlotlyResult, { props: { spec } })
+    await flushPromises()
+
+    spec.data[0]!.x.push(3)
+    spec.data[0]!.y.push(4)
+    await wrapper.setProps({ spec: { ...spec } })
+    await flushPromises()
+
+    expect(plotly.react).toHaveBeenCalledTimes(2)
+    expect(plotly.react.mock.lastCall?.[1]).toEqual([{ x: [1, 3], y: [2, 4] }])
+  })
+
   it.each([
     ['Heatmap', { type: 'heatmap', z: [[1, 2], [3, 4]] }],
     ['Scatter3d', { type: 'scatter3d', x: [1], y: [2], z: [3] }],
@@ -86,7 +115,7 @@ describe('GeneratedPlotlyResult', () => {
     expect(plotly.react).toHaveBeenCalledWith(
       expect.any(HTMLElement),
       [trace],
-      {},
+      expect.objectContaining({ autosize: true }),
       { responsive: true, displaylogo: false },
     )
   })
@@ -112,6 +141,24 @@ describe('GeneratedPlotlyResult', () => {
   it('should restore the interactive chart after a new immutable spec renders successfully', async () => {
     const wrapper = await mountAndRecover()
 
-    expect(wrapper.get('.mint-generated-result__plotly').isVisible()).toBe(true)
+    expect(wrapper.get('.mint-plotly-chart__plot').isVisible()).toBe(true)
+  })
+
+  it('should reveal the interactive canvas before retrying Plotly', async () => {
+    const wrapper = mount(GeneratedPlotlyResult, {
+      props: { spec: { data: [] } },
+    })
+    await flushPromises()
+
+    let displayDuringRetry: string | undefined
+    plotly.react.mockImplementation(async (element: HTMLElement) => {
+      displayDuringRetry = element.style.display
+    })
+    await wrapper.setProps({
+      spec: { data: [{ type: 'scatter', x: [1], y: [2] }] },
+    })
+    await flushPromises()
+
+    expect(displayDuringRetry).not.toBe('none')
   })
 })