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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morscherlab/mint-sdk",
-  "version": "1.1.0-beta.2",
+  "version": "1.1.0-beta.20",
   "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__/components/BaseSelect.test.ts

@@ -3,6 +3,58 @@ import { describe, expect, it } from 'vitest'
 import BaseSelect from '../../components/BaseSelect.vue'
 
 describe('BaseSelect', () => {
+  it('forwards native attributes to the select instead of the wrapper', () => {
+    const wrapper = mount(BaseSelect, {
+      props: {
+        options: ['linear'],
+      },
+      attrs: {
+        id: 'curve-model',
+        name: 'curve-model',
+        'aria-label': 'Curve model',
+        'data-testid': 'curve-model-select',
+        class: 'curve-model-layout',
+        style: 'width: 12rem;',
+      },
+    })
+
+    const select = wrapper.get('select')
+
+    expect({
+      select: {
+        id: select.attributes('id'),
+        name: select.attributes('name'),
+        ariaLabel: select.attributes('aria-label'),
+        testId: select.attributes('data-testid'),
+        layoutClass: select.classes().includes('curve-model-layout'),
+      },
+      wrapper: {
+        id: wrapper.attributes('id'),
+        name: wrapper.attributes('name'),
+        ariaLabel: wrapper.attributes('aria-label'),
+        testId: wrapper.attributes('data-testid'),
+        layoutClass: wrapper.classes().includes('curve-model-layout'),
+        style: wrapper.attributes('style'),
+      },
+    }).toEqual({
+      select: {
+        id: 'curve-model',
+        name: 'curve-model',
+        ariaLabel: 'Curve model',
+        testId: 'curve-model-select',
+        layoutClass: false,
+      },
+      wrapper: {
+        id: undefined,
+        name: undefined,
+        ariaLabel: undefined,
+        testId: undefined,
+        layoutClass: true,
+        style: 'width: 12rem;',
+      },
+    })
+  })
+
   it('accepts string and number shorthand options', async () => {
     const wrapper = mount(BaseSelect, {
       props: {

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

@@ -0,0 +1,40 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import BaseToggle from '../../components/BaseToggle.vue'
+
+describe('BaseToggle', () => {
+  it('uses ariaLabel for the switch name without changing the visual label', () => {
+    const wrapper = mount(BaseToggle, {
+      props: {
+        label: 'Enabled',
+        ariaLabel: 'Email notifications',
+      },
+    })
+
+    expect({
+      accessibleName: wrapper.get('[role="switch"]').attributes('aria-label'),
+      visualText: wrapper.text(),
+      wrapperAriaLabel: wrapper.attributes('aria-label'),
+    }).toEqual({
+      accessibleName: 'Email notifications',
+      visualText: 'Enabled',
+      wrapperAriaLabel: undefined,
+    })
+  })
+
+  it('keeps using the visual label as the default switch name', () => {
+    const wrapper = mount(BaseToggle, {
+      props: {
+        label: 'Enabled',
+      },
+    })
+
+    expect(wrapper.get('[role="switch"]').attributes('aria-label')).toBe('Enabled')
+  })
+
+  it('keeps the existing fallback name when no labels are provided', () => {
+    const wrapper = mount(BaseToggle)
+
+    expect(wrapper.get('[role="switch"]').attributes('aria-label')).toBe('Toggle')
+  })
+})

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

@@ -190,6 +190,16 @@ describe('GeneratedPluginView', () => {
     expect(wrapper.find('[aria-label="Job resource requirements"]').text()).toBe('Host service')
   })
 
+  it('describes process CPU declarations as an upper bound', async () => {
+    const wrapper = mount(GeneratedPluginView, {
+      props: { baseUrl: '/api/demo' },
+      global: { plugins: [createPinia()], stubs: { 'router-link': true, Teleport: true } },
+    })
+    await flushPromises()
+
+    expect(wrapper.find('[aria-label="Job resource requirements"]').text()).toBe('Up to 2 CPU')
+  })
+
   it('should pass the host transport to the generated analysis composable', async () => {
     const transport = vi.fn()
     mount(GeneratedPluginView, {

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/analysisArtifactTarget.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  buildAnalysisArtifactTargetQuery,
+  parseAnalysisArtifactTarget,
+} from '../../composables/analysisArtifactTarget'
+import {
+  currentExperimentIdFromUrl,
+  resolveCurrentPluginId,
+} from '../../composables/platformContextHelpers'
+
+describe('analysis artifact target', () => {
+  afterEach(() => {
+    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
+    vi.unstubAllGlobals()
+  })
+
+  it('should resolve the canonical injected plugin id', () => {
+    ;(window as unknown as { __MINT_PLATFORM__: unknown }).__MINT_PLATFORM__ = {
+      isIntegrated: true,
+      plugin: { id: 'LEAF', name: 'Leaf UI' },
+      theme: 'system',
+    }
+
+    expect(resolveCurrentPluginId()).toBe('LEAF')
+  })
+
+  it('should tolerate a host that provides a partial location object', () => {
+    vi.stubGlobal('window', {
+      location: { search: '' },
+    })
+
+    expect(currentExperimentIdFromUrl()).toBeUndefined()
+  })
+
+  it('should build the canonical readable query when an artifact id hint is present', () => {
+    const query = buildAnalysisArtifactTargetQuery({
+      experimentId: 66,
+      artifactPluginId: 'LEAF',
+      artifactKey: 'exp316_260703_ys_rna_ide_scr',
+      artifactId: 206,
+    })
+
+    expect(query.toString()).toBe(
+      'experiment_id=66&artifact_plugin_id=LEAF'
+      + '&artifact_key=exp316_260703_ys_rna_ide_scr&artifact_id=206',
+    )
+  })
+
+  it('should parse the canonical identity without requiring an artifact id hint', () => {
+    const target = parseAnalysisArtifactTarget(new URLSearchParams(
+      'experiment_id=66&artifact_plugin_id=LEAF&artifact_key=result',
+    ))
+
+    expect(target).toEqual({
+      experimentId: 66,
+      artifactPluginId: 'LEAF',
+      artifactKey: 'result',
+    })
+  })
+
+  it('should reject an incomplete target instead of guessing another artifact', () => {
+    const target = parseAnalysisArtifactTarget(new URLSearchParams(
+      'experiment_id=66&artifact_key=result',
+    ))
+
+    expect(target).toBeNull()
+  })
+
+  it('should reject non-positive numeric identifiers', () => {
+    const target = parseAnalysisArtifactTarget(new URLSearchParams(
+      'experiment_id=0&artifact_plugin_id=LEAF&artifact_key=result&artifact_id=-1',
+    ))
+
+    expect(target).toBeNull()
+  })
+})

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

@@ -19,7 +19,10 @@ vi.mock('../../composables/useApi', () => ({
 }))
 
 import { useAnalysisArtifacts } from '../../composables/useAnalysisArtifacts'
-import type { AnalysisArtifactSummary } from '../../types/analysisArtifactTypes'
+import type {
+  AnalysisArtifactDetail,
+  AnalysisArtifactSummary,
+} from '../../types/analysisArtifactTypes'
 
 // ---------------------------------------------------------------------------
 // Fixtures
@@ -177,6 +180,76 @@ describe('useAnalysisArtifacts', () => {
     })
   })
 
+  describe('resolveTarget', () => {
+    it('should resolve the exact stable identity when the numeric hint is stale', async () => {
+      const detail = {
+        ...makeArtifact({
+          id: 2,
+          experiment_id: 42,
+          plugin_id: 'plugin-b',
+          artifact_key: 'peaks',
+        }),
+        result: { schema_version: 'mint.analysis_file.v1' },
+        tree: [],
+        summary: null,
+      } satisfies AnalysisArtifactDetail
+      mockGet
+        .mockResolvedValueOnce({ artifacts: ARTIFACTS })
+        .mockResolvedValueOnce(detail)
+      const { resolveTarget } = setup()
+
+      const resolved = await resolveTarget({
+        experimentId: 42,
+        artifactPluginId: 'plugin-b',
+        artifactKey: 'peaks',
+        artifactId: 999,
+      })
+
+      expect({
+        resolvedId: resolved?.id,
+        detailPath: mockGet.mock.calls[1]?.[0],
+      }).toEqual({
+        resolvedId: 2,
+        detailPath: '/experiments/42/analysis-artifacts/2',
+      })
+    })
+
+    it('should fail explicitly when the stable identity is not available', async () => {
+      const { resolveTarget, error } = setup()
+
+      const resolved = await resolveTarget({
+        experimentId: 42,
+        artifactPluginId: 'LEAF',
+        artifactKey: 'missing',
+      })
+
+      expect({ resolved, error: error.value }).toEqual({
+        resolved: null,
+        error: 'Analysis artifact LEAF/missing is not available.',
+      })
+    })
+
+    it('should reject a target from another experiment before making a request', async () => {
+      const { resolveTarget, error } = setup()
+
+      const resolved = await resolveTarget({
+        experimentId: 66,
+        artifactPluginId: 'LEAF',
+        artifactKey: 'result',
+      })
+
+      expect({
+        resolved,
+        error: error.value,
+        requests: mockGet.mock.calls,
+      }).toEqual({
+        resolved: null,
+        error: 'Analysis artifact target belongs to experiment 66, not 42.',
+        requests: [],
+      })
+    })
+  })
+
   // -------------------------------------------------------------------------
   // experiment id resolution
   // -------------------------------------------------------------------------

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

@@ -407,6 +407,7 @@ describe('useGeneratedAnalysis', () => {
         uploadUrl: upload?.[0],
         uploadMethod: upload?.[1]?.method,
         uploadSessionHeader: new Headers(upload?.[1]?.headers).get('X-Mint-Job-Session'),
+        uploadDefinitionHeader: new Headers(upload?.[1]?.headers).get('X-Mint-Job-Definition'),
         sessionId: form.get('session_id'),
         relativePaths: form.getAll('relative_paths'),
         submittedSource: submit.inputs.source,
@@ -414,6 +415,7 @@ describe('useGeneratedAnalysis', () => {
         uploadUrl: '/api/demo/jobs/uploads',
         uploadMethod: 'POST',
         uploadSessionHeader: 'session-1',
+        uploadDefinitionHeader: 'run',
         sessionId: 'session-1',
         relativePaths: ['data.csv'],
         submittedSource: { token: 'upload-token' },

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

@@ -22,12 +22,37 @@ import { AuthenticationRequiredError } from '../../composables/useApi'
 import { useAuthStore } from '../../stores/auth'
 
 const contract: PluginContract = {
-  schemaVersion: 1,
+  schemaVersion: 2,
   plugin: {
     routesPrefix: '/drp',
     apiPrefix: '/api/drp',
     type: 'analysis',
   },
+  settings: {
+    modelName: 'PluginSettings',
+    valueSchema: {
+      type: 'object',
+      properties: {
+        threshold: { type: 'number', default: 0.05 },
+      },
+    },
+    formSchema: {
+      groups: [
+        {
+          id: 'settings',
+          label: 'Settings',
+          fields: [
+            {
+              name: 'threshold',
+              label: 'Threshold',
+              type: 'number',
+              defaultValue: 0.05,
+            },
+          ],
+        },
+      ],
+    },
+  },
   endpoints: [],
   hash: 'sha256:test',
 }
@@ -818,6 +843,16 @@ describe('usePluginClient', () => {
     })
   })
 
+  it('should preserve the contract v2 form schema in settingsConfig', () => {
+    const settings = usePluginSettings({
+      apiBaseUrl: '/api/drp',
+      loadOnMount: false,
+      schema: contract.settings.formSchema,
+    })
+
+    expect(settings.settingsConfig.value.schema).toBe(contract.settings.formSchema)
+  })
+
   it('should use the platform facade for an explicit different plugin name', async () => {
     ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
       isIntegrated: true,