@fideus-labs/fidnii 0.1.0 → 0.2.0

package/src/index.ts

@@ -34,30 +34,13 @@
  * ```
  */
 
-// Main class
-export { OMEZarrNVImage } from "./OMEZarrNVImage.js";
-
-// Types
-export type {
-  AttachedNiivueState,
-  ChunkAlignedRegion,
-  ChunkCache,
-  ClipPlane,
-  ClipPlanes,
-  OMEZarrNVImageOptions,
-  PixelRegion,
-  RegionFetchResult,
-  ResolutionSelection,
-  SlabBufferState,
-  SlabSliceType,
-  TypedArray,
-  VolumeBounds,
-  ZarrDtype,
-} from "./types.js";
-
-// Re-export SLICE_TYPE from types (which re-exports from niivue)
-export { SLICE_TYPE } from "./types.js";
+// Re-export Methods enum so consumers can check isLabelImage or compare method values
+export { Methods } from "@fideus-labs/ngff-zarr"
+// Worker pool lifecycle (re-exported from ngff-zarr)
+export { terminateWorkerPool } from "@fideus-labs/ngff-zarr/browser"
 
+// Buffer manager
+export { BufferManager } from "./BufferManager.js"
 // Clip planes utilities
 export {
   alignToChunks,
@@ -77,8 +60,20 @@ export {
   normalToAzimuthElevation,
   pointToPlaneDistance,
   validateClipPlanes,
-} from "./ClipPlanes.js";
-
+} from "./ClipPlanes.js"
+export type {
+  OMEZarrNVImageEventListener,
+  OMEZarrNVImageEventListenerOptions,
+  OMEZarrNVImageEventMap,
+  PopulateTrigger,
+} from "./events.js"
+// Event system (browser-native EventTarget API)
+export { OMEZarrNVImageEvent } from "./events.js"
+// Main class
+export { OMEZarrNVImage } from "./OMEZarrNVImage.js"
+// Region coalescer
+export { RegionCoalescer } from "./RegionCoalescer.js"
+export type { OrthogonalAxis } from "./ResolutionSelector.js"
 // Resolution selector utilities
 export {
   alignRegionToChunks,
@@ -89,16 +84,43 @@ export {
   getVolumeShape,
   select2DResolution,
   selectResolution,
-} from "./ResolutionSelector.js";
-
-export type { OrthogonalAxis } from "./ResolutionSelector.js";
-
-// Buffer manager
-export { BufferManager } from "./BufferManager.js";
-
-// Region coalescer
-export { RegionCoalescer } from "./RegionCoalescer.js";
-
+} from "./ResolutionSelector.js"
+// Types
+export type {
+  AttachedNiivueState,
+  ChunkAlignedRegion,
+  ChunkCache,
+  ClipPlane,
+  ClipPlanes,
+  OMEZarrNVImageOptions,
+  PixelRegion,
+  RegionFetchResult,
+  ResolutionSelection,
+  SlabBufferState,
+  SlabSliceType,
+  TypedArray,
+  VolumeBounds,
+  ZarrDtype,
+} from "./types.js"
+// Re-export SLICE_TYPE from types (which re-exports from niivue)
+// Type utilities
+export {
+  getBytesPerPixel,
+  getNiftiDataType,
+  getTypedArrayConstructor,
+  NiftiDataType,
+  parseZarritaDtype,
+  SLICE_TYPE,
+} from "./types.js"
+// Affine utilities
+export {
+  affineToNiftiSrows,
+  calculateWorldBounds,
+  createAffineFromNgffImage,
+  createAffineFromOMEZarr,
+  getPixelDimensions,
+  updateAffineForRegion,
+} from "./utils/affine.js"
 // Coordinate utilities
 export {
   ceilPixelCoord,
@@ -111,43 +133,11 @@ export {
   worldToNormalized,
   worldToPixel,
   worldToPixelAffine,
-} from "./utils/coordinates.js";
-
-// Affine utilities
-export {
-  affineToNiftiSrows,
-  calculateWorldBounds,
-  createAffineFromNgffImage,
-  createAffineFromOMEZarr,
-  getPixelDimensions,
-  updateAffineForRegion,
-} from "./utils/affine.js";
-
-// Type utilities
-export {
-  getBytesPerPixel,
-  getNiftiDataType,
-  getTypedArrayConstructor,
-  NiftiDataType,
-  parseZarritaDtype,
-} from "./types.js";
-
-// Worker pool lifecycle (re-exported from ngff-zarr)
-export { terminateWorkerPool } from "@fideus-labs/ngff-zarr/browser";
-
+} from "./utils/coordinates.js"
 // Viewport bounds utilities
 export {
   boundsApproxEqual,
   computeViewportBounds2D,
   computeViewportBounds3D,
   intersectBounds,
-} from "./ViewportBounds.js";
-
-// Event system (browser-native EventTarget API)
-export { OMEZarrNVImageEvent } from "./events.js";
-export type {
-  OMEZarrNVImageEventListener,
-  OMEZarrNVImageEventListenerOptions,
-  OMEZarrNVImageEventMap,
-  PopulateTrigger,
-} from "./events.js";
+} from "./ViewportBounds.js"

package/src/types.ts

@@ -1,11 +1,12 @@
 // SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
 // SPDX-License-Identifier: MIT
 
-import type { Multiscales } from "@fideus-labs/ngff-zarr";
-import type { Niivue, NVImage } from "@niivue/niivue";
-import { SLICE_TYPE } from "@niivue/niivue";
-import type { BufferManager } from "./BufferManager.js";
-import type { PopulateTrigger } from "./events.js";
+import type { Multiscales } from "@fideus-labs/ngff-zarr"
+import type { Niivue, NVImage } from "@niivue/niivue"
+import { SLICE_TYPE } from "@niivue/niivue"
+
+import type { BufferManager } from "./BufferManager.js"
+import type { PopulateTrigger } from "./events.js"
 
 /**
  * A single clip plane defined by a point and normal vector.
@@ -14,9 +15,9 @@ import type { PopulateTrigger } from "./events.js";
  */
 export interface ClipPlane {
   /** A point on the plane (center of volume projected to plane) [x, y, z] in world coordinates */
-  point: [number, number, number];
+  point: [number, number, number]
   /** Unit normal vector pointing toward visible region [x, y, z] */
-  normal: [number, number, number];
+  normal: [number, number, number]
 }
 
 /**
@@ -24,14 +25,14 @@ export interface ClipPlane {
  * Each plane clips away the half-space on the negative side of its normal.
  * Maximum 6 planes (NiiVue limit). Empty array = full volume visible.
  */
-export type ClipPlanes = ClipPlane[];
+export type ClipPlanes = ClipPlane[]
 
 /**
  * Volume bounds in world space.
  */
 export interface VolumeBounds {
-  min: [number, number, number];
-  max: [number, number, number];
+  min: [number, number, number]
+  max: [number, number, number]
 }
 
 /**
@@ -40,9 +41,9 @@ export interface VolumeBounds {
  */
 export interface PixelRegion {
   /** Start indices [z, y, x] (inclusive) */
-  start: [number, number, number];
+  start: [number, number, number]
   /** End indices [z, y, x] (exclusive) */
-  end: [number, number, number];
+  end: [number, number, number]
 }
 
 /**
@@ -50,11 +51,11 @@ export interface PixelRegion {
  */
 export interface ChunkAlignedRegion extends PixelRegion {
   /** Chunk-aligned start indices [z, y, x] */
-  chunkAlignedStart: [number, number, number];
+  chunkAlignedStart: [number, number, number]
   /** Chunk-aligned end indices [z, y, x] */
-  chunkAlignedEnd: [number, number, number];
+  chunkAlignedEnd: [number, number, number]
   /** True if the original region didn't align with chunk boundaries */
-  needsClipping: boolean;
+  needsClipping: boolean
 }
 
 /**
@@ -62,11 +63,11 @@ export interface ChunkAlignedRegion extends PixelRegion {
  */
 export interface ResolutionSelection {
   /** Index into multiscales.images array */
-  levelIndex: number;
+  levelIndex: number
   /** Dimensions of the buffer [z, y, x] */
-  dimensions: [number, number, number];
+  dimensions: [number, number, number]
   /** Total pixel count */
-  pixelCount: number;
+  pixelCount: number
 }
 
 /**
@@ -93,9 +94,9 @@ export interface ResolutionSelection {
  */
 export interface ChunkCache {
   /** Look up a cached decoded chunk by key. */
-  get(key: string): unknown | undefined;
+  get(key: string): unknown | undefined
   /** Store a decoded chunk under the given key. */
-  set(key: string, value: unknown): void;
+  set(key: string, value: unknown): void
 }
 
 /**
@@ -103,36 +104,36 @@ export interface ChunkCache {
  */
 export interface OMEZarrNVImageOptions {
   /** The OME-Zarr multiscales data */
-  multiscales: Multiscales;
+  multiscales: Multiscales
   /** Reference to the NiiVue instance for rendering updates */
-  niivue: Niivue;
+  niivue: Niivue
   /** Maximum number of pixels to use (default: 50,000,000) */
-  maxPixels?: number;
+  maxPixels?: number
   /** Debounce delay for clip plane data refetch in milliseconds (default: 300) */
-  clipPlaneDebounceMs?: number;
+  clipPlaneDebounceMs?: number
   /**
    * Automatically add to NiiVue and start progressive loading (default: true).
    * Set to false to manually control when populateVolume() is called.
    * Listen to 'populateComplete' event to know when loading finishes.
    */
-  autoLoad?: boolean;
+  autoLoad?: boolean
   /**
    * Maximum 3D render zoom level for scroll-wheel zoom (default: 10.0).
    * NiiVue's built-in 3D zoom is hardcoded to [0.5, 2.0]. This option
    * overrides the scroll-wheel zoom handler to allow zooming beyond that limit.
    */
-  max3DZoom?: number;
+  max3DZoom?: number
   /**
    * Minimum 3D render zoom level for scroll-wheel zoom (default: 0.3).
    * @see max3DZoom
    */
-  min3DZoom?: number;
+  min3DZoom?: number
   /**
    * Enable viewport-aware resolution selection (default: true).
    * When enabled, zoom/pan interactions constrain the fetch region to the
    * visible viewport, allowing higher resolution within the same maxPixels budget.
    */
-  viewportAware?: boolean;
+  viewportAware?: boolean
   /**
    * Maximum number of decoded-chunk cache entries (default: 200).
    *
@@ -142,7 +143,7 @@ export interface OMEZarrNVImageOptions {
    *
    * Set to `0` to disable caching entirely.
    */
-  maxCacheEntries?: number;
+  maxCacheEntries?: number
   /**
    * Optional pre-built decoded-chunk cache. When provided, overrides the
    * internal LRU cache created from `maxCacheEntries`.
@@ -152,7 +153,7 @@ export interface OMEZarrNVImageOptions {
    *
    * @see {@link ChunkCache}
    */
-  cache?: ChunkCache;
+  cache?: ChunkCache
 }
 
 /**
@@ -160,11 +161,11 @@ export interface OMEZarrNVImageOptions {
  */
 export interface RegionFetchResult {
   /** The pixel data as a typed array */
-  data: TypedArray;
+  data: TypedArray
   /** Shape of the fetched data [z, y, x] */
-  shape: number[];
+  shape: number[]
   /** Stride of the fetched data */
-  stride: number[];
+  stride: number[]
 }
 
 /**
@@ -178,7 +179,7 @@ export type ZarrDtype =
   | "int16"
   | "int32"
   | "float32"
-  | "float64";
+  | "float64"
 
 /**
  * Union of all typed array types we support.
@@ -191,7 +192,7 @@ export type TypedArray =
   | Int16Array
   | Int32Array
   | Float32Array
-  | Float64Array;
+  | Float64Array
 
 /**
  * Typed arrays supported by NiiVue.
@@ -202,10 +203,10 @@ export type NiiVueTypedArray =
   | Uint16Array
   | Int16Array
   | Float32Array
-  | Float64Array;
+  | Float64Array
 
 // Re-export SLICE_TYPE for convenience
-export { SLICE_TYPE };
+export { SLICE_TYPE }
 
 /**
  * The 2D slice types that use slab-based loading.
@@ -214,7 +215,7 @@ export { SLICE_TYPE };
 export type SlabSliceType =
   | typeof SLICE_TYPE.AXIAL
   | typeof SLICE_TYPE.CORONAL
-  | typeof SLICE_TYPE.SAGITTAL;
+  | typeof SLICE_TYPE.SAGITTAL
 
 /**
  * State for a per-slice-type slab buffer.
@@ -225,37 +226,37 @@ export type SlabSliceType =
  */
 export interface SlabBufferState {
   /** The NVImage instance for this slab */
-  nvImage: NVImage;
+  nvImage: NVImage
   /** Buffer manager for this slab's pixel data */
-  bufferManager: BufferManager;
+  bufferManager: BufferManager
   /** Current resolution level index for this slab */
-  levelIndex: number;
+  levelIndex: number
   /** Target resolution level index for this slab */
-  targetLevelIndex: number;
+  targetLevelIndex: number
   /** Start index of the currently loaded slab in the orthogonal axis (pixel coords at current level) */
-  slabStart: number;
+  slabStart: number
   /** End index of the currently loaded slab in the orthogonal axis (pixel coords at current level) */
-  slabEnd: number;
+  slabEnd: number
   /** Whether this slab is currently loading */
-  isLoading: boolean;
+  isLoading: boolean
   /** Data type of the slab */
-  dtype: ZarrDtype;
+  dtype: ZarrDtype
   /**
    * The affine normalization scale applied to the slab NVImage header.
    * NiiVue mm values = world * normalizationScale.
    * This is 1/maxVoxelSize where maxVoxelSize = max(sx, sy, sz).
    * Used to convert NiiVue 2D FOV coordinates back to physical world coords.
    */
-  normalizationScale: number;
+  normalizationScale: number
   /**
    * Pending reload request queued while this slab was loading.
    * Latest-wins semantics: only the most recent request is kept.
    * Auto-drained when the current load completes.
    */
   pendingReload: {
-    worldCoord: [number, number, number];
-    trigger: PopulateTrigger;
-  } | null;
+    worldCoord: [number, number, number]
+    trigger: PopulateTrigger
+  } | null
 }
 
 /**
@@ -263,25 +264,25 @@ export interface SlabBufferState {
  */
 export interface AttachedNiivueState {
   /** The Niivue instance */
-  nv: Niivue;
+  nv: Niivue
   /** The current slice type of this NV instance */
-  currentSliceType: SLICE_TYPE;
+  currentSliceType: SLICE_TYPE
   /** Previous onLocationChange callback (to chain) */
-  previousOnLocationChange?: (location: unknown) => void;
+  previousOnLocationChange?: (location: unknown) => void
   /** Previous onOptsChange callback (to chain) */
   previousOnOptsChange?: (
     propertyName: string,
     newValue: unknown,
     oldValue: unknown,
-  ) => void;
+  ) => void
   /** Previous onMouseUp callback (to chain, for viewport-aware mode) */
-  previousOnMouseUp?: (data: unknown) => void;
+  previousOnMouseUp?: (data: unknown) => void
   /** Previous onZoom3DChange callback (to chain, for viewport-aware mode) */
-  previousOnZoom3DChange?: (zoom: number) => void;
+  previousOnZoom3DChange?: (zoom: number) => void
   /** AbortController for viewport-aware event listeners (wheel, etc.) */
-  viewportAbortController?: AbortController;
+  viewportAbortController?: AbortController
   /** AbortController for the 3D zoom override wheel listener */
-  zoomOverrideAbortController?: AbortController;
+  zoomOverrideAbortController?: AbortController
 }
 
 /**
@@ -295,7 +296,7 @@ export type TypedArrayConstructor =
   | Int16ArrayConstructor
   | Int32ArrayConstructor
   | Float32ArrayConstructor
-  | Float64ArrayConstructor;
+  | Float64ArrayConstructor
 
 /**
  * NIfTI data type codes.
@@ -309,10 +310,10 @@ export const NiftiDataType = {
   INT8: 256,
   UINT16: 512,
   UINT32: 768,
-} as const;
+} as const
 
 export type NiftiDataTypeCode =
-  (typeof NiftiDataType)[keyof typeof NiftiDataType];
+  (typeof NiftiDataType)[keyof typeof NiftiDataType]
 
 /**
  * Map zarr dtype to typed array constructor.
@@ -322,23 +323,23 @@ export function getTypedArrayConstructor(
 ): TypedArrayConstructor {
   switch (dtype) {
     case "uint8":
-      return Uint8Array;
+      return Uint8Array
     case "uint16":
-      return Uint16Array;
+      return Uint16Array
     case "uint32":
-      return Uint32Array;
+      return Uint32Array
     case "int8":
-      return Int8Array;
+      return Int8Array
     case "int16":
-      return Int16Array;
+      return Int16Array
     case "int32":
-      return Int32Array;
+      return Int32Array
     case "float32":
-      return Float32Array;
+      return Float32Array
     case "float64":
-      return Float64Array;
+      return Float64Array
     default:
-      throw new Error(`Unsupported dtype: ${dtype}`);
+      throw new Error(`Unsupported dtype: ${dtype}`)
   }
 }
 
@@ -349,18 +350,18 @@ export function getBytesPerPixel(dtype: ZarrDtype): number {
   switch (dtype) {
     case "uint8":
     case "int8":
-      return 1;
+      return 1
     case "uint16":
     case "int16":
-      return 2;
+      return 2
     case "uint32":
     case "int32":
     case "float32":
-      return 4;
+      return 4
     case "float64":
-      return 8;
+      return 8
     default:
-      throw new Error(`Unsupported dtype: ${dtype}`);
+      throw new Error(`Unsupported dtype: ${dtype}`)
   }
 }
 
@@ -370,23 +371,23 @@ export function getBytesPerPixel(dtype: ZarrDtype): number {
 export function getNiftiDataType(dtype: ZarrDtype): NiftiDataTypeCode {
   switch (dtype) {
     case "uint8":
-      return NiftiDataType.UINT8;
+      return NiftiDataType.UINT8
     case "uint16":
-      return NiftiDataType.UINT16;
+      return NiftiDataType.UINT16
     case "uint32":
-      return NiftiDataType.UINT32;
+      return NiftiDataType.UINT32
     case "int8":
-      return NiftiDataType.INT8;
+      return NiftiDataType.INT8
     case "int16":
-      return NiftiDataType.INT16;
+      return NiftiDataType.INT16
     case "int32":
-      return NiftiDataType.INT32;
+      return NiftiDataType.INT32
     case "float32":
-      return NiftiDataType.FLOAT32;
+      return NiftiDataType.FLOAT32
     case "float64":
-      return NiftiDataType.FLOAT64;
+      return NiftiDataType.FLOAT64
     default:
-      throw new Error(`Unsupported dtype: ${dtype}`);
+      throw new Error(`Unsupported dtype: ${dtype}`)
   }
 }
 
@@ -396,34 +397,34 @@ export function getNiftiDataType(dtype: ZarrDtype): NiftiDataTypeCode {
  */
 export function parseZarritaDtype(dtype: string): ZarrDtype {
   // Remove endianness prefix if present
-  const normalized = dtype.replace(/^[|<>]/, "");
+  const normalized = dtype.replace(/^[|<>]/, "")
 
   switch (normalized) {
     case "u1":
     case "uint8":
-      return "uint8";
+      return "uint8"
     case "u2":
     case "uint16":
-      return "uint16";
+      return "uint16"
     case "u4":
     case "uint32":
-      return "uint32";
+      return "uint32"
     case "i1":
     case "int8":
-      return "int8";
+      return "int8"
     case "i2":
     case "int16":
-      return "int16";
+      return "int16"
     case "i4":
     case "int32":
-      return "int32";
+      return "int32"
     case "f4":
     case "float32":
-      return "float32";
+      return "float32"
     case "f8":
     case "float64":
-      return "float64";
+      return "float64"
     default:
-      throw new Error(`Unsupported zarrita dtype: ${dtype}`);
+      throw new Error(`Unsupported zarrita dtype: ${dtype}`)
   }
 }