@morscherlab/mint-sdk 1.2.0-beta.1 → 1.2.0-beta.11

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

@@ -89,4 +89,144 @@ describe('useRequestSyncState', () => {
     expect(state.lastSavedAt.value).toBeNull()
     expect(state.lastRunAt.value).toBeNull()
   })
+
+  describe('stale-response guard', () => {
+    function deferred<T>() {
+      let resolve!: (value: T) => void
+      let reject!: (reason: unknown) => void
+      const promise = new Promise<T>((res, rej) => {
+        resolve = res
+        reject = rej
+      })
+      return { promise, resolve, reject }
+    }
+
+    it('lets only the newest run own loading', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+
+      const firstRun = state.run(() => first.promise, { success: 'load' })
+      const secondRun = state.run(() => second.promise, { success: 'load' })
+
+      first.resolve('stale')
+      await expect(firstRun).resolves.toBe('stale')
+      expect(state.loading.value).toBe(true)
+
+      second.resolve('fresh')
+      await expect(secondRun).resolves.toBe('fresh')
+      expect(state.loading.value).toBe(false)
+    })
+
+    it('does not let a stale success move the sync timestamps', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+
+      const firstRun = state.run(() => first.promise, { success: 'save' })
+      const secondRun = state.run(() => second.promise, { success: 'load' })
+
+      first.resolve('stale')
+      await firstRun
+      expect(state.lastSavedAt.value).toBeNull()
+
+      second.resolve('fresh')
+      await secondRun
+      expect(state.lastLoadedAt.value).toBeInstanceOf(Date)
+      expect(state.lastSavedAt.value).toBeNull()
+    })
+
+    it('does not let a stale failure write the error, but still rejects its caller', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+
+      const firstRun = state.run(() => first.promise, { errorMessage: 'first failed' })
+      const secondRun = state.run(() => second.promise, { success: 'load' })
+
+      first.reject(new Error('stale failure'))
+      await expect(firstRun).rejects.toThrow('stale failure')
+      expect(state.error.value).toBeNull()
+
+      second.resolve('fresh')
+      await secondRun
+      expect(state.error.value).toBeNull()
+      expect(state.loading.value).toBe(false)
+    })
+
+    it('aborts the superseded run signal by default', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+      let firstSignal: AbortSignal | undefined
+
+      const firstRun = state.run((signal) => {
+        firstSignal = signal
+        return first.promise
+      })
+      expect(firstSignal?.aborted).toBe(false)
+
+      const secondRun = state.run(() => second.promise)
+      expect(firstSignal?.aborted).toBe(true)
+
+      first.resolve('stale')
+      second.resolve('fresh')
+      await Promise.all([firstRun, secondRun])
+    })
+
+    it('leaves the previous signal alone when abortPrevious is false', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+      let firstSignal: AbortSignal | undefined
+
+      const firstRun = state.run((signal) => {
+        firstSignal = signal
+        return first.promise
+      })
+      const secondRun = state.run(() => second.promise, { abortPrevious: false })
+
+      expect(firstSignal?.aborted).toBe(false)
+      first.resolve('stale')
+      second.resolve('fresh')
+      await Promise.all([firstRun, secondRun])
+    })
+
+    it('forwards a caller signal onto the operation signal', async () => {
+      const state = useRequestSyncState()
+      const caller = new AbortController()
+      const pending = deferred<string>()
+      let operationSignal: AbortSignal | undefined
+
+      const run = state.run((signal) => {
+        operationSignal = signal
+        return pending.promise
+      }, { signal: caller.signal })
+
+      caller.abort()
+      expect(operationSignal?.aborted).toBe(true)
+
+      pending.resolve('done')
+      await run
+    })
+
+    it('cancel() aborts the in-flight run and drops loading', async () => {
+      const state = useRequestSyncState()
+      const pending = deferred<string>()
+      let operationSignal: AbortSignal | undefined
+
+      const run = state.run((signal) => {
+        operationSignal = signal
+        return pending.promise
+      }, { success: 'load' })
+
+      state.cancel()
+      expect(operationSignal?.aborted).toBe(true)
+      expect(state.loading.value).toBe(false)
+
+      pending.resolve('too late')
+      await expect(run).resolves.toBe('too late')
+      expect(state.lastLoadedAt.value).toBeNull()
+    })
+  })
 })

package/src/__tests__/docs/frontendDocsCatalog.test.ts

@@ -22,7 +22,7 @@ interface FrontendManifest {
     }>
     composables: Array<{
       name: string
-      members?: Array<{ name: string }>
+      members?: Array<{ name: string; type?: string }>
       examples?: Array<{ title: string; language: string; code: string }>
     }>
     templateExports: Array<{ name: string }>
@@ -271,11 +271,14 @@ describe('frontend docs catalog coverage', () => {
     })
   })
 
-  it('documents only the source-driven JobsStatusTray props', () => {
+  it('documents the source and MINT 1.1 JobsStatusTray props', () => {
     const manifest = extractFrontendManifest()
     const jobsStatusTray = manifest.categories.components.find(item => item.name === 'JobsStatusTray')
 
     expect(jobsStatusTray?.props?.map(prop => prop.name).sort()).toEqual([
+      'adapter',
+      'eventStream',
+      'jobs',
       'loadOnMount',
       'source',
       'teleportTo',
@@ -319,6 +322,18 @@ describe('frontend docs catalog coverage', () => {
       'AppPillNav',
       'usePluginApi',
       'UsePluginApiOptions',
+    ]
+
+    for (const name of retiredNames) {
+      expect(rootIndex).not.toMatch(new RegExp(`\\b${name}\\b`))
+      expect(componentsIndex).not.toMatch(new RegExp(`\\b${name}\\b`))
+      expect(composableExports).not.toMatch(new RegExp(`\\b${name}\\b`))
+    }
+  })
+
+  it('keeps the MINT 1.1 composable compatibility exports', () => {
+    const composablesIndex = readFileSync(join(SDK_ROOT, 'src', 'composables', 'index.ts'), 'utf8')
+    const expected = [
       'useJobsStatusTray',
       'UseJobsStatusTrayOptions',
       'UseJobsStatusTrayReturn',
@@ -329,11 +344,7 @@ describe('frontend docs catalog coverage', () => {
       'usePluginClient',
     ]
 
-    for (const name of retiredNames) {
-      expect(rootIndex).not.toMatch(new RegExp(`\\b${name}\\b`))
-      expect(componentsIndex).not.toMatch(new RegExp(`\\b${name}\\b`))
-      expect(composableExports).not.toMatch(new RegExp(`\\b${name}\\b`))
-    }
+    expect(expected.filter(name => !new RegExp(`\\b${name}\\b`).test(composablesIndex))).toEqual([])
   })
 
   it('documents every public composable/helper export used by docs and doctor', () => {
@@ -422,4 +433,25 @@ describe('frontend docs catalog coverage', () => {
 
     expect(useFormBuilder?.members?.map(member => member.name)).toContain('updateSchema')
   })
+
+  it('extracts inherited return interface members', () => {
+    const manifest = extractFrontendManifest()
+    const workspace = manifest.categories.composables.find(item => item.name === 'useBioTemplateWorkspace')
+
+    expect(workspace?.members?.map(member => member.name)).toContain('componentUsage')
+  })
+
+  it('ignores generic constraints when extracting inherited return members', () => {
+    const manifest = extractFrontendManifest()
+    const history = manifest.categories.composables.find(item => item.name === 'useCommandHistory')
+
+    expect(history?.members?.map(member => member.name)).not.toContain('description')
+  })
+
+  it('extracts exact array return member types while resolving inheritance', () => {
+    const manifest = extractFrontendManifest()
+    const bindings = manifest.categories.composables.find(item => item.name === 'controlValuesToComponentBindings')
+
+    expect(bindings?.members?.find(member => member.name === 'props')?.type).toBe('Record<string, unknown>')
+  })
 })

package/src/__tests__/stores/settings.test.ts

@@ -1,6 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { createPinia, setActivePinia } from 'pinia'
-import { useSettingsStore } from '../../stores/settings'
+import { nextTick } from 'vue'
+import {
+  paletteCssVariables,
+  tableDensityToSize,
+  tryUseSettingsStore,
+  useSettingsStore,
+} from '../../stores/settings'
 
 function mockMatchMedia(matches = false) {
   Object.defineProperty(window, 'matchMedia', {
@@ -46,6 +52,8 @@ describe('useSettingsStore', () => {
     setActivePinia(createPinia())
     installLocalStorage()
     document.documentElement.classList.remove('dark')
+    document.documentElement.removeAttribute('style')
+    delete document.documentElement.dataset.density
     mockMatchMedia(false)
   })
 
@@ -75,4 +83,66 @@ describe('useSettingsStore', () => {
       tableDensity: 'compact',
     }))
   })
+
+  describe('palette and density DOM sync', () => {
+    it('writes no palette overrides for the default palette', () => {
+      const settings = useSettingsStore()
+      settings.initialize()
+
+      expect(paletteCssVariables('default')).toEqual({})
+      expect(document.documentElement.style.getPropertyValue('--color-primary')).toBe('')
+    })
+
+    it('applies the stored palette hues to html on initialize', () => {
+      localStorage.setItem('mint-settings', JSON.stringify({ colorPalette: 'viridis' }))
+
+      const settings = useSettingsStore()
+      settings.initialize()
+
+      const style = document.documentElement.style
+      expect(style.getPropertyValue('--color-primary')).toBe('hsl(280 84% 67%)')
+      expect(style.getPropertyValue('--color-primary-hover')).toBe('hsl(280 75% 59%)')
+      expect(style.getPropertyValue('--color-cta')).toBe('hsl(80 95% 53%)')
+    })
+
+    it('re-applies the overrides when the palette changes and clears them on default', async () => {
+      const settings = useSettingsStore()
+      settings.initialize()
+
+      settings.colorPalette = 'pastel'
+      await nextTick()
+      expect(document.documentElement.style.getPropertyValue('--color-primary')).toBe('hsl(200 84% 67%)')
+
+      settings.colorPalette = 'default'
+      await nextTick()
+      expect(document.documentElement.style.getPropertyValue('--color-primary')).toBe('')
+      expect(document.documentElement.style.getPropertyValue('--color-primary-soft')).toBe('')
+    })
+
+    it('mirrors the table density onto html[data-density]', async () => {
+      const settings = useSettingsStore()
+      settings.initialize()
+      expect(document.documentElement.dataset.density).toBe('normal')
+
+      settings.tableDensity = 'compact'
+      await nextTick()
+      expect(document.documentElement.dataset.density).toBe('compact')
+    })
+
+    it('maps each density onto a table size', () => {
+      const settings = useSettingsStore()
+      settings.initialize()
+
+      expect(tableDensityToSize('compact')).toBe('sm')
+      expect(tableDensityToSize('normal')).toBe('md')
+      expect(tableDensityToSize('comfortable')).toBe('lg')
+
+      settings.tableDensity = 'comfortable'
+      expect(settings.getTableSize()).toBe('lg')
+    })
+  })
+
+  it('exposes the store through tryUseSettingsStore when Pinia is active', () => {
+    expect(tryUseSettingsStore()).not.toBeNull()
+  })
 })

package/src/__tests__/styles/cssTokens.test.ts

@@ -0,0 +1,131 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { dirname, join, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const srcRoot = resolve(here, '../..')
+const stylesDir = join(srcRoot, 'styles')
+const variablesCss = readFileSync(join(stylesDir, 'variables.css'), 'utf-8')
+
+/**
+ * Custom properties that are legitimately *not* declared in variables.css:
+ * they are set at runtime (inline `:style` bindings, JS-built names) or are
+ * component-local knobs declared in the same stylesheet that consumes them.
+ * Anything else must be a canonical token from variables.css.
+ */
+const RUNTIME_PROPERTY_ALLOWLIST = new Set<string>([
+  // Names assembled in JS (`--grp-${i}`) — the literal prefix is what the
+  // scanner sees in a template string.
+  '--grp-',
+])
+
+const SOURCE_EXTENSIONS = ['.vue', '.css', '.ts']
+const IGNORED_DIRS = new Set(['__tests__', 'generated-ui', 'node_modules'])
+
+function walk(dir: string, out: string[] = []): string[] {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry)
+    if (statSync(full).isDirectory()) {
+      if (!IGNORED_DIRS.has(entry)) walk(full, out)
+    } else if (SOURCE_EXTENSIONS.some((ext) => entry.endsWith(ext))) {
+      out.push(full)
+    }
+  }
+  return out
+}
+
+const sourceFiles = walk(srcRoot)
+
+function declaredIn(text: string): Set<string> {
+  const names = new Set<string>()
+  // `--foo: value` declarations, in CSS blocks and in JS style objects.
+  for (const m of text.matchAll(/(--[A-Za-z0-9_-]+)\s*:/g)) names.add(m[1])
+  // setProperty('--foo', …) / `'--foo'` keys in style bindings.
+  for (const m of text.matchAll(/['"`](--[A-Za-z0-9_-]+)['"`]/g)) names.add(m[1])
+  return names
+}
+
+const canonicalTokens = declaredIn(variablesCss)
+
+// Component-local custom properties: declared in a stylesheet or set from an
+// inline `:style` binding in the SFC that owns it. They are legitimate, they
+// just are not part of the global token set.
+const componentLocalProperties = new Set<string>()
+for (const file of sourceFiles) {
+  for (const name of declaredIn(readFileSync(file, 'utf-8'))) {
+    componentLocalProperties.add(name)
+  }
+}
+
+interface Usage {
+  file: string
+  token: string
+}
+
+const usages: Usage[] = []
+for (const file of sourceFiles) {
+  const text = readFileSync(file, 'utf-8')
+  for (const m of text.matchAll(/var\(\s*(--[A-Za-z0-9_-]+)/g)) {
+    usages.push({ file, token: m[1] })
+  }
+}
+
+describe('CSS custom properties', () => {
+  it('scans a meaningful number of var() references', () => {
+    expect(usages.length).toBeGreaterThan(500)
+    expect(canonicalTokens.size).toBeGreaterThan(70)
+  })
+
+  it('only references custom properties that are actually defined', () => {
+    const undefinedUsages = usages.filter(({ token }) => {
+      if (canonicalTokens.has(token)) return false
+      if (RUNTIME_PROPERTY_ALLOWLIST.has(token)) return false
+      return !componentLocalProperties.has(token)
+    })
+
+    const report = [
+      ...new Set(
+        undefinedUsages.map(
+          ({ file, token }) => `${token} (${relative(srcRoot, file)})`,
+        ),
+      ),
+    ].sort()
+
+    expect(report).toEqual([])
+  })
+
+  it('does not use the platform-only --color-bg-*/--color-text-*/--color-border aliases', () => {
+    const platformOnly = /^--color-(bg|text)-|^--color-border$/
+    const offenders = [
+      ...new Set(
+        usages
+          .filter(({ token }) => platformOnly.test(token))
+          .map(({ file, token }) => `${token} (${relative(srcRoot, file)})`),
+      ),
+    ].sort()
+
+    expect(offenders).toEqual([])
+  })
+
+  it('aggregates every component stylesheet in styles/index.css', () => {
+    const index = readFileSync(join(stylesDir, 'index.css'), 'utf-8')
+    const imported = new Set(
+      [...index.matchAll(/@import\s+'\.\/components\/([^']+)'/g)].map((m) => m[1]),
+    )
+    const onDisk = readdirSync(join(stylesDir, 'components')).filter((f) =>
+      f.endsWith('.css'),
+    )
+    expect([...onDisk].filter((f) => !imported.has(f)).sort()).toEqual([])
+  })
+
+  it('does not re-import aggregated stylesheets from SFC <style> blocks', () => {
+    const offenders = sourceFiles
+      .filter((f) => f.endsWith('.vue'))
+      .filter((f) => /@import\s+['"][^'"]*styles\/components\//.test(readFileSync(f, 'utf-8')))
+      .map((f) => relative(srcRoot, f))
+      .sort()
+
+    expect(offenders).toEqual([])
+  })
+})

package/src/__tests__/utils/permissions.test.ts

@@ -7,6 +7,7 @@ import {
   hasAllPermissions,
   hasAnyPermission,
   isAdminUser,
+  normalizeAccessPolicy,
 } from '../../permissions'
 
 describe('permission helpers', () => {
@@ -60,3 +61,70 @@ describe('permission helpers', () => {
     expect(canAccessByPolicy(member, { plugin: 'reports' })).toBe(false)
   })
 })
+
+describe('normalizeAccessPolicy precedence', () => {
+  it('returns an empty policy for an absent rule', () => {
+    expect(normalizeAccessPolicy(undefined)).toEqual({})
+  })
+
+  it('reads a flat-only rule as-is', () => {
+    expect(normalizeAccessPolicy({
+      visibleFor: 'admin',
+      requiresAdmin: true,
+      permissions: ['users.manage'],
+      anyPermissions: ['plugins.install'],
+    })).toEqual({
+      visibleFor: 'admin',
+      requiresAdmin: true,
+      permissions: ['users.manage'],
+      anyPermissions: ['plugins.install'],
+    })
+  })
+
+  it('lifts a nested-only policy to the top level', () => {
+    expect(normalizeAccessPolicy({
+      access: { requiresAuth: true, plugin: 'reports', visibleFor: 'admin' },
+    })).toEqual({
+      requiresAuth: true,
+      plugin: 'reports',
+      visibleFor: 'admin',
+    })
+  })
+
+  it('lets the nested policy win over the deprecated flat duplicates', () => {
+    expect(normalizeAccessPolicy({
+      access: {
+        visibleFor: 'admin',
+        requiresAdmin: true,
+        permissions: ['users.manage'],
+        anyPermissions: ['plugins.install'],
+      },
+      visibleFor: 'user',
+      requiresAdmin: false,
+      permissions: ['experiments.view'],
+      anyPermissions: ['experiments.edit'],
+    })).toEqual({
+      visibleFor: 'admin',
+      requiresAdmin: true,
+      permissions: ['users.manage'],
+      anyPermissions: ['plugins.install'],
+    })
+  })
+
+  it('treats an undefined nested field as unset instead of masking the flat one', () => {
+    expect(normalizeAccessPolicy({
+      access: { visibleFor: undefined, requiresAdmin: true },
+      visibleFor: 'user',
+    })).toEqual({
+      visibleFor: 'user',
+      requiresAdmin: true,
+    })
+  })
+
+  it('feeds canAccessByPolicy from the nested policy', () => {
+    const member = { role: 'member', permissions: ['experiments.view'] }
+
+    expect(canAccessByPolicy(member, { access: { requiresAdmin: true }, requiresAdmin: false })).toBe(false)
+    expect(canAccessByPolicy(member, { access: { visibleFor: 'user' }, visibleFor: 'admin' })).toBe(true)
+  })
+})