@aics/vole-core 3.12.4 → 3.13.0

package/README.md

@@ -16,7 +16,7 @@ There are several ways to deliver volume data to the viewer:
 - Load raw TypedArrays of 3d volume data ( see `RawArrayLoader` and `Volume.setChannelDataFromVolume` ).
 - (legacy) Load texture atlases as .png files or Uint8Arrays containing volume slices tiled across a 2d image ( see `JsonImageInfoLoader` and `Volume.setChannelDataFromAtlas` ).
 
-# Example
+## Example
 
 See [`public/index.ts`](./public/index.ts) for a working example. (`npm install; npm run dev` will run that code)
 
@@ -59,19 +59,20 @@ view3D.addVolume(volume);
 loader.loadVolumeData(volume);
 ```
 
-# React example
+## React example
 
-See [vole-app](https://github.com/allen-cell-animated/website-3d-cell-viewer) for a complete application that wraps View3D in a React component.
+See [vole-app](https://github.com/allen-cell-animated/vole-app) for a complete application that wraps View3D in a React component.
 
-# Acknowledgements
+## Acknowledgements
 
 The ray marched volume shader is a heavily modified version of one that has its origins in [Bisque](http://bioimage.ucsb.edu/bisque).
 The core path tracing implementation was adapted from ExposureRender.
 
-## BisQue license
+### BisQue license
 
 Center for Bio-Image Informatics, University of California at Santa Barbara
 
+```text
 Copyright (c) 2007-2017 by the Regents of the University of California
 All rights reserved
 
@@ -106,14 +107,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 The views and conclusions contained in the software and documentation
 are those of the authors and should not be interpreted as representing
 official policies, either expressed or implied, of the Regents of the University of California.
+```
 
 ## Exposure Render license
 
-    Copyright (c) 2011, T. Kroes <t.kroes@tudelft.nl>
-    All rights reserved.
-    Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-    - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-    - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-    - Neither the name of the TU Delft nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+```text
+Copyright (c) 2011, T. Kroes <t.kroes@tudelft.nl>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+- Neither the name of the TU Delft nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
 
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```

package/es/View3d.js

@@ -826,16 +826,21 @@ export class View3d {
     const prefetch = pane.addFolder({
       title: "Prefetch"
     });
+    // Not all `IVolumeLoader`s implement `updateFetchOptions`. This cast makes it sound to try to call it, but we
+    //   still have to be careful to null-check it!
+    // TODO depending on how the relationship between loaders and images pans out, it's not impossible that the loader
+    //   for an image will be changeable and this variable will capture a stale reference to old loaders. Careful!
+    const loader = this.image?.volume.loader;
     // one number will be used for all axis directions
     prefetch.addInput(allGlobalLoadingOptions, "numChunksToPrefetchAhead").on("change", event => {
-      this.loaderContext?.getActiveLoader()?.updateFetchOptions({
+      loader?.updateFetchOptions?.({
         maxPrefetchDistance: [event.value, event.value, event.value, event.value]
       });
       this.image?.volume.updateRequiredData({});
     });
     // should we try to prefetch along Z even if we are only playing along T?
     prefetch.addInput(allGlobalLoadingOptions, "prefetchAlongNonPlayingAxis").on("change", event => {
-      this.loaderContext?.getActiveLoader()?.updateFetchOptions({
+      loader?.updateFetchOptions?.({
         onlyPriorityDirections: !event.value
       });
     });

package/es/VolumeRenderSettings.js

@@ -3,14 +3,23 @@ import { Euler, Vector2, Vector3 } from "three";
  * Marks groups of related settings that may have changed.
  */
 export let SettingsFlags = /*#__PURE__*/function (SettingsFlags) {
+  /** parameters: translation, rotation, scale, flipAxes */
   SettingsFlags[SettingsFlags["TRANSFORM"] = 1] = "TRANSFORM";
+  /** parameters: gammaMin, gammaLevel, gammaMax, brightness*/
   SettingsFlags[SettingsFlags["CAMERA"] = 2] = "CAMERA";
+  /** parameters: showBoundingBox, boundingBoxColor */
   SettingsFlags[SettingsFlags["BOUNDING_BOX"] = 4] = "BOUNDING_BOX";
+  /** parameters: bounds, zSlice */
   SettingsFlags[SettingsFlags["ROI"] = 8] = "ROI";
+  /** parameters: maskAlpha */
   SettingsFlags[SettingsFlags["MASK_ALPHA"] = 16] = "MASK_ALPHA";
+  /** parameters: density, diffuse, specular, emissive, glossiness */
   SettingsFlags[SettingsFlags["MATERIAL"] = 32] = "MATERIAL";
+  /** parameters: resolution, useInterpolation, pixelSamplingRate, primaryRayStepSize, secondaryRayStepSize*/
   SettingsFlags[SettingsFlags["SAMPLING"] = 64] = "SAMPLING";
+  /** parameters: isOrtho, orthoScale, viewAxis, visible, maxProjectMode */
   SettingsFlags[SettingsFlags["VIEW"] = 128] = "VIEW";
+  /** parameters: maskChannelIndex */
   SettingsFlags[SettingsFlags["MASK_DATA"] = 256] = "MASK_DATA";
   SettingsFlags[SettingsFlags["ALL"] = 1023] = "ALL";
   return SettingsFlags;
@@ -19,7 +28,9 @@ export let Axis = /*#__PURE__*/function (Axis) {
   Axis["X"] = "x";
   Axis["Y"] = "y";
   Axis["Z"] = "z";
+  /** Alias for NONE, indicates 3D mode */
   Axis["XYZ"] = "";
+  /** No current axis, indicates 3D mode */
   Axis["NONE"] = "";
   return Axis;
 }({});

package/es/loaders/TiffLoader.js

@@ -191,7 +191,9 @@ class TiffLoader extends ThreadableVolumeLoader {
           bytesPerSample: getBytesPerSample(dims.pixeltype),
           url: this.url
         };
-        const worker = new Worker(new URL("../workers/FetchTiffWorker", import.meta.url));
+        const worker = new Worker(new URL("../workers/FetchTiffWorker", import.meta.url), {
+          type: "module"
+        });
         worker.onmessage = e => {
           if (e.data.isError) {
             reject(deserializeError(e.data.error));

package/es/types/NaiveSurfaceNets.d.ts

@@ -7,5 +7,5 @@ declare function SurfaceNets(data: any, dims: any, isovalue: any): {
     vertices: number[][];
     faces: number[][];
 };
-declare function ConstructTHREEGeometry(surfaceNetResult: any): BufferGeometry[];
+declare function ConstructTHREEGeometry(surfaceNetResult: any): BufferGeometry<import("three").NormalBufferAttributes>[];
 import { BufferGeometry } from "three/src/core/BufferGeometry";

package/es/types/RayMarchedAtlasVolume.d.ts

@@ -33,7 +33,7 @@ export default class RayMarchedAtlasVolume implements VolumeRenderImpl {
     private createGeometry;
     private createTickMarks;
     cleanup(): void;
-    doRender(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture): void;
+    doRender(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture | null): void;
     get3dObject(): Group;
     private setUniform;
     updateActiveChannels(channelcolors: FuseChannel[], channeldata: Channel[]): void;

package/es/types/ThreeJsPanel.d.ts

@@ -18,7 +18,7 @@ export declare class ThreeJsPanel {
     scene: Scene;
     private meshRenderTarget;
     private meshRenderToBuffer;
-    animateFuncs: ((renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture) => void)[];
+    animateFuncs: ((renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | null) => void)[];
     private inRenderLoop;
     private requestedRender;
     hasWebGL2: boolean;
@@ -81,7 +81,7 @@ export declare class ThreeJsPanel {
     replaceCamera(newCam: PerspectiveCamera | OrthographicCamera): void;
     replaceControls(newControls: TrackballControls): void;
     switchViewMode(mode: string): void;
-    getMeshDepthTexture(): DepthTexture;
+    getMeshDepthTexture(): DepthTexture | null;
     resize(comp: HTMLElement | null, w?: number, h?: number, _ow?: number, _oh?: number, _eOpts?: unknown): void;
     setClearColor(color: Color, alpha: number): void;
     getWidth(): number;

package/es/types/TrackballControls.d.ts

@@ -1,5 +1,5 @@
 export default TrackballControls;
-declare class TrackballControls extends EventDispatcher<import("three").Event> {
+declare class TrackballControls extends EventDispatcher<any> {
     constructor(object: any, domElement: any);
     object: any;
     domElement: any;

package/es/types/VolumeDrawable.d.ts

@@ -56,7 +56,7 @@ export default class VolumeDrawable {
     setGamma(gmin: number, glevel: number, gmax: number): void;
     setFlipAxes(flipX: -1 | 1, flipY: -1 | 1, flipZ: -1 | 1): void;
     setMaxProjectMode(isMaxProject: boolean): void;
-    onAnimate(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture): void;
+    onAnimate(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture | null): void;
     getViewMode(): Axis;
     getIsovalue(channel: number): number | undefined;
     hasIsosurface(channel: number): boolean;

package/es/types/VolumeRenderImpl.d.ts

@@ -13,7 +13,7 @@ export interface VolumeRenderImpl {
      */
     updateSettings: (settings: VolumeRenderSettings, dirtyFlags?: number | SettingsFlags) => void;
     get3dObject: () => Object3D;
-    doRender: (renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture) => void;
+    doRender: (renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture | null) => void;
     updateVolumeDimensions: () => void;
     cleanup: () => void;
     viewpointMoved: () => void;

package/es/types/index.d.ts

@@ -22,7 +22,7 @@ import { Light, AREA_LIGHT, SKY_LIGHT } from "./Light.js";
 export type { ImageInfo } from "./ImageInfo.js";
 export type { ControlPoint } from "./Lut.js";
 export type { CreateLoaderOptions } from "./loaders/index.js";
-export type { IVolumeLoader, PerChannelCallback } from "./loaders/IVolumeLoader.js";
+export type { IVolumeLoader, PerChannelCallback, ThreadableVolumeLoader } from "./loaders/IVolumeLoader.js";
 export type { ZarrLoaderFetchOptions } from "./loaders/OmeZarrLoader.js";
 export type { WorkerLoader } from "./workers/VolumeLoaderContext.js";
 export { Histogram, Lut, remapControlPoints, View3d, Volume, VolumeDrawable, LoadSpec, VolumeMaker, VolumeCache, RequestQueue, SubscribableRequestQueue, PrefetchDirection, OMEZarrLoader, JsonImageInfoLoader, RawArrayLoader, type RawArrayData, type RawArrayInfo, type RawArrayLoaderOptions, TiffLoader, VolumeLoaderContext, VolumeLoadError, VolumeLoadErrorType, VolumeFileFormat, createVolumeLoader, Channel, Light, ViewportCorner, AREA_LIGHT, RENDERMODE_PATHTRACE, RENDERMODE_RAYMARCH, SKY_LIGHT, type CameraState, };

package/es/types/workers/VolumeLoaderContext.d.ts

@@ -4,9 +4,8 @@ import { CreateLoaderOptions, PrefetchDirection } from "../loaders/index.js";
 import { ThreadableVolumeLoader, LoadSpec, RawChannelDataCallback, LoadedVolumeInfo } from "../loaders/IVolumeLoader.js";
 import { RawArrayLoader } from "../loaders/RawArrayLoader.js";
 import { TiffLoader } from "../loaders/TiffLoader.js";
-import type { WorkerRequestPayload, WorkerResponsePayload, ChannelLoadEvent, MetadataUpdateEvent } from "./types.js";
+import type { ChannelLoadEvent, MetadataUpdateEvent, WorkerMsgTypeGlobal, WorkerMsgTypeWithLoader, WorkerRequestPayload, WorkerResponsePayload } from "./types.js";
 import type { ZarrLoaderFetchOptions } from "../loaders/OmeZarrLoader.js";
-import { WorkerMsgType } from "./types.js";
 /**
  * A handle that holds the worker and manages requests and messages to/from it.
  *
@@ -22,9 +21,7 @@ declare class SharedLoadWorkerHandle {
     private worker;
     private pendingRequests;
     private workerOpen;
-    private throttleChannelData;
-    onChannelData: ((e: ChannelLoadEvent) => void) | undefined;
-    onUpdateMetadata: ((e: MetadataUpdateEvent) => void) | undefined;
+    onEvent: ((e: ChannelLoadEvent | MetadataUpdateEvent) => void) | undefined;
     constructor();
     /** Given a handle for settling a promise when a response is received from the worker, store it and return its ID */
     private registerMessagePromise;
@@ -35,16 +32,16 @@ declare class SharedLoadWorkerHandle {
      * Send a message of type `T` to the worker.
      * Returns a `Promise` that resolves with the worker's response, or rejects with an error message.
      */
-    sendMessage<T extends WorkerMsgType>(type: T, payload: WorkerRequestPayload<T>): Promise<WorkerResponsePayload<T>>;
+    sendMessage<T extends WorkerMsgTypeGlobal>(type: T, payload: WorkerRequestPayload<T>): Promise<WorkerResponsePayload<T>>;
+    sendMessage<T extends WorkerMsgTypeWithLoader>(type: T, payload: WorkerRequestPayload<T>, loaderId: number): Promise<WorkerResponsePayload<T>>;
     /** Receive a message from the worker. If it's an event, call a callback; otherwise, resolve/reject a promise. */
     private receiveMessage;
-    setThrottleChannelData(throttle: boolean): void;
 }
 /**
  * A context in which volume loaders can be run, which allows loading to run on a WebWorker (where it won't block
  * rendering or UI updates) and loaders to share a single `VolumeCache` and `RequestQueue`.
  *
- * ### To use:
+ * # To use:
  * 1. Create a `VolumeLoaderContext` with the desired cache and queue configuration.
  * 2. Before creating a loader, await `onOpen` to ensure the worker is ready.
  * 3. Create a loader with `createLoader`. This accepts nearly the same arguments as `createVolumeLoader`, but without
@@ -56,14 +53,15 @@ declare class SharedLoadWorkerHandle {
  */
 declare class VolumeLoaderContext {
     private workerHandle;
+    private loaders;
     private openPromise;
-    private activeLoader;
-    private activeLoaderId;
+    private throttleChannelData;
     constructor(maxCacheSize?: number, maxActiveRequests?: number, maxLowPriorityRequests?: number);
     /** Returns a `Promise` that resolves when the worker is ready. `await` it before trying to create a loader. */
     onOpen(): Promise<void>;
     /** Close this context, its worker, and any active loaders. */
     close(): void;
+    private handleEvent;
     /**
      * Create a new loader within this context. This loader will share the context's `VolumeCache` and `RequestQueue`.
      *
@@ -71,7 +69,6 @@ declare class VolumeLoaderContext {
      */
     createLoader(path: string | string[], options?: Omit<CreateLoaderOptions, "cache" | "queue">): Promise<WorkerLoader | TiffLoader | RawArrayLoader>;
     setThrottleChannelData(throttle: boolean): void;
-    getActiveLoader(): WorkerLoader | undefined;
 }
 /**
  * A handle to an instance of `IVolumeLoader` (technically, a `ThreadableVolumeLoader`) running on a WebWorker.
@@ -81,12 +78,11 @@ declare class VolumeLoaderContext {
 declare class WorkerLoader extends ThreadableVolumeLoader {
     private loaderId;
     private workerHandle;
-    private isOpen;
     private currentLoadId;
     private currentLoadCallback;
     private currentMetadataUpdateCallback;
     constructor(loaderId: number, workerHandle: SharedLoadWorkerHandle);
-    private checkIsOpen;
+    private getLoaderId;
     /** Close and permanently invalidate this loader. */
     close(): void;
     /**

package/es/types/workers/types.d.ts

@@ -9,13 +9,18 @@ import type { ZarrLoaderFetchOptions } from "../loaders/OmeZarrLoader.js";
 export declare const enum WorkerMsgType {
     INIT = 0,
     CREATE_LOADER = 1,
-    CREATE_VOLUME = 2,
-    LOAD_DIMS = 3,
-    LOAD_VOLUME_DATA = 4,
-    SET_PREFETCH_PRIORITY_DIRECTIONS = 5,
-    SYNCHRONIZE_MULTICHANNEL_LOADING = 6,
-    UPDATE_FETCH_OPTIONS = 7
+    CLOSE_LOADER = 2,
+    CREATE_VOLUME = 3,
+    LOAD_DIMS = 4,
+    LOAD_VOLUME_DATA = 5,
+    SET_PREFETCH_PRIORITY_DIRECTIONS = 6,
+    SYNCHRONIZE_MULTICHANNEL_LOADING = 7,
+    UPDATE_FETCH_OPTIONS = 8
 }
+/** The variants of `WorkerMessageType` which represent "global" actions that don't require a specific loader */
+export type WorkerMsgTypeGlobal = WorkerMsgType.INIT | WorkerMsgType.CREATE_LOADER;
+/** The variants of `WorkerMessageType` which represent actions on a specific loader */
+export type WorkerMsgTypeWithLoader = Exclude<WorkerMsgType, WorkerMsgTypeGlobal>;
 /** The kind of response a worker can return - `SUCCESS`, `ERROR`, or `EVENT`. */
 export declare const enum WorkerResponseResult {
     SUCCESS = 0,
@@ -29,9 +34,13 @@ export declare const enum WorkerEventType {
     /** Fired when data for a channel (or batch of channels) is loaded */
     CHANNEL_LOAD = 1
 }
-/** All messages to/from a worker carry a `msgId`, a `type`, and a `payload` (whose type is determined by `type`). */
+/**
+ * All messages to/from a worker carry a `msgId`, a `type`, and a `payload` (whose type is determined by `type`).
+ * Messages which operate on a specific loader also require a `loaderId`.
+ */
 type WorkerMsgBase<T extends WorkerMsgType, P> = {
     msgId: number;
+    loaderId: T extends WorkerMsgTypeWithLoader ? number : undefined;
     type: T;
     payload: P;
 };
@@ -46,12 +55,12 @@ export type WorkerRequestPayload<T extends WorkerMsgType> = {
         path: string | string[];
         options?: CreateLoaderOptions;
     };
+    [WorkerMsgType.CLOSE_LOADER]: void;
     [WorkerMsgType.CREATE_VOLUME]: LoadSpec;
     [WorkerMsgType.LOAD_DIMS]: LoadSpec;
     [WorkerMsgType.LOAD_VOLUME_DATA]: {
         imageInfo: ImageInfo;
         loadSpec: LoadSpec;
-        loaderId: number;
         loadId: number;
     };
     [WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS]: PrefetchDirection[];
@@ -61,7 +70,8 @@ export type WorkerRequestPayload<T extends WorkerMsgType> = {
 /** Maps each `WorkerMsgType` to the type of the payload of responses of that type. */
 export type WorkerResponsePayload<T extends WorkerMsgType> = {
     [WorkerMsgType.INIT]: void;
-    [WorkerMsgType.CREATE_LOADER]: boolean;
+    [WorkerMsgType.CREATE_LOADER]: number | undefined;
+    [WorkerMsgType.CLOSE_LOADER]: void;
     [WorkerMsgType.CREATE_VOLUME]: LoadedVolumeInfo;
     [WorkerMsgType.LOAD_DIMS]: VolumeDims[];
     [WorkerMsgType.LOAD_VOLUME_DATA]: void;
@@ -69,11 +79,13 @@ export type WorkerResponsePayload<T extends WorkerMsgType> = {
     [WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING]: void;
     [WorkerMsgType.UPDATE_FETCH_OPTIONS]: void;
 }[T];
-/** Event for when a batch of channel data loads. */
-export type ChannelLoadEvent = {
-    eventType: WorkerEventType.CHANNEL_LOAD;
+type WorkerEventBase<T extends WorkerEventType> = {
+    eventType: T;
     loaderId: number;
     loadId: number;
+};
+/** Event for when a batch of channel data loads. */
+export type ChannelLoadEvent = WorkerEventBase<WorkerEventType.CHANNEL_LOAD> & {
     channelIndex: number[];
     dtype: NumberType[];
     data: TypedArray<NumberType>[];
@@ -81,10 +93,7 @@ export type ChannelLoadEvent = {
     atlasDims?: [number, number];
 };
 /** Event for when metadata updates. */
-export type MetadataUpdateEvent = {
-    eventType: WorkerEventType.METADATA_UPDATE;
-    loaderId: number;
-    loadId: number;
+export type MetadataUpdateEvent = WorkerEventBase<WorkerEventType.METADATA_UPDATE> & {
     imageInfo?: ImageInfo;
     loadSpec?: LoadSpec;
 };

package/es/workers/VolumeLoadWorker.js

@@ -9,9 +9,16 @@ import { rebuildLoadSpec } from "./util.js";
 let cache = undefined;
 let queue = undefined;
 let subscribableQueue = undefined;
-let loader = undefined;
+let loaderCount = 0;
+const loaders = new Map();
+const getLoader = loaderId => {
+  const loader = loaders.get(loaderId);
+  if (loader === undefined) {
+    throw new VolumeLoadError(`Loader with ID ${loaderId} does not exist`);
+  }
+  return loader;
+};
 let initialized = false;
-let copyOnLoad = false;
 const messageHandlers = {
   [WorkerMsgType.INIT]: ({
     maxCacheSize,
@@ -30,37 +37,50 @@ const messageHandlers = {
     path,
     options
   }) => {
-    const pathString = Array.isArray(path) ? path[0] : path;
-    const fileType = options?.fileType || pathToFileType(pathString);
-    copyOnLoad = fileType === VolumeFileFormat.JSON;
-    loader = await createVolumeLoader(path, {
+    const loader = await createVolumeLoader(path, {
       ...options,
       cache,
       queue: subscribableQueue
     });
-    return loader !== undefined;
-  },
-  [WorkerMsgType.CREATE_VOLUME]: async loadSpec => {
     if (loader === undefined) {
-      throw new VolumeLoadError("No loader created");
+      return undefined;
     }
+    const pathString = Array.isArray(path) ? path[0] : path;
+    const fileType = options?.fileType || pathToFileType(pathString);
+    const copyOnLoad = fileType === VolumeFileFormat.JSON;
+    const loaderId = loaderCount;
+    loaderCount += 1;
+    loaders.set(loaderId, {
+      loader,
+      copyOnLoad
+    });
+    return loaderId;
+  },
+  [WorkerMsgType.CLOSE_LOADER]: (_, loaderId) => {
+    loaders.delete(loaderId);
+    return Promise.resolve();
+  },
+  [WorkerMsgType.CREATE_VOLUME]: async (loadSpec, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     return await loader.createImageInfo(rebuildLoadSpec(loadSpec));
   },
-  [WorkerMsgType.LOAD_DIMS]: async loadSpec => {
-    if (loader === undefined) {
-      throw new VolumeLoadError("No loader created");
-    }
+  [WorkerMsgType.LOAD_DIMS]: async (loadSpec, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     return await loader.loadDims(rebuildLoadSpec(loadSpec));
   },
   [WorkerMsgType.LOAD_VOLUME_DATA]: ({
     imageInfo,
     loadSpec,
-    loaderId,
     loadId
-  }) => {
-    if (loader === undefined) {
-      throw new VolumeLoadError("No loader created");
-    }
+  }, loaderId) => {
+    const {
+      loader,
+      copyOnLoad
+    } = getLoader(loaderId);
     return loader.loadRawChannelData(imageInfo, rebuildLoadSpec(loadSpec), (imageInfo, loadSpec) => {
       const message = {
         responseResult: WorkerResponseResult.EVENT,
@@ -86,16 +106,25 @@ const messageHandlers = {
       self.postMessage(message, copyOnLoad ? [] : data.map(d => d.buffer));
     });
   },
-  [WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS]: directions => {
+  [WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS]: (directions, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     // Silently does nothing if the loader isn't an `OMEZarrLoader`
     loader?.setPrefetchPriority(directions);
     return Promise.resolve();
   },
-  [WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING]: syncChannels => {
+  [WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING]: (syncChannels, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     loader?.syncMultichannelLoading(syncChannels);
     return Promise.resolve();
   },
-  [WorkerMsgType.UPDATE_FETCH_OPTIONS]: fetchOptions => {
+  [WorkerMsgType.UPDATE_FETCH_OPTIONS]: (fetchOptions, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     loader?.updateFetchOptions(fetchOptions);
     return Promise.resolve();
   }
@@ -103,25 +132,18 @@ const messageHandlers = {
 self.onmessage = async ({
   data
 }) => {
-  const {
-    msgId,
-    type,
-    payload
-  } = data;
   let message;
   try {
-    const response = await messageHandlers[type](payload);
+    const response = await messageHandlers[data.type](data.payload, data.loaderId);
     message = {
+      ...data,
       responseResult: WorkerResponseResult.SUCCESS,
-      msgId,
-      type,
       payload: response
     };
   } catch (e) {
     message = {
+      ...data,
       responseResult: WorkerResponseResult.ERROR,
-      msgId,
-      type,
       payload: serializeError(e)
     };
   }