@morscherlab/mint-sdk 1.0.63 → 1.1.0-beta.10

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

@@ -0,0 +1,93 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+
+import ChartContainer from '../../components/ChartContainer.vue'
+import DataFrame from '../../components/DataFrame.vue'
+import GeneratedResultRenderer from '../../components/GeneratedResultRenderer.vue'
+
+describe('GeneratedResultRenderer', () => {
+  it('renders tabular results with the standard DataFrame component', () => {
+    const wrapper = mount(GeneratedResultRenderer, {
+      props: {
+        result: {
+          kind: 'table',
+          columns: ['sample', 'value'],
+          rows: [{ sample: 'A', value: 1.5 }],
+        },
+      },
+    })
+
+    expect(wrapper.findComponent(DataFrame).props()).toMatchObject({
+      data: [{ sample: 'A', value: 1.5 }],
+      columns: [
+        { key: 'sample', label: 'Sample', sortable: true },
+        { key: 'value', label: 'Value', sortable: true },
+      ],
+    })
+  })
+
+  it('renders Matplotlib images inside the standard chart container', () => {
+    const wrapper = mount(GeneratedResultRenderer, {
+      props: {
+        result: { kind: 'image', media_type: 'image/png', data: 'cG5n', alt: 'PCA' },
+      },
+    })
+
+    expect({
+      chart: wrapper.findComponent(ChartContainer).exists(),
+      source: wrapper.get('img').attributes('src'),
+      alt: wrapper.get('img').attributes('alt'),
+    }).toEqual({ chart: true, source: 'data:image/png;base64,cG5n', alt: 'PCA' })
+  })
+
+  it('never interprets JSON results as HTML', () => {
+    const wrapper = mount(GeneratedResultRenderer, {
+      props: {
+        result: { kind: 'json', value: { unsafe: '<script>window.bad = true</script>' } },
+      },
+    })
+
+    expect({ scripts: wrapper.findAll('script').length, text: wrapper.text() }).toEqual({
+      scripts: 0,
+      text: expect.stringContaining('<script>window.bad = true</script>'),
+    })
+  })
+
+  it('should preserve the artifact filename when downloading a result', () => {
+    const wrapper = mount(GeneratedResultRenderer, {
+      props: {
+        result: {
+          kind: 'artifact',
+          id: 'artifact-1',
+          name: 'analysis.csv',
+          media_type: 'text/csv',
+          size: 3,
+          data: 'YSxi',
+        },
+      },
+    })
+
+    expect(wrapper.get('a').attributes('download')).toBe('analysis.csv')
+  })
+
+  it('uses the host download route for a managed file result', () => {
+    const wrapper = mount(GeneratedResultRenderer, {
+      props: {
+        result: {
+          kind: 'artifact',
+          id: 'artifact-2',
+          name: 'large.msd',
+          media_type: 'application/octet-stream',
+          size: 512_000_000,
+          download_url: '/api/leaf/jobs/job-1/result/file/scoped-token',
+          managed: true,
+        },
+      },
+    })
+
+    expect(wrapper.get('a').attributes()).toMatchObject({
+      href: '/api/leaf/jobs/job-1/result/file/scoped-token',
+      download: 'large.msd',
+    })
+  })
+})

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

@@ -0,0 +1,59 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, expectTypeOf, it } from 'vitest'
+import type { VNode } from 'vue'
+import InstrumentAlertLog from '../../components/InstrumentAlertLog.vue'
+import type { InstrumentAlert } from '../../types'
+
+type EventKeyIsOptional = {} extends Pick<InstrumentAlert, 'event_key'> ? true : false
+
+function alert(message: string): InstrumentAlert {
+  return {
+    event_key: 'orbitrap-01:acquisition-stopped:42',
+    instrument_id: 'orbitrap-01',
+    level: 'critical',
+    rule: 'acquisition-stopped',
+    message,
+    timestamp: '2026-07-22T08:30:00Z',
+  }
+}
+
+function findAlertVNodeKey(vnode: VNode): VNode['key'] {
+  const classes = vnode.props?.class
+  if (typeof classes === 'string' && classes.split(' ').includes('mint-instrument-alert')) {
+    return vnode.key
+  }
+  if (Array.isArray(vnode.children)) {
+    for (const child of vnode.children) {
+      if (typeof child !== 'object' || child === null) continue
+      const key = findAlertVNodeKey(child as VNode)
+      if (key !== null) return key
+    }
+  }
+  if (vnode.component?.subTree) return findAlertVNodeKey(vnode.component.subTree)
+  return null
+}
+
+describe('InstrumentAlertLog', () => {
+  it('should require a stable event_key in the public alert type', () => {
+    expectTypeOf<EventKeyIsOptional>().toEqualTypeOf<false>()
+  })
+
+  it('should retain the rendered alert when mutable content changes for the same event_key', async () => {
+    const wrapper = mount(InstrumentAlertLog, {
+      props: { alerts: [alert('Acquisition stopped')] },
+    })
+    const renderedAlert = wrapper.get('.mint-instrument-alert').element
+
+    await wrapper.setProps({ alerts: [alert('Acquisition remains stopped')] })
+
+    expect(wrapper.get('.mint-instrument-alert').element).toBe(renderedAlert)
+  })
+
+  it('should key each rendered alert by event_key', () => {
+    const wrapper = mount(InstrumentAlertLog, {
+      props: { alerts: [alert('Acquisition stopped')] },
+    })
+
+    expect(findAlertVNodeKey(wrapper.vm.$.subTree)).toBe('orbitrap-01:acquisition-stopped:42')
+  })
+})

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

@@ -1,4 +1,5 @@
 import { flushPromises, mount } from '@vue/test-utils'
+import type { VueWrapper } from '@vue/test-utils'
 import { createPinia } from 'pinia'
 import { computed, h, nextTick, ref } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
@@ -10,7 +11,7 @@ import ExperimentSelectorModal from '../../components/ExperimentSelectorModal.vu
 import PluginWorkspaceView from '../../components/PluginWorkspaceView.vue'
 import { defineDoseDesignControlModel } from '../../composables/useControlSchema'
 import { usePlatformContext } from '../../composables/usePlatformContext'
-import type { PillNavItem, SidebarToolSection } from '../../types'
+import type { PageSelectorItemInput, PillNavItem, SidebarToolSection } from '../../types'
 
 vi.mock('../../composables/usePlatformContext', () => ({
   usePlatformContext: vi.fn(() => ({
@@ -79,6 +80,44 @@ const globalOptions = {
   },
 }
 
+interface PageSelectorWorkspaceProps {
+  pageSelector?: PageSelectorItemInput[]
+  currentPageSelectorId?: string
+}
+
+function mountIntegratedPageSelectorWorkspace(
+  props: PageSelectorWorkspaceProps = {},
+): VueWrapper {
+  vi.mocked(usePlatformContext).mockReturnValueOnce({
+    isIntegrated: computed(() => true),
+    context: ref({ isIntegrated: true, theme: 'system' }),
+    plugin: computed(() => ({
+      id: 'workspace-plugin',
+      name: 'Workspace Plugin',
+      version: '1.0.0',
+      route_prefix: '/workspace-plugin',
+      api_prefix: '/api/workspace-plugin',
+      nav_items: [
+        { path: '/platform-one', label: 'Platform One' },
+        { path: '/platform-two', label: 'Platform Two' },
+      ],
+    })),
+    user: computed(() => undefined),
+    theme: computed(() => 'system' as const),
+    features: computed(() => undefined),
+    navigate: vi.fn(),
+    notify: vi.fn(),
+    sendToPlatform: vi.fn(),
+  })
+  return mount(PluginWorkspaceView, {
+    props: {
+      title: 'Workspace',
+      ...props,
+    },
+    global: globalOptions,
+  })
+}
+
 describe('PluginWorkspaceView', () => {
   it('renders the standard AppLayout, AppTopBar, and AppSidebar plugin shell', () => {
     const wrapper = mount(PluginWorkspaceView, {
@@ -146,22 +185,37 @@ describe('PluginWorkspaceView', () => {
     expect(wrapper.emitted('pill-select')).toEqual([[{ id: 'results', label: 'Results' }]])
   })
 
-  it('hides topbar page selector until multiple pages are registered', () => {
-    const wrapper = mount(PluginWorkspaceView, {
-      props: {
-        title: 'Downloader',
-        subtitle: 'Downloads',
-        pageSelector: [
-          { id: 'downloads', label: 'Downloads', to: '/' },
-        ],
-        currentPageSelectorId: 'downloads',
-      },
-      global: globalOptions,
+  it('should use platform pages when pageSelector is omitted', () => {
+    const wrapper = mountIntegratedPageSelectorWorkspace()
+
+    expect(wrapper.find('.mint-page-selector').exists()).toBe(true)
+  })
+
+  it('should suppress platform pages when pageSelector is explicitly empty', () => {
+    const wrapper = mountIntegratedPageSelectorWorkspace({ pageSelector: [] })
+
+    expect(wrapper.find('.mint-page-selector').exists()).toBe(false)
+  })
+
+  it('should hide one explicit page without falling back to platform pages', () => {
+    const wrapper = mountIntegratedPageSelectorWorkspace({
+      pageSelector: [{ id: 'downloads', label: 'Downloads', to: '/' }],
+      currentPageSelectorId: 'downloads',
     })
 
-    expect(wrapper.findComponent(AppTopBar).props('pageSelector')).toBeUndefined()
     expect(wrapper.find('.mint-page-selector').exists()).toBe(false)
-    expect(wrapper.find('.mint-topbar-title-group').text()).toContain('Downloader')
+  })
+
+  it('should render multiple explicit pages ahead of platform pages', () => {
+    const wrapper = mountIntegratedPageSelectorWorkspace({
+      pageSelector: [
+        { id: 'overview', label: 'Overview', to: '/' },
+        { id: 'reports', label: 'Reports', to: '/reports' },
+      ],
+      currentPageSelectorId: 'overview',
+    })
+
+    expect(wrapper.get('.mint-page-selector__label').text()).toBe('Overview')
   })
 
   it('passes compact control models to the sidebar for generated forms', () => {

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

@@ -0,0 +1,181 @@
+import { describe, it, expect } from 'vitest'
+import { mount } from '@vue/test-utils'
+import SectionCard from '../../components/SectionCard.vue'
+
+describe('SectionCard', () => {
+  describe('basic rendering', () => {
+    it('should render container, header, and title when given the required title prop', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments' },
+      })
+      expect(wrapper.find('.mint-section-card').exists()).toBe(true)
+      expect(wrapper.find('.mint-section-card__header').exists()).toBe(true)
+      expect(wrapper.find('.mint-section-card__title').text()).toBe('Experiments')
+    })
+
+    it('should render default slot content in the body', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments' },
+        slots: { default: '<p class="body-probe">rows</p>' },
+      })
+      expect(wrapper.find('.mint-section-card__body .body-probe').exists()).toBe(true)
+    })
+  })
+
+  describe('count meta', () => {
+    it('should render the count in the header when provided', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Plugins', count: '10 enabled' },
+      })
+      expect(wrapper.find('.mint-section-card__count').text()).toBe('10 enabled')
+    })
+
+    it('should not render a count element when count is omitted', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Plugins' },
+      })
+      expect(wrapper.find('.mint-section-card__count').exists()).toBe(false)
+    })
+
+    it('should accept a numeric count', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Artifacts', count: 4 },
+      })
+      expect(wrapper.find('.mint-section-card__count').text()).toBe('4')
+    })
+  })
+
+  describe('title style variants', () => {
+    it('should apply the uppercase modifier when uppercase is true', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments', uppercase: true },
+      })
+      expect(wrapper.find('.mint-section-card__title--uppercase').exists()).toBe(true)
+    })
+
+    it('should not apply the uppercase modifier by default', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Design data' },
+      })
+      expect(wrapper.find('.mint-section-card__title--uppercase').exists()).toBe(false)
+    })
+  })
+
+  describe('icon chip', () => {
+    it('should render an icon chip with an SVG path when icon is provided', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments', icon: 'M4 7v10c0 2.21 3.582 4 8 4s8-1.79 8-4V7' },
+      })
+      expect(wrapper.find('.mint-section-card__icon-chip').exists()).toBe(true)
+      expect(wrapper.find('.mint-section-card__icon-chip path').exists()).toBe(true)
+    })
+
+    it('should render one path per entry when icon is an array of paths', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments', icon: ['M4 7v10', 'M4 7c0 2.21'] },
+      })
+      expect(wrapper.findAll('.mint-section-card__icon-chip path')).toHaveLength(2)
+    })
+
+    it('should not render an icon chip when icon is omitted', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments' },
+      })
+      expect(wrapper.find('.mint-section-card__icon-chip').exists()).toBe(false)
+    })
+
+    it('should apply the accent modifier class matching the accent prop', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Projects', icon: 'M3 7v10', accent: 'project' },
+      })
+      expect(wrapper.find('.mint-section-card__icon-chip--project').exists()).toBe(true)
+    })
+
+    it('should default to the primary accent when accent is omitted', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Projects', icon: 'M3 7v10' },
+      })
+      expect(wrapper.find('.mint-section-card__icon-chip--primary').exists()).toBe(true)
+    })
+  })
+
+  describe('header divider', () => {
+    it('should use the strong divider by default', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments' },
+      })
+      expect(wrapper.find('.mint-section-card__header--divider-light').exists()).toBe(false)
+    })
+
+    it('should apply the light divider modifier when divider is light', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Design data', divider: 'light' },
+      })
+      expect(wrapper.find('.mint-section-card__header--divider-light').exists()).toBe(true)
+    })
+  })
+
+  describe('fill mode', () => {
+    it('should not stretch by default', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments' },
+      })
+      expect(wrapper.find('.mint-section-card--fill').exists()).toBe(false)
+    })
+
+    it('should apply the fill modifier when fill is true', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments', fill: true },
+      })
+      expect(wrapper.find('.mint-section-card--fill').exists()).toBe(true)
+    })
+
+    it('should render the toolbar slot outside the scrolling body', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments', fill: true },
+        slots: { toolbar: '<div class="toolbar-probe">chips</div>', default: '<p>rows</p>' },
+      })
+      expect(wrapper.find('.mint-section-card__toolbar .toolbar-probe').exists()).toBe(true)
+      expect(wrapper.find('.mint-section-card__body .toolbar-probe').exists()).toBe(false)
+    })
+
+    it('should not render a toolbar region when the slot is unused', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments' },
+      })
+      expect(wrapper.find('.mint-section-card__toolbar').exists()).toBe(false)
+    })
+
+    it('should keep the header, body and footer structure when filling', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments', fill: true },
+        slots: { default: '<p>rows</p>', footer: '<span>1 / 3</span>' },
+      })
+      expect(wrapper.find('.mint-section-card__header').exists()).toBe(true)
+      expect(wrapper.find('.mint-section-card__body').exists()).toBe(true)
+      expect(wrapper.find('.mint-section-card__footer').exists()).toBe(true)
+    })
+  })
+
+  describe('slots', () => {
+    it('should render the actions slot at the end of the header', () => {
+      const wrapper = mount(SectionCard, {
+        props: { title: 'Experiments' },
+        slots: { actions: '<a class="actions-probe" href="#">All →</a>' },
+      })
+      expect(wrapper.find('.mint-section-card__header .actions-probe').exists()).toBe(true)
+    })
+
+    it('should render the footer strip only when the footer slot is provided', () => {
+      const withFooter = mount(SectionCard, {
+        props: { title: 'Experiments' },
+        slots: { footer: '<span class="footer-probe">Showing 1–18 of 42</span>' },
+      })
+      const withoutFooter = mount(SectionCard, {
+        props: { title: 'Experiments' },
+      })
+      expect(withFooter.find('.mint-section-card__footer .footer-probe').exists()).toBe(true)
+      expect(withoutFooter.find('.mint-section-card__footer').exists()).toBe(false)
+    })
+  })
+})

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

@@ -9,7 +9,7 @@ describe('formBuilderRegistry', () => {
         'text', 'email', 'password', 'tel', 'url', 'search',
         'number', 'textarea', 'select', 'multiselect',
         'checkbox', 'toggle', 'radio', 'slider', 'tags',
-        'date', 'time', 'datetime', 'file',
+        'date', 'time', 'datetime', 'file', 'path',
         'formula', 'sequence', 'molecule', 'concentration', 'unit',
       ]
 
@@ -59,6 +59,10 @@ describe('formBuilderRegistry', () => {
       expect(entry.vModel).toBe(false)
     })
 
+    it('should bind generated path inputs with v-model', () => {
+      expect(getFieldRegistryEntry('path').vModel).toBe(true)
+    })
+
     it('should have vModel true for all non-file types', () => {
       const vModelTypes: FormFieldType[] = [
         'text', 'email', 'password', 'tel', 'url', 'search',

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

@@ -47,6 +47,14 @@ describe('useApi URL helpers', () => {
     expect(api.buildUrl('')).toBe('/api/plugin/')
   })
 
+  it('keeps absolute URLs outside the configured API base', () => {
+    const api = useApi({ baseUrl: '/api/plugin' })
+
+    expect(api.buildUrl('https://files.example.test/result.csv')).toBe(
+      'https://files.example.test/result.csv',
+    )
+  })
+
   it('joins configured WebSocket base URLs without duplicate slashes', () => {
     vi.stubEnv('VITE_API_PREFIX', '/api/')
     const api = useApi()