nuxt-cornerstone 1.0.0

package/dist/module.d.mts

@@ -0,0 +1,22 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { CornerstoneModuleOptions } from '../dist/runtime/types.js';
+export { CornerstoneI18nOptions, CornerstoneModuleOptions, LocaleSource, ResolvedCornerstoneOptions } from '../dist/runtime/types.js';
+export { CornerstoneMessageKey, CornerstoneTranslator, MessageCatalog, MessageKey, MessageParams, MessageValue, PluralCategory } from '../dist/runtime/i18n/index.js';
+export { AddFilesOptions, AddZipOptions, AddZipResult, DicomSeries, IndexUrlsOptions, IndexUrlsResult, SkipReason, SkippedEntry, ZipProgress } from '../dist/runtime/composables/useDicomFiles.js';
+export { PrefetchOptions, PrefetchProgress, PrefetchResult } from '../dist/runtime/composables/useImagePrefetch.js';
+export { CinePlayerOptions } from '../dist/runtime/composables/useCinePlayer.js';
+export { OpenUrlsOptions, Problem, SourceInfo } from '../dist/runtime/composables/useDicomStudy.js';
+export { GuardResult, RejectedFile } from '../dist/runtime/composables/useDicomGuard.js';
+export { StackCineOptions } from '../dist/runtime/composables/useStackCine.js';
+export { AnnotationReportOptions } from '../dist/runtime/composables/useAnnotationReport.js';
+export { ToolShortcut, ViewerShortcutHandlers, ViewerShortcutOptions } from '../dist/runtime/composables/useViewerShortcuts.js';
+export { AddBoxesOptions, AddBoxesResult, AddJsonOptions, AddJsonResult, DicomBox, PixelBox } from '../dist/runtime/composables/useDicomAnnotations.js';
+export { Measurement, MeasurementsOptions } from '../dist/runtime/composables/useMeasurements.js';
+export { AnnotationFormat, FindingLabelInfo, ReadAnnotationsOptions, ReadAnnotationsResult } from '../dist/runtime/annotation-json.js';
+
+type ModuleOptions = CornerstoneModuleOptions;
+
+declare const _default: _nuxt_schema.NuxtModule<CornerstoneModuleOptions, CornerstoneModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "nuxt-cornerstone",
+  "configKey": "cornerstone",
+  "compatibility": {
+    "nuxt": ">=4.0.0"
+  },
+  "version": "1.0.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.3",
+    "unbuild": "unknown"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,168 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { defineNuxtModule, useLogger, createResolver, addPlugin, addImportsDir, addComponent, tryResolveModule } from '@nuxt/kit';
+import { defu } from 'defu';
+import { DEFAULT_TOOLS } from '../dist/runtime/types.js';
+
+const MODULE_NAME = "nuxt-cornerstone";
+const REQUIRED_PACKAGES = [
+  "@cornerstonejs/core",
+  "@cornerstonejs/tools",
+  "@cornerstonejs/dicom-image-loader",
+  "@cornerstonejs/metadata",
+  "@cornerstonejs/utils",
+  "dicom-parser"
+];
+const BROWSER_ONLY_PACKAGES = [
+  "@cornerstonejs/core",
+  "@cornerstonejs/tools",
+  "@cornerstonejs/dicom-image-loader"
+];
+const module$1 = defineNuxtModule({
+  meta: {
+    name: MODULE_NAME,
+    configKey: "cornerstone",
+    compatibility: { nuxt: ">=4.0.0" }
+  },
+  defaults: {
+    autoInit: true,
+    core: {},
+    dicomImageLoader: {},
+    tools: { enabled: true, register: [...DEFAULT_TOOLS] },
+    i18n: {
+      locale: "en",
+      fallbackLocale: "en",
+      messages: {},
+      numberingSystem: "auto",
+      detect: false
+    },
+    viteCommonjs: true,
+    prefix: "Cornerstone",
+    renderingEngineId: "nuxt-cornerstone",
+    toolGroupId: "nuxt-cornerstone-tools"
+  },
+  async setup(options, nuxt) {
+    const logger = useLogger(MODULE_NAME);
+    const { resolve } = createResolver(import.meta.url);
+    await assertPeerDependencies(nuxt.options.rootDir, logger);
+    const { value: publicOptions, dropped } = stripFunctions(options);
+    if (dropped.length > 0) {
+      logger.warn(
+        `These options are functions and cannot be serialized into runtimeConfig: ${dropped.join(", ")}. Set \`cornerstone.autoInit: false\` and pass them to \`ensureCornerstone()\` from your own plugin instead.`
+      );
+    }
+    const runtimeConfig = nuxt.options.runtimeConfig.public;
+    runtimeConfig.cornerstone = defu(
+      runtimeConfig.cornerstone,
+      publicOptions
+    );
+    nuxt.hook("vite:extendConfig", async (viteConfig, { isClient }) => {
+      if (!isClient) return;
+      const config = viteConfig;
+      config.optimizeDeps ??= {};
+      config.optimizeDeps.exclude = unique([
+        ...config.optimizeDeps.exclude ?? [],
+        "@cornerstonejs/dicom-image-loader"
+      ]);
+      config.optimizeDeps.include = unique([
+        ...config.optimizeDeps.include ?? [],
+        "dicom-parser",
+        "fflate",
+        "@cornerstonejs/core",
+        "@cornerstonejs/tools",
+        "@cornerstonejs/metadata",
+        "@cornerstonejs/utils"
+      ]);
+      config.worker = { ...config.worker, format: "es" };
+      config.assetsInclude = unique([...toArray(config.assetsInclude), "**/*.wasm"]);
+      if (nuxt.options.dev) {
+        config.plugins ??= [];
+        config.plugins.push(stripDanglingSourcemaps());
+      }
+      if (options.viteCommonjs) {
+        const { viteCommonjs } = await import('@originjs/vite-plugin-commonjs');
+        config.plugins ??= [];
+        config.plugins.push(viteCommonjs());
+      }
+    });
+    nuxt.options.nitro.externals = defu(nuxt.options.nitro.externals, {
+      external: BROWSER_ONLY_PACKAGES
+    });
+    addPlugin({ src: resolve("./runtime/plugin.i18n") });
+    addPlugin({ src: resolve("./runtime/plugin.client"), mode: "client" });
+    addImportsDir(resolve("./runtime/composables"));
+    addComponent({
+      name: `${options.prefix}Viewport`,
+      filePath: resolve("./runtime/components/CornerstoneViewport.vue"),
+      // Cornerstone needs a DOM, a WebGL context and web workers. Client-only
+      // registration means consumers do not have to remember <ClientOnly>.
+      mode: "client"
+    });
+  }
+});
+const MAP_COMMENT = /\/\/[#@]\s*sourceMappingURL=(\S+)\s*$/;
+function stripDanglingSourcemaps() {
+  return {
+    name: "nuxt-cornerstone:dangling-sourcemaps",
+    enforce: "pre",
+    apply: "serve",
+    async load(id) {
+      const file = id.split("?")[0];
+      if (!file.endsWith(".js") || !file.includes("node_modules")) return null;
+      let code;
+      try {
+        code = await readFile(file, "utf8");
+      } catch {
+        return null;
+      }
+      const target = code.match(MAP_COMMENT)?.[1];
+      if (!target || target.startsWith("data:")) return null;
+      if (existsSync(resolve(dirname(file), target))) return null;
+      return { code: code.replace(MAP_COMMENT, ""), map: null };
+    }
+  };
+}
+async function assertPeerDependencies(rootDir, logger) {
+  const from = [pathToFileURL(rootDir + "/").href, import.meta.url];
+  const missing = [];
+  for (const name of REQUIRED_PACKAGES) {
+    const resolved = await tryResolveModule(`${name}/package.json`, from);
+    if (!resolved) missing.push(name);
+  }
+  if (missing.length === 0) return;
+  const install = missing.map((name) => `${name}@^5.10.7`).join(" ");
+  logger.error(`Missing peer dependencies: ${missing.join(", ")}`);
+  throw new Error(
+    `[${MODULE_NAME}] missing peer dependencies: ${missing.join(", ")}.
+Install them with:
+  npm install ${install}
+All @cornerstonejs packages must be on the same version \u2014 they pin each other exactly.`
+  );
+}
+function stripFunctions(value, path = []) {
+  if (typeof value === "function") {
+    return { value: void 0, dropped: [path.join(".")] };
+  }
+  if (Array.isArray(value) || value === null || typeof value !== "object") {
+    return { value, dropped: [] };
+  }
+  const out = {};
+  const dropped = [];
+  for (const [key, entry] of Object.entries(value)) {
+    const result = stripFunctions(entry, [...path, key]);
+    dropped.push(...result.dropped);
+    if (result.value !== void 0) out[key] = result.value;
+  }
+  return { value: out, dropped };
+}
+function toArray(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+
+export { module$1 as default };

package/dist/runtime/annotation-json.d.ts

@@ -0,0 +1,76 @@
+import type { DicomBox } from './composables/useDicomAnnotations.js';
+/**
+ * Reading a JSON report into the boxes {@link useDicomAnnotations} draws.
+ *
+ * Two shapes are accepted, because the two that matter in practice are not the
+ * same thing. One is this module's own: a flat list of boxes already keyed by
+ * SOPInstanceUID, which is what an application produces when it has done its
+ * own translation. The other is a detector's nested output — findings, each
+ * holding the per-slice boxes it was seen on — which is what arrives when the
+ * report comes straight off an inference service.
+ *
+ * Nothing here guesses at coordinates. A box is only read from fields that are
+ * unambiguously in image pixel space; a finding-level bounding box in the
+ * model's own resampled volume is ignored, since it does not describe the DICOM
+ * images on screen.
+ */
+/** Which of the accepted layouts a file turned out to be. */
+export type AnnotationFormat = 'boxes' | 'findings';
+export interface ReadAnnotationsOptions {
+    /**
+     * Drop findings whose confidence is below this, 0..1. Only the nested
+     * detector shape carries confidence; a flat box list is unaffected.
+     * Default: `0` — keep everything the file lists.
+     */
+    minConfidence?: number;
+    /**
+     * Build the caption for a box read from the detector shape. Default:
+     * the finding's own `name`/`label`, followed by its confidence as a
+     * percentage when it has one.
+     */
+    label?: (finding: FindingLabelInfo) => string | undefined;
+}
+/** What {@link ReadAnnotationsOptions.label} is given about a finding. */
+export interface FindingLabelInfo {
+    /** 1-based position among the findings that survived the threshold. */
+    index: number;
+    /** The finding's own name or numeric class, when it carries one. */
+    name: string | null;
+    /** 0..1, or `null` when the report does not say. */
+    confidence: number | null;
+    /** The slice this particular box sits on. */
+    sopInstanceUid: string;
+}
+export interface ReadAnnotationsResult {
+    /** Boxes ready to hand to `addBoxes()`. */
+    boxes: DicomBox[];
+    /** Which layout the file used. */
+    format: AnnotationFormat;
+    /** Findings read, before the confidence threshold. `0` for a flat list. */
+    findings: number;
+    /** Findings dropped by {@link ReadAnnotationsOptions.minConfidence}. */
+    filtered: number;
+    /**
+     * Entries that were the right shape's wrong shape — a box missing its UID,
+     * a coordinate that is not a number. They are counted rather than thrown on,
+     * so one bad row does not discard a usable report.
+     */
+    malformed: number;
+    /**
+     * SeriesInstanceUID the report names, when it names one. Worth showing when
+     * no box matches anything loaded: it says which study to open.
+     */
+    seriesInstanceUid: string | null;
+}
+/**
+ * Read a JSON annotation file.
+ *
+ * Takes what a file picker, a drop target or `$fetch` hands over: a `File` or
+ * `Blob`, the JSON text, or the already-parsed object. Throws when the bytes
+ * are not JSON or the JSON is not one of the accepted layouts; a file that is
+ * simply empty of boxes comes back with an empty list instead, since a report
+ * finding nothing is a result, not a failure.
+ */
+export declare function readAnnotationJson(input: File | Blob | string | unknown, options?: ReadAnnotationsOptions): Promise<ReadAnnotationsResult>;
+/** The synchronous half, for callers that already hold the parsed value. */
+export declare function parseAnnotationJson(value: unknown, options?: ReadAnnotationsOptions): ReadAnnotationsResult;

package/dist/runtime/annotation-json.js

@@ -0,0 +1,176 @@
+import { t } from "./i18n/index.js";
+export async function readAnnotationJson(input, options = {}) {
+  return parseAnnotationJson(await toJson(input), options);
+}
+async function toJson(input) {
+  const text = typeof input === "string" ? input : input instanceof Blob ? await input.text() : null;
+  if (text === null) return input;
+  try {
+    return JSON.parse(text);
+  } catch (caught) {
+    const message = caught instanceof Error ? caught.message : String(caught);
+    throw new Error(t("annotationJson.notJson", { message }), { cause: caught });
+  }
+}
+export function parseAnnotationJson(value, options = {}) {
+  const boxList = findBoxList(value);
+  if (boxList) return readBoxList(boxList, value);
+  const findings = findFindingList(value);
+  if (findings) return readFindings(findings, value, options);
+  throw new Error(t("annotationJson.unknownShape"));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function arrayAt(value, keys) {
+  if (!isRecord(value)) return null;
+  for (const key of keys) {
+    const found = value[key];
+    if (Array.isArray(found)) return found;
+  }
+  return null;
+}
+function findBoxList(value) {
+  if (Array.isArray(value)) return looksLikeBox(value[0]) ? value : null;
+  const found = arrayAt(value, ["boxes", "annotations"]);
+  return found && looksLikeBox(found[0]) ? found : null;
+}
+function looksLikeBox(entry) {
+  if (!isRecord(entry)) return false;
+  return "box" in entry || "sopInstanceUid" in entry || "sop_instance_uid" in entry;
+}
+function findFindingList(value) {
+  const nested = isRecord(value) ? value.predictions : null;
+  return arrayAt(nested, ["findings"]) ?? arrayAt(value, ["findings"]);
+}
+function readBoxList(entries, document) {
+  const boxes = [];
+  let malformed = 0;
+  for (const entry of entries) {
+    const box = toBox(entry);
+    if (box) boxes.push(box);
+    else malformed += 1;
+  }
+  return {
+    boxes,
+    format: "boxes",
+    findings: 0,
+    filtered: 0,
+    malformed,
+    seriesInstanceUid: seriesUidOf(document)
+  };
+}
+function toBox(entry) {
+  if (!isRecord(entry)) return null;
+  const sopInstanceUid = textOf(entry.sopInstanceUid ?? entry.sop_instance_uid);
+  if (!sopInstanceUid) return null;
+  const corners = toCorners(entry.box ?? entry.bounding_box ?? entry.boundingBox ?? entry);
+  if (!corners) return null;
+  const label = textOf(entry.label ?? entry.text ?? entry.name);
+  const uid = textOf(entry.uid ?? entry.annotationUID ?? entry.id);
+  return { sopInstanceUid, box: corners, ...label ? { label } : {}, ...uid ? { uid } : {} };
+}
+function toCorners(value) {
+  if (Array.isArray(value) && value.length === 4) {
+    const [x12 = Number.NaN, y12 = Number.NaN, x22 = Number.NaN, y22 = Number.NaN] = value.map(numberOf);
+    return finite(x12, y12, x22, y22) ? { x1: x12, y1: y12, x2: x22, y2: y22 } : null;
+  }
+  if (!isRecord(value)) return null;
+  const x1 = numberOf(value.x1 ?? value.upper_left_x ?? value.upperLeftX ?? value.xMin ?? value.x);
+  const y1 = numberOf(value.y1 ?? value.upper_left_y ?? value.upperLeftY ?? value.yMin ?? value.y);
+  if (!finite(x1, y1)) return null;
+  const x2 = numberOf(value.x2 ?? value.lower_right_x ?? value.lowerRightX ?? value.xMax);
+  const y2 = numberOf(value.y2 ?? value.lower_right_y ?? value.lowerRightY ?? value.yMax);
+  if (finite(x2, y2)) return { x1, y1, x2, y2 };
+  const width = numberOf(value.width ?? value.w);
+  const height = numberOf(value.height ?? value.h);
+  if (finite(width, height)) return { x1, y1, x2: x1 + width, y2: y1 + height };
+  return null;
+}
+function readFindings(entries, document, options) {
+  const { minConfidence = 0, label = defaultLabel } = options;
+  const boxes = [];
+  let filtered = 0;
+  let malformed = 0;
+  let index = 0;
+  for (const entry of entries) {
+    if (!isRecord(entry)) {
+      malformed += 1;
+      continue;
+    }
+    const confidence = numberOf(entry.confidence ?? entry.score ?? entry.probability);
+    const hasConfidence = Number.isFinite(confidence);
+    if (hasConfidence && confidence < minConfidence) {
+      filtered += 1;
+      continue;
+    }
+    const slices = arrayAt(entry, ["slice_findings", "sliceFindings", "slices", "boxes"]);
+    if (!slices) {
+      malformed += 1;
+      continue;
+    }
+    index += 1;
+    const name = textOf(entry.name ?? entry.class_name ?? entry.className) ?? numberText(entry.label ?? entry.class ?? entry.category);
+    for (const slice of slices) {
+      const box = toBox(slice);
+      if (!box) {
+        malformed += 1;
+        continue;
+      }
+      boxes.push({
+        ...box,
+        // A slice that captioned itself keeps its caption; the rest are
+        // described by the finding they belong to.
+        label: box.label ?? label({
+          index,
+          name,
+          confidence: hasConfidence ? confidence : null,
+          sopInstanceUid: box.sopInstanceUid
+        }),
+        // A detector's boxes carry no id of their own, and adding the same
+        // report twice must replace its boxes rather than stack a second set
+        // on the first, so one is derived from what does identify a box: the
+        // finding it belongs to and the slice it sits on.
+        uid: box.uid ?? `finding-${index}-${box.sopInstanceUid}`
+      });
+    }
+  }
+  return {
+    boxes,
+    format: "findings",
+    findings: entries.length,
+    filtered,
+    malformed,
+    seriesInstanceUid: seriesUidOf(document)
+  };
+}
+function defaultLabel(finding) {
+  const name = finding.name ?? t("annotationJson.finding", { index: finding.index });
+  if (finding.confidence === null) return name;
+  return t("annotationJson.labelled", {
+    name,
+    confidence: Math.round(finding.confidence * 100)
+  });
+}
+function seriesUidOf(document) {
+  if (!isRecord(document)) return null;
+  const scope = isRecord(document.predictions) ? document.predictions : document;
+  return textOf(scope.seriesInstanceUid ?? scope.series_instance_uid);
+}
+function numberOf(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.trim()) return Number(value);
+  return Number.NaN;
+}
+function finite(...values) {
+  return values.every((value) => Number.isFinite(value));
+}
+function textOf(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function numberText(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return t("annotationJson.class", { value });
+}

package/dist/runtime/components/CornerstoneViewport.d.vue.ts

@@ -0,0 +1,57 @@
+/**
+ * A Cornerstone3D stack viewport.
+ *
+ * Registered with `mode: 'client'`, so Nuxt never renders it on the server —
+ * WebGL, web workers and the WASM decoders have no server-side equivalent.
+ */
+type __VLS_Props = {
+    /** `wadouri:` / `wadors:` / `dicomfile:` imageIds, in display order. */
+    imageIds: string[];
+    /** Defaults to a generated id, unique per component instance. */
+    viewportId?: string;
+    renderingEngineId?: string;
+    toolGroupId?: string;
+    /** Index into `imageIds`. Two-way via the `imageIndexChange` event. */
+    imageIndex?: number;
+    /** Canvas background as RGB in 0..1. */
+    background?: [number, number, number];
+    /** Tool to bind to left-drag once mounted, or `false` to leave it alone. */
+    defaultTool?: string | false;
+};
+declare var __VLS_1: {
+    status: "ready" | "error" | "loading";
+    error: Error | null;
+    viewport: import("@cornerstonejs/core").StackViewport | null;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    /** The Cornerstone stack viewport, once mounted. */
+    viewport: import("vue").ShallowRef<import("@cornerstonejs/core").StackViewport | null, import("@cornerstonejs/core").StackViewport | null>;
+    viewportId: string;
+    renderingEngineId: string;
+    status: import("vue").Ref<"ready" | "error" | "loading", "ready" | "error" | "loading">;
+    error: import("vue").ShallowRef<Error | null, Error | null>;
+    setImageIndex: (index: number) => Promise<void>;
+    resetCamera: () => void;
+    getRenderingEngine: () => import("@cornerstonejs/core").RenderingEngine | null;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    ready: (viewport: import("@cornerstonejs/core").StackViewport) => any;
+    error: (error: Error) => any;
+    imageRendered: () => any;
+    imageIndexChange: (index: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onReady?: ((viewport: import("@cornerstonejs/core").StackViewport) => any) | undefined;
+    onError?: ((error: Error) => any) | undefined;
+    onImageRendered?: (() => any) | undefined;
+    onImageIndexChange?: ((index: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};