@cytario/web 2.1.4 → 2.1.6

package/app/components/.client/ImageViewer/state/decoders/decodeJPEG2000.js

@@ -1,5 +1,5 @@
-import openjpegWasmUrl from '@cornerstonejs/codec-openjpeg/decodewasm?url'
-import openJpegFactory from '@cornerstonejs/codec-openjpeg/decodewasmjs';
+import openjpegWasmUrl from "@cornerstonejs/codec-openjpeg/decodewasm?url";
+import openJpegFactory from "@cornerstonejs/codec-openjpeg/decodewasmjs";
 
 const local = {
   codec: undefined,
@@ -16,7 +16,7 @@ const local = {
  */
 export function loadJp2KDecoder(decodeConfig) {
   local.decodeConfig = decodeConfig;
-  
+
   // Return existing codec or loading promise
   if (local.codec) {
     return Promise.resolve();
@@ -28,7 +28,7 @@ export function loadJp2KDecoder(decodeConfig) {
   local.isLoading = true;
   local.loadPromise = openJpegFactory({
     locateFile: (f) => {
-      if (typeof f === 'string' && f.endsWith('.wasm')) {
+      if (typeof f === "string" && f.endsWith(".wasm")) {
         return openjpegWasmUrl;
       }
       return f;
@@ -57,30 +57,30 @@ export function loadJp2KDecoder(decodeConfig) {
  */
 export async function decodeJPEG2000(compressedImageFrame) {
   if (!compressedImageFrame || compressedImageFrame.length === 0) {
-    throw new Error('Invalid compressed image frame: empty or null');
+    throw new Error("Invalid compressed image frame: empty or null");
   }
 
   await loadJp2KDecoder();
-  
+
   if (!local.decoder) {
-    throw new Error('JPEG2000 decoder not initialized');
+    throw new Error("JPEG2000 decoder not initialized");
   }
 
   const decoder = local.decoder;
-  
+
   // Get encoded buffer and copy data
   const encodedBufferInWASM = decoder.getEncodedBuffer(compressedImageFrame.length);
   encodedBufferInWASM.set(compressedImageFrame);
-  
+
   // Decode the image
   decoder.decode();
-  
+
   // Extract decoded data
   const frameInfo = decoder.getFrameInfo();
   const decodedBufferInWASM = decoder.getDecodedBuffer();
   const imageFrame = new Uint8Array(decodedBufferInWASM.length);
   imageFrame.set(decodedBufferInWASM);
-  
+
   return {
     info: frameInfo,
     pixels: imageFrame,

package/app/components/.client/ImageViewer/state/decoders/decoder.worker.js

@@ -6,71 +6,71 @@ import { decodeJPEG2000, cleanupJp2KDecoder } from "./decodeJPEG2000";
  * Decoder types supported by this worker
  */
 const DECODER_TYPES = {
-    LZW: "lzw-decoder",
-    JP2K: "jp2k-decoder",
+  LZW: "lzw-decoder",
+  JP2K: "jp2k-decoder",
 };
 
 /**
  * Worker message handler for image decoding tasks
  */
 self.onmessage = async (event) => {
-    const { taskId, buffer, maxUncompressedSize, decoderId } = event.data;
+  const { taskId, buffer, maxUncompressedSize, decoderId } = event.data;
 
-    // Validate input
-    if (!taskId) {
-        self.postMessage({ 
-            taskId: 'unknown', 
-            error: 'Missing taskId in worker message' 
-        });
-        return;
-    }
-
-    if (!buffer || !decoderId) {
-        self.postMessage({ 
-            taskId, 
-            error: 'Missing required parameters: buffer or decoderId' 
-        });
-        return;
-    }
+  // Validate input
+  if (!taskId) {
+    self.postMessage({
+      taskId: "unknown",
+      error: "Missing taskId in worker message",
+    });
+    return;
+  }
 
-    try {
-        const bytes = new Uint8Array(buffer);
-        let pixels;
+  if (!buffer || !decoderId) {
+    self.postMessage({
+      taskId,
+      error: "Missing required parameters: buffer or decoderId",
+    });
+    return;
+  }
 
-        switch (decoderId) {
-            case DECODER_TYPES.LZW: {
-                if (!maxUncompressedSize) {
-                    throw new Error('maxUncompressedSize required for LZW decoder');
-                }
-                const decoded = await decompress(bytes, maxUncompressedSize);
-                pixels = decoded.buffer;
-                break;
-            }
+  try {
+    const bytes = new Uint8Array(buffer);
+    let pixels;
 
-            case DECODER_TYPES.JP2K: {
-                const image = await decodeJPEG2000(bytes);
-                pixels = image.pixels.buffer;
-                break;
-            }
-
-            default:
-                throw new Error(`Unknown decoder type: ${decoderId}`);
+    switch (decoderId) {
+      case DECODER_TYPES.LZW: {
+        if (!maxUncompressedSize) {
+          throw new Error("maxUncompressedSize required for LZW decoder");
         }
+        const decoded = await decompress(bytes, maxUncompressedSize);
+        pixels = decoded.buffer;
+        break;
+      }
+
+      case DECODER_TYPES.JP2K: {
+        const image = await decodeJPEG2000(bytes);
+        pixels = image.pixels.buffer;
+        break;
+      }
 
-        // Transfer the ArrayBuffer to avoid copying
-        self.postMessage({ taskId, result: pixels }, [pixels]);
-    } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        self.postMessage({ 
-            taskId, 
-            error: errorMessage 
-        });
+      default:
+        throw new Error(`Unknown decoder type: ${decoderId}`);
     }
+
+    // Transfer the ArrayBuffer to avoid copying
+    self.postMessage({ taskId, result: pixels }, [pixels]);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    self.postMessage({
+      taskId,
+      error: errorMessage,
+    });
+  }
 };
 
 /**
  * Cleanup when worker is being terminated
  */
-self.addEventListener('close', () => {
-    cleanupJp2KDecoder();
+self.addEventListener("close", () => {
+  cleanupJp2KDecoder();
 });

package/app/components/.client/ImageViewer/state/decoders/genericDecoder.ts

@@ -23,117 +23,112 @@ const getWorkerPool = (): WorkerPool => {
 
 // Cache for decoded blocks with LRU eviction
 const bufferCache = new LRUCache<number, ArrayBuffer>({
-    max: CACHE_SIZE_LIMIT,
+  max: CACHE_SIZE_LIMIT,
 });
 
 export interface FileDirectory {
-    TileWidth?: number;
-    ImageWidth?: number;
-    TileLength?: number;
-    ImageLength?: number;
-    BitsPerSample: number[];
+  TileWidth?: number;
+  ImageWidth?: number;
+  TileLength?: number;
+  ImageLength?: number;
+  BitsPerSample: number[];
 }
 
 /**
  * Base decoder class for handling image block decoding with worker pool and caching
  */
 export class GenericDecoder extends BaseDecoder {
-    private readonly maxUncompressedSize: number;
+  private readonly maxUncompressedSize: number;
 
-    constructor(fileDirectory: FileDirectory) {
-        super();
+  constructor(fileDirectory: FileDirectory) {
+    super();
 
-        if (
-            !fileDirectory.BitsPerSample ||
-            fileDirectory.BitsPerSample.length === 0
-        ) {
-            throw new Error("FileDirectory must have BitsPerSample defined");
-        }
+    if (!fileDirectory.BitsPerSample || fileDirectory.BitsPerSample.length === 0) {
+      throw new Error("FileDirectory must have BitsPerSample defined");
+    }
+
+    const width = fileDirectory.TileWidth || fileDirectory.ImageWidth || 0;
+    const height = fileDirectory.TileLength || fileDirectory.ImageLength || 0;
+    const nbytes = fileDirectory.BitsPerSample[0] / 8;
 
-        const width = fileDirectory.TileWidth || fileDirectory.ImageWidth || 0;
-        const height =
-            fileDirectory.TileLength || fileDirectory.ImageLength || 0;
-        const nbytes = fileDirectory.BitsPerSample[0] / 8;
+    this.maxUncompressedSize = width * height * nbytes;
+  }
 
-        this.maxUncompressedSize = width * height * nbytes;
+  /**
+   * Decodes a compressed image block using worker pool and caching
+   * @param inputBuffer - The compressed image block
+   * @returns Decoded image buffer
+   */
+  async decodeBlock(inputBuffer: ArrayBuffer): Promise<ArrayBuffer> {
+    if (!inputBuffer || inputBuffer.byteLength === 0) {
+      throw new Error("Invalid input buffer: empty or null");
     }
 
-    /**
-     * Decodes a compressed image block using worker pool and caching
-     * @param inputBuffer - The compressed image block
-     * @returns Decoded image buffer
-     */
-    async decodeBlock(inputBuffer: ArrayBuffer): Promise<ArrayBuffer> {
-        if (!inputBuffer || inputBuffer.byteLength === 0) {
-            throw new Error("Invalid input buffer: empty or null");
-        }
-
-        const bufferHash = this.hashBuffer(inputBuffer);
-
-        // Check cache first
-        const cachedResult = bufferCache.get(bufferHash);
-        if (cachedResult) {
-            return cachedResult;
-        }
-
-        try {
-            const outputBuffer = await getWorkerPool().runTask({
-                buffer: inputBuffer,
-                maxUncompressedSize: this.maxUncompressedSize,
-                decoderId: this.getDecoderId(),
-            });
-
-            // Cache the result
-            bufferCache.set(bufferHash, outputBuffer);
-            return outputBuffer;
-        } catch (error) {
-            const errorMessage =
-                error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to decode block: ${errorMessage}`);
-        }
+    const bufferHash = this.hashBuffer(inputBuffer);
+
+    // Check cache first
+    const cachedResult = bufferCache.get(bufferHash);
+    if (cachedResult) {
+      return cachedResult;
     }
 
-    /**
-     * Returns the decoder identifier (must be overridden by subclasses)
-     */
-    public getDecoderId(): string {
-        return "uninitialized-decoder";
+    try {
+      const outputBuffer = await getWorkerPool().runTask({
+        buffer: inputBuffer,
+        maxUncompressedSize: this.maxUncompressedSize,
+        decoderId: this.getDecoderId(),
+      });
+
+      // Cache the result
+      bufferCache.set(bufferHash, outputBuffer);
+      return outputBuffer;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to decode block: ${errorMessage}`);
     }
+  }
 
-    /**
-     * FNV-1a hash function for ArrayBuffer - faster and better distribution than simple hash
-     * @param buffer - The buffer to hash
-     * @returns Hash value
-     */
-    private hashBuffer(buffer: ArrayBuffer): number {
-        const FNV_OFFSET_BASIS = 2166136261;
-        const FNV_PRIME = 16777619;
-
-        let hash = FNV_OFFSET_BASIS;
-        const view = new Uint8Array(buffer);
-        const len = view.length;
-
-        for (let i = 0; i < len; i++) {
-            hash ^= view[i];
-            hash = Math.imul(hash, FNV_PRIME);
-        }
-
-        return hash >>> 0; // Convert to unsigned 32-bit integer
+  /**
+   * Returns the decoder identifier (must be overridden by subclasses)
+   */
+  public getDecoderId(): string {
+    return "uninitialized-decoder";
+  }
+
+  /**
+   * FNV-1a hash function for ArrayBuffer - faster and better distribution than simple hash
+   * @param buffer - The buffer to hash
+   * @returns Hash value
+   */
+  private hashBuffer(buffer: ArrayBuffer): number {
+    const FNV_OFFSET_BASIS = 2166136261;
+    const FNV_PRIME = 16777619;
+
+    let hash = FNV_OFFSET_BASIS;
+    const view = new Uint8Array(buffer);
+    const len = view.length;
+
+    for (let i = 0; i < len; i++) {
+      hash ^= view[i];
+      hash = Math.imul(hash, FNV_PRIME);
     }
+
+    return hash >>> 0; // Convert to unsigned 32-bit integer
+  }
 }
 
 /**
  * Clears the decoder cache
  */
 export function clearDecoderCache(): void {
-    bufferCache.clear();
+  bufferCache.clear();
 }
 
 /**
  * Terminates the worker pool and releases resources
  */
 export function shutdownDecoderPool(): void {
-    workerPool?.terminate();
-    workerPool = null;
-    bufferCache.clear();
+  workerPool?.terminate();
+  workerPool = null;
+  bufferCache.clear();
 }

package/app/components/.client/ImageViewer/state/decoders/jp2k-decoder.ts

@@ -5,14 +5,14 @@ import { GenericDecoder, FileDirectory } from "./genericDecoder";
  * Used for decoding JPEG2000-compressed image data
  */
 export class JP2KDecoder extends GenericDecoder {
-    constructor(fileDirectory: FileDirectory) {
-        super(fileDirectory);
-    }
+  constructor(fileDirectory: FileDirectory) {
+    super(fileDirectory);
+  }
 
-    /**
-     * Returns the decoder identifier for the worker pool
-     */
-    public getDecoderId(): string {
-        return "jp2k-decoder";
-    }
+  /**
+   * Returns the decoder identifier for the worker pool
+   */
+  public getDecoderId(): string {
+    return "jp2k-decoder";
+  }
 }

package/app/components/.client/ImageViewer/state/decoders/lzwDecoder.ts

@@ -5,14 +5,14 @@ import { GenericDecoder, FileDirectory } from "./genericDecoder";
  * Used for decoding LZW-compressed TIFF image data
  */
 export class LZWDecoder extends GenericDecoder {
-    constructor(fileDirectory: FileDirectory) {
-        super(fileDirectory);
-    }
+  constructor(fileDirectory: FileDirectory) {
+    super(fileDirectory);
+  }
 
-    /**
-     * Returns the decoder identifier for the worker pool
-     */
-    public getDecoderId(): string {
-        return "lzw-decoder";
-    }
+  /**
+   * Returns the decoder identifier for the worker pool
+   */
+  public getDecoderId(): string {
+    return "lzw-decoder";
+  }
 }

package/app/components/.client/ImageViewer/state/loaders/loadBioformatsZarrWithCredentials.ts

@@ -59,15 +59,11 @@ export function rootAttrsToImage(rootAttrs: RootAttrs, loader: Loader): Image {
   const SizeT = shape[dimIndex("t")] ?? 1;
   const SizeC = shape[dimIndex("c")] ?? (channels.length || 1);
 
-  const { PhysicalSizeX, PhysicalSizeY, PhysicalSizeZ } = extractPhysicalSizes(
-    multiscale,
-    axes,
-  );
+  const { PhysicalSizeX, PhysicalSizeY, PhysicalSizeZ } = extractPhysicalSizes(multiscale, axes);
 
   const axisUnit = (name: string) => {
     const axis = axes.find(
-      (a): a is { name: string; unit?: string } =>
-        typeof a !== "string" && a.name === name,
+      (a): a is { name: string; unit?: string } => typeof a !== "string" && a.name === name,
     );
     return axis?.unit ?? "µm";
   };
@@ -94,13 +90,11 @@ export function rootAttrsToImage(rootAttrs: RootAttrs, loader: Loader): Image {
       PhysicalSizeXUnit: axisUnit("x"),
       PhysicalSizeYUnit: axisUnit("y"),
       PhysicalSizeZUnit: axisUnit("z"),
-      Channels: channels.map(
-        (ch: { label: string; color: string }, i: number) => ({
-          ID: `Channel:0:${i}`,
-          Name: ch.label,
-          Color: parseOmeroColor(ch.color),
-        }),
-      ),
+      Channels: channels.map((ch: { label: string; color: string }, i: number) => ({
+        ID: `Channel:0:${i}`,
+        Name: ch.label,
+        Color: parseOmeroColor(ch.color),
+      })),
     },
   } as Image;
 }
@@ -112,18 +106,14 @@ export function extractPhysicalSizes(
 ) {
   const datasets = (multiscale?.datasets ?? []) as DatasetWithTransforms[];
   const firstDataset = datasets[0];
-  const scaleTransform = firstDataset?.coordinateTransformations?.find(
-    (t) => t.type === "scale",
-  );
+  const scaleTransform = firstDataset?.coordinateTransformations?.find((t) => t.type === "scale");
 
   if (!scaleTransform?.scale || !axes) {
     return {};
   }
 
   const resolvedAxes =
-    axes.map((a: string | { name: string }) =>
-      typeof a === "string" ? a : a.name,
-    ) ?? [];
+    axes.map((a: string | { name: string }) => (typeof a === "string" ? a : a.name)) ?? [];
 
   const scaleForAxis = (name: string): number | undefined => {
     const idx = resolvedAxes.indexOf(name);
@@ -141,9 +131,7 @@ export function extractPhysicalSizes(
  * Omero colors are hex strings — "FF0000" (RGB) or "FF0000FF" (RGBA).
  * Exported for testing.
  */
-export function parseOmeroColor(
-  color: string,
-): [number, number, number, number] | undefined {
+export function parseOmeroColor(color: string): [number, number, number, number] | undefined {
   if (!color) return undefined;
 
   const hex = color.replace(/^#/, "");

package/app/components/.client/ImageViewer/state/store/ViewerStoreContext.tsx

@@ -82,32 +82,18 @@ interface ViewerStoreProviderProps {
 }
 
 // Viewer is auth-agnostic — caller owns URL construction and signing.
-export const ViewerStoreProvider = ({
-  url,
-  signedFetch,
-  children,
-}: ViewerStoreProviderProps) => {
+export const ViewerStoreProvider = ({ url, signedFetch, children }: ViewerStoreProviderProps) => {
   const registerViewer = useViewerRegistryStore((s) => s.registerViewer);
 
-  const store = useMemo(
-    () => registerViewer(url, signedFetch),
-    [url, signedFetch, registerViewer],
-  );
+  const store = useMemo(() => registerViewer(url, signedFetch), [url, signedFetch, registerViewer]);
 
-  return (
-    <ViewerStoreContext.Provider value={store}>
-      {children}
-    </ViewerStoreContext.Provider>
-  );
+  return <ViewerStoreContext.Provider value={store}>{children}</ViewerStoreContext.Provider>;
 };
 
 /** Access the viewer store from within a ViewerStoreProvider. */
 export const useViewerStore = <T,>(selector: (state: ViewerStore) => T): T => {
   const store = useContext(ViewerStoreContext);
 
-  if (!store)
-    throw new Error(
-      "useViewerStoreContext must be used within ViewerStoreProvider",
-    );
+  if (!store) throw new Error("useViewerStoreContext must be used within ViewerStoreProvider");
   return useStore(store, selector);
 };