@aics/vole-app 2.15.0 → 3.1.1

package/type-declarations/aics-image-viewer/shared/utils/urlParsing.d.ts

@@ -1,23 +1,29 @@
-import { CameraState } from "@aics/vole-core";
-import { FirebaseFirestore } from "@firebase/firestore-types";
+import type { CameraState } from "@aics/vole-core";
+import type { FirebaseFirestore } from "@firebase/firestore-types";
 import type { AppProps } from "../../components/App/types";
-import type { ChannelState, ViewerState, ViewerStateContextType } from "../../components/ViewerStateProvider/types";
+import type { ViewerStore } from "../../state/store";
+import type { ChannelState, ViewerState } from "../../state/types";
 import { ViewMode } from "../enums";
 import type { MetadataRecord } from "../types";
-import { ColorArray } from "./colorRepresentations";
+import type { ColorArray } from "./colorRepresentations";
 import type { ViewerChannelSetting } from "./viewerChannelSettings";
 export declare const ENCODED_COMMA_REGEX: RegExp;
 export declare const ENCODED_COLON_REGEX: RegExp;
 /**
  * LEGACY: Matches a COMMA-separated list of control points, where each control point is represented
  * by a triplet of `{x}:{opacity}:{hex color}`.
- * The hex color can be replaced with `w` to represent white (`ffffff`).
+ * The hex color can be replaced with `1` to represent white (`ffffff`).
  */
 export declare const LEGACY_CONTROL_POINTS_REGEX: RegExp;
 /**
- * Matches a COLON-separated list of control points, where each control point is represented
- * by a triplet of `{x}:{opacity}:{hex color}`.
- * The hex color can be replaced with `w` to represent white (`ffffff`).
+ * Matches a COLON-separated list of control points, where each control point is
+ * represented by a triplet of `{x}:{opacity}:{hex color}`.
+ * - `x` is a value that will either be parsed as a histogram bin index (legacy,
+ *   for `ControlPointsLegacy`) or intensity value (for `ControlPoints`),
+ *   depending on on which field is being parsed.
+ * - Opacity is a float in the [0, 1] range.
+ * - The hex color is a 6-digit hex color (e.g. `ffeecc`), and can be replaced
+ *   with `1` to represent white (`ffffff`).
  */
 export declare const CONTROL_POINTS_REGEX: RegExp;
 /**
@@ -65,12 +71,15 @@ export declare enum ViewerChannelSettingKeys {
     ColorizeAlpha = "cza",
     IsosurfaceAlpha = "isa",
     Lut = "lut",
-    Ramp = "rmp",
-    ControlPoints = "cps",
+    ControlPoints = "cpt",
+    ControlPointsLegacy = "cps",
+    Ramp = "ram",
+    RampLegacy = "rmp",
     ControlPointsEnabled = "cpe",
     VolumeEnabled = "ven",
     SurfaceEnabled = "sen",
-    IsosurfaceValue = "isv"
+    IsosurfaceValue = "isv",
+    KeepRange = "pin"
 }
 /**
  * The serialized form of a ViewerChannelSetting, as a dictionary object.
@@ -112,12 +121,24 @@ export declare class ViewerChannelSettingParams {
      */
     [ViewerChannelSettingKeys.Lut]?: string;
     /**
-     * Control points for the transfer function. If provided, overrides the
-     * `lut` field when calculating the control points. Should be a list
-     * of `x:opacity:color` triplets, separated by colon.
+     * Legacy specifier for control points for the transfer function as a list of
+     * `x:opacity:color` triplets, separated by colon. Uses histogram bin indices
+     * instead of intensity values.
+     * - `x` is a histogram bin index in the [0, 255] range.
+     * - `opacity` is a float in the [0, 1] range.
+     * - `color` is a 6-digit hex color, e.g. `ff0000`.
+     *
+     * Will be overridden by the ControlPoints field (`cpt`) if provided.
+     */
+    [ViewerChannelSettingKeys.ControlPointsLegacy]?: string;
+    /**
+     * Control points for the transfer function, formatted as a list of
+     * `x:opacity:color` triplets, separated by colons.
      * - `x` is a numeric intensity value.
      * - `opacity` is a float in the [0, 1] range.
      * - `color` is a 6-digit hex color, e.g. `ff0000`.
+     *
+     * If provided, overrides the `lut` field when calculating the control points.
      */
     [ViewerChannelSettingKeys.ControlPoints]?: string;
     /**
@@ -126,8 +147,14 @@ export declare class ViewerChannelSettingParams {
      */
     [ViewerChannelSettingKeys.ControlPointsEnabled]?: "1" | "0";
     /**
-     * Raw ramp values, which should be two numeric values separated by a colon.
-     * If provided, overrides the `lut` field when calculating the ramp values.
+     * Legacy specifier for the transfer function ramp which uses histogram bin
+     * indices instead of intensity values, formatted as `min:max`. Will be
+     * overridden by the Ramp field (`ram`) if provided.
+     */
+    [ViewerChannelSettingKeys.RampLegacy]?: string;
+    /**
+     * Ramp min and max intensity values (`min:max`). If provided, overrides the
+     * `lut` field when calculating the ramp.
      */
     [ViewerChannelSettingKeys.Ramp]?: string;
     /** Volume enabled. "1" is enabled. Disabled by default. */
@@ -136,6 +163,11 @@ export declare class ViewerChannelSettingParams {
     [ViewerChannelSettingKeys.SurfaceEnabled]?: "1" | "0";
     /** Isosurface value, in the [0, 255] range. Set to `128` by default. */
     [ViewerChannelSettingKeys.IsosurfaceValue]?: string;
+    /**
+     * Whether to keep the current contrast settings when loading a new volume.
+     * "1" is enabled. Disabled by default.
+     */
+    [ViewerChannelSettingKeys.KeepRange]?: "1" | "0";
 }
 /**
  * Channels, matching the pattern `c0`, `c1`, etc. corresponding to the index of the channel being configured.
@@ -209,8 +241,15 @@ export declare class ViewerStateParams {
 /** URL parameters that define data sources when loading volumes. */
 declare class DataParams {
     /**
-     * One or more volume URLs to load. If multiple URLs are provided, they should
-     * be separated by commas.
+     * One or more volume URLs to load.
+     *
+     * This parameter may represent a single image with multiple data sources by delimiting each source URL with `,`.
+     * It may also represent multiple scenes by delimiting each scene URL (and/or each collection of multiple
+     * `,`-delimited source URLs) with `+`. E.g. `url1+url2,url3` represents a collection of two scenes, where the first
+     * scene comes from `url1` and the second is a combination of the channels from the images at `url2` and `url3`.
+     *
+     * When parsing, we do our best to account for `%`-encoding, including the possibility that each source/scene URL was
+     * encoded separately, then concatenated with the proper delimiters, then encoded again.
      */
     url?: string;
     /**
@@ -221,14 +260,24 @@ declare class DataParams {
      * See `ManifestJson` for the type definition.
      */
     manifest?: string;
-    /**
-     * The name of a dataset in the Cell Feature Explorer database. Used with `id`.
-     */
+    /** The name of a dataset in the Cell Feature Explorer database. Used with `id`. */
     dataset?: string;
+    /** The ID of a cell within the loaded dataset. Used with `dataset`. */
+    id?: string;
+    /** The key of a collection of scenes stored in local storage. Overrides `url`. */
+    collectionid?: string;
     /**
-     * The ID of a cell within the loaded dataset. Used with `dataset`.
+     * The origin of an opening window that wants to send a message to this window.
+     *
+     * The presence of this param implies that this window has just been opened by another app, and the opening app has
+     * more data to send. Until that message is received, we fall back to `url`. Once that message arrives, the scenes to
+     * open are written to local storage at a new `collectionid` and `msgorigin` is removed, allowing the window to
+     * switch to reading local storage.
+     *
+     * All this happens independently of URL parsing, so the only meaningful thing this parsing code does with this param
+     * is check whether it is present.
      */
-    id?: string;
+    msgorigin?: string;
 }
 declare class DeprecatedParams {
     /** Deprecated query parameter for channel settings. */
@@ -239,6 +288,18 @@ declare class DeprecatedParams {
     colors?: string;
 }
 type AppParams = Partial<ViewerStateParams & DataParams & DeprecatedParams & ChannelParams>;
+/**
+ * A message sent from an external application after this app was opened,
+ * containing data that was too large to pack into the URL.
+ */
+type ViewerMessage = {
+    /** A (possibly very long) list of scene URLs. */
+    scenes?: string[];
+    /** A (likely very large) list of metadata records for each scene. */
+    meta?: Record<string, MetadataRecord>;
+    /** The scene to open once this message arrives. */
+    sceneIndex?: number;
+};
 /**
  * Filters a set of URLSearchParams for only the keys that are valid parameters for the viewer.
  * Non-matching keys are discarded.
@@ -246,6 +307,8 @@ type AppParams = Partial<ViewerStateParams & DataParams & DeprecatedParams & Cha
  * @returns a dictionary object matching the type of `Params`.
  */
 export declare function getAllowedParams(searchParams: URLSearchParams): AppParams;
+/** Parses the `url` query param into a 2D URL array: one or more scenes, with one or more sources per scene. */
+export declare const parseImageURLParam: (urlParam: string) => string[][];
 /**
  * Parse a string list of comma-separated key:value pairs into
  * a key-value object.
@@ -319,26 +382,26 @@ export declare function loadFromManifest(manifestUrl: string): Promise<{
 }>;
 /**
  * Parses a set of URL search parameters into props for the viewer.
- * @param urlSearchParams The URLSearchParams object to parse.
- * @param firestore Optional Firestore instance. If provided, the function can
- * load data from a Firestore dataset if the `dataset` and `id` parameters are
- * provided.
+ * @param search The query string to parse, which must be valid in the `URLSearchParams constructor
+ * @param firestore Optional Firestore instance. If provided, the function can load data from a
+ * Firestore dataset if the `dataset` and `id` parameters are provided.
  * @returns An object containing:
  * - `args`: Partial AppProps object.
  * - `viewerSettings`: Partial ViewerState object.
  *
- * `args` can be passed as props to the `ImageViewerApp`, and `viewerSettings`
- * can be passed to `ViewerStateProvider`.
+ * `args` can be passed as props to the `ImageViewerApp`, and `viewerSettings` can be passed to `ViewerStateProvider`.
  */
-export declare function parseViewerUrlParams(urlSearchParams: URLSearchParams, firestore?: FirebaseFirestore): Promise<{
+export declare function parseViewerUrlParams(search: string, firestore?: FirebaseFirestore): Promise<{
     args: Partial<AppProps>;
     viewerSettings: Partial<ViewerState>;
 }>;
+/** Adds the data in a newly-arrived `ViewerMessage` to an existing stored `AppProps` instance. */
+export declare function addViewerParamsFromMessage<P extends Pick<AppProps, "imageUrl" | "metadata">>(args: P, message: ViewerMessage): P;
 /**
  * Serializes the ViewerState and ChannelState of a ViewerStateContext into a URLSearchParams object.
  * @param state ViewerStateContext to serialize.
  * @param removeDefaults If true, shortens parameters by removing any properties that match the default state.
  * This includes the output of GET_DEFAULT_VIEWER_STATE and GET_DEFAULT_CHANNEL_STATE.
  */
-export declare function serializeViewerUrlParams(state: Partial<ViewerStateContextType>, removeDefaults?: boolean): AppParams;
+export declare function serializeViewerUrlParams(state: Partial<ViewerStore>, removeDefaults?: boolean): AppParams;
 export {};

package/type-declarations/aics-image-viewer/shared/utils/viewerChannelSettings.d.ts

@@ -1,4 +1,28 @@
-import { ControlPoint } from "@aics/vole-core";
+import type { ControlPoint } from "@aics/vole-core";
+export type IntensitySettings = {
+    /**
+     * Defines a linear function for mapping from intensity values in the volume
+     * to opacity between two [min, max] intensity values.
+     */
+    ramp?: [number, number];
+    /**
+     * Defines a piecewise linear function for mapping from intensity values in
+     * the volume to opacity and color.
+     */
+    controlPoints?: ControlPoint[];
+    /**
+     * Min and max values for the intensity lookup table, which maps from raw intensity values
+     * in the volume to opacity and color. Defaults to [0, 255].
+     *
+     * - Plain numbers are indices of histogram bins, in the range [0, 255].
+     * - `v{n}` represents a raw intensity value, where `n` is an integer.
+     * - `p{n}` represents a percentile, where `n` is a percentile in the [0, 100] range.
+     * - `m{n}` represents the median multiplied by `n / 100`.
+     * - `autoij` in either the min or max fields will use the "auto" algorithm
+     * from ImageJ to select the min and max.
+     */
+    lut?: [string, string];
+};
 /** Settings for a single channel, as passed in via props by App users */
 export interface ViewerChannelSetting {
     match: (string | number)[] | string | number;
@@ -16,6 +40,8 @@ export interface ViewerChannelSetting {
      * - `m{n}` represents the median multiplied by `n / 100`.
      * - `autoij` in either the min or max fields will use the "auto" algorithm
      * from ImageJ to select the min and max.
+     * @deprecated Will be removed in a future update. Specify via `intensity.lut`
+     * instead.
      */
     lut?: [string, string];
     /**
@@ -23,12 +49,24 @@ export interface ViewerChannelSetting {
      * Defaults to false.
      */
     controlPointsEnabled?: boolean;
+    /**
+     * Control points for the transfer function, as histogram bin values.
+     * @deprecated Will be removed in a future update. Specify via `intensity.controlPoints` instead.
+     */
     controlPoints?: ControlPoint[];
+    /**
+     * Min and max ramp values for the transfer function, as histogram bin values.
+     * @deprecated Will be removed in a future update. Specify via
+     * `intensity.ramp` instead.
+     */
     ramp?: [number, number];
+    intensity?: IntensitySettings;
     isovalue?: number;
     surfaceOpacity?: number;
     colorizeEnabled?: boolean;
     colorizeAlpha?: number;
+    /** Whether to keep the current contrast settings when switching volumes. */
+    keepIntensityRange?: boolean;
 }
 export interface ViewerChannelGroup {
     name: string;

package/type-declarations/aics-image-viewer/shared/utils/viewerState.d.ts

@@ -1,9 +1,6 @@
-import { ChannelState, ViewerSettingUpdater, ViewerState } from "../../components/ViewerStateProvider/types";
-import { ColorArray } from "./colorRepresentations";
-import { ViewerChannelSettings } from "./viewerChannelSettings";
-/** Sets all fields of the viewer state to the values of the `newState`. */
-export declare function overrideViewerState(changeViewerSetting: ViewerSettingUpdater, newState: ViewerState): void;
-export declare function overrideChannelStates(setChannelSettings: (settings: ChannelState[]) => void, currentStates: ChannelState[], newStates: ChannelState[]): void;
+import type { ChannelState } from "../../state/types";
+import type { ColorArray } from "./colorRepresentations";
+import type { ViewerChannelSettings } from "./viewerChannelSettings";
 /** Returns the indices of channels that have either the volume or isosurface enabled. */
 export declare function getEnabledChannelIndices(channelSettings: ChannelState[]): number[];
 export declare function colorHexToArray(hex: string): ColorArray | null;

package/type-declarations/aics-image-viewer/state/reset.d.ts

@@ -0,0 +1,29 @@
+import type { StateCreator } from "zustand";
+import type { ViewerChannelSettings } from "../shared/utils/viewerChannelSettings";
+import type { ViewerState } from "../state/types";
+import type { ViewerStore } from "./store";
+export type ResetStateActions = {
+    /**
+     * Removes the channel from the list of channels to be reset (as given by
+     * `getChannelsAwaitingReset()` or `getChannelsAwaitingResetOnLoad()`).
+     */
+    onResetChannel: (channelIndex: number) => void;
+    /**
+     * Resets the viewer and all channels to a saved initial state, determined
+     * by viewer props.
+     */
+    resetToSavedViewerState: (savedState?: Partial<ViewerState>, viewerChannelSettings?: ViewerChannelSettings) => void;
+    /**
+     * Resets the viewer and all channels to the default state, as though
+     * loaded from scratch with no initial parameters set.
+     * Uses the default channel settings as given by `getDefaultViewerChannelSettings()`.
+     */
+    resetToDefaultViewerState: () => void;
+};
+export type ResetState = {
+    useDefaultViewerChannelSettings: boolean;
+    channelsToReset: number[];
+    channelsToResetOnLoad: number[];
+};
+export type ResetStateSlice = ResetStateActions & ResetState;
+export declare const createResetSlice: StateCreator<ViewerStore, [], [], ResetStateSlice>;

package/type-declarations/aics-image-viewer/state/store.d.ts

@@ -0,0 +1,30 @@
+import type { ColorArray } from "../shared/utils/colorRepresentations";
+import { type ResetStateSlice } from "./reset";
+import type { ChannelState, ViewerState } from "./types";
+export type ViewerStateActions = {
+    changeViewerSetting: <K extends keyof ViewerState>(key: K, value: Partial<ViewerState[K]>) => void;
+    mergeViewerSettings: (value: Partial<{
+        [K in keyof ViewerState]: Partial<ViewerState[K]>;
+    }>) => void;
+    changeChannelSetting: <K extends keyof ChannelState>(index: number | number[], value: Partial<Record<K, ChannelState[K]>>) => void;
+    replaceAllChannelSettings: (channelSettings: ChannelState[]) => void;
+    applyColorPresets: (colors: ColorArray[]) => void;
+};
+export type ViewerStore = ViewerState & ViewerStateActions & ResetStateSlice & {
+    channelSettings: ChannelState[];
+};
+export declare const useViewerState: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ViewerStore>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: ViewerStore, previousSelectedState: ViewerStore) => void): () => void;
+        <U>(selector: (state: ViewerStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+export declare const selectViewerSettings: (store: ViewerStore) => ViewerState;
+/**
+ * A small boilerplate-reducer for subscribing to a single state value with `useViewerStore`.
+ * Should only be used with string literals for best type-checking results.
+ */
+export declare const select: <K extends string>(key: K) => <V>(settings: Record<K, V>) => Record<K, V>[K];

package/type-declarations/aics-image-viewer/state/subscribers.d.ts

@@ -0,0 +1,4 @@
+import { type View3d, type Volume } from "@aics/vole-core";
+import { type useViewerState } from "./store";
+export declare const subscribeViewToState: (store: typeof useViewerState, view3d: View3d) => (() => void);
+export declare const subscribeImageToState: (store: typeof useViewerState, view3d: View3d, image: Volume) => (() => void);

package/type-declarations/aics-image-viewer/state/types.d.ts

@@ -0,0 +1,46 @@
+import type { CameraState, ControlPoint } from "@aics/vole-core";
+import type { ImageType, RenderMode, ViewMode } from "../shared/enums";
+import type { PerAxis } from "../shared/types";
+import type { ColorArray } from "../shared/utils/colorRepresentations";
+/** Global (not per-channel) viewer state which may be changed in the UI */
+export type ViewerState = {
+    viewMode: ViewMode;
+    renderMode: RenderMode;
+    imageType: ImageType;
+    showAxes: boolean;
+    showBoundingBox: boolean;
+    boundingBoxColor: ColorArray;
+    backgroundColor: ColorArray;
+    autorotate: boolean;
+    maskAlpha: number;
+    brightness: number;
+    density: number;
+    levels: [number, number, number];
+    interpolationEnabled: boolean;
+    region: PerAxis<[number, number]>;
+    slice: PerAxis<number>;
+    time: number;
+    scene: number;
+    cameraState: Partial<CameraState> | undefined;
+};
+export type ChannelState = {
+    name: string;
+    displayName: string;
+    volumeEnabled: boolean;
+    isosurfaceEnabled: boolean;
+    isovalue: number;
+    colorizeEnabled: boolean;
+    colorizeAlpha: number;
+    opacity: number;
+    color: ColorArray;
+    ramp: [number, number];
+    useControlPoints: boolean;
+    controlPoints: ControlPoint[];
+    plotMin: number;
+    plotMax: number;
+    /**
+     * If true, when a new volume is loaded, keeps the current intensity values
+     * (ramp, control points, and isovalue) instead of reinitializing them.
+     */
+    keepIntensityRange: boolean;
+};

package/type-declarations/aics-image-viewer/state/util.d.ts

@@ -0,0 +1,8 @@
+import type { ViewerState } from "../state/types";
+/**
+ * Accepts a `key` and a new (potentially partial) `value` for a single field of `ViewerState`, & returns a fragment of
+ * `ViewerState` that can safely be merged into `currentState` to apply that value without creating an illegal state.
+ */
+export declare const validateStateValue: <K extends keyof ViewerState>(currentState: ViewerState, key: K, value: Partial<ViewerState[K]>) => Partial<ViewerState>;
+/** Ensures a fragment of `ViewerState` can be safely merged into `currentState` without creating an illegal state. */
+export declare const validateState: (currentState: ViewerState, newState: Partial<{ [K in keyof ViewerState]: Partial<ViewerState[K]>; }>) => Partial<ViewerState>;

package/type-declarations/index.d.ts

@@ -1,9 +1,9 @@
-import { parseViewerUrlParams } from "./aics-image-viewer/shared/utils/urlParsing";
 import ImageViewerApp from "./aics-image-viewer/components/App";
-import ViewerStateProvider from "./aics-image-viewer/components/ViewerStateProvider";
+export { addViewerParamsFromMessage, parseViewerUrlParams } from "./aics-image-viewer/shared/utils/urlParsing";
+export { writeMetadata, writeScenes } from "./aics-image-viewer/shared/utils/storage";
 export type { ViewerChannelSettings, ViewerChannelGroup, ViewerChannelSetting, } from "./aics-image-viewer/shared/utils/viewerChannelSettings";
-export type { ViewerState } from "./aics-image-viewer/components/ViewerStateProvider/types";
+export type { ViewerState } from "./aics-image-viewer/state/types";
 export { ViewMode, RenderMode, ImageType } from "./aics-image-viewer/shared/enums";
 export type { AppProps } from "./aics-image-viewer/components/App/types";
 export type { RawArrayData, RawArrayInfo } from "@aics/vole-core";
-export { ImageViewerApp, ViewerStateProvider, parseViewerUrlParams };
+export { ImageViewerApp };

package/es/aics-image-viewer/components/ViewerStateProvider/ResetStateProvider.js

@@ -1,163 +0,0 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-import { isEqual } from "lodash";
-import { getDefaultViewerState, getDefaultCameraState, getDefaultChannelState, getDefaultViewerChannelSettings, getDefaultChannelColor } from "../../shared/constants";
-import { ViewMode } from "../../shared/enums";
-import { overrideViewerState, overrideChannelStates, getEnabledChannelIndices, initializeOneChannelSetting } from "../../shared/utils/viewerState";
-/**
- * Provides reset functionality for the viewer and channel states.
- */
-var ResetStateProvider = /*#__PURE__*/function () {
-  function ResetStateProvider(viewerStateRef) {
-    _classCallCheck(this, ResetStateProvider);
-    this.ref = viewerStateRef;
-    this.savedViewerState = {};
-    this.channelsToReset = new Set();
-    this.channelsToResetOnLoad = new Set();
-    this.savedViewerChannelSettings = undefined;
-    this.useDefaultViewerChannelSettings = false;
-    this.resetToSavedViewerState = this.resetToSavedViewerState.bind(this);
-    this.resetToDefaultViewerState = this.resetToDefaultViewerState.bind(this);
-    this.resetToState = this.resetToState.bind(this);
-    this.setSavedViewerState = this.setSavedViewerState.bind(this);
-    this.setSavedViewerChannelSettings = this.setSavedViewerChannelSettings.bind(this);
-    this.getChannelsAwaitingReset = this.getChannelsAwaitingReset.bind(this);
-    this.getChannelsAwaitingResetOnLoad = this.getChannelsAwaitingResetOnLoad.bind(this);
-    this.onResetChannel = this.onResetChannel.bind(this);
-    this.getCurrentViewerChannelSettings = this.getCurrentViewerChannelSettings.bind(this);
-  }
-
-  // Setup Callbacks ////////////////////////////////////////////////////////////////////
-  return _createClass(ResetStateProvider, [{
-    key: "setSavedViewerState",
-    value: function setSavedViewerState(state) {
-      this.savedViewerState = state;
-    }
-  }, {
-    key: "setSavedViewerChannelSettings",
-    value: function setSavedViewerChannelSettings(settings) {
-      this.savedViewerChannelSettings = settings;
-    }
-  }, {
-    key: "getChannelsAwaitingReset",
-    value: function getChannelsAwaitingReset() {
-      return this.channelsToReset;
-    }
-  }, {
-    key: "getChannelsAwaitingResetOnLoad",
-    value: function getChannelsAwaitingResetOnLoad() {
-      return this.channelsToResetOnLoad;
-    }
-  }, {
-    key: "onResetChannel",
-    value: function onResetChannel(channelIndex) {
-      this.channelsToReset["delete"](channelIndex);
-      this.channelsToResetOnLoad["delete"](channelIndex);
-    }
-
-    /**
-     * Returns the current viewer channel settings that the viewer should use when
-     * resetting channels to an initial state.
-     */
-  }, {
-    key: "getCurrentViewerChannelSettings",
-    value: function getCurrentViewerChannelSettings() {
-      if (this.useDefaultViewerChannelSettings) {
-        return getDefaultViewerChannelSettings();
-      }
-      return this.savedViewerChannelSettings;
-    }
-
-    /**
-     * Helper method. Resets the viewer and all channels to the provided state. If new data needs to
-     * be loaded, handles setup so the reset will be applied to each channel as it loads in.
-     */
-  }, {
-    key: "resetToState",
-    value: function resetToState(newState, newChannelStates) {
-      var _this$ref$current = this.ref.current,
-        changeViewerSetting = _this$ref$current.changeViewerSetting,
-        setChannelSettings = _this$ref$current.setChannelSettings,
-        channelSettings = _this$ref$current.channelSettings,
-        viewMode = _this$ref$current.viewMode,
-        time = _this$ref$current.time,
-        slice = _this$ref$current.slice;
-
-      // Needs reset on reload if one of the view modes is 2D while the other is 3D,
-      // if the timestamp is different, or if we're on a different z slice.
-      // TODO: Handle stopping playback? Requires playback to be part of ViewerStateContext
-      var isInDifferentViewMode = viewMode !== newState.viewMode && (viewMode === ViewMode.xy || newState.viewMode === ViewMode.xy);
-      var isAtDifferentTime = time !== newState.time;
-      var isAtDifferentZSlice = newState.viewMode === ViewMode.xy && !isEqual(newState.slice.z, slice.z);
-      var willNeedResetOnLoad = isInDifferentViewMode || isAtDifferentTime || isAtDifferentZSlice;
-      overrideViewerState(changeViewerSetting, newState);
-      overrideChannelStates(setChannelSettings, channelSettings, newChannelStates);
-      this.channelsToReset = new Set(Array(newChannelStates.length).keys());
-      if (willNeedResetOnLoad) {
-        var enabledChannelsAndResetState = getEnabledChannelIndices(newChannelStates);
-        this.channelsToResetOnLoad = new Set(enabledChannelsAndResetState);
-        var _iterator = _createForOfIteratorHelper(enabledChannelsAndResetState),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var channelIndex = _step.value;
-            this.channelsToReset["delete"](channelIndex);
-          }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
-        }
-      }
-    }
-
-    /** Resets to the initial saved state of the viewer, as shown to the user on load. */
-  }, {
-    key: "resetToSavedViewerState",
-    value: function resetToSavedViewerState() {
-      var _this = this;
-      var channelSettings = this.ref.current.channelSettings;
-      var newViewerState = _objectSpread(_objectSpread({}, getDefaultViewerState()), {}, {
-        cameraState: getDefaultCameraState(this.savedViewerState.viewMode || ViewMode.threeD)
-      }, this.savedViewerState);
-      var newChannelSettings = channelSettings.map(function (_, index) {
-        var initialChannelSetting = initializeOneChannelSetting(channelSettings[index].name, index, getDefaultChannelColor(index), _this.savedViewerChannelSettings);
-        return _objectSpread(_objectSpread({}, initialChannelSetting), {}, {
-          plotMin: channelSettings[index].plotMin,
-          plotMax: channelSettings[index].plotMax
-        });
-      });
-      this.resetToState(newViewerState, newChannelSettings);
-      this.useDefaultViewerChannelSettings = false;
-    }
-
-    /** Reset to global default viewer state, as if loading the volume with no parameters. */
-  }, {
-    key: "resetToDefaultViewerState",
-    value: function resetToDefaultViewerState() {
-      var channelSettings = this.ref.current.channelSettings;
-      var defaultViewerState = _objectSpread(_objectSpread({}, getDefaultViewerState()), {}, {
-        cameraState: getDefaultCameraState(ViewMode.threeD)
-      });
-      var defaultChannelStates = channelSettings.map(function (_, index) {
-        return getDefaultChannelState(index);
-      });
-      for (var i = 0; i < Math.min(3, defaultChannelStates.length); i++) {
-        defaultChannelStates[i].volumeEnabled = true;
-      }
-      this.resetToState(defaultViewerState, defaultChannelStates);
-      this.useDefaultViewerChannelSettings = true;
-    }
-  }]);
-}();
-export { ResetStateProvider as default };