@morscherlab/mint-sdk 1.2.0-beta.2 → 1.2.0-beta.3

package/src/composables/useReagentSeries.ts

@@ -1,91 +0,0 @@
-/**
- * Composable for generating dilution series used in plate-based experiments.
- * Provides geometric series generation from presets (2x, 3x, ½ log, 10x)
- * and utility functions for series manipulation.
- */
-
-export interface LevelEntry {
-  value: number
-  replicates: number
-}
-
-export interface DilutionPreset {
-  label: string
-  factor: number | 'half-log'
-}
-
-export const DEFAULT_PRESETS: DilutionPreset[] = [
-  { label: '2x', factor: 2 },
-  { label: '3x', factor: 3 },
-  { label: '½ log', factor: 'half-log' },
-  { label: '10x', factor: 10 },
-]
-
-export const DEFAULT_UNITS = ['µM', 'nM', 'mM', 'pM']
-
-function resolveFactor(factor: number | 'half-log'): number {
-  return factor === 'half-log' ? Math.sqrt(10) : factor
-}
-
-function roundToSignificant(value: number, digits: number = 4): number {
-  if (value === 0) return 0
-  const magnitude = Math.floor(Math.log10(Math.abs(value))) + 1
-  const factor = Math.pow(10, digits - magnitude)
-  return Math.round(value * factor) / factor
-}
-
-export function generateDilutionSeries(
-  startConcentration: number,
-  count: number,
-  factor: number | 'half-log',
-  defaultReplicates: number = 1,
-): LevelEntry[] {
-  if (count < 1 || startConcentration <= 0) return []
-
-  const divisor = resolveFactor(factor)
-  const levels: LevelEntry[] = []
-
-  for (let i = 0; i < count; i++) {
-    levels.push({
-      value: roundToSignificant(startConcentration / Math.pow(divisor, i)),
-      replicates: defaultReplicates,
-    })
-  }
-
-  return levels
-}
-
-export interface UseReagentSeriesReturn {
-  generateSeries: (
-    start: number,
-    count: number,
-    factor: number | 'half-log',
-    defaultReplicates?: number,
-  ) => LevelEntry[]
-  sortLevels: (levels: LevelEntry[], order?: 'asc' | 'desc') => LevelEntry[]
-  totalPositions: (levels: LevelEntry[]) => number
-}
-
-/** Generates and sorts geometric dilution series (2x, 3x, ½ log, 10x) for plate-based experiments. */
-export function useReagentSeries(): UseReagentSeriesReturn {
-  function generateSeries(
-    start: number,
-    count: number,
-    factor: number | 'half-log',
-    defaultReplicates: number = 1,
-  ): LevelEntry[] {
-    return generateDilutionSeries(start, count, factor, defaultReplicates)
-  }
-
-  function sortLevels(levels: LevelEntry[], order: 'asc' | 'desc' = 'desc'): LevelEntry[] {
-    return [...levels].sort((a, b) =>
-      order === 'desc' ? b.value - a.value : a.value - b.value,
-    )
-  }
-
-  function totalPositions(levels: LevelEntry[]): number {
-    return levels.reduce((sum, l) => sum + l.replicates, 0)
-  }
-
-  return { generateSeries, sortLevels, totalPositions }
-}

package/src/composables/useRequestSyncState.ts

@@ -1,126 +0,0 @@
-import { ref, type Ref } from 'vue'
-
-export type RequestSyncSuccessKind = 'load' | 'save' | 'run'
-
-export interface RequestSyncRunOptions {
-  success?: RequestSyncSuccessKind
-  errorMessage?: string
-}
-
-export interface UseRequestSyncStateReturn {
-  /** Whether a request is in progress. */
-  loading: Ref<boolean>
-  /** Message from the last failed request, or null. */
-  error: Ref<string | null>
-  /** Timestamp of the last successful load operation, or null. */
-  lastLoadedAt: Ref<Date | null>
-  /** Timestamp of the last successful save operation, or null. */
-  lastSavedAt: Ref<Date | null>
-  /** Timestamp of the last successful run operation, or null. */
-  lastRunAt: Ref<Date | null>
-  /** Clear the current error without changing loading or timestamps. */
-  clearError: () => void
-  /** Convert thrown values into a developer-facing error message. */
-  readErrorMessage: (value: unknown, fallback?: string) => string
-  /** Store and return a normalized error message. */
-  setError: (value: unknown, fallback?: string) => string
-  /** Mark the resource as successfully loaded. */
-  markLoaded: (date?: Date) => void
-  /** Mark the resource as successfully saved. */
-  markSaved: (date?: Date) => void
-  /** Mark the operation as successfully run. */
-  markRun: (date?: Date) => void
-  /** Run a request with shared loading/error handling and optional sync marking. */
-  run: <T>(operation: () => Promise<T>, options?: RequestSyncRunOptions) => Promise<T>
-}
-
-/** Shared loading/error/timestamp state for generated plugin request helpers. */
-export function useRequestSyncState(
-  defaultErrorMessage = 'Request failed.',
-): UseRequestSyncStateReturn {
-  const loading = ref(false)
-  const error = ref<string | null>(null)
-  const lastLoadedAt = ref<Date | null>(null)
-  const lastSavedAt = ref<Date | null>(null)
-  const lastRunAt = ref<Date | null>(null)
-
-  function clearError(): void {
-    error.value = null
-  }
-
-  function readErrorMessage(value: unknown, fallback = defaultErrorMessage): string {
-    if (value instanceof Error && value.message) {
-      return value.message
-    }
-    if (typeof value === 'string' && value.trim()) {
-      return value
-    }
-    if (
-      typeof value === 'object'
-      && value !== null
-      && 'message' in value
-      && typeof (value as { message?: unknown }).message === 'string'
-      && (value as { message: string }).message
-    ) {
-      return (value as { message: string }).message
-    }
-    return fallback
-  }
-
-  function setError(value: unknown, fallback?: string): string {
-    const message = readErrorMessage(value, fallback)
-    error.value = message
-    return message
-  }
-
-  function markLoaded(date = new Date()): void {
-    lastLoadedAt.value = date
-  }
-
-  function markSaved(date = new Date()): void {
-    lastSavedAt.value = date
-  }
-
-  function markRun(date = new Date()): void {
-    lastRunAt.value = date
-  }
-
-  async function run<T>(
-    operation: () => Promise<T>,
-    options: RequestSyncRunOptions = {},
-  ): Promise<T> {
-    loading.value = true
-    clearError()
-    try {
-      const response = await operation()
-      if (options.success === 'load') {
-        markLoaded()
-      } else if (options.success === 'save') {
-        markSaved()
-      } else if (options.success === 'run') {
-        markRun()
-      }
-      return response
-    } catch (err) {
-      setError(err, options.errorMessage)
-      throw err
-    } finally {
-      loading.value = false
-    }
-  }
-
-  return {
-    loading,
-    error,
-    lastLoadedAt,
-    lastSavedAt,
-    lastRunAt,
-    clearError,
-    readErrorMessage,
-    setError,
-    markLoaded,
-    markSaved,
-    markRun,
-    run,
-  }
-}

package/src/composables/useResourceCrud.ts

@@ -1,245 +0,0 @@
-import { computed, ref, shallowRef, type ComputedRef, type Ref, type ShallowRef } from 'vue'
-
-export type ResourceKey = string | number
-
-export interface ResourceCrudAdapter<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
-  list: () => Promise<TItem[]>
-  create?: (payload: TCreate) => Promise<TItem>
-  update?: (key: TKey, payload: TUpdate) => Promise<TItem>
-  remove?: (key: TKey) => Promise<void>
-}
-
-export interface UseResourceCrudOptions<
-  TItem,
-  TCreate = Partial<TItem>,
-  TUpdate = Partial<TItem>,
-  TKey extends ResourceKey = ResourceKey,
-> {
-  adapter: ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey>
-  initialItems?: readonly TItem[]
-  getKey?: (item: TItem) => TKey
-  readErrorMessage?: (error: unknown) => string
-}
-
-export interface UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey extends ResourceKey> {
-  items: Ref<TItem[]>
-  loading: ShallowRef<boolean>
-  saving: ShallowRef<boolean>
-  deleting: ShallowRef<boolean>
-  error: Ref<string | null>
-  isBusy: ComputedRef<boolean>
-  load: () => Promise<TItem[]>
-  createItem: (payload: TCreate) => Promise<TItem>
-  updateItem: (key: TKey, payload: TUpdate) => Promise<TItem>
-  deleteItem: (keyOrItem: TKey | TItem) => Promise<void>
-  setItems: (items: readonly TItem[]) => void
-  upsertLocal: (item: TItem) => void
-  removeLocal: (keyOrItem: TKey | TItem) => void
-  clearError: () => void
-}
-
-/** Common list/create/update/delete state wrapper for generated plugin clients. */
-export function useResourceCrud<
-  TItem,
-  TCreate = Partial<TItem>,
-  TUpdate = Partial<TItem>,
-  TKey extends ResourceKey = ResourceKey,
->(
-  options: UseResourceCrudOptions<TItem, TCreate, TUpdate, TKey>,
-): UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey> {
-  const items = ref<TItem[]>([...(options.initialItems ?? [])]) as Ref<TItem[]>
-  const loading = shallowRef(false)
-  const saving = shallowRef(false)
-  const deleting = shallowRef(false)
-  const error = ref<string | null>(null)
-  const isBusy = computed(() => loading.value || saving.value || deleting.value)
-
-  const readMessage = options.readErrorMessage ?? readErrorMessage
-  const getKey = options.getKey ?? defaultGetKey<TKey, TItem>
-
-  function clearError(): void {
-    error.value = null
-  }
-
-  function setError(err: unknown): void {
-    error.value = readMessage(err)
-  }
-
-  function setItems(nextItems: readonly TItem[]): void {
-    items.value = [...nextItems]
-  }
-
-  function upsertLocal(item: TItem): void {
-    const key = getKey(item)
-    const index = items.value.findIndex(existing => getKey(existing) === key)
-    if (index === -1) {
-      items.value = [...items.value, item]
-      return
-    }
-    items.value = [
-      ...items.value.slice(0, index),
-      item,
-      ...items.value.slice(index + 1),
-    ]
-  }
-
-  function removeLocal(keyOrItem: TKey | TItem): void {
-    const key = resolveKey(keyOrItem, getKey)
-    items.value = items.value.filter(item => getKey(item) !== key)
-  }
-
-  async function load(): Promise<TItem[]> {
-    loading.value = true
-    clearError()
-    try {
-      const result = await options.adapter.list()
-      setItems(result)
-      return result
-    } catch (err) {
-      setError(err)
-      throw err
-    } finally {
-      loading.value = false
-    }
-  }
-
-  async function createItem(payload: TCreate): Promise<TItem> {
-    if (!options.adapter.create) {
-      throw new Error('[MINT SDK] Resource adapter does not implement create().')
-    }
-    saving.value = true
-    clearError()
-    try {
-      const result = await options.adapter.create(payload)
-      upsertLocal(result)
-      return result
-    } catch (err) {
-      setError(err)
-      throw err
-    } finally {
-      saving.value = false
-    }
-  }
-
-  async function updateItem(key: TKey, payload: TUpdate): Promise<TItem> {
-    if (!options.adapter.update) {
-      throw new Error('[MINT SDK] Resource adapter does not implement update().')
-    }
-    saving.value = true
-    clearError()
-    try {
-      const result = await options.adapter.update(key, payload)
-      upsertLocal(result)
-      return result
-    } catch (err) {
-      setError(err)
-      throw err
-    } finally {
-      saving.value = false
-    }
-  }
-
-  async function deleteItem(keyOrItem: TKey | TItem): Promise<void> {
-    if (!options.adapter.remove) {
-      throw new Error('[MINT SDK] Resource adapter does not implement remove().')
-    }
-    const key = resolveKey(keyOrItem, getKey)
-    deleting.value = true
-    clearError()
-    try {
-      await options.adapter.remove(key)
-      removeLocal(key)
-    } catch (err) {
-      setError(err)
-      throw err
-    } finally {
-      deleting.value = false
-    }
-  }
-
-  return {
-    items,
-    loading,
-    saving,
-    deleting,
-    error,
-    isBusy,
-    load,
-    createItem,
-    updateItem,
-    deleteItem,
-    setItems,
-    upsertLocal,
-    removeLocal,
-    clearError,
-  }
-}
-
-export interface PluginResourceClientOptions<
-  TClient,
-  TItem,
-  TCreate = Partial<TItem>,
-  TUpdate = Partial<TItem>,
-  TKey extends ResourceKey = ResourceKey,
-> {
-  client: TClient
-  list: (client: TClient) => Promise<TItem[]>
-  create?: (client: TClient, payload: TCreate) => Promise<TItem>
-  update?: (client: TClient, key: TKey, payload: TUpdate) => Promise<TItem>
-  remove?: (client: TClient, key: TKey) => Promise<void>
-}
-
-export function createPluginResourceClient<
-  TClient,
-  TItem,
-  TCreate = Partial<TItem>,
-  TUpdate = Partial<TItem>,
-  TKey extends ResourceKey = ResourceKey,
->(
-  options: PluginResourceClientOptions<TClient, TItem, TCreate, TUpdate, TKey>,
-): ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey> {
-  return {
-    list: () => options.list(options.client),
-    create: options.create
-      ? payload => options.create!(options.client, payload)
-      : undefined,
-    update: options.update
-      ? (key, payload) => options.update!(options.client, key, payload)
-      : undefined,
-    remove: options.remove
-      ? key => options.remove!(options.client, key)
-      : undefined,
-  }
-}
-
-function defaultGetKey<TKey extends ResourceKey, TItem>(item: TItem): TKey {
-  if (item && typeof item === 'object' && 'id' in item) {
-    return (item as { id: ResourceKey }).id as TKey
-  }
-  throw new Error('[MINT SDK] Resource items need an id field or a getKey option.')
-}
-
-function resolveKey<TItem, TKey extends ResourceKey>(
-  keyOrItem: TKey | TItem,
-  getKey: (item: TItem) => TKey,
-): TKey {
-  if (typeof keyOrItem === 'string' || typeof keyOrItem === 'number') {
-    return keyOrItem as TKey
-  }
-  return getKey(keyOrItem as TItem)
-}
-
-function readErrorMessage(value: unknown): string {
-  if (value instanceof Error && value.message) return value.message
-  if (typeof value === 'string' && value.trim()) return value
-  if (
-    typeof value === 'object'
-    && value !== null
-    && 'message' in value
-    && typeof (value as { message?: unknown }).message === 'string'
-    && (value as { message: string }).message.trim()
-  ) {
-    return (value as { message: string }).message
-  }
-  return 'Request failed.'
-}

package/src/composables/useRuntimeAlignment.ts

@@ -1,184 +0,0 @@
-import {
-  computed,
-  onMounted,
-  onScopeDispose,
-  readonly,
-  ref,
-  toValue,
-  type MaybeRefOrGetter,
-  type Ref,
-} from 'vue'
-
-const RUNTIME_RELOAD_KEY_PREFIX = 'mint:runtime-reload:'
-const REVISION_QUERY_KEY = '__mint_revision'
-const inMemoryReloadGuards = new Set<string>()
-
-interface RuntimeStorage {
-  getItem(key: string): string | null
-  setItem(key: string, value: string): void
-}
-
-interface RuntimeEventTarget {
-  addEventListener(type: 'vite:preloadError', listener: EventListener): void
-  removeEventListener(type: 'vite:preloadError', listener: EventListener): void
-}
-
-interface RuntimeVisibilityTarget {
-  addEventListener(type: 'visibilitychange', listener: EventListener): void
-  removeEventListener(type: 'visibilitychange', listener: EventListener): void
-}
-
-export interface RuntimeRevisionResponse {
-  frontend_revision?: string | null
-}
-
-export interface RuntimeAlignmentOptions {
-  /** Revision embedded in the HTML that booted this tab. */
-  currentRevision?: MaybeRefOrGetter<string | null | undefined>
-  /** Browser visibility seam. */
-  visibility?: () => DocumentVisibilityState
-  /** Current location seam. */
-  currentUrl?: () => string
-  /** Location replacement seam. */
-  replace?: (url: string) => void
-  /** Per-tab recovery guard storage. */
-  storage?: RuntimeStorage | null
-  /** Vite preload error source. */
-  eventTarget?: RuntimeEventTarget | null
-  /** Browser visibility event source. */
-  visibilityTarget?: RuntimeVisibilityTarget | null
-}
-
-export interface UseRuntimeAlignmentReturn {
-  updateAvailable: Readonly<Ref<boolean>>
-  nextRevision: Readonly<Ref<string | null>>
-  observe: (response: RuntimeRevisionResponse | unknown) => void
-  reload: () => void
-  recoverMissingChunk: () => void
-}
-
-function browserStorage(): RuntimeStorage | null {
-  try {
-    return globalThis.sessionStorage ?? null
-  } catch {
-    return null
-  }
-}
-
-function browserEventTarget(): RuntimeEventTarget | null {
-  return typeof globalThis.window === 'undefined' ? null : globalThis.window
-}
-
-function browserVisibilityTarget(): RuntimeVisibilityTarget | null {
-  return typeof globalThis.document === 'undefined' ? null : globalThis.document
-}
-
-function responseRevision(response: RuntimeRevisionResponse | unknown): string | null {
-  if (!response || typeof response !== 'object') return null
-  const value = (response as RuntimeRevisionResponse).frontend_revision
-  return typeof value === 'string' && value ? value : null
-}
-
-/** Keep a loaded MINT frontend aligned with the backend revision serving its scope. */
-export function useRuntimeAlignment(
-  options: RuntimeAlignmentOptions = {},
-): UseRuntimeAlignmentReturn {
-  const storage = options.storage === undefined ? browserStorage() : options.storage
-  const eventTarget = options.eventTarget === undefined ? browserEventTarget() : options.eventTarget
-  const visibilityTarget = options.visibilityTarget === undefined
-    ? browserVisibilityTarget()
-    : options.visibilityTarget
-  const visibility = options.visibility ?? (() => globalThis.document?.visibilityState ?? 'visible')
-  const currentUrl = options.currentUrl ?? (() => globalThis.location?.href ?? '/')
-  const replace = options.replace ?? ((url: string) => globalThis.location?.replace(url))
-  const initialRevision = computed(() => toValue(options.currentRevision) ?? null)
-  const baselineRevision = ref<string | null>(initialRevision.value)
-  const nextRevision = ref<string | null>(null)
-  const updateAvailable = computed(() => nextRevision.value !== null)
-  let wasHidden = false
-
-  function reloadTo(revision: string, guardKind: 'revision' | 'chunk'): void {
-    const guardKey = `${RUNTIME_RELOAD_KEY_PREFIX}${guardKind}:${revision}`
-    const url = new URL(currentUrl(), globalThis.location?.origin ?? 'http://localhost')
-    if (url.searchParams.get(REVISION_QUERY_KEY) === revision) return
-    if (inMemoryReloadGuards.has(guardKey)) return
-    try {
-      if (storage?.getItem(guardKey)) {
-        inMemoryReloadGuards.add(guardKey)
-        return
-      }
-      storage?.setItem(guardKey, '1')
-    } catch {
-      // A blocked sessionStorage must not block recovery.
-    }
-    inMemoryReloadGuards.add(guardKey)
-    url.searchParams.set(REVISION_QUERY_KEY, revision)
-    replace(url.toString())
-  }
-
-  function observe(response: RuntimeRevisionResponse | unknown): void {
-    const revision = responseRevision(response)
-    if (!revision) return
-    const current = initialRevision.value ?? baselineRevision.value
-    if (!current) {
-      baselineRevision.value = revision
-      return
-    }
-    if (revision === current) {
-      wasHidden = false
-      return
-    }
-    if (wasHidden || visibility() === 'hidden') {
-      wasHidden = false
-      reloadTo(revision, 'revision')
-      return
-    }
-    nextRevision.value = revision
-  }
-
-  function reload(): void {
-    if (nextRevision.value) reloadTo(nextRevision.value, 'revision')
-  }
-
-  function recoverMissingChunk(): void {
-    reloadTo(baselineRevision.value ?? initialRevision.value ?? 'unknown', 'chunk')
-  }
-
-  function handlePreloadError(event: Event): void {
-    event.preventDefault()
-    recoverMissingChunk()
-  }
-
-  function handleVisibilityChange(): void {
-    if (visibility() === 'hidden') wasHidden = true
-  }
-
-  onMounted(() => {
-    eventTarget?.addEventListener('vite:preloadError', handlePreloadError)
-    visibilityTarget?.addEventListener('visibilitychange', handleVisibilityChange)
-  })
-  onScopeDispose(() => {
-    eventTarget?.removeEventListener('vite:preloadError', handlePreloadError)
-    visibilityTarget?.removeEventListener('visibilitychange', handleVisibilityChange)
-  })
-
-  return {
-    updateAvailable: readonly(updateAvailable),
-    nextRevision: readonly(nextRevision),
-    observe,
-    reload,
-    recoverMissingChunk,
-  }
-}
-
-/** Read the revision injected into the HTML that started this browser tab. */
-export function getInjectedFrontendRevision(): string | null {
-  if (typeof globalThis.window === 'undefined') return null
-  const runtimeWindow = globalThis.window as typeof globalThis.window & {
-    __MINT_FRONTEND_REVISION__?: string
-    __MINT_PLATFORM__?: { plugin?: { frontend_revision?: string } }
-  }
-  return runtimeWindow.__MINT_PLATFORM__?.plugin?.frontend_revision
-    ?? runtimeWindow.__MINT_FRONTEND_REVISION__
-    ?? null
-}