nuxt-cornerstone 1.0.0

package/dist/runtime/composables/useImagePrefetch.d.ts

@@ -0,0 +1,78 @@
+export interface PrefetchOptions {
+    /**
+     * Images decoded at once. Default: `4`.
+     *
+     * Decoding happens in the web worker pool, so this is really a ceiling on
+     * how much of that pool the prefetch is allowed to hold. Too high and the
+     * slice the user just scrolled to queues behind twenty they have not asked
+     * for yet.
+     */
+    concurrency?: number;
+    /**
+     * Index to start from. Default: `0`.
+     *
+     * Pass the slice that is on screen: with the default `order`, loading fans
+     * out from there, so scrolling either way finds images already decoded.
+     */
+    from?: number;
+    /**
+     * - `'outward'` (default) alternates either side of {@link PrefetchOptions.from}.
+     * - `'forward'` runs from `from` to the end of the stack, which is the order
+     *   cine playback consumes them in.
+     */
+    order?: 'outward' | 'forward';
+    /** Passed to Cornerstone's loader. Lower runs sooner. Default: `0`. */
+    priority?: number;
+    /**
+     * Passed to Cornerstone's loader, as `Enums.RequestType`. Default:
+     * `'prefetch'`, which is the class the request pool serves after anything
+     * the user is waiting on.
+     */
+    requestType?: string;
+    /** Called after each image settles. */
+    onProgress?: (progress: PrefetchProgress) => void;
+}
+export interface PrefetchProgress {
+    /** Images in the cache — decoded by this run, or already there when it began. */
+    loaded: number;
+    /** Images that could not be decoded. */
+    failed: number;
+    /** Images this run was asked for. */
+    total: number;
+}
+export interface PrefetchResult extends PrefetchProgress {
+    /** True when {@link useImagePrefetch.cancel} or a newer run stopped this one. */
+    cancelled: boolean;
+    /**
+     * True when the image cache ran out of room and the rest of the stack was
+     * left alone. What was decoded stays decoded; raise the ceiling with
+     * `cache.setMaxCacheSize()` if a whole study has to fit.
+     */
+    cacheFull: boolean;
+}
+/**
+ * Decode a stack into Cornerstone's image cache ahead of time.
+ *
+ * A stack viewport loads each slice the moment it is shown, which is right for
+ * scrolling and wrong for anything that moves on its own: at 15 frames a
+ * second the decode never keeps up and playback stutters through whatever
+ * happens to be cached. Preparing the stack first turns every later frame
+ * change into a cache hit.
+ *
+ * State is per call, so a component that prepares two stacks tracks them with
+ * two instances. One instance runs one prepare at a time: a second call cancels
+ * the first, which is what you want when the user switches series mid-load.
+ */
+export declare function useImagePrefetch(): {
+    loaded: import("vue").Ref<number, number>;
+    failed: import("vue").Ref<number, number>;
+    total: import("vue").Ref<number, number>;
+    pending: import("vue").Ref<boolean, boolean>;
+    progress: import("vue").ComputedRef<number>;
+    complete: import("vue").ComputedRef<boolean>;
+    cacheFull: import("vue").Ref<boolean, boolean>;
+    prepare: (imageIds: string[], options?: PrefetchOptions) => Promise<PrefetchResult>;
+    cancel: () => void;
+    reset: () => void;
+    isPrepared: (imageId: string) => boolean;
+};

package/dist/runtime/composables/useImagePrefetch.js

@@ -0,0 +1,119 @@
+import { computed, getCurrentScope, onScopeDispose, ref } from "vue";
+import { ensureCornerstone, getLoadedCornerstone } from "../cornerstone.js";
+const DEFAULT_CONCURRENCY = 4;
+export function useImagePrefetch() {
+  const loaded = ref(0);
+  const failed = ref(0);
+  const total = ref(0);
+  const pending = ref(false);
+  const cacheFull = ref(false);
+  const progress = computed(() => {
+    if (total.value === 0) return 1;
+    return (loaded.value + failed.value) / total.value;
+  });
+  const complete = computed(() => !pending.value && loaded.value + failed.value >= total.value);
+  let run = null;
+  async function prepare(imageIds, options = {}) {
+    const {
+      concurrency = DEFAULT_CONCURRENCY,
+      from = 0,
+      order = "outward",
+      priority = 0,
+      onProgress
+    } = options;
+    cancel();
+    const { core } = await ensureCornerstone();
+    const { cache, imageLoader, Enums } = core;
+    const requestType = options.requestType ?? Enums.RequestType.Prefetch;
+    const current = { cancelled: false, cacheFull: false, inFlight: /* @__PURE__ */ new Set() };
+    run = current;
+    const queue = orderImageIds(imageIds, from, order);
+    loaded.value = 0;
+    failed.value = 0;
+    total.value = queue.length;
+    cacheFull.value = false;
+    pending.value = queue.length > 0;
+    function report() {
+      onProgress?.({ loaded: loaded.value, failed: failed.value, total: total.value });
+    }
+    report();
+    let cursor = 0;
+    async function worker() {
+      while (cursor < queue.length) {
+        if (current.cancelled) return;
+        const imageId = queue[cursor++];
+        if (cache.isLoaded(imageId)) {
+          loaded.value += 1;
+          report();
+          continue;
+        }
+        if (cache.getBytesAvailable() <= 0) {
+          current.cacheFull = true;
+          return;
+        }
+        current.inFlight.add(imageId);
+        try {
+          await imageLoader.loadAndCacheImage(imageId, { priority, requestType });
+          loaded.value += 1;
+        } catch {
+          if (!current.cancelled) failed.value += 1;
+        } finally {
+          current.inFlight.delete(imageId);
+        }
+        report();
+      }
+    }
+    await Promise.all(
+      Array.from({ length: Math.min(Math.max(1, concurrency), queue.length) }, () => worker())
+    );
+    if (run === current) {
+      run = null;
+      pending.value = false;
+      cacheFull.value = current.cacheFull;
+    }
+    return {
+      loaded: loaded.value,
+      failed: failed.value,
+      total: total.value,
+      cancelled: current.cancelled,
+      cacheFull: current.cacheFull
+    };
+  }
+  function cancel() {
+    const current = run;
+    if (!current) return;
+    current.cancelled = true;
+    run = null;
+    pending.value = false;
+    if (current.inFlight.size > 0) {
+      getLoadedCornerstone()?.core.imageLoader.cancelLoadImages([...current.inFlight]);
+      current.inFlight.clear();
+    }
+  }
+  function reset() {
+    cancel();
+    loaded.value = 0;
+    failed.value = 0;
+    total.value = 0;
+    cacheFull.value = false;
+  }
+  function isPrepared(imageId) {
+    return getLoadedCornerstone()?.core.cache.isLoaded(imageId) ?? false;
+  }
+  if (getCurrentScope()) onScopeDispose(cancel);
+  return { loaded, failed, total, pending, progress, complete, cacheFull, prepare, cancel, reset, isPrepared };
+}
+function orderImageIds(imageIds, from, order) {
+  const count = imageIds.length;
+  if (count === 0) return [];
+  const start = Math.min(Math.max(Math.trunc(from) || 0, 0), count - 1);
+  if (order === "forward") return imageIds.slice(start).concat(imageIds.slice(0, start));
+  const queue = [imageIds[start]];
+  for (let step = 1; queue.length < count; step++) {
+    const after = start + step;
+    const before = start - step;
+    if (after < count) queue.push(imageIds[after]);
+    if (before >= 0) queue.push(imageIds[before]);
+  }
+  return queue;
+}

package/dist/runtime/composables/useMeasurements.d.ts

@@ -0,0 +1,51 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { StackViewport } from '../types.js';
+/** One measurement the user drew, as the delete controls see it. */
+export interface Measurement {
+    uid: string;
+    /** The `toolName` that drew it — `'Length'`, `'RectangleROI'`, and so on. */
+    toolName: string;
+    /** The slice it is pinned to, or `null` when it is not pinned to one. */
+    imageId: string | null;
+    selected: boolean;
+}
+export interface MeasurementsOptions {
+    /**
+     * Tool names whose annotations are left alone, neither counted nor deleted.
+     *
+     * The overlay tool that {@link useDicomAnnotations} draws imported boxes
+     * with is always in this set: those boxes belong to a report rather than to
+     * the reader, and `useAnnotationReport().reset()` is what takes them away.
+     * Locked annotations are skipped for the same reason, whatever drew them.
+     */
+    keep?: string[];
+}
+/**
+ * Deleting the measurements the user drew.
+ *
+ * Cornerstone gives every annotation tool a way to *draw* and no way to
+ * un-draw: a stray Length or a mis-clicked Probe stays on the slice for as
+ * long as the study is open. This is the other half — the counts a toolbar
+ * needs to decide what to offer, and the three removals worth offering:
+ * whatever is selected, everything on the slice on screen, and everything in
+ * the stack.
+ *
+ * Only the reader's own work is in scope. Boxes that came out of a report are
+ * excluded by tool name and anything locked is excluded outright, so a viewer
+ * can put a delete button next to an imported overlay without the button being
+ * able to erase it.
+ *
+ * Counts follow the annotation state rather than being recomputed by the
+ * caller: they move when the user draws, deletes, selects or scrolls.
+ */
+export declare function useMeasurements(source: MaybeRefOrGetter<StackViewport | null | undefined>, options?: MeasurementsOptions): {
+    list: () => Measurement[];
+    refresh: () => void;
+    remove: (uid: string) => boolean;
+    deleteSelected: () => number;
+    deleteOnSlice: () => number;
+    deleteAll: () => number;
+    total: Ref<number, number>;
+    onSlice: Ref<number, number>;
+    selected: Ref<number, number>;
+};

package/dist/runtime/composables/useMeasurements.js

@@ -0,0 +1,138 @@
+import { getCurrentScope, onScopeDispose, ref, toValue, watch } from "vue";
+import { getLoadedCornerstone } from "../cornerstone.js";
+import { OVERLAY_TOOL_NAME } from "./useDicomAnnotations.js";
+export function useMeasurements(source, options = {}) {
+  const kept = /* @__PURE__ */ new Set([OVERLAY_TOOL_NAME, ...options.keep ?? []]);
+  const total = ref(0);
+  const onSlice = ref(0);
+  const selected = ref(0);
+  let libs = null;
+  let listening = null;
+  let subscribed = false;
+  function annotationEvents() {
+    const { Events } = libs.tools.Enums;
+    return [
+      Events.ANNOTATION_ADDED,
+      Events.ANNOTATION_REMOVED,
+      Events.ANNOTATION_SELECTION_CHANGE,
+      Events.ANNOTATION_LOCK_CHANGE
+    ];
+  }
+  function list() {
+    const viewport = toValue(source);
+    if (!libs || !viewport) return [];
+    const { tools } = libs;
+    const imageIds = new Set(viewport.getImageIds());
+    const frameOfReferenceUid = viewport.getFrameOfReferenceUID();
+    const found = [];
+    for (const annotation of tools.annotation.state.getAllAnnotations()) {
+      const uid = annotation.annotationUID;
+      const metadata = annotation.metadata;
+      const toolName = metadata?.toolName;
+      if (!uid || !toolName || kept.has(toolName)) continue;
+      if (tools.annotation.locking.isAnnotationLocked(uid)) continue;
+      const imageId = metadata.referencedImageId ?? null;
+      const belongs = imageId ? imageIds.has(imageId) : metadata.FrameOfReferenceUID === frameOfReferenceUid;
+      if (!belongs) continue;
+      found.push({
+        uid,
+        toolName,
+        imageId,
+        selected: tools.annotation.selection.isAnnotationSelected(uid)
+      });
+    }
+    return found;
+  }
+  function refresh() {
+    const measurements = list();
+    const current = toValue(source)?.getCurrentImageId() ?? null;
+    total.value = measurements.length;
+    onSlice.value = current ? measurements.filter((entry) => entry.imageId === current).length : 0;
+    selected.value = measurements.filter((entry) => entry.selected).length;
+  }
+  function render() {
+    const viewport = toValue(source);
+    if (viewport) libs?.tools.utilities.triggerAnnotationRenderForViewportIds([viewport.id]);
+  }
+  function removeMany(uids) {
+    if (!libs || uids.length === 0) return 0;
+    const { tools } = libs;
+    for (const uid of uids) {
+      if (tools.annotation.selection.isAnnotationSelected(uid)) {
+        tools.annotation.selection.deselectAnnotation(uid);
+      }
+      tools.annotation.state.removeAnnotation(uid);
+    }
+    refresh();
+    render();
+    return uids.length;
+  }
+  function remove(uid) {
+    return removeMany(list().filter((entry) => entry.uid === uid).map((entry) => entry.uid)) > 0;
+  }
+  function deleteSelected() {
+    return removeMany(list().filter((entry) => entry.selected).map((entry) => entry.uid));
+  }
+  function deleteOnSlice() {
+    const current = toValue(source)?.getCurrentImageId();
+    if (!current) return 0;
+    return removeMany(list().filter((entry) => entry.imageId === current).map((entry) => entry.uid));
+  }
+  function deleteAll() {
+    return removeMany(list().map((entry) => entry.uid));
+  }
+  function subscribe() {
+    if (subscribed || !libs) return;
+    for (const event of annotationEvents()) {
+      libs.core.eventTarget.addEventListener(event, refresh);
+    }
+    subscribed = true;
+  }
+  function unsubscribe() {
+    if (!subscribed || !libs) return;
+    for (const event of annotationEvents()) {
+      libs.core.eventTarget.removeEventListener(event, refresh);
+    }
+    subscribed = false;
+  }
+  function watchElement(viewport) {
+    const element = viewport.element;
+    if (listening === element) return;
+    stopWatching();
+    element.addEventListener(libs.core.Enums.Events.STACK_NEW_IMAGE, refresh);
+    listening = element;
+  }
+  function stopWatching() {
+    if (!listening || !libs) return;
+    listening.removeEventListener(libs.core.Enums.Events.STACK_NEW_IMAGE, refresh);
+    listening = null;
+  }
+  watch(() => toValue(source), (viewport) => {
+    libs ??= getLoadedCornerstone();
+    if (!libs || !viewport) {
+      stopWatching();
+      refresh();
+      return;
+    }
+    subscribe();
+    watchElement(viewport);
+    refresh();
+  }, { immediate: true });
+  if (getCurrentScope()) {
+    onScopeDispose(() => {
+      unsubscribe();
+      stopWatching();
+    });
+  }
+  return {
+    list,
+    refresh,
+    remove,
+    deleteSelected,
+    deleteOnSlice,
+    deleteAll,
+    total,
+    onSlice,
+    selected
+  };
+}

package/dist/runtime/composables/useRenderingEngine.d.ts

@@ -0,0 +1,6 @@
+import type { Types as CoreTypes } from '@cornerstonejs/core';
+export declare function useRenderingEngine(): {
+    acquire: (id?: string) => Promise<CoreTypes.IRenderingEngine>;
+    release: (id?: string) => void;
+    get: (id?: string) => CoreTypes.IRenderingEngine | null;
+};

package/dist/runtime/composables/useRenderingEngine.js

@@ -0,0 +1,46 @@
+import { ensureCornerstone, getCornerstoneOptions } from "../cornerstone.js";
+const hot = import.meta.hot;
+const state = hot ? hot.data.cornerstoneEngines ??= {} : {};
+state.engines ??= /* @__PURE__ */ new Map();
+export function useRenderingEngine() {
+  async function acquire(id) {
+    const { core } = await ensureCornerstone();
+    const engineId = id ?? getCornerstoneOptions().renderingEngineId;
+    const engines = state.engines;
+    let entry = engines.get(engineId);
+    if (entry && !core.getRenderingEngine(engineId)) {
+      engines.delete(engineId);
+      entry = void 0;
+    }
+    if (!entry) {
+      const existing = core.getRenderingEngine(engineId);
+      entry = {
+        engine: existing ?? new core.RenderingEngine(engineId),
+        refs: 0,
+        owned: !existing
+      };
+      engines.set(engineId, entry);
+    }
+    entry.refs += 1;
+    return entry.engine;
+  }
+  function release(id) {
+    const engineId = id ?? getCornerstoneOptions().renderingEngineId;
+    const engines = state.engines;
+    const entry = engines.get(engineId);
+    if (!entry) return;
+    entry.refs = Math.max(0, entry.refs - 1);
+    if (entry.refs > 0) return;
+    engines.delete(engineId);
+    if (!entry.owned) return;
+    try {
+      entry.engine.destroy();
+    } catch {
+    }
+  }
+  function get(id) {
+    const engineId = id ?? getCornerstoneOptions().renderingEngineId;
+    return state.engines.get(engineId)?.engine ?? null;
+  }
+  return { acquire, release, get };
+}

package/dist/runtime/composables/useStackCine.d.ts

@@ -0,0 +1,50 @@
+import type { Ref } from 'vue';
+/**
+ * A reasonable set of frame rates for a transport to offer.
+ *
+ * 15 is the default because it is fast enough to read as motion and slow
+ * enough that a stack coming off the network can nearly keep up; the ones
+ * either side cover walking a stack slowly and playing a short cardiac loop at
+ * something close to its acquired rate.
+ */
+export declare const FRAME_RATES: readonly [5, 10, 15, 24, 30];
+/**
+ * How much of the stack has to be decoded before play is offered.
+ *
+ * Waiting for all of it is more than playback needs: the film starts at the
+ * first image and the prefetch runs the same way, so half a stack is already
+ * a comfortable head start and the rest lands while the first half plays.
+ * Waiting for none of it is the stutter the prefetch exists to avoid.
+ */
+export declare const PLAY_READY_RATIO = 0.5;
+export interface StackCineOptions {
+    /** Frames per second to start at. Default: `15`. */
+    frameRate?: number;
+}
+/**
+ * Cine playback for the stack on screen, and the prefetch that makes it
+ * watchable.
+ *
+ * {@link useCinePlayer} and {@link useImagePrefetch} are deliberately separate
+ * primitives, but an application almost always wants them together: a stack
+ * viewport loads each slice as it is shown, so playing a stack nobody has
+ * prepared runs at the speed of the decoder rather than at the frame rate that
+ * was asked for. Here preparing is not something the user has to think of
+ * first — a stack starts preparing as soon as it is loaded, and pressing play
+ * starts it too if for any reason it is not already done.
+ */
+export declare function useStackCine(imageIds: Ref<string[]>, imageIndex: Ref<number>, options?: StackCineOptions): {
+    playing: Ref<boolean, boolean>;
+    canPlay: import("vue").ComputedRef<boolean>;
+    frameRate: import("vue").WritableComputedRef<number, number>;
+    loop: Ref<boolean, boolean>;
+    preparing: Ref<boolean, boolean>;
+    prepared: import("vue").ComputedRef<boolean>;
+    buffering: import("vue").ComputedRef<boolean>;
+    percent: import("vue").ComputedRef<number>;
+    statusText: import("vue").ComputedRef<string | null>;
+    play: () => void;
+    pause: () => void;
+    toggle: () => void;
+    prepare: () => Promise<import("./useImagePrefetch.js").PrefetchResult>;
+};

package/dist/runtime/composables/useStackCine.js

@@ -0,0 +1,62 @@
+import { computed, watch } from "vue";
+import { t } from "../i18n/index.js";
+import { useCinePlayer } from "./useCinePlayer.js";
+import { useImagePrefetch } from "./useImagePrefetch.js";
+export const FRAME_RATES = [5, 10, 15, 24, 30];
+export const PLAY_READY_RATIO = 0.5;
+export function useStackCine(imageIds, imageIndex, options = {}) {
+  const prefetch = useImagePrefetch();
+  const cine = useCinePlayer(imageIndex, () => imageIds.value.length, {
+    frameRate: options.frameRate ?? 15
+  });
+  const percent = computed(() => Math.round(prefetch.progress.value * 100));
+  const prepared = computed(
+    () => prefetch.total.value > 0 && !prefetch.pending.value && !prefetch.cacheFull.value && prefetch.loaded.value + prefetch.failed.value >= prefetch.total.value
+  );
+  const buffering = computed(
+    () => prefetch.pending.value && prefetch.progress.value < PLAY_READY_RATIO
+  );
+  const statusText = computed(() => {
+    if (prefetch.pending.value) return t("cine.preparing", { percent: percent.value });
+    if (prefetch.total.value === 0) return null;
+    if (prefetch.cacheFull.value) return t("cine.cacheFull", { count: prefetch.loaded.value });
+    if (prefetch.failed.value > 0) {
+      return t("cine.preparedWithFailures", {
+        count: prefetch.loaded.value,
+        failed: prefetch.failed.value
+      });
+    }
+    if (prepared.value) return t("cine.prepared", { count: prefetch.loaded.value });
+    return null;
+  });
+  function prepare() {
+    return prefetch.prepare(imageIds.value, { from: imageIndex.value, order: "outward" });
+  }
+  function toggle() {
+    if (!cine.playing.value && buffering.value) return;
+    if (!cine.playing.value && !prepared.value && !prefetch.pending.value) {
+      prefetch.prepare(imageIds.value, { from: imageIndex.value, order: "forward" });
+    }
+    cine.toggle();
+  }
+  watch(imageIds, (ids) => {
+    cine.pause();
+    prefetch.reset();
+    if (ids.length > 1) prefetch.prepare(ids, { from: imageIndex.value, order: "forward" });
+  });
+  return {
+    playing: cine.playing,
+    canPlay: cine.canPlay,
+    frameRate: cine.frameRate,
+    loop: cine.loop,
+    preparing: prefetch.pending,
+    prepared,
+    buffering,
+    percent,
+    statusText,
+    play: cine.play,
+    pause: cine.pause,
+    toggle,
+    prepare
+  };
+}

package/dist/runtime/composables/useViewerShortcuts.d.ts

@@ -0,0 +1,94 @@
+/** A tool the keyboard can select, by its `@cornerstonejs/tools` class name. */
+export interface ToolShortcut {
+    className: string;
+    /** A single letter, matched at its QWERTY position — see below. */
+    shortcut: string;
+}
+/**
+ * The letter bindings, following the OHIF viewer's defaults where it has them:
+ * `w`, `p` and `z` for window/level, pan and zoom. OHIF binds no keys for
+ * annotation tools, so the rest are conventional rather than specified — `m`
+ * for measure because `l` is rotate-left in OHIF, and `b` for the box because
+ * `r` is rotate-right.
+ *
+ * Pass your own list to {@link useViewerShortcuts} when your toolbar offers a
+ * different set; a toolbar and its keymap should read from one table, so that
+ * the key a button advertises is the key that works.
+ */
+export declare const DEFAULT_TOOL_SHORTCUTS: ToolShortcut[];
+export interface ViewerShortcutHandlers {
+    /** False while nothing is loaded, so the keys stay inert on an empty viewer. */
+    isEnabled: () => boolean;
+    /** Move through the stack, positive forwards. */
+    step: (delta: number) => void;
+    first: () => void;
+    last: () => void;
+    /** Move through the archive's series, positive forwards. */
+    stepSeries: (delta: number) => void;
+    setTool: (className: string) => void;
+    resetViewport: () => void;
+    /** Start or stop cine playback. */
+    togglePlay: () => void;
+    /** Show the application's own list of these bindings. */
+    toggleHelp: () => void;
+    /**
+     * Delete the measurements the user has selected. Optional: a viewer with no
+     * annotation tools has nothing to delete, and leaving it out keeps Delete
+     * and Backspace with the browser.
+     */
+    deleteMeasurement?: () => void;
+}
+export interface ViewerShortcutOptions {
+    /** Defaults to {@link DEFAULT_TOOL_SHORTCUTS}. */
+    tools?: ToolShortcut[];
+}
+/**
+ * Keyboard control for a viewer, following the OHIF viewer's default keymap
+ * — the closest thing this corner of the world has to a standard, and the one
+ * anyone arriving from a PACS will try first.
+ *
+ * Bindings are matched on `event.code`, the physical key, rather than
+ * `event.key`, the character it produces. This is not a detail: `event.key`
+ * depends on the operating system's keyboard layout, so on a Persian layout
+ * the W key reports `'ش'` and on a Russian one `'ц'`, and every letter binding
+ * silently stops working — which is exactly the kind of "sometimes it works"
+ * that is hard to pin down, because it follows the layout rather than the app.
+ * `event.code` names the key's position instead, so `W` is the key marked W on
+ * the keyboard whatever it types, and the letters in the tooltips stay true.
+ * The trade-off is Dvorak and other remapped layouts, where the keys keep
+ * their QWERTY positions; component libraries make the same choice.
+ *
+ * The horizontal arrows are deliberately unbound: OHIF gives them to moving
+ * between viewports, and a single-viewport layout has nowhere to go. That also
+ * sidesteps the question of which arrow means "forward" when the chrome is
+ * right-to-left.
+ *
+ * Space is the one place this parts company with OHIF, which resets the
+ * viewport with it. Space means play/pause everywhere a person has ever used
+ * a media player, and a stack has a film to play, so it goes to cine and the
+ * reset moves to `R`. `R` is free here — it is rotate-right in OHIF, and there
+ * is no rotate tool in this module's default set.
+ *
+ * Delete and Backspace remove the selected measurements, when the caller
+ * supplies `deleteMeasurement`. Both, because the key a reader reaches for is
+ * whichever one their keyboard has.
+ */
+export declare function useViewerShortcuts(handlers: ViewerShortcutHandlers, options?: ViewerShortcutOptions): void;
+/**
+ * Drop focus from a button that was clicked with a pointer.
+ *
+ * A clicked button keeps focus afterwards, and a focused button owns the
+ * spacebar — the browser activates it rather than letting the key through. So
+ * picking a tool from a toolbar with the mouse and then pressing Space appears
+ * to do nothing at all: the key is quietly re-pressing the tool button that is
+ * still focused, and never reaches the viewer's play/pause binding.
+ *
+ * `event.detail` is the click count, and it is `0` for a click the browser
+ * synthesised from Enter or Space on a focused control. Blurring only when it
+ * is non-zero therefore drops focus for mouse and touch, where nobody is
+ * following it, and leaves it exactly where it was for anyone driving the page
+ * from the keyboard — who needs it to tab onwards from.
+ *
+ * Attach it once to a toolbar's root and let the clicks bubble to it.
+ */
+export declare function releaseFocus(event: MouseEvent): void;