@vitessce/all 4.0.1 → 4.0.2

package/dist/{GeometryAndMeshXR-o1KV1S6m.js → GeometryAndMeshXR-DngaDWBF.js}

@@ -3,7 +3,7 @@ import { useRef, useEffect, useState } from "react";
 import { useThree, useFrame } from "@react-three/fiber";
 import { Bvh } from "@react-three/drei";
 import { Matrix4, Vector3, Box3, FrontSide } from "three";
-import { g as getXRModule, i as isValidGeometrySize, M as MeasureLine, s as stringifyLineData } from "./index-0nuepTVk.js";
+import { g as getXRModule, i as isValidGeometrySize, M as MeasureLine, s as stringifyLineData } from "./index-CwGBUQIk.js";
 const { useXR, useXRInputSourceState } = getXRModule();
 function getHandJoint(hand, jointName) {
   return hand.get(jointName);

package/dist/{ReactNeuroglancer-BuXB_Emb.js → ReactNeuroglancer-DSiLDSuM.js}

@@ -1,6 +1,6 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import React__default from "react";
-import { a as getDefaultExportFromCjs, d as requireAssign, f as require_export, h as require_core, j as require_fails, k as require_toObject, m as require_objectKeys, n as require_cof, o as require_wks, p as require_iterators, q as requireWeb_dom_iterable, s as requireEs6_string_iterator, t as require_anObject, v as require_hide, w as require_ctx, x as require_toLength, y as require_global, z as require_objectDp, A as require_descriptors, D as require_isObject, E as require_objectCreate, F as require_iterDefine, G as require_iterStep, H as require_meta, I as require_isArray, J as require_iobject, K as require_setToStringTag, M as require_aFunction, N as requireIterator, O as require_propertyDesc, c as commonjsGlobal, P as requireEs6_symbol, Q as requireDefineProperty, R as require_toIobject, S as require_objectGopd, T as require_html, U as require_domCreate, V as require_library, W as requireSymbol, X as require_objectPie, Y as require_has, Z as require_redefine, _ as require_objectAssign, $ as diffCameraState } from "./index-moreUHDf.js";
+import { a as getDefaultExportFromCjs, d as requireAssign, f as require_export, h as require_core, j as require_fails, k as require_toObject, m as require_objectKeys, n as require_cof, o as require_wks, p as require_iterators, q as requireWeb_dom_iterable, s as requireEs6_string_iterator, t as require_anObject, v as require_hide, w as require_ctx, x as require_toLength, y as require_global, z as require_objectDp, A as require_descriptors, D as require_isObject, E as require_objectCreate, F as require_iterDefine, G as require_iterStep, H as require_meta, I as require_isArray, J as require_iobject, K as require_setToStringTag, M as require_aFunction, N as requireIterator, O as require_propertyDesc, c as commonjsGlobal, P as requireEs6_symbol, Q as requireDefineProperty, R as require_toIobject, S as require_objectGopd, T as require_html, U as require_domCreate, V as require_library, W as requireSymbol, X as require_objectPie, Y as require_has, Z as require_redefine, _ as require_objectAssign, $ as GREY_HEX, a0 as diffCameraState } from "./index-B8FH88N6.js";
 var assignExports = requireAssign();
 const _Object$assign = /* @__PURE__ */ getDefaultExportFromCjs(assignExports);
 var es6_object_keys = {};
@@ -65179,7 +65179,6 @@ function setupDefaultViewer(options) {
   disableContextMenu(options.target);
   return viewer;
 }
-const GREY_HEX = "#323232";
 const viewersKeyed = {};
 let viewerNoKey;
 function parseUrlHash(url) {
@@ -65499,21 +65498,50 @@ class Neuroglancer extends React__default.Component {
     const stripColors = (layers) => (layers || []).map((l) => {
       if (!l)
         return l;
-      const { segmentColors, ...rest } = l;
+      const { segmentColors, visible, shader, objectAlpha, segments, ...rest } = l;
       return rest;
     });
     const prevLayers = stripColors(prevVS?.layers);
     const nextLayers = stripColors(nextVS?.layers);
     return JSON.stringify(prevLayers) !== JSON.stringify(nextLayers);
   };
+  // Helper to preserve dimensions across restoreState calls to prevent
+  // NG from permanently switching to the data source's native coordinate space.
+  preserveDimensions = (restoreFn) => {
+    const currentDimensions = this.viewer.state.toJSON().dimensions;
+    restoreFn();
+    if (currentDimensions) {
+      this.viewer.state.restoreState({ dimensions: currentDimensions });
+    }
+  };
+  // Convert hex color string to NG's BGR integer format
+  hexToNgColor = (hex) => {
+    if (!hex || hex.length < 7)
+      return 0;
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return b * 65536 + g * 256 + r;
+  };
   /* To add colors to the segments, turning unselected to grey  */
   applyColorsAndVisibility = (cellColorMappingByLayer) => {
     if (!this.viewer)
       return;
     const baseLayers = this.props.viewerState?.layers ?? (this.viewer.state.toJSON().layers || []);
+    let defaultColor;
     const newLayers = baseLayers.map((layer) => {
       const layerScope = Object.keys(cellColorMappingByLayer).find((scope) => layer.name?.includes(scope));
       const selected = { ...cellColorMappingByLayer[layerScope]?.colors || {} };
+      defaultColor = cellColorMappingByLayer[layerScope]?.defaultColor ?? GREY_HEX;
+      const currentSegments = layer.segments ?? [];
+      if (currentSegments.length > 0) {
+        const segmentSet = new Set(currentSegments.map(String));
+        const fullSegmentColors2 = {};
+        for (const id of segmentSet) {
+          fullSegmentColors2[id] = selected[id] || defaultColor;
+        }
+        return { ...layer, segmentColors: fullSegmentColors2 };
+      }
       if (!this.allKnownIdsByLayer)
         this.allKnownIdsByLayer = {};
       if (!this.allKnownIdsByLayer[layerScope]) {
@@ -65523,17 +65551,47 @@ class Neuroglancer extends React__default.Component {
         this.allKnownIdsByLayer[layerScope].add(id);
       }
       const fullSegmentColors = {};
-      for (const id of this.allKnownIdsByLayer[layerScope] || []) {
-        fullSegmentColors[id] = selected[id] || GREY_HEX;
+      for (const id of this.allKnownIdsByLayer[layerScope]) {
+        fullSegmentColors[id] = selected[id] || defaultColor;
       }
-      if (layer.type === "segmentation") {
-        return { ...layer, segmentColors: fullSegmentColors };
-      }
-      return layer;
-    });
-    this.withoutEmitting(() => {
-      this.viewer.state.restoreState({ layers: newLayers });
+      return { ...layer, segmentColors: fullSegmentColors };
     });
+    let usedDirectUpdate = false;
+    for (const managedLayer of this.viewer.layerManager.managedLayers) {
+      if (!(managedLayer.layer instanceof SegmentationUserLayer))
+        continue;
+      const matchingNewLayer = newLayers.find((l) => l.name === managedLayer.name);
+      if (!matchingNewLayer?.segmentColors)
+        continue;
+      const segGroupState = managedLayer.layer.displayState.segmentationColorGroupState?.value;
+      const statedColors = segGroupState?.segmentStatedColors;
+      if (!statedColors)
+        continue;
+      const currentJson = statedColors.toJSON();
+      const newColors = matchingNewLayer.segmentColors;
+      for (const id of Object.keys(currentJson)) {
+        if (!newColors[id]) {
+          const colorInt = this.hexToNgColor(defaultColor || GREY_HEX);
+          statedColors.delete_({ low: Number(id), high: 0 });
+          statedColors.set_({ low: Number(id), high: 0 }, { low: colorInt, high: 0 });
+        }
+      }
+      for (const [id, hex] of Object.entries(newColors)) {
+        const colorInt = this.hexToNgColor(hex);
+        statedColors.delete_({ low: Number(id), high: 0 });
+        statedColors.set_({ low: Number(id), high: 0 }, { low: colorInt, high: 0 });
+      }
+      statedColors.changed.dispatch();
+      usedDirectUpdate = true;
+    }
+    if (!usedDirectUpdate) {
+      this.withoutEmitting(() => {
+        this.preserveDimensions(() => {
+          this.viewer.state.restoreState({ layers: newLayers });
+        });
+      });
+    }
+    this.viewer.display.scheduleRedraw();
   };
   componentDidMount() {
     const {
@@ -65575,32 +65633,83 @@ class Neuroglancer extends React__default.Component {
     }
     const { visibleChunksChanged } = this.viewer.chunkQueueManager;
     let firstChunkLoaded = false;
-    this.disposers.push(visibleChunksChanged.add(() => {
-      if (!firstChunkLoaded) {
-        for (const layer of this.viewer.layerManager.managedLayers) {
-          if (layer.layer instanceof SegmentationUserLayer) {
-            const hasVisibleChunk = layer.layer.renderLayers?.some((rl) => {
-              const { numVisibleChunksAvailable, numVisibleChunksNeeded } = rl.layerChunkProgressInfo || {};
-              if (!numVisibleChunksNeeded || !numVisibleChunksAvailable)
-                return false;
-              return numVisibleChunksAvailable / numVisibleChunksNeeded > 0.25;
-            });
-            if (hasVisibleChunk) {
-              firstChunkLoaded = true;
-              requestAnimationFrame(() => {
-                requestAnimationFrame(() => {
-                  this.props.onLayerLoadingChange?.(true);
-                });
+    const checkAndMarkLoaded = () => {
+      if (firstChunkLoaded)
+        return false;
+      for (const layer of this.viewer.layerManager.managedLayers) {
+        if (layer.layer instanceof SegmentationUserLayer) {
+          const hasVisibleChunk = layer.layer.renderLayers?.some((rl) => {
+            const { numVisibleChunksAvailable, numVisibleChunksNeeded } = rl.layerChunkProgressInfo || {};
+            if (!numVisibleChunksNeeded || !numVisibleChunksAvailable)
+              return false;
+            return numVisibleChunksAvailable / numVisibleChunksNeeded > 0.25;
+          });
+          if (hasVisibleChunk) {
+            firstChunkLoaded = true;
+            requestAnimationFrame(() => requestAnimationFrame(() => {
+              this.props.onLayerLoadingChange?.(true);
+            }));
+            return true;
+          }
+        }
+        if (layer.layer instanceof AnnotationUserLayer) {
+          const hasVisibleChunk = layer.layer.renderLayers?.some((rl) => {
+            const { numVisibleChunksNeeded } = rl.layerChunkProgressInfo || {};
+            return numVisibleChunksNeeded > 0;
+          });
+          if (hasVisibleChunk) {
+            firstChunkLoaded = true;
+            requestAnimationFrame(() => requestAnimationFrame(() => {
+              this.props.onLayerLoadingChange?.(true);
+            }));
+            const annotState = layer.layer.annotationStates?.states[0];
+            const t = annotState?.chunkTransform?.value?.layerToChunkTransform;
+            const serializers = annotState?.source?.annotationPropertySerializers;
+            if (t && serializers) {
+              this.props.onAnnotationSourceReady?.({
+                x: t[0],
+                y: t[5],
+                z: t[10],
+                serializers,
+                // pass all serializers
+                serializer: serializers[0]
+                // keep default for backward compat
               });
-              return;
             }
+            return true;
           }
         }
       }
-    }));
+      return false;
+    };
+    this.disposers.push(visibleChunksChanged.add(checkAndMarkLoaded));
+    setTimeout(() => {
+      if (!firstChunkLoaded)
+        checkAndMarkLoaded();
+    }, 100);
+    setTimeout(() => {
+      if (!firstChunkLoaded)
+        checkAndMarkLoaded();
+    }, 1e3);
     this.disposers.push(() => {
       firstChunkLoaded = false;
     });
+    document.addEventListener("wheel", (e) => {
+      if (e.ctrlKey)
+        e.preventDefault();
+    }, { passive: false });
+    this.disposers.push(() => {
+      document.removeEventListener("wheel", (e) => {
+        if (e.ctrlKey)
+          e.preventDefault();
+      });
+    });
+    this.disposers.push(this.viewer.chunkQueueManager.visibleChunksChanged.add(() => {
+      if (this.props.cellColorMapping) {
+        this.applyColorsAndVisibility(this.props.cellColorMapping);
+      }
+    }));
+    window.viewer = this.viewer;
   }
   componentDidUpdate(prevProps, prevState) {
     const { viewerState, cellColorMapping: cellColorMappingByLayer } = this.props;
@@ -65611,13 +65720,19 @@ class Neuroglancer extends React__default.Component {
         selectedSegments[layer.name] = segmentSelectionState.selectedSegment;
       }
     }
+    for (const managedLayer of this.viewer.layerManager.managedLayers) {
+      const matchingLayer = (viewerState?.layers || []).find((l) => l.name === managedLayer.name);
+      if (matchingLayer && typeof matchingLayer.visible === "boolean" && managedLayer.visible !== matchingLayer.visible) {
+        managedLayer.setVisible(matchingLayer.visible);
+      }
+    }
     for (const layer of this.viewer.layerManager.managedLayers) {
       if (layer.layer instanceof SegmentationUserLayer) {
         const { segmentSelectionState } = layer.layer.displayState;
         segmentSelectionState.set(selectedSegments[layer.name]);
         const layerScope = Object.keys(cellColorMappingByLayer).find((scope) => layer.name?.includes(scope));
         if (layerScope) {
-          const opacity = cellColorMappingByLayer[layerScope]?.opacity ?? 1;
+          const opacity = this.props.meshOpacity !== void 0 ? this.props.meshOpacity : cellColorMappingByLayer[layerScope]?.opacity ?? 1;
           layer.layer.displayState.objectAlpha.value = opacity;
         }
       }
@@ -65634,6 +65749,8 @@ class Neuroglancer extends React__default.Component {
     if (!viewerState)
       return;
     const prevVS = prevProps.viewerState;
+    const prevLayers = prevProps.viewerState?.layers;
+    const nextLayers = viewerState?.layers;
     const camState = diffCameraState(prevVS, viewerState);
     if (camState.changed) {
       const patch = {};
@@ -65650,39 +65767,34 @@ class Neuroglancer extends React__default.Component {
     }
     if (this.didLayersChange(prevVS, viewerState)) {
       this.withoutEmitting(() => {
-        const layers = Array.isArray(viewerState.layers) ? viewerState.layers : [];
-        this.viewer.state.restoreState({ layers });
-        if (cellColorMappingByLayer && Object.keys(cellColorMappingByLayer).length) {
-          this.applyColorsAndVisibility(cellColorMappingByLayer);
-        }
+        this.preserveDimensions(() => {
+          this.viewer.state.restoreState({ layers: nextLayers });
+        });
       });
     }
-    const prevSize = prevProps.cellColorMapping ? Object.values(prevProps.cellColorMapping).reduce((acc, v) => acc + Object.keys(v?.colors || {}).length, 0) : 0;
-    const currSize = cellColorMappingByLayer ? Object.values(cellColorMappingByLayer).reduce((acc, v) => acc + Object.keys(v?.colors || {}).length, 0) : 0;
-    const mappingRefChanged = prevProps.cellColorMapping !== this.props.cellColorMapping;
-    if (!this.didLayersChange(prevVS, viewerState) && (mappingRefChanged || prevSize !== currSize)) {
+    const stripOpacity = (mapping) => {
+      const result = {};
+      Object.entries(mapping || {}).forEach(([k, v]) => {
+        result[k] = { colors: v?.colors };
+      });
+      return result;
+    };
+    const prevColorsJSON = JSON.stringify(stripOpacity(prevProps.cellColorMapping));
+    const currColorsJSON = JSON.stringify(stripOpacity(cellColorMappingByLayer));
+    const colorsActuallyChanged = prevColorsJSON !== currColorsJSON;
+    if (!this.didLayersChange(prevVS, viewerState) && colorsActuallyChanged) {
       this.withoutEmitting(() => {
         this.applyColorsAndVisibility(cellColorMappingByLayer);
       });
     }
-    const stripSegFields = (layers) => (layers || []).map((l) => {
-      if (!l)
-        return l;
-      const { segments, segmentColors, objectAlpha, ...rest } = l;
-      return rest;
-    });
-    const prevLayers = prevProps.viewerState?.layers;
-    const nextLayers = viewerState?.layers;
-    const prevCore = JSON.stringify(stripSegFields(prevLayers));
-    const nextCore = JSON.stringify(stripSegFields(nextLayers));
-    const sourcesChanged = prevCore !== nextCore;
-    const prevSegCount = prevLayers && prevLayers[0] && Array.isArray(prevLayers[0].segments) ? prevLayers[0].segments.length : 0;
-    const nextSegCount = nextLayers && nextLayers[0] && Array.isArray(nextLayers[0].segments) ? nextLayers[0].segments.length : 0;
-    const initialSegmentsAdded = prevSegCount === 0 && nextSegCount > 0;
-    if (sourcesChanged || initialSegmentsAdded) {
-      this.withoutEmitting(() => {
+    const prevSegIds = prevLayers?.[0]?.segments ?? [];
+    const nextSegIds = nextLayers?.[0]?.segments ?? [];
+    const segmentsChanged = prevSegIds.length !== nextSegIds.length || prevSegIds[0] !== nextSegIds[0] || prevSegIds[prevSegIds.length - 1] !== nextSegIds[nextSegIds.length - 1];
+    if (segmentsChanged && nextSegIds.length > 0) {
+      this.preserveDimensions(() => {
         this.viewer.state.restoreState({ layers: nextLayers });
       });
+      this.applyColorsAndVisibility(cellColorMappingByLayer);
     }
   }
   componentWillUnmount() {
@@ -65713,7 +65825,7 @@ class Neuroglancer extends React__default.Component {
    *
    */
   setCallbacks(callbacks) {
-    callbacks.forEach((callback) => {
+    (callbacks ?? []).forEach((callback) => {
       this.viewer.bindCallback(callback.name, callback.function);
       this.viewer.inputEventBindings.sliceView.set(callback.event, callback.name);
     });

package/dist/{XREnterButton-DZUdn-IL.js → XREnterButton-Beha7PBD.js}

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { useState, useEffect } from "react";
-import { x as xrStore } from "./xrStore-gGt4Wkvz.js";
+import { x as xrStore } from "./xrStore-Dhi1LSJi.js";
 function XREnterButton() {
   const [supported, setSupported] = useState(false);
   const [entered, setEntered] = useState(false);

package/dist/{XRSceneComponents-Cgrg-9p2.js → XRSceneComponents-CNuqVsYi.js}

@@ -1,7 +1,7 @@
 import { jsxs, Fragment, jsx } from "react/jsx-runtime";
 import { useRef } from "react";
 import { useThree, useFrame } from "@react-three/fiber";
-import { g as getXRModule } from "./index-0nuepTVk.js";
+import { g as getXRModule } from "./index-CwGBUQIk.js";
 const { useXRInputSourceState } = getXRModule();
 function getHandJoint(hand, jointName) {
   return hand.get(jointName);

package/dist/{XRWrapper-BB28re-M.js → XRWrapper-BsV3wgJG.js}

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
-import { g as getXRModule } from "./index-0nuepTVk.js";
-import { x as xrStore } from "./xrStore-gGt4Wkvz.js";
+import { g as getXRModule } from "./index-CwGBUQIk.js";
+import { x as xrStore } from "./xrStore-Dhi1LSJi.js";
 const { XR } = getXRModule();
 function XRWrapper({ children }) {
   return jsx(XR, { store: xrStore, children });

package/dist/{deflate-E8TfyvM7.js → deflate-BnG3V84V.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-SxljTded.js";
-import { B as BaseDecoder } from "./index-moreUHDf.js";
+import { B as BaseDecoder } from "./index-B8FH88N6.js";
 class DeflateDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return inflate_1(new Uint8Array(buffer)).buffer;

package/dist/{higlass-CGhpbMxK.js → higlass-4OKx7mdy.js}

@@ -1,6 +1,6 @@
 import * as React from "react";
 import React__default, { createContext, isValidElement, PureComponent, Component, useMemo, useState, useRef, useEffect, useCallback, memo, useContext, useReducer, useLayoutEffect } from "react";
-import { r as requireObjectAssign, a as getDefaultExportFromCjs$1, c as commonjsGlobal, e as earcut } from "./index-moreUHDf.js";
+import { r as requireObjectAssign, a as getDefaultExportFromCjs$1, c as commonjsGlobal, e as earcut } from "./index-B8FH88N6.js";
 import ReactDOM__default, { unstable_batchedUpdates, createPortal } from "react-dom";
 import { jsx, jsxs } from "react/jsx-runtime";
 function finallyConstructor(callback) {