@morscherlab/mint-sdk 1.0.12 → 1.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morscherlab/mint-sdk",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "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/ExperimentPopover.test.ts

@@ -21,6 +21,29 @@ describe('ExperimentPopover', () => {
     document.body.innerHTML = ''
   })
 
+  it('prefers the experiment name in the trigger when both name and code are available', () => {
+    const wrapper = mountPopover({
+      experimentName: 'Dose response run',
+      experimentCode: 'EXP-001',
+    })
+
+    const trigger = wrapper.find('.mint-experiment-popover__trigger')
+    expect(trigger.text()).toContain('Dose response run')
+    expect(trigger.text()).not.toContain('EXP-001')
+
+    wrapper.unmount()
+  })
+
+  it('falls back to the experiment code in the trigger when the name is unavailable', () => {
+    const wrapper = mountPopover({
+      experimentCode: 'EXP-001',
+    })
+
+    expect(wrapper.find('.mint-experiment-popover__trigger').text()).toContain('EXP-001')
+
+    wrapper.unmount()
+  })
+
   it('opens and closes the popover on trigger and outside click', async () => {
     const wrapper = mountPopover({
       experimentName: 'Dose response run',

package/src/__tests__/composables/experiment-utils.test.ts

@@ -22,9 +22,9 @@ describe('experiment-utils', () => {
     expect(getExperimentStatusVariant(undefined)).toBe('default')
   })
 
-  it('resolves formal experiment codes before generated compact fallbacks', () => {
+  it('resolves only formal experiment codes', () => {
     expect(resolveExperimentCode({ id: 42, experiment_code: 'DR-042' })).toBe('DR-042')
-    expect(resolveExperimentCode({ id: 42 })).toBe('EXP-42')
+    expect(resolveExperimentCode({ id: 42 })).toBeUndefined()
     expect(resolveExperimentCode({ id: null })).toBeUndefined()
   })
 })

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

@@ -121,12 +121,13 @@ describe('useAppExperiment', () => {
     })
 
     it('should update experimentName and experimentId on set', () => {
-      const { set, experimentName, experimentId } = useAppExperiment()
+      const { set, experimentName, experimentCode, experimentId } = useAppExperiment()
       const experiment = makeExperiment({ id: 7, name: 'Alpha Run' })
 
       set(experiment)
 
       expect(experimentName.value).toBe('Alpha Run')
+      expect(experimentCode.value).toBeUndefined()
       expect(experimentId.value).toBe(7)
     })
 

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

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+
+import { useCommandHistory, type CommandHistoryCommand } from '../../composables/useCommandHistory'
+
+describe('useCommandHistory', () => {
+  it('executes commands and tracks undo/redo stacks', () => {
+    const values: string[] = []
+    const command: CommandHistoryCommand = {
+      description: 'Add A',
+      execute: () => { values.push('A') },
+      undo: () => { values.pop() },
+    }
+    const history = useCommandHistory()
+
+    history.execute(command)
+
+    expect(values).toEqual(['A'])
+    expect(history.canUndo.value).toBe(true)
+    expect(history.undoDescription.value).toBe('Add A')
+
+    history.undo()
+    expect(values).toEqual([])
+    expect(history.canRedo.value).toBe(true)
+    expect(history.redoDescription.value).toBe('Add A')
+
+    history.redo()
+    expect(values).toEqual(['A'])
+    expect(history.canUndo.value).toBe(true)
+  })
+
+  it('enforces max depth and supports skipExecute', () => {
+    const values: number[] = []
+    const history = useCommandHistory({ maxDepth: 2 })
+
+    history.execute({ execute: () => { values.push(1) }, undo: () => undefined })
+    history.execute({ execute: () => { values.push(2) }, undo: () => undefined })
+    history.execute({ execute: () => { values.push(3) }, undo: () => undefined })
+    history.execute({ execute: () => { values.push(4) }, undo: () => undefined }, { skipExecute: true })
+
+    expect(values).toEqual([1, 2, 3])
+    expect(history.undoStack.value).toHaveLength(2)
+  })
+})

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

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  detectDelimiter,
+  parseDelimitedText,
+  useFileImport,
+  validateImportFile,
+} from '../../composables/useFileImport'
+
+describe('file import helpers', () => {
+  it('parses quoted CSV fields', () => {
+    const parsed = parseDelimitedText('name,notes\nSample A,"hello, world"\n')
+
+    expect(parsed.delimiter).toBe(',')
+    expect(parsed.columns).toEqual(['name', 'notes'])
+    expect(parsed.rows).toEqual([{ name: 'Sample A', notes: 'hello, world' }])
+  })
+
+  it('detects TSV data', () => {
+    expect(detectDelimiter('name\tvalue\nA\t1')).toBe('\t')
+  })
+
+  it('validates accepted extensions and size', () => {
+    const file = new File(['abc'], 'plate.csv', { type: 'text/csv' })
+
+    expect(() => validateImportFile(file, { accept: '.csv', maxSizeBytes: 10 })).not.toThrow()
+    expect(() => validateImportFile(file, { accept: '.xlsx' })).toThrow('Unsupported file type')
+    expect(() => validateImportFile(file, { maxSizeBytes: 1 })).toThrow('File is too large')
+  })
+
+  it('reads and parses a file through useFileImport', async () => {
+    const file = new File(['name\nA\n'], 'samples.csv', { type: 'text/csv' })
+    const importer = useFileImport({
+      accept: '.csv',
+      parse: text => parseDelimitedText(text),
+    })
+
+    const result = await importer.importFile(file)
+
+    expect(importer.fileName.value).toBe('samples.csv')
+    expect(result.rows).toEqual([{ name: 'A' }])
+    expect(importer.loading.value).toBe(false)
+  })
+})

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

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+
+import { useOptimisticMutation } from '../../composables/useOptimisticMutation'
+
+describe('useOptimisticMutation', () => {
+  it('applies optimistic state and commits server data', async () => {
+    const items = ['A']
+    const mutation = useOptimisticMutation<string, string, string[]>({
+      snapshot: () => [...items],
+      apply: value => { items.push(value) },
+      mutation: async (value: string) => value.toLowerCase(),
+      commit: result => { items[items.length - 1] = result },
+    })
+
+    const result = await mutation.run('B')
+
+    expect(result).toBe('b')
+    expect(items).toEqual(['A', 'b'])
+    expect(mutation.loading.value).toBe(false)
+    expect(mutation.error.value).toBeNull()
+  })
+
+  it('rolls back and rethrows failed mutations', async () => {
+    const items = ['A']
+    const failure = new Error('backend rejected')
+    const mutation = useOptimisticMutation<string, never, string[]>({
+      snapshot: () => [...items],
+      apply: value => { items.push(value) },
+      mutation: async () => { throw failure },
+      rollback: snapshot => {
+        items.splice(0, items.length, ...(snapshot ?? []))
+      },
+    })
+
+    await expect(mutation.run('B')).rejects.toThrow('backend rejected')
+
+    expect(items).toEqual(['A'])
+    expect(mutation.error.value).toBe('backend rejected')
+  })
+})

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

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest'
+
+import { useResourceCrud } from '../../composables/useResourceCrud'
+
+interface Item {
+  id: string
+  name: string
+}
+
+describe('useResourceCrud', () => {
+  it('loads and mutates local resource state through an adapter', async () => {
+    const remote: Item[] = [{ id: 'a', name: 'Alpha' }]
+    const resource = useResourceCrud<Item, Pick<Item, 'name'>, Partial<Item>, string>({
+      adapter: {
+        list: async () => [...remote],
+        create: async payload => {
+          const item = { id: payload.name.toLowerCase(), name: payload.name }
+          remote.push(item)
+          return item
+        },
+        update: async (id, payload) => {
+          const item = { id, name: payload.name ?? 'Untitled' }
+          remote.splice(remote.findIndex(candidate => candidate.id === id), 1, item)
+          return item
+        },
+        remove: async id => {
+          remote.splice(remote.findIndex(candidate => candidate.id === id), 1)
+        },
+      },
+    })
+
+    await resource.load()
+    expect(resource.items.value).toEqual([{ id: 'a', name: 'Alpha' }])
+
+    await resource.createItem({ name: 'Beta' })
+    expect(resource.items.value.map(item => item.name)).toEqual(['Alpha', 'Beta'])
+
+    await resource.updateItem('beta', { name: 'Bravo' })
+    expect(resource.items.value.find(item => item.id === 'beta')?.name).toBe('Bravo')
+
+    await resource.deleteItem('a')
+    expect(resource.items.value.map(item => item.id)).toEqual(['beta'])
+  })
+
+  it('normalizes adapter errors', async () => {
+    const resource = useResourceCrud<Item>({
+      adapter: {
+        list: async () => { throw new Error('nope') },
+      },
+    })
+
+    await expect(resource.load()).rejects.toThrow('nope')
+    expect(resource.error.value).toBe('nope')
+    expect(resource.loading.value).toBe(false)
+  })
+})

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

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  coordinateToWellId,
+  useWellPainting,
+  wellIdToCoordinate,
+  wellIdsInRectangle,
+} from '../../composables/useWellPainting'
+
+describe('useWellPainting', () => {
+  it('converts well coordinates and computes rectangle selections', () => {
+    expect(wellIdToCoordinate('B2')).toEqual({ row: 1, col: 1 })
+    expect(coordinateToWellId({ row: 0, col: 0 })).toBe('A1')
+    expect(wellIdsInRectangle({ row: 0, col: 0 }, { row: 1, col: 1 }, 96)).toEqual([
+      'A1',
+      'A2',
+      'B1',
+      'B2',
+    ])
+  })
+
+  it('emits rectangle selections in select mode', () => {
+    const completed: string[][] = []
+    const painting = useWellPainting({
+      format: 96,
+      initialMode: 'select',
+      onComplete: result => completed.push(result.wellIds),
+    })
+
+    painting.onWellMouseDown('A1')
+    painting.onWellMouseMove('B2')
+    expect(painting.previewWellIds.value).toEqual(['A1', 'A2', 'B1', 'B2'])
+    painting.onWellMouseUp()
+
+    expect(completed).toEqual([['A1', 'A2', 'B1', 'B2']])
+  })
+
+  it('tracks paint trails for non-select modes', () => {
+    const completed: { mode: string; wells: string[] }[] = []
+    const painting = useWellPainting({
+      format: 96,
+      initialMode: 'paint',
+      onComplete: result => completed.push({ mode: result.mode, wells: result.wellIds }),
+    })
+
+    painting.onWellMouseDown('A1')
+    painting.onWellMouseMove('A3')
+    painting.onWellMouseUp()
+
+    expect(completed).toEqual([{ mode: 'paint', wells: ['A1', 'A3'] }])
+  })
+})

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

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  createColumnConditions,
+  createRowConditions,
+  createWellPlateWells,
+} from '../../composables/useWellPlateAdapter'
+
+describe('well plate adapter helpers', () => {
+  it('maps domain entries to WellPlate wells', () => {
+    const wells = createWellPlateWells(
+      [{ id: 'B3', type: 'sample', signal: 42 }],
+      {
+        getWellId: entry => entry.id,
+        getSampleType: entry => entry.type,
+        getValue: entry => entry.signal,
+        getMetadata: () => ({ source: 'analysis' }),
+      },
+    )
+
+    expect(wells.B3).toEqual({
+      id: 'B3',
+      row: 1,
+      col: 2,
+      state: 'filled',
+      sampleType: 'sample',
+      value: 42,
+      metadata: { source: 'analysis' },
+    })
+  })
+
+  it('builds row and column condition spans from axis entries', () => {
+    const entry = {
+      label: 'Drug A',
+      color: '#123456',
+      start: 2,
+      unit: 'uM',
+      concentrations: [{ value: 1, replicates: 2 }, { value: 10 }],
+    }
+
+    expect(createColumnConditions([entry])[0]).toMatchObject({
+      cols: [2, 3, 4],
+      concentrations: [1, 1, 10],
+    })
+    expect(createRowConditions([{ ...entry, start: 'B' }])[0]).toMatchObject({
+      rows: ['B', 'C', 'D'],
+      concentrations: [1, 1, 10],
+    })
+  })
+})

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

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest'
+
+import { runWellPlateValidation, useWellPlateValidation } from '../../composables/useWellPlateValidation'
+
+describe('well plate validation helpers', () => {
+  it('runs rule-driven validation', () => {
+    const warnings = runWellPlateValidation(
+      { assigned: 0 },
+      [
+        {
+          type: 'empty',
+          severity: 'warning',
+          validate: context => context.assigned === 0 && 'No wells assigned',
+        },
+      ],
+    )
+
+    expect(warnings).toEqual([
+      { type: 'empty', severity: 'warning', message: 'No wells assigned' },
+    ])
+  })
+
+  it('derives blocking state and counts', () => {
+    const validation = useWellPlateValidation({
+      context: { overlaps: ['A1'] },
+      rules: [
+        {
+          type: 'overlap',
+          severity: 'error',
+          validate: context => ({
+            message: `${context.overlaps.length} overlap`,
+            affectedWells: context.overlaps,
+          }),
+        },
+      ],
+    })
+
+    expect(validation.hasBlockingIssues.value).toBe(true)
+    expect(validation.errorCount.value).toBe(1)
+    expect(validation.warningCount.value).toBe(1)
+  })
+})

package/src/components/ExperimentPopover.story.vue

@@ -48,8 +48,8 @@ const STATUSES = ['planned', 'ongoing', 'completed', 'ready_to_extract', 'proces
       </template>
 
       <template #controls="{ state }">
-        <HstText v-model="state.experimentCode" title="Experiment code (shown in trigger)" />
-        <HstText v-model="state.experimentName" title="Experiment name (shown in panel)" />
+        <HstText v-model="state.experimentCode" title="Experiment code (shown in panel)" />
+        <HstText v-model="state.experimentName" title="Experiment name (shown in trigger)" />
         <HstSelect
           v-model="state.experimentStatus"
           title="Status"
@@ -93,8 +93,7 @@ const STATUSES = ['planned', 'ongoing', 'completed', 'ready_to_extract', 'proces
         />
       </div>
       <div style="text-align: center; font-size: 0.75rem; color: var(--text-muted); padding: 0 1rem 1rem;">
-        Trigger shows only the code (<code>EXP-042</code>). Click to open the panel — full name, status, and actions
-        live inside.
+        Trigger shows the name. Click to open the panel — formal code, status, and actions live inside.
       </div>
     </Variant>
 

package/src/components/ExperimentPopover.vue

@@ -92,8 +92,8 @@ onUnmounted(() => {
         { 'mint-experiment-popover__split--with-save': showSave && experimentName },
       ]"
     >
-      <!-- Left: experiment trigger (opens popover) — shows only the code for
-           maximum topbar compactness; full name + status live in the panel. -->
+      <!-- Left: experiment trigger (opens popover). Prefer the human-readable
+           name; the formal code, when present, stays in the detail panel. -->
       <button
         type="button"
         :class="[
@@ -101,7 +101,7 @@ onUnmounted(() => {
           { 'mint-experiment-popover__trigger--active': isOpen },
           { 'mint-experiment-popover__trigger--empty': !experimentCode && !experimentName },
         ]"
-        :title="experimentName || undefined"
+        :title="experimentName || experimentCode || undefined"
         @click.stop="toggle"
       >
         <!-- Flask icon -->
@@ -113,9 +113,9 @@ onUnmounted(() => {
             d="M19.428 15.428a2 2 0 00-1.022-.547l-2.387-.477a6 6 0 00-3.86.517l-.318.158a6 6 0 01-3.86.517L6.05 15.21a2 2 0 00-1.806.547M8 4h8l-1 1v5.172a2 2 0 00.586 1.414l5 5c1.26 1.26.367 3.414-1.415 3.414H4.828c-1.782 0-2.674-2.154-1.414-3.414l5-5A2 2 0 009 10.172V5L8 4z"
           />
         </svg>
-        <!-- Code preferred, name as fallback, "No experiment" as empty state -->
-        <span v-if="experimentCode" class="mint-experiment-popover__trigger-code">{{ experimentCode }}</span>
-        <span v-else-if="experimentName" class="mint-experiment-popover__trigger-text">{{ experimentName }}</span>
+        <!-- Name preferred, code as fallback, "No experiment" as empty state -->
+        <span v-if="experimentName" class="mint-experiment-popover__trigger-text">{{ experimentName }}</span>
+        <span v-else-if="experimentCode" class="mint-experiment-popover__trigger-code">{{ experimentCode }}</span>
         <span v-else class="mint-experiment-popover__trigger-text">No experiment</span>
         <!-- Chevron -->
         <svg class="mint-experiment-popover__trigger-chevron" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">

package/src/components/PluginWorkspaceView.vue

@@ -37,10 +37,10 @@ const props = withDefaults(defineProps<PluginWorkspaceViewProps>(), {
   pluginSwitcher: undefined,
   pillNav: undefined,
   currentPillId: undefined,
-  showThemeToggle: false,
-  showSettings: false,
+  showThemeToggle: true,
+  showSettings: true,
   settingsConfig: undefined,
-  showStandaloneLabel: true,
+  showStandaloneLabel: false,
   standaloneLabel: 'Standalone',
   accountMenu: undefined,
   showNotifications: false,

package/src/composables/experiment-utils.ts

@@ -64,7 +64,7 @@ export function getExperimentStatusVariant(status?: ExperimentStatus | string |
 
 export function resolveExperimentCode(experiment: ExperimentCodeSource): string | undefined {
   if (experiment.experiment_code) return experiment.experiment_code
-  return experiment.id != null ? `EXP-${experiment.id}` : undefined
+  return undefined
 }
 
 export const DATE_PRESET_OPTIONS: SelectOption<string>[] = [

package/src/composables/index.ts

@@ -191,6 +191,41 @@ export {
   type RequestSyncSuccessKind,
   type UseRequestSyncStateReturn,
 } from './useRequestSyncState'
+export {
+  useCommandHistory,
+  type CommandHistoryCommand,
+  type CommandHistoryExecuteOptions,
+  type CommandHistoryResult,
+  type UseCommandHistoryOptions,
+  type UseCommandHistoryReturn,
+} from './useCommandHistory'
+export {
+  useOptimisticMutation,
+  type OptimisticMutationContext,
+  type UseOptimisticMutationOptions,
+  type UseOptimisticMutationReturn,
+} from './useOptimisticMutation'
+export {
+  createPluginResourceClient,
+  useResourceCrud,
+  type PluginResourceClientOptions,
+  type ResourceCrudAdapter,
+  type ResourceKey,
+  type UseResourceCrudOptions,
+  type UseResourceCrudReturn,
+} from './useResourceCrud'
+export {
+  detectDelimiter,
+  parseDelimitedText,
+  readFileAsText,
+  useFileImport,
+  validateImportFile,
+  type DelimitedTable,
+  type FileImportOptions,
+  type FileImportValidationOptions,
+  type ParseDelimitedTextOptions,
+  type UseFileImportReturn,
+} from './useFileImport'
 export {
   useSelectionLimit,
   type SelectionLimitSource,
@@ -248,6 +283,38 @@ export {
   type UseTextSearchOptions,
   type UseTextSearchReturn,
 } from './useTextSearch'
+export {
+  coordinateToWellId,
+  useWellPainting,
+  wellIdToCoordinate,
+  wellIdsInRectangle,
+  type UseWellPaintingOptions,
+  type UseWellPaintingReturn,
+  type WellCoordinate,
+  type WellPaintResult,
+  type WellPlateSource,
+} from './useWellPainting'
+export {
+  createColumnConditions,
+  createRowConditions,
+  createWellPlateWells,
+  useWellPlateAdapter,
+  type AxisConditionEntry,
+  type UseWellPlateAdapterReturn,
+  type WellPlateAdapterOptions,
+  type WellPlateAdapterSource,
+  type WellPlateEntry,
+} from './useWellPlateAdapter'
+export {
+  runWellPlateValidation,
+  useWellPlateValidation,
+  type UseWellPlateValidationOptions,
+  type UseWellPlateValidationReturn,
+  type WellPlateValidationRule,
+  type WellPlateValidationSeverity,
+  type WellPlateValidationSource,
+  type WellPlateValidationWarning,
+} from './useWellPlateValidation'
 export {
   controlsToFormSchema,
   controlsToSectionFormSchema,

package/src/composables/useCommandHistory.ts

@@ -0,0 +1,113 @@
+import { computed, ref, type ComputedRef, type Ref } from 'vue'
+
+export type CommandHistoryResult = void | Promise<void>
+
+export interface CommandHistoryCommand {
+  execute: () => CommandHistoryResult
+  undo: () => CommandHistoryResult
+  redo?: () => CommandHistoryResult
+  description?: string
+}
+
+export interface CommandHistoryExecuteOptions {
+  skipExecute?: boolean
+}
+
+export interface UseCommandHistoryOptions {
+  maxDepth?: number
+}
+
+export interface UseCommandHistoryReturn<TCommand extends CommandHistoryCommand = CommandHistoryCommand> {
+  undoStack: Ref<TCommand[]>
+  redoStack: Ref<TCommand[]>
+  canUndo: ComputedRef<boolean>
+  canRedo: ComputedRef<boolean>
+  undoDescription: ComputedRef<string>
+  redoDescription: ComputedRef<string>
+  execute: (command: TCommand, options?: CommandHistoryExecuteOptions) => CommandHistoryResult
+  push: (command: TCommand) => void
+  undo: () => CommandHistoryResult
+  redo: () => CommandHistoryResult
+  clear: () => void
+}
+
+/** Generic command-stack state for plugin editors with undo/redo controls. */
+export function useCommandHistory<TCommand extends CommandHistoryCommand = CommandHistoryCommand>(
+  options: UseCommandHistoryOptions = {},
+): UseCommandHistoryReturn<TCommand> {
+  const maxDepth = Math.max(1, options.maxDepth ?? 50)
+  const undoStack = ref<TCommand[]>([]) as Ref<TCommand[]>
+  const redoStack = ref<TCommand[]>([]) as Ref<TCommand[]>
+
+  const canUndo = computed(() => undoStack.value.length > 0)
+  const canRedo = computed(() => redoStack.value.length > 0)
+  const undoDescription = computed(() => undoStack.value[undoStack.value.length - 1]?.description ?? '')
+  const redoDescription = computed(() => redoStack.value[redoStack.value.length - 1]?.description ?? '')
+
+  function push(command: TCommand): void {
+    undoStack.value = [...undoStack.value.slice(-(maxDepth - 1)), command]
+    redoStack.value = []
+  }
+
+  function execute(
+    command: TCommand,
+    executeOptions: CommandHistoryExecuteOptions = {},
+  ): CommandHistoryResult {
+    if (executeOptions.skipExecute) {
+      push(command)
+      return
+    }
+
+    return afterMaybePromise(command.execute(), () => push(command))
+  }
+
+  function undo(): CommandHistoryResult {
+    const command = undoStack.value[undoStack.value.length - 1]
+    if (!command) return
+
+    return afterMaybePromise(command.undo(), () => {
+      undoStack.value = undoStack.value.slice(0, -1)
+      redoStack.value = [...redoStack.value, command]
+    })
+  }
+
+  function redo(): CommandHistoryResult {
+    const command = redoStack.value[redoStack.value.length - 1]
+    if (!command) return
+
+    return afterMaybePromise((command.redo ?? command.execute)(), () => {
+      redoStack.value = redoStack.value.slice(0, -1)
+      undoStack.value = [...undoStack.value.slice(-(maxDepth - 1)), command]
+    })
+  }
+
+  function clear(): void {
+    undoStack.value = []
+    redoStack.value = []
+  }
+
+  return {
+    undoStack,
+    redoStack,
+    canUndo,
+    canRedo,
+    undoDescription,
+    redoDescription,
+    execute,
+    push,
+    undo,
+    redo,
+    clear,
+  }
+}
+
+function afterMaybePromise(result: CommandHistoryResult, callback: () => void): CommandHistoryResult {
+  if (isPromiseLike(result)) {
+    return result.then(callback)
+  }
+  callback()
+}
+
+function isPromiseLike(value: unknown): value is Promise<void> {
+  return !!value && typeof (value as { then?: unknown }).then === 'function'
+}