@vitessce/all 3.6.11 → 3.6.13

package/dist/{ReactNeuroglancer-ByxOvkt_.js → ReactNeuroglancer-D4Xivd2K.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs, aV as requireAssign, aW as require_export, aX as require_core, aY as require_fails, aZ as require_toObject, a_ as require_objectKeys, a$ as require_cof, b0 as require_wks, b1 as require_iterators, b2 as requireWeb_dom_iterable, b3 as requireEs6_string_iterator, b4 as require_anObject, b5 as require_hide, b6 as require_ctx, b7 as require_toLength, b8 as require_global, b9 as require_objectDp, ba as require_descriptors, bb as require_isObject, bc as require_objectCreate, bd as require_iterDefine, be as require_iterStep, bf as require_meta, bg as require_isArray, bh as require_iobject, bi as require_setToStringTag, bj as require_aFunction, bk as requireIterator, bl as require_propertyDesc, aS as commonjsGlobal, bm as requireEs6_symbol, bn as requireDefineProperty, bo as require_toIobject, bp as require_objectGopd, bq as require_html, br as require_domCreate, bs as require_library, bt as requireSymbol, bu as require_objectPie, bv as require_has, bw as require_redefine, bx as require_objectAssign, by as getAugmentedNamespace, bz as requirePropTypes, aI as jsxRuntimeExports } from "./index-Dr34Nsn3.js";
+import { g as getDefaultExportFromCjs, aV as requireAssign, aW as require_export, aX as require_core, aY as require_fails, aZ as require_toObject, a_ as require_objectKeys, a$ as require_cof, b0 as require_wks, b1 as require_iterators, b2 as requireWeb_dom_iterable, b3 as requireEs6_string_iterator, b4 as require_anObject, b5 as require_hide, b6 as require_ctx, b7 as require_toLength, b8 as require_global, b9 as require_objectDp, ba as require_descriptors, bb as require_isObject, bc as require_objectCreate, bd as require_iterDefine, be as require_iterStep, bf as require_meta, bg as require_isArray, bh as require_iobject, bi as require_setToStringTag, bj as require_aFunction, bk as requireIterator, bl as require_propertyDesc, aS as commonjsGlobal, bm as requireEs6_symbol, bn as requireDefineProperty, bo as require_toIobject, bp as require_objectGopd, bq as require_html, br as require_domCreate, bs as require_library, bt as requireSymbol, bu as require_objectPie, bv as require_has, bw as require_redefine, bx as require_objectAssign, by as getAugmentedNamespace, bz as requirePropTypes, aI as jsxRuntimeExports } from "./index-DcZv7teI.js";
 import React__default from "react";
 var lib = {};
 var assignExports = requireAssign();

package/dist/{deflate-DlNs33aU.js → deflate-B2CAUF5S.js}

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

package/dist/{higlass-cF4tD6Th.js → higlass-DNEa7gM7.js}

@@ -1,7 +1,7 @@
 import * as React$7 from "react";
 import React__default, { isValidElement, PureComponent, Component, createElement, createContext, createRef } from "react";
 import ReactDOM__default, { findDOMNode as findDOMNode$1 } from "react-dom";
-import { aS as commonjsGlobal$1, aT as requireObjectAssign, g as getDefaultExportFromCjs$1, aU as earcut } from "./index-Dr34Nsn3.js";
+import { aS as commonjsGlobal$1, aT as requireObjectAssign, g as getDefaultExportFromCjs$1, aU as earcut } from "./index-DcZv7teI.js";
 var promise = {};
 var hasRequiredPromise;
 function requirePromise() {

package/dist/{index-xo9xcZLg.js → index-DG6RbZza.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs, R as Raycaster, O as OrthographicCamera, P as PerspectiveCamera, S as Scene, a as PCFSoftShadowMap, V as VSMShadowMap, b as PCFShadowMap, B as BasicShadowMap, N as NoToneMapping, A as ACESFilmicToneMapping, c as Vector3, d as Vector2, C as Clock, W as WebGLRenderer, e as Camera, f as BufferGeometry, M as Material, L as Layers, T as Texture, h as RGBAFormat, U as UnsignedByteType, i as Color, _ as _extends, j as THREE, G as Group, k as Matrix4, l as TrianglesDrawMode, m as TriangleFanDrawMode, n as TriangleStripDrawMode, o as REVISION, E as EventDispatcher, p as MOUSE, q as TOUCH, r as Spherical, Q as Quaternion, s as Ray$1, t as Plane, u as Loader, v as LoaderUtils, F as FileLoader, w as MeshPhysicalMaterial, x as SpotLight, y as PointLight, D as DirectionalLight, I as InstancedMesh, z as Object3D, H as TextureLoader, J as ImageBitmapLoader, K as BufferAttribute, X as InterleavedBuffer, Y as LinearMipmapLinearFilter, Z as NearestMipmapLinearFilter, $ as LinearMipmapNearestFilter, a0 as NearestMipmapNearestFilter, a1 as LinearFilter, a2 as NearestFilter, a3 as RepeatWrapping, a4 as MirroredRepeatWrapping, a5 as ClampToEdgeWrapping, a6 as PointsMaterial, a7 as LineBasicMaterial, a8 as MeshStandardMaterial, a9 as DoubleSide, aa as MeshBasicMaterial, ab as PropertyBinding, ac as SkinnedMesh, ad as Mesh, ae as LineSegments, af as Line$1, ag as LineLoop, ah as Points, ai as MathUtils, aj as Skeleton, ak as InterpolateDiscrete, al as InterpolateLinear, am as AnimationClip, an as Bone, ao as InterleavedBufferAttribute, ap as VectorKeyframeTrack, aq as QuaternionKeyframeTrack, ar as NumberKeyframeTrack, as as FrontSide, at as Interpolant, au as Box3, av as Sphere, aw as InstancedBufferGeometry, ax as Float32BufferAttribute, ay as InstancedInterleavedBuffer, az as WireframeGeometry, aA as ShaderMaterial, aB as UniformsUtils, aC as UniformsLib, aD as Vector4, aE as Line3, aF as SphereGeometry, aG as Triangle, aH as BackSide, aI as jsxRuntimeExports, aJ as Matrix3, aK as CoordinationType, aL as Data3DTexture, aM as RedFormat, aN as FloatType, aO as getImageSize } from "./index-Dr34Nsn3.js";
+import { g as getDefaultExportFromCjs, R as Raycaster, O as OrthographicCamera, P as PerspectiveCamera, S as Scene, a as PCFSoftShadowMap, V as VSMShadowMap, b as PCFShadowMap, B as BasicShadowMap, N as NoToneMapping, A as ACESFilmicToneMapping, c as Vector3, d as Vector2, C as Clock, W as WebGLRenderer, e as Camera, f as BufferGeometry, M as Material, L as Layers, T as Texture, h as RGBAFormat, U as UnsignedByteType, i as Color, _ as _extends, j as THREE, G as Group, k as Matrix4, l as TrianglesDrawMode, m as TriangleFanDrawMode, n as TriangleStripDrawMode, o as REVISION, E as EventDispatcher, p as MOUSE, q as TOUCH, r as Spherical, Q as Quaternion, s as Ray$1, t as Plane, u as Loader, v as LoaderUtils, F as FileLoader, w as MeshPhysicalMaterial, x as SpotLight, y as PointLight, D as DirectionalLight, I as InstancedMesh, z as Object3D, H as TextureLoader, J as ImageBitmapLoader, K as BufferAttribute, X as InterleavedBuffer, Y as LinearMipmapLinearFilter, Z as NearestMipmapLinearFilter, $ as LinearMipmapNearestFilter, a0 as NearestMipmapNearestFilter, a1 as LinearFilter, a2 as NearestFilter, a3 as RepeatWrapping, a4 as MirroredRepeatWrapping, a5 as ClampToEdgeWrapping, a6 as PointsMaterial, a7 as LineBasicMaterial, a8 as MeshStandardMaterial, a9 as DoubleSide, aa as MeshBasicMaterial, ab as PropertyBinding, ac as SkinnedMesh, ad as Mesh, ae as LineSegments, af as Line$1, ag as LineLoop, ah as Points, ai as MathUtils, aj as Skeleton, ak as InterpolateDiscrete, al as InterpolateLinear, am as AnimationClip, an as Bone, ao as InterleavedBufferAttribute, ap as VectorKeyframeTrack, aq as QuaternionKeyframeTrack, ar as NumberKeyframeTrack, as as FrontSide, at as Interpolant, au as Box3, av as Sphere, aw as InstancedBufferGeometry, ax as Float32BufferAttribute, ay as InstancedInterleavedBuffer, az as WireframeGeometry, aA as ShaderMaterial, aB as UniformsUtils, aC as UniformsLib, aD as Vector4, aE as Line3, aF as SphereGeometry, aG as Triangle, aH as BackSide, aI as jsxRuntimeExports, aJ as Matrix3, aK as CoordinationType, aL as Data3DTexture, aM as RedFormat, aN as FloatType, aO as getImageSize } from "./index-DcZv7teI.js";
 import * as React from "react";
 import React__default, { useReducer, useRef, useEffect, useLayoutEffect, useDebugValue, useState, useMemo, forwardRef } from "react";
 var constants = { exports: {} };
@@ -23637,7 +23637,7 @@ const Text = /* @__PURE__ */ React.forwardRef(({
   const {
     Text: TextMeshImpl,
     preloadFont
-  } = suspend(async () => import("./troika-three-text.esm-C4mcmvqE.js"), []);
+  } = suspend(async () => import("./troika-three-text.esm-DLsbwboO.js"), []);
   const invalidate2 = useThree(({
     invalidate: invalidate3
   }) => invalidate3);

package/dist/{index-Dr34Nsn3.js → index-DcZv7teI.js}

@@ -209669,22 +209669,22 @@ async function getDecoder(fileDirectory) {
   const Decoder = await importFn();
   return new Decoder(fileDirectory);
 }
-addDecoder([void 0, 1], () => import("./raw-BloA4686.js").then((m2) => m2.default));
-addDecoder(5, () => import("./lzw-DhNvTBt-.js").then((m2) => m2.default));
+addDecoder([void 0, 1], () => import("./raw-DqALOEt-.js").then((m2) => m2.default));
+addDecoder(5, () => import("./lzw-kKlj6Pam.js").then((m2) => m2.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-BchP2GI5.js").then((m2) => m2.default));
-addDecoder([8, 32946], () => import("./deflate-DlNs33aU.js").then((m2) => m2.default));
-addDecoder(32773, () => import("./packbits-C6We0BcA.js").then((m2) => m2.default));
+addDecoder(7, () => import("./jpeg-DY_DkYi3.js").then((m2) => m2.default));
+addDecoder([8, 32946], () => import("./deflate-B2CAUF5S.js").then((m2) => m2.default));
+addDecoder(32773, () => import("./packbits-DzhxlAeC.js").then((m2) => m2.default));
 addDecoder(
   34887,
-  () => import("./lerc-Yewj5Mkt.js").then(async (m2) => {
+  () => import("./lerc-Bz6jtDu9.js").then(async (m2) => {
     await m2.zstd.init();
     return m2;
   }).then((m2) => m2.default)
 );
-addDecoder(50001, () => import("./webimage-DyPRDNMg.js").then((m2) => m2.default));
+addDecoder(50001, () => import("./webimage-B46sb8Pc.js").then((m2) => m2.default));
 function copyNewSize(array2, width2, height2, samplesPerPixel = 1) {
   return new (Object.getPrototypeOf(array2)).constructor(width2 * height2 * samplesPerPixel);
 }
@@ -247593,6 +247593,61 @@ function abbreviateNumber(value2) {
     return naive;
   return value2.toExponential(0);
 }
+class DAG {
+  /**
+     * DAG constructor.
+     * @param {{ from: string, to: string, attributes: any}[]} edges
+     */
+  constructor(edges) {
+    this.graph = /* @__PURE__ */ new Map();
+    this.edgeData = new InternMap$1([], JSON.stringify);
+    edges.forEach((edge) => {
+      const { from: from2, to } = edge;
+      if (!this.graph.has(from2)) {
+        this.graph.set(from2, []);
+      }
+      this.graph.get(from2).push(to);
+      this.edgeData.set([from2, to], edge.attributes);
+    });
+  }
+  /**
+   * Find a path from start to end using DFS.
+   * @param {string} start
+   * @param {string} end
+   * @returns {{ from: string, to: string, attributes: any }[] | null} Returns
+   * the path as an array of edges or null if no path exists.
+   */
+  findPath(start2, end2) {
+    const path2 = [];
+    const visited = /* @__PURE__ */ new Set();
+    const dfs = (node2) => {
+      if (node2 === end2) {
+        return true;
+      }
+      visited.add(node2);
+      const neighbors = this.graph.get(node2) || [];
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          path2.push([node2, neighbor]);
+          if (dfs(neighbor)) {
+            return true;
+          }
+          path2.pop();
+        }
+      }
+      return false;
+    };
+    const found = dfs(start2);
+    if (found) {
+      return path2.map(([from2, to]) => ({
+        from: from2,
+        to,
+        attributes: this.edgeData.get([from2, to])
+      }));
+    }
+    return null;
+  }
+}
 function getSourceFromLoader(loader2, level) {
   const { data: data2 } = loader2;
   const source2 = Array.isArray(data2) ? data2[data2.length - 1] : data2;
@@ -247904,8 +247959,14 @@ function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
           }
         } else if (spatialOutputAxes.length === 2) {
           const nextMat = new Matrix4$1().fromArray([
-            ...filteredAffine[0],
-            ...filteredAffine[1],
+            filteredAffine[0][0],
+            filteredAffine[0][1],
+            0,
+            filteredAffine[0][2],
+            filteredAffine[1][0],
+            filteredAffine[1][1],
+            0,
+            filteredAffine[1][2],
             0,
             0,
             1,
@@ -247921,6 +247982,7 @@ function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
             const swapMat = new Matrix4$1().fromArray(swapMatNested.flat());
             mat = mat.multiplyLeft(swapMat);
           }
+          mat = mat.transpose();
         } else {
           throw new Error("Affine transformation must have 2 or 3 rows.");
         }
@@ -247947,6 +248009,9 @@ function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
       }
     });
   }
+  if (mat.some((value2) => Number.isNaN(value2))) {
+    throw new Error("Matrix contains NaN values");
+  }
   return mat;
 }
 function hexToRgb(hex2) {
@@ -247965,6 +248030,9 @@ function normalizeAxes(axes) {
     return axisInfo;
   });
 }
+function getIntrinsicCoordinateSystem(normAxes) {
+  return normAxes.map((axis2) => axis2.name).join("");
+}
 function normalizeCoordinateTransformations(coordinateTransformations, datasets) {
   var _a3;
   let result = [];
@@ -247972,35 +248040,13 @@ function normalizeCoordinateTransformations(coordinateTransformations, datasets)
     result = coordinateTransformations.flatMap((transform3) => {
       if (transform3.input && transform3.output) {
         const { type: type2 } = transform3;
-        if (type2 === "translation") {
-          return {
-            type: type2,
-            translation: transform3.translation
-          };
-        }
-        if (type2 === "scale") {
-          return {
-            type: type2,
-            scale: transform3.scale
-          };
-        }
-        if (type2 === "affine") {
-          return {
-            type: type2,
-            affine: transform3.affine,
-            // Affine transformations can potentially swap axes,
-            // so we need to include the input and output axes.
-            input: transform3.input,
-            output: transform3.output
-          };
-        }
-        if (type2 === "identity") {
-          return { type: type2 };
-        }
         if (type2 === "sequence") {
-          return normalizeCoordinateTransformations(transform3.transformations, datasets);
+          return normalizeCoordinateTransformations(transform3.transformations, null);
+        }
+        if (type2 === "affine" || type2 === "translation" || type2 === "scale" || type2 === "identity") {
+          return transform3;
         }
-        log$b.warn(`Coordinate transformation type "${type2}" is not supported.`);
+        log$b.error(`Coordinate transformation type "${type2}" is not supported.`);
       }
       return transform3;
     });
@@ -248013,6 +248059,27 @@ function normalizeCoordinateTransformations(coordinateTransformations, datasets)
   }
   return result;
 }
+function coordinateTransformationsToMatrixForSpatialData(ngffMetadata, targetCoordinateSystem) {
+  const { datasets, coordinateTransformations, axes } = ngffMetadata;
+  const normAxes = normalizeAxes(axes);
+  const intrinsicCoordinateSystem = getIntrinsicCoordinateSystem(normAxes);
+  const edges = coordinateTransformations.map((ct) => ({
+    from: ct.input.name,
+    to: ct.output.name,
+    attributes: ct
+  }));
+  const dag = new DAG(edges);
+  const ctPath = dag.findPath(intrinsicCoordinateSystem, targetCoordinateSystem);
+  if (!ctPath) {
+    if (!coordinateTransformations.find((ct) => ct.output.name === targetCoordinateSystem)) {
+      throw new Error(`No coordinate transformation found with output.name "${targetCoordinateSystem}".`);
+    }
+    throw new Error(`No path found from "${intrinsicCoordinateSystem}" to "${targetCoordinateSystem}".`);
+  }
+  const filteredTransformations = ctPath.map((ctEdge) => ctEdge.attributes);
+  const normalizedTransformations = normalizeCoordinateTransformations(filteredTransformations, datasets);
+  return coordinateTransformationsToMatrix(normalizedTransformations, normAxes);
+}
 class NodeNotFoundError extends Error {
   constructor(context2, options = {}) {
     super(`Node not found: ${context2}`, options);
@@ -253493,7 +253560,7 @@ class ErrorBoundary extends React__default.Component {
   }
 }
 const LazySpatialThree = React__default.lazy(async () => {
-  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-xo9xcZLg.js");
+  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-DG6RbZza.js");
   return { default: SpatialWrapper2 };
 });
 const SpatialThreeAdapter = React__default.forwardRef((props, ref2) => jsxRuntimeExports.jsx("div", { ref: ref2, style: { width: "100%", height: "100%" }, children: jsxRuntimeExports.jsx(ErrorBoundary, { children: jsxRuntimeExports.jsx(Suspense, { fallback: jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: jsxRuntimeExports.jsx(LazySpatialThree, { ...props }) }) }) }));
@@ -265334,7 +265401,7 @@ function HiglassGlobalStyles(props) {
 }
 register({ dataFetcher: ZarrMultivecDataFetcher_default, config: ZarrMultivecDataFetcher_default.config }, { pluginType: "dataFetcher" });
 const LazyHiGlassComponent = React__default.lazy(async () => {
-  const { HiGlassComponent } = await import("./higlass-cF4tD6Th.js");
+  const { HiGlassComponent } = await import("./higlass-DNEa7gM7.js");
   return { default: HiGlassComponent };
 });
 const HG_SIZE = 800;
@@ -268278,7 +268345,7 @@ function NeuroglancerGlobalStyles(props) {
   const { classes: classes2 } = props;
   return jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [jsxRuntimeExports.jsx(GlobalStyles$3, { styles: globalNeuroglancerCss }), jsxRuntimeExports.jsx(ScopedGlobalStyles, { styles: globalNeuroglancerStyles, parentClassName: classes2.neuroglancerWrapper })] });
 }
-const LazyReactNeuroglancer = React__default.lazy(() => import("./ReactNeuroglancer-ByxOvkt_.js"));
+const LazyReactNeuroglancer = React__default.lazy(() => import("./ReactNeuroglancer-D4Xivd2K.js"));
 function createWorker() {
   return new WorkerFactory();
 }
@@ -325823,13 +325890,22 @@ class ImageWrapper {
     return this.modelMatrix;
   }
   _getModelMatrix() {
-    const { coordinateTransformations: coordinateTransformationsFromOptions } = this.options;
+    const { coordinateSystem = "global", coordinateTransformations: coordinateTransformationsFromOptions } = this.options;
     if ("multiscales" in this.vivLoader.metadata) {
       const { multiscales: [{ datasets, coordinateTransformations: coordinateTransformationsFromFile, axes }] } = this.vivLoader.metadata;
       const ngffAxes = getNgffAxes(axes);
       const transformMatrixFromOptions = coordinateTransformationsToMatrix(coordinateTransformationsFromOptions, ngffAxes);
-      const normCoordinateTransformationsFromFile = normalizeCoordinateTransformations(coordinateTransformationsFromFile, datasets);
-      const transformMatrixFromFile = coordinateTransformationsToMatrix(normCoordinateTransformationsFromFile, ngffAxes);
+      let transformMatrixFromFile;
+      if ("spatialdata_attrs" in this.vivLoader.metadata) {
+        transformMatrixFromFile = coordinateTransformationsToMatrixForSpatialData(
+          // Pass the first multiscales element.
+          this.vivLoader.metadata.multiscales[0],
+          coordinateSystem
+        );
+      } else {
+        const normCoordinateTransformationsFromFile = normalizeCoordinateTransformations(coordinateTransformationsFromFile, datasets);
+        transformMatrixFromFile = coordinateTransformationsToMatrix(normCoordinateTransformationsFromFile, ngffAxes);
+      }
       const transformMatrix = transformMatrixFromFile.multiplyLeft(transformMatrixFromOptions);
       return transformMatrix;
     }
@@ -326321,16 +326397,7 @@ class SpatialDataLabelsLoader extends SpatialDataImageLoader {
     return result;
   }
 }
-function getCoordsPath(path2) {
-  return `${path2}/coords`;
-}
-function getRadiusPath(path2) {
-  return `${path2}/radius`;
-}
-function getGeometryPath$1(path2) {
-  return `${path2}/geometry`;
-}
-const DEFAULT_AXES$1 = [
+const OLD_SHAPES_DEFAULT_AXES = [
   {
     name: "x",
     type: "space",
@@ -326342,7 +326409,7 @@ const DEFAULT_AXES$1 = [
     unit: "unit"
   }
 ];
-const DEFAULT_COORDINATE_TRANSFORMATIONS$1 = [
+const OLD_SHAPES_DEFAULT_COORDINATE_TRANSFORMATIONS = [
   {
     input: {
       axes: [
@@ -326377,6 +326444,15 @@ const DEFAULT_COORDINATE_TRANSFORMATIONS$1 = [
     type: "identity"
   }
 ];
+function getCoordsPath(path2) {
+  return `${path2}/coords`;
+}
+function getRadiusPath(path2) {
+  return `${path2}/radius`;
+}
+function getGeometryPath$1(path2) {
+  return `${path2}/geometry`;
+}
 class SpatialDataObsSpotsLoader extends AbstractTwoStepLoader {
   async loadModelMatrix() {
     const { path: path2, coordinateSystem = "global" } = this.options;
@@ -326384,12 +326460,9 @@ class SpatialDataObsSpotsLoader extends AbstractTwoStepLoader {
       return this.modelMatrix;
     }
     const zattrs = await this.dataSource.loadSpatialDataElementAttrs(path2);
-    const coordinateTransformationsFromFile = ((zattrs == null ? void 0 : zattrs.coordinateTransformations) || DEFAULT_COORDINATE_TRANSFORMATIONS$1).filter(({ input: { name: inputName }, output: { name: outputName } }) => inputName === "xy" && outputName === coordinateSystem);
-    const axes = (zattrs == null ? void 0 : zattrs.axes) ?? DEFAULT_AXES$1;
-    const normAxes = normalizeAxes(axes);
-    const normCoordinateTransformationsFromFile = normalizeCoordinateTransformations(coordinateTransformationsFromFile, null);
-    const transformMatrixFromFile = coordinateTransformationsToMatrix(normCoordinateTransformationsFromFile, normAxes);
-    this.modelMatrix = transformMatrixFromFile;
+    const coordinateTransformations = (zattrs == null ? void 0 : zattrs.coordinateTransformations) ?? OLD_SHAPES_DEFAULT_COORDINATE_TRANSFORMATIONS;
+    const axes = (zattrs == null ? void 0 : zattrs.axes) ?? OLD_SHAPES_DEFAULT_AXES;
+    this.modelMatrix = coordinateTransformationsToMatrixForSpatialData({ axes, coordinateTransformations }, coordinateSystem);
     return this.modelMatrix;
   }
   /**
@@ -326488,53 +326561,6 @@ class SpatialDataObsSpotsLoader extends AbstractTwoStepLoader {
 function getGeometryPath(path2) {
   return `${path2}/geometry`;
 }
-const DEFAULT_AXES = [
-  {
-    name: "x",
-    type: "space",
-    unit: "unit"
-  },
-  {
-    name: "y",
-    type: "space",
-    unit: "unit"
-  }
-];
-const DEFAULT_COORDINATE_TRANSFORMATIONS = [
-  {
-    input: {
-      axes: [
-        {
-          name: "x",
-          type: "space",
-          unit: "unit"
-        },
-        {
-          name: "y",
-          type: "space",
-          unit: "unit"
-        }
-      ],
-      name: "xy"
-    },
-    output: {
-      axes: [
-        {
-          name: "x",
-          type: "space",
-          unit: "unit"
-        },
-        {
-          name: "y",
-          type: "space",
-          unit: "unit"
-        }
-      ],
-      name: "global"
-    },
-    type: "identity"
-  }
-];
 class SpatialDataObsSegmentationsLoader extends AbstractTwoStepLoader {
   async loadModelMatrix() {
     const { path: path2, coordinateSystem = "global" } = this.options;
@@ -326542,12 +326568,9 @@ class SpatialDataObsSegmentationsLoader extends AbstractTwoStepLoader {
       return this.modelMatrix;
     }
     const zattrs = await this.dataSource.loadSpatialDataElementAttrs(path2);
-    const coordinateTransformationsFromFile = ((zattrs == null ? void 0 : zattrs.coordinateTransformations) ?? DEFAULT_COORDINATE_TRANSFORMATIONS).filter(({ input: { name: inputName }, output: { name: outputName } }) => inputName === "xy" && outputName === coordinateSystem);
-    const axes = (zattrs == null ? void 0 : zattrs.axes) ?? DEFAULT_AXES;
-    const normAxes = normalizeAxes(axes);
-    const normCoordinateTransformationsFromFile = normalizeCoordinateTransformations(coordinateTransformationsFromFile, null);
-    const transformMatrixFromFile = coordinateTransformationsToMatrix(normCoordinateTransformationsFromFile, normAxes);
-    this.modelMatrix = transformMatrixFromFile;
+    const coordinateTransformations = (zattrs == null ? void 0 : zattrs.coordinateTransformations) ?? OLD_SHAPES_DEFAULT_COORDINATE_TRANSFORMATIONS;
+    const axes = (zattrs == null ? void 0 : zattrs.axes) ?? OLD_SHAPES_DEFAULT_AXES;
+    this.modelMatrix = coordinateTransformationsToMatrixForSpatialData({ axes, coordinateTransformations }, coordinateSystem);
     return this.modelMatrix;
   }
   /**
@@ -326624,11 +326647,7 @@ class SpatialDataObsPointsLoader extends AbstractTwoStepLoader {
     if (!coordinateTransformations) {
       throw new Error("The coordinate transformations metadata must be defined for point elements.");
     }
-    const normAxes = normalizeAxes(axes);
-    const coordinateTransformationsFromFile = coordinateTransformations.filter(({ input: { name: inputName }, output: { name: outputName } }) => inputName === "xyz" && outputName === coordinateSystem);
-    const normCoordinateTransformationsFromFile = normalizeCoordinateTransformations(coordinateTransformationsFromFile, null);
-    const transformMatrixFromFile = coordinateTransformationsToMatrix(normCoordinateTransformationsFromFile, normAxes);
-    this.modelMatrix = transformMatrixFromFile;
+    this.modelMatrix = coordinateTransformationsToMatrixForSpatialData({ axes, coordinateTransformations }, coordinateSystem);
     return this.modelMatrix;
   }
   /**
@@ -336260,7 +336279,7 @@ class SpatialDataTableSource extends AnnDataSource {
         const schemaBytes = await this.loadParquetSchemaBytes(parquetPath);
         if (schemaBytes) {
           const wasmSchema = readSchema(schemaBytes);
-          const arrowTableForSchema = tableFromIPC(wasmSchema.intoIPCStream());
+          const arrowTableForSchema = await tableFromIPC(wasmSchema.intoIPCStream());
           indexColumnName = tableToIndexColumnName(arrowTableForSchema);
         }
       } catch (e3) {
@@ -336276,14 +336295,14 @@ class SpatialDataTableSource extends AnnDataSource {
     }
     if (columns2 && !indexColumnName) {
       const wasmSchema = readSchema(parquetBytes);
-      const arrowTableForSchema = tableFromIPC(wasmSchema.intoIPCStream());
+      const arrowTableForSchema = await tableFromIPC(wasmSchema.intoIPCStream());
       indexColumnName = tableToIndexColumnName(arrowTableForSchema);
     }
     if (options.columns && indexColumnName) {
       options.columns = [...options.columns, indexColumnName];
     }
     const wasmTable = readParquet(parquetBytes, options);
-    const arrowTable = tableFromIPC(wasmTable.intoIPCStream());
+    const arrowTable = await tableFromIPC(wasmTable.intoIPCStream());
     return arrowTable;
   }
   // TABLE-SPECIFIC METHODS
@@ -377944,6 +377963,9 @@ function makeFileType(name2, dataType, dataLoaderClass, dataSourceClass, options
 }
 function makeZarrFileTypes(name2, dataType, dataLoaderClass, dataSourceClass, optionsSchema) {
   const altFileTypes = ALT_ZARR_STORE_TYPES[name2];
+  if (!altFileTypes) {
+    throw new Error(`No alternative file types found for Zarr-based fileType ${name2}`);
+  }
   return [
     new PluginFileType(name2, dataType, dataLoaderClass, dataSourceClass, optionsSchema),
     ...Object.entries(altFileTypes).map(([key2, fileType]) => {
@@ -378032,15 +378054,15 @@ const baseFileTypes = [
   ...makeZarrFileTypes(FileType$1.OBS_SEGMENTATIONS_OME_ZARR, DataType$3.OBS_SEGMENTATIONS, OmeZarrAsObsSegmentationsLoader, ZarrDataSource, obsSegmentationsOmeZarrSchema),
   makeFileType(FileType$1.OBS_SEGMENTATIONS_OME_TIFF, DataType$3.OBS_SEGMENTATIONS, OmeTiffAsObsSegmentationsLoader, OmeTiffSource, obsSegmentationsOmeTiffSchema),
   // SpatialData file types
-  makeFileType(FileType$1.IMAGE_SPATIALDATA_ZARR, DataType$3.IMAGE, SpatialDataImageLoader, ZarrDataSource, imageSpatialdataSchema),
-  makeFileType(FileType$1.LABELS_SPATIALDATA_ZARR, DataType$3.OBS_SEGMENTATIONS, SpatialDataLabelsLoader, ZarrDataSource, obsSegmentationsSpatialdataSchema),
-  makeFileType(FileType$1.SHAPES_SPATIALDATA_ZARR, DataType$3.OBS_SEGMENTATIONS, SpatialDataObsSegmentationsLoader, SpatialDataShapesSource, obsSegmentationsSpatialdataSchema),
-  makeFileType(FileType$1.OBS_SPOTS_SPATIALDATA_ZARR, DataType$3.OBS_SPOTS, SpatialDataObsSpotsLoader, SpatialDataShapesSource, obsSpotsSpatialdataSchema),
-  makeFileType(FileType$1.OBS_POINTS_SPATIALDATA_ZARR, DataType$3.OBS_POINTS, SpatialDataObsPointsLoader, SpatialDataPointsSource, obsPointsSpatialdataSchema),
-  makeFileType(FileType$1.OBS_FEATURE_MATRIX_SPATIALDATA_ZARR, DataType$3.OBS_FEATURE_MATRIX, ObsFeatureMatrixAnndataLoader, SpatialDataTableSource, obsFeatureMatrixSpatialdataSchema),
-  makeFileType(FileType$1.OBS_SETS_SPATIALDATA_ZARR, DataType$3.OBS_SETS, SpatialDataObsSetsLoader, SpatialDataTableSource, obsSetsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType$1.IMAGE_SPATIALDATA_ZARR, DataType$3.IMAGE, SpatialDataImageLoader, ZarrDataSource, imageSpatialdataSchema),
+  ...makeZarrFileTypes(FileType$1.LABELS_SPATIALDATA_ZARR, DataType$3.OBS_SEGMENTATIONS, SpatialDataLabelsLoader, ZarrDataSource, obsSegmentationsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType$1.SHAPES_SPATIALDATA_ZARR, DataType$3.OBS_SEGMENTATIONS, SpatialDataObsSegmentationsLoader, SpatialDataShapesSource, obsSegmentationsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType$1.OBS_SPOTS_SPATIALDATA_ZARR, DataType$3.OBS_SPOTS, SpatialDataObsSpotsLoader, SpatialDataShapesSource, obsSpotsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType$1.OBS_POINTS_SPATIALDATA_ZARR, DataType$3.OBS_POINTS, SpatialDataObsPointsLoader, SpatialDataPointsSource, obsPointsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType$1.OBS_FEATURE_MATRIX_SPATIALDATA_ZARR, DataType$3.OBS_FEATURE_MATRIX, ObsFeatureMatrixAnndataLoader, SpatialDataTableSource, obsFeatureMatrixSpatialdataSchema),
+  ...makeZarrFileTypes(FileType$1.OBS_SETS_SPATIALDATA_ZARR, DataType$3.OBS_SETS, SpatialDataObsSetsLoader, SpatialDataTableSource, obsSetsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType$1.FEATURE_LABELS_SPATIALDATA_ZARR, DataType$3.FEATURE_LABELS, FeatureLabelsAnndataLoader, SpatialDataTableSource, featureLabelsAnndataSchema),
   makeFileType(FileType$1.OBS_SEGMENTATIONS_GLB, DataType$3.OBS_SEGMENTATIONS, GlbDataLoader, GlbSource, meshGlbSchema),
-  makeFileType(FileType$1.FEATURE_LABELS_SPATIALDATA_ZARR, DataType$3.FEATURE_LABELS, FeatureLabelsAnndataLoader, SpatialDataTableSource, featureLabelsAnndataSchema),
   // All legacy file types
   makeFileType(FileType$1.OBS_FEATURE_MATRIX_EXPRESSION_MATRIX_ZARR, DataType$3.OBS_FEATURE_MATRIX, MatrixZarrAsObsFeatureMatrixLoader, ZarrDataSource, z.null()),
   makeFileType(FileType$1.IMAGE_RASTER_JSON, DataType$3.IMAGE, RasterJsonAsImageLoader, JsonSource, rasterJsonSchema),

package/dist/index.js

@@ -1,4 +1,4 @@
-import { bL, bJ, bH, bK, bI, bG, bM } from "./index-Dr34Nsn3.js";
+import { bL, bJ, bH, bK, bI, bG, bM } from "./index-DcZv7teI.js";
 import { useComplexCoordination, useComplexCoordinationSecondary, useCoordination, useCoordinationScopes, useCoordinationScopesBy, useGridItemSize, useMultiCoordinationScopesNonNull, useMultiCoordinationScopesSecondaryNonNull, usePageModeView } from "@vitessce/vit-s";
 export {
   bL as PluginAsyncFunction,

package/dist/{jpeg-BchP2GI5.js → jpeg-DY_DkYi3.js}

@@ -1,4 +1,4 @@
-import { aP as BaseDecoder } from "./index-Dr34Nsn3.js";
+import { aP as BaseDecoder } from "./index-DcZv7teI.js";
 const dctZigZag = new Int32Array([
   0,
   1,

package/dist/{lerc-Yewj5Mkt.js → lerc-Bz6jtDu9.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-SxljTded.js";
-import { g as getDefaultExportFromCjs, aP as BaseDecoder, aQ as LercParameters, aR as LercAddCompression } from "./index-Dr34Nsn3.js";
+import { g as getDefaultExportFromCjs, aP as BaseDecoder, aQ as LercParameters, aR as LercAddCompression } from "./index-DcZv7teI.js";
 var LercDecode = { exports: {} };
 var hasRequiredLercDecode;
 function requireLercDecode() {

package/dist/{lzw-DhNvTBt-.js → lzw-kKlj6Pam.js}

@@ -1,4 +1,4 @@
-import { aP as BaseDecoder } from "./index-Dr34Nsn3.js";
+import { aP as BaseDecoder } from "./index-DcZv7teI.js";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;
 const EOI_CODE = 257;

package/dist/{packbits-C6We0BcA.js → packbits-DzhxlAeC.js}

@@ -1,4 +1,4 @@
-import { aP as BaseDecoder } from "./index-Dr34Nsn3.js";
+import { aP as BaseDecoder } from "./index-DcZv7teI.js";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     const dataView = new DataView(buffer);

package/dist/{raw-BloA4686.js → raw-DqALOEt-.js}

@@ -1,4 +1,4 @@
-import { aP as BaseDecoder } from "./index-Dr34Nsn3.js";
+import { aP as BaseDecoder } from "./index-DcZv7teI.js";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return buffer;

package/dist/{troika-three-text.esm-C4mcmvqE.js → troika-three-text.esm-DLsbwboO.js}

@@ -1,4 +1,4 @@
-import { bA as MeshDistanceMaterial, bB as MeshDepthMaterial, bC as RGBADepthPacking, aB as UniformsUtils, bD as ShaderChunk, aw as InstancedBufferGeometry, av as Sphere, au as Box3, aH as BackSide, a9 as DoubleSide, ad as Mesh, as as FrontSide, aa as MeshBasicMaterial, i as Color, c as Vector3, k as Matrix4, d as Vector2, aJ as Matrix3, aD as Vector4, T as Texture, a1 as LinearFilter, bE as PlaneGeometry, f as BufferGeometry, ax as Float32BufferAttribute, bF as InstancedBufferAttribute } from "./index-Dr34Nsn3.js";
+import { bA as MeshDistanceMaterial, bB as MeshDepthMaterial, bC as RGBADepthPacking, aB as UniformsUtils, bD as ShaderChunk, aw as InstancedBufferGeometry, av as Sphere, au as Box3, aH as BackSide, a9 as DoubleSide, ad as Mesh, as as FrontSide, aa as MeshBasicMaterial, i as Color, c as Vector3, k as Matrix4, d as Vector2, aJ as Matrix3, aD as Vector4, T as Texture, a1 as LinearFilter, bE as PlaneGeometry, f as BufferGeometry, ax as Float32BufferAttribute, bF as InstancedBufferAttribute } from "./index-DcZv7teI.js";
 function workerBootstrap() {
   var modules = /* @__PURE__ */ Object.create(null);
   function registerModule(ref, callback) {

package/dist/{webimage-DyPRDNMg.js → webimage-B46sb8Pc.js}

@@ -1,4 +1,4 @@
-import { aP as BaseDecoder } from "./index-Dr34Nsn3.js";
+import { aP as BaseDecoder } from "./index-DcZv7teI.js";
 class WebImageDecoder extends BaseDecoder {
   constructor() {
     super();

package/dist-tsc/base-plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-plugins.d.ts","sourceRoot":"","sources":["../src/base-plugins.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"base-plugins.d.ts","sourceRoot":"","sources":["../src/base-plugins.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,CAAC,EAmDF,MAAM,mBAAmB,CAAC;AA8K3B,eAAO,MAAM,aAAa,kBA8BzB,CAAC;AAEF,eAAO,MAAM,aAAa,wDAyEzB,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAiFG,CAAC;gCAGhC,CAAC;;;yBAEF,CAAF;gCAAsD,CAAC;;;;;;;;;;;;;;;;iBAS3C,CAAC;;;;iBAEkG,CAAC;;;;;;;YAMV,CAAC;;;YAEnF,CAAC;;;;;;;YAOjB,CAAH;;;YAGU,CAAC;;;;;;;YAM2F,CAAC;;;YAE9C,CAAC;;;;;;;;;;;;;;YAUvD,CAAD;;;YAEM,CAAC;;;;;;;;YAOwH,CAAC;;;;YAI5H,CAAC;;;;;;;;;;;;;;;;;;;;;;;;yBAmBJ,CAAC;gCAEK,CAAC;;;;;;;;iBAUN,CAAC;;;;YAGwB,CAAC;;;;YAK1B,CAAC;;;;YAIO,CAAC;;;;;;;YAEQ,CAAC;;;;YACQ,CAAC;;;;;;;;;;;;;;;;;;;;yBAKvB,CAAC;gCAAsD,CAAC;;;;;;;;iBAGnD,CAAC;;;;YACb,CAAD;;;;YACC,CAAC;;;;YACI,CAAC;;;;;;;YAC2E,CAAC;;;;YACY,CAAC;;;;;;;;;;;wBAkE4uC,CAAC;;;wBAA6E,CAAC;;;;;;;;iBAAwR,CAAC;wBAA8C,CAAC;;;iBAAsE,CAAC;wBAA8C,CAAC;;;;;;;;iBAAiR,CAAC;wBAA8C,CAAC;;;iBAAsE,CAAC;wBAA8C,CAAC;;;;;;;;;;yBAAkZ,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;yBAA8E,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;;;;;;iBAAgR,CAAC;wBAA8C,CAAC;;;iBAAsE,CAAC;wBAA8C,CAAC;;;;;;;;;;;;qBAAygB,CAAC;;;;qBAA2J,CAAC;;;;;;qBAAsN,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;;qBAA0K,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;;;wBAAwL,CAAC;;;;iBAAyG,CAAC;wBAA8C,CAAC;;;;iBAAkG,CAAC;wBAA8C,CAAC;;;;yBAAiH,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;;iBAAiG,CAAC;wBAA8C,CAAC;;;;;;qBAAoM,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;;;wBAAqJ,CAAC;;;;iBAAyG,CAAC;wBAA8C,CAAC;;;;iBAAkG,CAAC;wBAA8C,CAAC;;;;yBAAiH,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;;iBAAiG,CAAC;wBAA8C,CAAC;;;;;;qBAAoM,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA7hB72N,CAAC;;;;;qBAGkB,CAAC;qBAC5B,CAAC;;;;;;;;;qBAGyC,CAAC;6BACvC,CAAC;;sBAEjB,CAAC;;;;;qBAQvB,CAAC;qBACK,CAAC;;;;;;;;;qBAYR,CAAA;6BAEC,CAAC;;;;;;;;;;;;;kBAwBQ,CAAC;mBACQ,CAAC;gBAEZ,CAAC;gBACa,CAAC;uBAEV,CAAC;iBACM,CAAC;oBAER,CAAC;oBAEd,CAAD;qBACgB,CAAC;;kBAEX,CAAC;mBACS,CAAC;gBAIhB,CAAA;gBACoB,CAAC;uBAErB,CAAA;iBAGI,CAAC;oBAEgB,CAAC;oBAEV,CAAC;qBAEV,CAAC;;;;;;gBAKS,CAAC;sBACX,CAAC;;;;;qBAWH,CAAC;qBAGD,CAAC;;;;;;;;;qBAUW,CAAC;6BAEM,CAAC;;mBAGN,CAAC;kBACJ,CAAC;mBACI,CAAC;gBAGZ,CAAC;gBACQ,CAAC;uBAGhB,CAAA;iBACgB,CAAC;oBAEE,CAAC;oBAEX,CAAC;qBACZ,CAAA;;;;;;gBACiF,CAAC;sBAG5E,CAAC;;;;;qBAC2B,CAAA;qBAA4C,CAAC;;;;;;;;;qBAIJ,CAAC;6BAAoD,CAAC;;mBACxH,CAAC;kBAAsB,CAAC;mBAE7B,CAAH;gBAAoD,CAAA;gBAEnD,CAAF;uBACkC,CAAC;iBAAuC,CAAC;oBAC3D,CAAC;oBAA0C,CAAC;qBACpB,CAAC;;;;;;;;;gBAG+E,CAAC;sBAKhH,CAAC;;;;;qBAGgD,CAAC;qBAC1B,CAAC;;;;;;;;;qBAIA,CAAC;6BACD,CAAC;;mBACE,CAAC;kBAAsB,CAAC;mBAC7B,CAAC;gBAC5B,CAAC;gBAAsC,CAAC;uBACN,CAAC;iBAAuC,CAAC;oBACpD,CAAC;oBAC1B,CAAC;qBAA2C,CAAC;;;;;;;;;;;gBAK9C,CAAA;sBAA0B,CAAC;;;;;qBAGN,CAAC;qBACtB,CAAD;;;;;;;;;qBAGqD,CAAC;6BAC9B,CAAC;;mBAAgE,CAAC;kBACtE,CAAC;mBAAyC,CAAC;gBAGlD,CAAC;gBACO,CAAC;uBACqB,CAAC;iBAAuC,CAAC;oBAC/D,CAAC;oBAA0C,CAAC;qBAA2C,CAAC;;;;;;;;;;;;;;OA0F7G,CAAC;AAIF,eAAO,MAAM,qBAAqB;;;;;;;;aArWtB,CAAC;cAGX,CAAD;eAES,CAAC;;;aAIH,CAAC;cAEP,CAAF;eACgB,CAAC;;;;;;;;;;;;;;;;;;;aAgCd,CAAC;cACQ,CAAC;eAEH,CAAC;;;;;;;;;;;;;;;;;;;aAmBF,CAAA;cAAsC,CAAC;eACf,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAnErB,CAAC;cAGX,CAAD;eAES,CAAC;;;aAIH,CAAC;cAEP,CAAF;eACgB,CAAC;;;;;;;;;;;;;;;;;;;aAgCd,CAAC;cACQ,CAAC;eAEH,CAAC;;;;;;;;;;;;;;;;;;;aAmBF,CAAA;cAAsC,CAAC;eACf,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kzBAmhBhC,CAAC;AAEF,eAAO,MAAM,kBAAkB,uBAK9B,CAAC"}

package/dist-tsc/base-plugins.js

@@ -52,9 +52,13 @@ function makeViewType(name, component) {
 function makeFileType(name, dataType, dataLoaderClass, dataSourceClass, optionsSchema) {
     return new PluginFileType(name, dataType, dataLoaderClass, dataSourceClass, optionsSchema);
 }
-// For when we have multiple file types with the same data type and options schema.
+// For when we have multiple file types with the same data type and options schema,
+// e.g., for Zip- and H5AD- variants of Zarr file types.
 function makeZarrFileTypes(name, dataType, dataLoaderClass, dataSourceClass, optionsSchema) {
     const altFileTypes = ALT_ZARR_STORE_TYPES[name];
+    if (!altFileTypes) {
+        throw new Error(`No alternative file types found for Zarr-based fileType ${name}`);
+    }
     return [
         new PluginFileType(name, dataType, dataLoaderClass, dataSourceClass, optionsSchema),
         ...Object.entries(altFileTypes).map(([key, fileType]) => {
@@ -143,15 +147,15 @@ export const baseFileTypes = [
     ...makeZarrFileTypes(FileType.OBS_SEGMENTATIONS_OME_ZARR, DataType.OBS_SEGMENTATIONS, OmeZarrAsObsSegmentationsLoader, ZarrDataSource, obsSegmentationsOmeZarrSchema),
     makeFileType(FileType.OBS_SEGMENTATIONS_OME_TIFF, DataType.OBS_SEGMENTATIONS, OmeTiffAsObsSegmentationsLoader, OmeTiffSource, obsSegmentationsOmeTiffSchema),
     // SpatialData file types
-    makeFileType(FileType.IMAGE_SPATIALDATA_ZARR, DataType.IMAGE, SpatialDataImageLoader, ZarrDataSource, imageSpatialdataSchema),
-    makeFileType(FileType.LABELS_SPATIALDATA_ZARR, DataType.OBS_SEGMENTATIONS, SpatialDataLabelsLoader, ZarrDataSource, obsSegmentationsSpatialdataSchema),
-    makeFileType(FileType.SHAPES_SPATIALDATA_ZARR, DataType.OBS_SEGMENTATIONS, SpatialDataObsSegmentationsLoader, SpatialDataShapesSource, obsSegmentationsSpatialdataSchema),
-    makeFileType(FileType.OBS_SPOTS_SPATIALDATA_ZARR, DataType.OBS_SPOTS, SpatialDataObsSpotsLoader, SpatialDataShapesSource, obsSpotsSpatialdataSchema),
-    makeFileType(FileType.OBS_POINTS_SPATIALDATA_ZARR, DataType.OBS_POINTS, SpatialDataObsPointsLoader, SpatialDataPointsSource, obsPointsSpatialdataSchema),
-    makeFileType(FileType.OBS_FEATURE_MATRIX_SPATIALDATA_ZARR, DataType.OBS_FEATURE_MATRIX, ObsFeatureMatrixAnndataLoader, SpatialDataTableSource, obsFeatureMatrixSpatialdataSchema),
-    makeFileType(FileType.OBS_SETS_SPATIALDATA_ZARR, DataType.OBS_SETS, SpatialDataObsSetsLoader, SpatialDataTableSource, obsSetsSpatialdataSchema),
+    ...makeZarrFileTypes(FileType.IMAGE_SPATIALDATA_ZARR, DataType.IMAGE, SpatialDataImageLoader, ZarrDataSource, imageSpatialdataSchema),
+    ...makeZarrFileTypes(FileType.LABELS_SPATIALDATA_ZARR, DataType.OBS_SEGMENTATIONS, SpatialDataLabelsLoader, ZarrDataSource, obsSegmentationsSpatialdataSchema),
+    ...makeZarrFileTypes(FileType.SHAPES_SPATIALDATA_ZARR, DataType.OBS_SEGMENTATIONS, SpatialDataObsSegmentationsLoader, SpatialDataShapesSource, obsSegmentationsSpatialdataSchema),
+    ...makeZarrFileTypes(FileType.OBS_SPOTS_SPATIALDATA_ZARR, DataType.OBS_SPOTS, SpatialDataObsSpotsLoader, SpatialDataShapesSource, obsSpotsSpatialdataSchema),
+    ...makeZarrFileTypes(FileType.OBS_POINTS_SPATIALDATA_ZARR, DataType.OBS_POINTS, SpatialDataObsPointsLoader, SpatialDataPointsSource, obsPointsSpatialdataSchema),
+    ...makeZarrFileTypes(FileType.OBS_FEATURE_MATRIX_SPATIALDATA_ZARR, DataType.OBS_FEATURE_MATRIX, ObsFeatureMatrixAnndataLoader, SpatialDataTableSource, obsFeatureMatrixSpatialdataSchema),
+    ...makeZarrFileTypes(FileType.OBS_SETS_SPATIALDATA_ZARR, DataType.OBS_SETS, SpatialDataObsSetsLoader, SpatialDataTableSource, obsSetsSpatialdataSchema),
+    ...makeZarrFileTypes(FileType.FEATURE_LABELS_SPATIALDATA_ZARR, DataType.FEATURE_LABELS, FeatureLabelsAnndataLoader, SpatialDataTableSource, featureLabelsAnndataSchema),
     makeFileType(FileType.OBS_SEGMENTATIONS_GLB, DataType.OBS_SEGMENTATIONS, GlbLoader, GlbSource, meshGlbSchema),
-    makeFileType(FileType.FEATURE_LABELS_SPATIALDATA_ZARR, DataType.FEATURE_LABELS, FeatureLabelsAnndataLoader, SpatialDataTableSource, featureLabelsAnndataSchema),
     // All legacy file types
     makeFileType(FileType.OBS_FEATURE_MATRIX_EXPRESSION_MATRIX_ZARR, DataType.OBS_FEATURE_MATRIX, MatrixZarrAsObsFeatureMatrixLoader, ZarrDataSource, z.null()),
     makeFileType(FileType.IMAGE_RASTER_JSON, DataType.IMAGE, RasterJsonAsImageLoader, JsonSource, rasterJsonSchema),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/all",
-  "version": "3.6.11",
+  "version": "3.6.13",
   "author": "HIDIVE Lab at HMS",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -17,37 +17,37 @@
   ],
   "dependencies": {
     "zod": "^3.21.4",
-    "@vitessce/styles": "3.6.11",
-    "@vitessce/constants-internal": "3.6.11",
-    "@vitessce/abstract": "3.6.11",
-    "@vitessce/error": "3.6.11",
-    "@vitessce/csv": "3.6.11",
-    "@vitessce/description": "3.6.11",
-    "@vitessce/feature-list": "3.6.11",
-    "@vitessce/genomic-profiles": "3.6.11",
-    "@vitessce/heatmap": "3.6.11",
-    "@vitessce/glb": "3.6.11",
-    "@vitessce/json": "3.6.11",
-    "@vitessce/layer-controller": "3.6.11",
-    "@vitessce/layer-controller-beta": "3.6.11",
-    "@vitessce/link-controller": "3.6.11",
-    "@vitessce/obs-sets-manager": "3.6.11",
-    "@vitessce/ome-tiff": "3.6.11",
-    "@vitessce/plugins": "3.6.11",
-    "@vitessce/scatterplot-embedding": "3.6.11",
-    "@vitessce/scatterplot-gating": "3.6.11",
-    "@vitessce/schemas": "3.6.11",
-    "@vitessce/spatial": "3.6.11",
-    "@vitessce/spatial-beta": "3.6.11",
-    "@vitessce/statistical-plots": "3.6.11",
-    "@vitessce/status": "3.6.11",
-    "@vitessce/vit-s": "3.6.11",
-    "@vitessce/zarr": "3.6.11",
-    "@vitessce/globals": "3.6.11",
-    "@vitessce/spatial-zarr": "3.6.11",
-    "@vitessce/spatial-three": "3.6.11",
-    "@vitessce/biomarker-select": "3.6.11",
-    "@vitessce/neuroglancer": "3.6.11"
+    "@vitessce/styles": "3.6.13",
+    "@vitessce/constants-internal": "3.6.13",
+    "@vitessce/abstract": "3.6.13",
+    "@vitessce/error": "3.6.13",
+    "@vitessce/csv": "3.6.13",
+    "@vitessce/description": "3.6.13",
+    "@vitessce/feature-list": "3.6.13",
+    "@vitessce/genomic-profiles": "3.6.13",
+    "@vitessce/heatmap": "3.6.13",
+    "@vitessce/glb": "3.6.13",
+    "@vitessce/json": "3.6.13",
+    "@vitessce/layer-controller": "3.6.13",
+    "@vitessce/layer-controller-beta": "3.6.13",
+    "@vitessce/link-controller": "3.6.13",
+    "@vitessce/obs-sets-manager": "3.6.13",
+    "@vitessce/ome-tiff": "3.6.13",
+    "@vitessce/plugins": "3.6.13",
+    "@vitessce/scatterplot-embedding": "3.6.13",
+    "@vitessce/scatterplot-gating": "3.6.13",
+    "@vitessce/schemas": "3.6.13",
+    "@vitessce/spatial": "3.6.13",
+    "@vitessce/spatial-beta": "3.6.13",
+    "@vitessce/statistical-plots": "3.6.13",
+    "@vitessce/status": "3.6.13",
+    "@vitessce/vit-s": "3.6.13",
+    "@vitessce/zarr": "3.6.13",
+    "@vitessce/globals": "3.6.13",
+    "@vitessce/spatial-zarr": "3.6.13",
+    "@vitessce/spatial-three": "3.6.13",
+    "@vitessce/biomarker-select": "3.6.13",
+    "@vitessce/neuroglancer": "3.6.13"
   },
   "devDependencies": {
     "@types/react": "^18.0.28",

package/src/base-plugins.ts

@@ -228,9 +228,13 @@ function makeViewType(name: string, component: any) {
 function makeFileType<T1 extends DataLoader, T2 extends DataSource>(name: string, dataType: string, dataLoaderClass: any, dataSourceClass: any, optionsSchema: z.ZodTypeAny) {
   return new PluginFileType(name, dataType, dataLoaderClass as T1, dataSourceClass as T2, optionsSchema);
 }
-// For when we have multiple file types with the same data type and options schema.
+// For when we have multiple file types with the same data type and options schema,
+// e.g., for Zip- and H5AD- variants of Zarr file types.
 function makeZarrFileTypes<T1 extends DataLoader, T2 extends DataSource>(name: string, dataType: string, dataLoaderClass: any, dataSourceClass: any, optionsSchema: z.ZodObject<any>) {
   const altFileTypes = ALT_ZARR_STORE_TYPES[name];
+  if (!altFileTypes) {
+    throw new Error(`No alternative file types found for Zarr-based fileType ${name}`);
+  }
   return [
     new PluginFileType(name, dataType, dataLoaderClass as T1, dataSourceClass as T2, optionsSchema),
     ...Object.entries(altFileTypes).map(([key, fileType]) => {
@@ -322,16 +326,16 @@ export const baseFileTypes = [
   ...makeZarrFileTypes(FileType.OBS_SEGMENTATIONS_OME_ZARR, DataType.OBS_SEGMENTATIONS, OmeZarrAsObsSegmentationsLoader, ZarrDataSource, obsSegmentationsOmeZarrSchema),
   makeFileType(FileType.OBS_SEGMENTATIONS_OME_TIFF, DataType.OBS_SEGMENTATIONS, OmeTiffAsObsSegmentationsLoader, OmeTiffSource, obsSegmentationsOmeTiffSchema),
   // SpatialData file types
-  makeFileType(FileType.IMAGE_SPATIALDATA_ZARR, DataType.IMAGE, SpatialDataImageLoader, ZarrDataSource, imageSpatialdataSchema),
-  makeFileType(FileType.LABELS_SPATIALDATA_ZARR, DataType.OBS_SEGMENTATIONS, SpatialDataLabelsLoader, ZarrDataSource, obsSegmentationsSpatialdataSchema),
-  makeFileType(FileType.SHAPES_SPATIALDATA_ZARR, DataType.OBS_SEGMENTATIONS, SpatialDataObsSegmentationsLoader, SpatialDataShapesSource, obsSegmentationsSpatialdataSchema),
-  makeFileType(FileType.OBS_SPOTS_SPATIALDATA_ZARR, DataType.OBS_SPOTS, SpatialDataObsSpotsLoader, SpatialDataShapesSource, obsSpotsSpatialdataSchema),
-  makeFileType(FileType.OBS_POINTS_SPATIALDATA_ZARR, DataType.OBS_POINTS, SpatialDataObsPointsLoader, SpatialDataPointsSource, obsPointsSpatialdataSchema),
-  makeFileType(FileType.OBS_FEATURE_MATRIX_SPATIALDATA_ZARR, DataType.OBS_FEATURE_MATRIX, ObsFeatureMatrixAnndataLoader, SpatialDataTableSource, obsFeatureMatrixSpatialdataSchema),
-  makeFileType(FileType.OBS_SETS_SPATIALDATA_ZARR, DataType.OBS_SETS, SpatialDataObsSetsLoader, SpatialDataTableSource, obsSetsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType.IMAGE_SPATIALDATA_ZARR, DataType.IMAGE, SpatialDataImageLoader, ZarrDataSource, imageSpatialdataSchema),
+  ...makeZarrFileTypes(FileType.LABELS_SPATIALDATA_ZARR, DataType.OBS_SEGMENTATIONS, SpatialDataLabelsLoader, ZarrDataSource, obsSegmentationsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType.SHAPES_SPATIALDATA_ZARR, DataType.OBS_SEGMENTATIONS, SpatialDataObsSegmentationsLoader, SpatialDataShapesSource, obsSegmentationsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType.OBS_SPOTS_SPATIALDATA_ZARR, DataType.OBS_SPOTS, SpatialDataObsSpotsLoader, SpatialDataShapesSource, obsSpotsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType.OBS_POINTS_SPATIALDATA_ZARR, DataType.OBS_POINTS, SpatialDataObsPointsLoader, SpatialDataPointsSource, obsPointsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType.OBS_FEATURE_MATRIX_SPATIALDATA_ZARR, DataType.OBS_FEATURE_MATRIX, ObsFeatureMatrixAnndataLoader, SpatialDataTableSource, obsFeatureMatrixSpatialdataSchema),
+  ...makeZarrFileTypes(FileType.OBS_SETS_SPATIALDATA_ZARR, DataType.OBS_SETS, SpatialDataObsSetsLoader, SpatialDataTableSource, obsSetsSpatialdataSchema),
+  ...makeZarrFileTypes(FileType.FEATURE_LABELS_SPATIALDATA_ZARR, DataType.FEATURE_LABELS, FeatureLabelsAnndataLoader, SpatialDataTableSource, featureLabelsAnndataSchema),
 
   makeFileType(FileType.OBS_SEGMENTATIONS_GLB, DataType.OBS_SEGMENTATIONS, GlbLoader, GlbSource, meshGlbSchema),
-  makeFileType(FileType.FEATURE_LABELS_SPATIALDATA_ZARR, DataType.FEATURE_LABELS, FeatureLabelsAnndataLoader, SpatialDataTableSource, featureLabelsAnndataSchema),
   // All legacy file types
   makeFileType(FileType.OBS_FEATURE_MATRIX_EXPRESSION_MATRIX_ZARR, DataType.OBS_FEATURE_MATRIX, MatrixZarrAsObsFeatureMatrixLoader, ZarrDataSource, z.null()),
   makeFileType(FileType.IMAGE_RASTER_JSON, DataType.IMAGE, RasterJsonAsImageLoader, JsonSource, rasterJsonSchema),