@vitessce/spatial-utils 3.4.8 → 3.4.10

package/dist/{deflate-f1fb5f5f.js → deflate-32efdab2.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
-import { B as BaseDecoder } from "./index-99145749.js";
+import { B as BaseDecoder } from "./index-a7bb8a96.js";
 import "react";
 class DeflateDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{index-99145749.js → index-a7bb8a96.js}

@@ -22,7 +22,7 @@ var __privateSet = (obj, member, value, setter2) => {
   setter2 ? setter2.call(obj, value) : member.set(obj, value);
   return value;
 };
-var _bytes, _encoder, _data, _encode_buffer, _strides, _TypedArray, _BYTES_PER_ELEMENT, _shape, _endian, _shape2, _strides2, _encoder_config, _decoder_config, _metadata, _metadata2, _a2, _b;
+var _bytes, _encoder, _data, _strides, _TypedArray, _BYTES_PER_ELEMENT, _shape, _endian, _encoder_config, _decoder_config, _shape2, _strides2, _metadata, _metadata2, _a2, _b;
 import "react";
 function _mergeNamespaces(n3, m) {
   for (var i2 = 0; i2 < m.length; i2++) {
@@ -119229,16 +119229,16 @@ function addDecoder(cases, importFn) {
   }
   cases.forEach((c) => registry$2.set(c, importFn));
 }
-addDecoder([void 0, 1], () => import("./raw-072bb393.js").then((m) => m.default));
-addDecoder(5, () => import("./lzw-3ea2d511.js").then((m) => m.default));
+addDecoder([void 0, 1], () => import("./raw-9ca04826.js").then((m) => m.default));
+addDecoder(5, () => import("./lzw-0caa4868.js").then((m) => m.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-43f7eb3d.js").then((m) => m.default));
-addDecoder([8, 32946], () => import("./deflate-f1fb5f5f.js").then((m) => m.default));
-addDecoder(32773, () => import("./packbits-bb194562.js").then((m) => m.default));
-addDecoder(34887, () => import("./lerc-f6703f92.js").then((m) => m.default));
-addDecoder(50001, () => import("./webimage-50d4efbc.js").then((m) => m.default));
+addDecoder(7, () => import("./jpeg-ddaf8c90.js").then((m) => m.default));
+addDecoder([8, 32946], () => import("./deflate-32efdab2.js").then((m) => m.default));
+addDecoder(32773, () => import("./packbits-a5fbf85a.js").then((m) => m.default));
+addDecoder(34887, () => import("./lerc-436605d8.js").then((m) => m.default));
+addDecoder(50001, () => import("./webimage-c0a22c4e.js").then((m) => m.default));
 function decodeRowAcc(row, stride) {
   let length2 = row.length - stride;
   let offset = 0;
@@ -133983,7 +133983,7 @@ function normalizeCoordinateTransformations(coordinateTransformations, datasets)
   var _a3;
   let result = [];
   if (Array.isArray(coordinateTransformations)) {
-    result = coordinateTransformations.map((transform2) => {
+    result = coordinateTransformations.flatMap((transform2) => {
       if (transform2.input && transform2.output) {
         const { type: type2 } = transform2;
         if (type2 === "translation") {
@@ -134001,6 +134001,9 @@ function normalizeCoordinateTransformations(coordinateTransformations, datasets)
         if (type2 === "identity") {
           return { type: type2 };
         }
+        if (type2 === "sequence") {
+          return normalizeCoordinateTransformations(transform2.transformations, datasets);
+        }
         console.warn(`Coordinate transformation type "${type2}" is not supported.`);
       }
       return transform2;
@@ -134135,7 +134138,6 @@ const _UnicodeStringArray = class {
   constructor(chars, x2, byteOffset, length2) {
     __privateAdd(this, _data, void 0);
     __publicField(this, "chars");
-    __privateAdd(this, _encode_buffer, void 0);
     this.chars = chars;
     if (typeof x2 === "number") {
       __privateSet(this, _data, new Int32Array(x2 * chars));
@@ -134153,7 +134155,6 @@ const _UnicodeStringArray = class {
         }
       }()));
     }
-    __privateSet(this, _encode_buffer, new Int32Array(chars));
   }
   get BYTES_PER_ELEMENT() {
     return __privateGet(this, _data).BYTES_PER_ELEMENT * this.chars;
@@ -134203,7 +134204,6 @@ const _UnicodeStringArray = class {
 };
 let UnicodeStringArray = _UnicodeStringArray;
 _data = new WeakMap();
-_encode_buffer = new WeakMap();
 function json_decode_object(bytes) {
   const str = new TextDecoder().decode(bytes);
   return JSON.parse(str);
@@ -134272,10 +134272,12 @@ function col_major_stride(shape) {
 }
 function create_chunk_key_encoder({ name: name2, configuration }) {
   if (name2 === "default") {
-    return (chunk_coords) => ["c", ...chunk_coords].join(configuration.separator);
+    const separator = (configuration == null ? void 0 : configuration.separator) ?? "/";
+    return (chunk_coords) => ["c", ...chunk_coords].join(separator);
   }
   if (name2 === "v2") {
-    return (chunk_coords) => chunk_coords.join(configuration.separator) || "0";
+    const separator = (configuration == null ? void 0 : configuration.separator) ?? ".";
+    return (chunk_coords) => chunk_coords.join(separator) || "0";
   }
   throw new Error(`Unknown chunk key encoding: ${name2}`);
 }
@@ -134295,17 +134297,17 @@ function coerce_dtype(dtype) {
   }
   let [, endian, rest] = match;
   let data_type = {
-    "b1": "bool",
-    "i1": "int8",
-    "u1": "uint8",
-    "i2": "int16",
-    "u2": "uint16",
-    "i4": "int32",
-    "u4": "uint32",
-    "i8": "int64",
-    "u8": "uint64",
-    "f4": "float32",
-    "f8": "float64"
+    b1: "bool",
+    i1: "int8",
+    u1: "uint8",
+    i2: "int16",
+    u2: "uint16",
+    i4: "int32",
+    u4: "uint32",
+    i8: "int64",
+    u8: "uint64",
+    f4: "float32",
+    f8: "float64"
   }[rest] ?? (rest.startsWith("S") || rest.startsWith("U") ? `v2:${rest}` : void 0);
   if (!data_type) {
     throw new Error(`Unsupported or unknown dtype: ${dtype}`);
@@ -134382,93 +134384,11 @@ function is_sharding_codec(codec) {
   return (codec == null ? void 0 : codec.name) === "sharding_indexed";
 }
 function ensure_correct_scalar(metadata) {
-  if ((metadata.data_type === "uint64" || metadata.data_type === "int64") && metadata.fill_value != void 0) {
+  if ((metadata.data_type === "uint64" || metadata.data_type === "int64") && metadata.fill_value != null) {
     return BigInt(metadata.fill_value);
   }
   return metadata.fill_value;
 }
-function proxy(arr) {
-  if (arr instanceof BoolArray || arr instanceof ByteStringArray || arr instanceof UnicodeStringArray) {
-    return new Proxy(arr, {
-      get(target, prop) {
-        return target.get(Number(prop));
-      },
-      set(target, prop, value) {
-        target.set(Number(prop), value);
-        return true;
-      }
-    });
-  }
-  return arr;
-}
-function empty_like(chunk, order) {
-  let data;
-  if (chunk.data instanceof ByteStringArray || chunk.data instanceof UnicodeStringArray) {
-    data = new chunk.constructor(
-      // @ts-expect-error
-      chunk.data.length,
-      chunk.data.chars
-    );
-  } else {
-    data = new chunk.constructor(chunk.data.length);
-  }
-  return {
-    data,
-    shape: chunk.shape,
-    stride: get_strides(chunk.shape, order)
-  };
-}
-function convert_array_order(src, target) {
-  let out = empty_like(src, target);
-  let n_dims = src.shape.length;
-  let size2 = src.data.length;
-  let index2 = Array(n_dims).fill(0);
-  let src_data = proxy(src.data);
-  let out_data = proxy(out.data);
-  for (let src_idx = 0; src_idx < size2; src_idx++) {
-    let out_idx = 0;
-    for (let dim = 0; dim < n_dims; dim++) {
-      out_idx += index2[dim] * out.stride[dim];
-    }
-    out_data[out_idx] = src_data[src_idx];
-    index2[0] += 1;
-    for (let dim = 0; dim < n_dims; dim++) {
-      if (index2[dim] === src.shape[dim]) {
-        if (dim + 1 === n_dims) {
-          break;
-        }
-        index2[dim] = 0;
-        index2[dim + 1] += 1;
-      }
-    }
-  }
-  return out;
-}
-function get_order(arr) {
-  if (!arr.stride)
-    return "C";
-  let row_major_strides = get_strides(arr.shape, "C");
-  return arr.stride.every((s2, i2) => s2 === row_major_strides[i2]) ? "C" : "F";
-}
-class TransposeCodec {
-  constructor(configuration) {
-    __publicField(this, "configuration");
-    __publicField(this, "kind", "array_to_array");
-    this.configuration = configuration;
-  }
-  static fromConfig(configuration) {
-    return new TransposeCodec(configuration);
-  }
-  encode(arr) {
-    if (get_order(arr) === this.configuration.order) {
-      return arr;
-    }
-    return convert_array_order(arr, this.configuration.order);
-  }
-  decode(arr) {
-    return arr;
-  }
-}
 const LITTLE_ENDIAN_OS = system_is_little_endian();
 function system_is_little_endian() {
   const a2 = new Uint32Array([305419896]);
@@ -134489,7 +134409,7 @@ const _BytesCodec = class {
     __privateAdd(this, _BYTES_PER_ELEMENT, void 0);
     __privateAdd(this, _shape, void 0);
     __privateAdd(this, _endian, void 0);
-    __privateSet(this, _endian, configuration.endian);
+    __privateSet(this, _endian, configuration == null ? void 0 : configuration.endian);
     __privateSet(this, _TypedArray, get_ctr(meta2.data_type));
     __privateSet(this, _shape, meta2.shape);
     __privateSet(this, _strides, get_strides(meta2.shape, get_array_order(meta2.codecs)));
@@ -134537,57 +134457,26 @@ class Crc32cCodec {
     return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength - 4);
   }
 }
-const _VLenUTF8 = class {
-  constructor(shape) {
-    __publicField(this, "kind", "array_to_bytes");
-    __privateAdd(this, _shape2, void 0);
-    __privateAdd(this, _strides2, void 0);
-    __privateSet(this, _shape2, shape);
-    __privateSet(this, _strides2, get_strides(shape, "C"));
-  }
-  static fromConfig(_, meta2) {
-    return new _VLenUTF8(meta2.shape);
-  }
-  encode(_chunk) {
-    throw new Error("Method not implemented.");
-  }
-  decode(bytes) {
-    let decoder = new TextDecoder();
-    let view = new DataView(bytes.buffer);
-    let data = Array(view.getUint32(0, true));
-    let pos = 4;
-    for (let i2 = 0; i2 < data.length; i2++) {
-      let item_length = view.getUint32(pos, true);
-      pos += 4;
-      data[i2] = decoder.decode(bytes.buffer.slice(pos, pos + item_length));
-      pos += item_length;
-    }
-    return { data, shape: __privateGet(this, _shape2), stride: __privateGet(this, _strides2) };
-  }
-};
-let VLenUTF8 = _VLenUTF8;
-_shape2 = new WeakMap();
-_strides2 = new WeakMap();
 function throw_on_nan_replacer(_key, value) {
-  if (value !== value) {
+  if (Number.isNaN(value)) {
     throw new Error("JsonCodec allow_nan is false but NaN was encountered during encoding.");
   }
-  if (value === Infinity) {
+  if (value === Number.POSITIVE_INFINITY) {
     throw new Error("JsonCodec allow_nan is false but Infinity was encountered during encoding.");
   }
-  if (value === -Infinity) {
+  if (value === Number.NEGATIVE_INFINITY) {
     throw new Error("JsonCodec allow_nan is false but -Infinity was encountered during encoding.");
   }
   return value;
 }
 function sort_keys_replacer(_key, value) {
-  return value instanceof Object && !(value instanceof Array) ? Object.keys(value).sort().reduce((sorted, key) => {
+  return value instanceof Object && !Array.isArray(value) ? Object.keys(value).sort().reduce((sorted, key) => {
     sorted[key] = value[key];
     return sorted;
   }, {}) : value;
 }
 const _JsonCodec = class {
-  constructor(configuration) {
+  constructor(configuration = {}) {
     __publicField(this, "configuration");
     __publicField(this, "kind", "array_to_bytes");
     __privateAdd(this, _encoder_config, void 0);
@@ -134637,20 +134526,20 @@ const _JsonCodec = class {
     items.push(buf.shape);
     let replacer = void 0;
     if (replacer_functions.length) {
-      replacer = function(key, value) {
+      replacer = (key, value) => {
         let new_value = value;
-        replacer_functions.forEach((sub_replacer) => {
+        for (let sub_replacer of replacer_functions) {
           new_value = sub_replacer(key, new_value);
-        });
+        }
         return new_value;
       };
     }
     let json_str = JSON.stringify(items, replacer, indent);
     if (ensure_ascii) {
-      json_str = json_str.replace(/[\u007F-\uFFFF]/g, function(chr) {
-        const full_str = "0000" + chr.charCodeAt(0).toString(16);
+      json_str = json_str.replace(/[\u007F-\uFFFF]/g, (chr) => {
+        const full_str = `0000${chr.charCodeAt(0).toString(16)}`;
         const sub_str = full_str.substring(full_str.length - 4);
-        return "\\u" + sub_str;
+        return `\\u${sub_str}`;
       });
     }
     return new TextEncoder().encode(json_str);
@@ -134665,16 +134554,130 @@ const _JsonCodec = class {
     items.pop();
     if (!shape) {
       throw new Error("0D not implemented for JsonCodec.");
-    } else {
-      const stride = get_strides(shape, "C");
-      const data = items;
-      return { data, shape, stride };
     }
+    const stride = get_strides(shape, "C");
+    const data = items;
+    return { data, shape, stride };
   }
 };
 let JsonCodec = _JsonCodec;
 _encoder_config = new WeakMap();
 _decoder_config = new WeakMap();
+function proxy(arr) {
+  if (arr instanceof BoolArray || arr instanceof ByteStringArray || arr instanceof UnicodeStringArray) {
+    const arrp = new Proxy(arr, {
+      get(target, prop) {
+        return target.get(Number(prop));
+      },
+      set(target, prop, value) {
+        target.set(Number(prop), value);
+        return true;
+      }
+    });
+    return arrp;
+  }
+  return arr;
+}
+function empty_like(chunk, order) {
+  let data;
+  if (chunk.data instanceof ByteStringArray || chunk.data instanceof UnicodeStringArray) {
+    data = new chunk.constructor(
+      // @ts-expect-error
+      chunk.data.length,
+      chunk.data.chars
+    );
+  } else {
+    data = new chunk.constructor(chunk.data.length);
+  }
+  return {
+    data,
+    shape: chunk.shape,
+    stride: get_strides(chunk.shape, order)
+  };
+}
+function convert_array_order(src, target) {
+  let out = empty_like(src, target);
+  let n_dims = src.shape.length;
+  let size2 = src.data.length;
+  let index2 = Array(n_dims).fill(0);
+  let src_data = proxy(src.data);
+  let out_data = proxy(out.data);
+  for (let src_idx = 0; src_idx < size2; src_idx++) {
+    let out_idx = 0;
+    for (let dim = 0; dim < n_dims; dim++) {
+      out_idx += index2[dim] * out.stride[dim];
+    }
+    out_data[out_idx] = src_data[src_idx];
+    index2[0] += 1;
+    for (let dim = 0; dim < n_dims; dim++) {
+      if (index2[dim] === src.shape[dim]) {
+        if (dim + 1 === n_dims) {
+          break;
+        }
+        index2[dim] = 0;
+        index2[dim + 1] += 1;
+      }
+    }
+  }
+  return out;
+}
+function get_order(arr) {
+  if (!arr.stride)
+    return "C";
+  let row_major_strides = get_strides(arr.shape, "C");
+  return arr.stride.every((s2, i2) => s2 === row_major_strides[i2]) ? "C" : "F";
+}
+class TransposeCodec {
+  constructor(configuration) {
+    __publicField(this, "configuration");
+    __publicField(this, "kind", "array_to_array");
+    this.configuration = configuration;
+  }
+  static fromConfig(configuration) {
+    return new TransposeCodec(configuration);
+  }
+  encode(arr) {
+    var _a3, _b2;
+    if (get_order(arr) === ((_a3 = this.configuration) == null ? void 0 : _a3.order)) {
+      return arr;
+    }
+    return convert_array_order(arr, ((_b2 = this.configuration) == null ? void 0 : _b2.order) ?? "C");
+  }
+  decode(arr) {
+    return arr;
+  }
+}
+const _VLenUTF8 = class {
+  constructor(shape) {
+    __publicField(this, "kind", "array_to_bytes");
+    __privateAdd(this, _shape2, void 0);
+    __privateAdd(this, _strides2, void 0);
+    __privateSet(this, _shape2, shape);
+    __privateSet(this, _strides2, get_strides(shape, "C"));
+  }
+  static fromConfig(_, meta2) {
+    return new _VLenUTF8(meta2.shape);
+  }
+  encode(_chunk) {
+    throw new Error("Method not implemented.");
+  }
+  decode(bytes) {
+    let decoder = new TextDecoder();
+    let view = new DataView(bytes.buffer);
+    let data = Array(view.getUint32(0, true));
+    let pos = 4;
+    for (let i2 = 0; i2 < data.length; i2++) {
+      let item_length = view.getUint32(pos, true);
+      pos += 4;
+      data[i2] = decoder.decode(bytes.buffer.slice(pos, pos + item_length));
+      pos += item_length;
+    }
+    return { data, shape: __privateGet(this, _shape2), stride: __privateGet(this, _strides2) };
+  }
+};
+let VLenUTF8 = _VLenUTF8;
+_shape2 = new WeakMap();
+_strides2 = new WeakMap();
 function create_default_registry() {
   return (/* @__PURE__ */ new Map()).set("blosc", () => import("./blosc-537fd004.js").then((m) => m.default)).set("gzip", () => import("./gzip-6a24f0fe.js").then((m) => m.default)).set("lz4", () => import("./lz4-bbd18009.js").then((m) => m.default)).set("zlib", () => import("./zlib-175cd38d.js").then((m) => m.default)).set("zstd", () => import("./zstd-ec5a40b8.js").then((m) => m.default)).set("transpose", () => TransposeCodec).set("bytes", () => BytesCodec).set("crc32c", () => Crc32cCodec).set("vlen-utf8", () => VLenUTF8).set("json2", () => JsonCodec);
 }
@@ -134989,8 +134992,8 @@ async function _open_v3(location) {
     });
   }
   let meta_doc = json_decode_object(meta2);
-  if (meta_doc.node_type === "array" && (meta_doc.data_type === "uint64" || meta_doc.data_type === "int64") && meta_doc.fill_value != void 0) {
-    meta_doc.fill_value = BigInt(meta_doc.fill_value);
+  if (meta_doc.node_type === "array") {
+    meta_doc.fill_value = ensure_correct_scalar(meta_doc);
   }
   return meta_doc.node_type === "array" ? new Array$1(store, location.path, meta_doc) : new Group(store, location.path, meta_doc);
 }
@@ -135284,7 +135287,7 @@ function object_array_view(arr, offset = 0, size2) {
   };
 }
 function compat_chunk(arr) {
-  if (arr.data instanceof globalThis.Array) {
+  if (globalThis.Array.isArray(arr.data)) {
     return {
       // @ts-expect-error
       data: object_array_view(arr.data),
@@ -135305,7 +135308,7 @@ function get_typed_array_constructor(arr) {
   return arr.constructor;
 }
 function compat_scalar(arr, value) {
-  if (arr.data instanceof globalThis.Array) {
+  if (globalThis.Array.isArray(arr.data)) {
     return object_array_view([value]);
   }
   let TypedArray2 = get_typed_array_constructor(arr.data);

package/dist/index.js

@@ -1,4 +1,4 @@
-import { D, e, a, b, c, d, F, G, Z, C, r, n, E, A, y, l, m, z, x, h, q, v, o, i, f, j, k, u, t, p, s, w } from "./index-99145749.js";
+import { D, e, a, b, c, d, F, G, Z, C, r, n, E, A, y, l, m, z, x, h, q, v, o, i, f, j, k, u, t, p, s, w } from "./index-a7bb8a96.js";
 import "react";
 export {
   D as DEFAULT_CELLS_LAYER,

package/dist/{jpeg-43f7eb3d.js → jpeg-ddaf8c90.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-99145749.js";
+import { B as BaseDecoder } from "./index-a7bb8a96.js";
 import "react";
 const dctZigZag = new Int32Array([
   0,

package/dist/{lerc-f6703f92.js → lerc-436605d8.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
-import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-99145749.js";
+import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-a7bb8a96.js";
 import "react";
 const LercParameters = {
   Version: 0,

package/dist/{lzw-3ea2d511.js → lzw-0caa4868.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-99145749.js";
+import { B as BaseDecoder } from "./index-a7bb8a96.js";
 import "react";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;

package/dist/{packbits-bb194562.js → packbits-a5fbf85a.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-99145749.js";
+import { B as BaseDecoder } from "./index-a7bb8a96.js";
 import "react";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{raw-072bb393.js → raw-9ca04826.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-99145749.js";
+import { B as BaseDecoder } from "./index-a7bb8a96.js";
 import "react";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{webimage-50d4efbc.js → webimage-c0a22c4e.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-99145749.js";
+import { B as BaseDecoder } from "./index-a7bb8a96.js";
 import "react";
 class WebImageDecoder extends BaseDecoder {
   constructor() {

package/dist-tsc/spatial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AAOA,wDAEC;AAiCD;;;;;;GAMG;AACH,4CAJW,MAAM,UACN,MAAM,YAAC,GACL,MAAM,CAMlB;AAoCD;;;;GAIG;AACH,8BAHW,MAAM,YACN,KAAK,GAAC,IAAI,WAiBpB;AAID,sHAkCC;AAiHD;;GAEG;AACH,qCAFW,KAAK,CAAE,MAAM,CAAC,WAKxB;AAED;;;;;;GAMG;AACH,gDALW,MAAM,eAEJ,MAAM,EAAE,CAuCpB;AAED;;;;;;;;;GASG;AACH,gEAJW,MAAM,EAAE,sBAER,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC,+CAuEzB;AASD;;;IAuBC;AAED,uDAQC;AAED;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,GAAC,SAAS,QAElB,MAAM,EAAE,GAAC,SAAS,GAEhB,OAAO,CA4CnB;AAED,6CAOC;AAED;;;;;;;;;GASG;AACH,8EANW,MAAM,EAAE,GAAC,SAAS,YAGlB,MAAM,EAAE,GACN,MAAM,EAAE,CAiDpB;AAhiBD,qCAAwC;AAExC,mDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBpD,mDAKE;AAeK;;;;;EAYN;AAEM,yEAkBN;wBAtFuB,SAAS;oBAGb,cAAc"}
+{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AAOA,wDAEC;AAiCD;;;;;;GAMG;AACH,4CAJW,MAAM,UACN,MAAM,YAAC,GACL,MAAM,CAMlB;AAoCD;;;;GAIG;AACH,8BAHW,MAAM,YACN,KAAK,GAAC,IAAI,WAiBpB;AAID,sHAkCC;AAiHD;;GAEG;AACH,qCAFW,KAAK,CAAE,MAAM,CAAC,WAKxB;AAED;;;;;;GAMG;AACH,gDALW,MAAM,eAEJ,MAAM,EAAE,CAuCpB;AAED;;;;;;;;;GASG;AACH,gEAJW,MAAM,EAAE,sBAER,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC,+CAuEzB;AASD;;;IAuBC;AAED,uDAQC;AAED;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,GAAC,SAAS,QAElB,MAAM,EAAE,GAAC,SAAS,GAEhB,OAAO,CA4CnB;AAED,6CAOC;AAED;;;;;;;;;GASG;AACH,8EANW,MAAM,EAAE,GAAC,SAAS,YAGlB,MAAM,EAAE,GACN,MAAM,EAAE,CAoDpB;AAniBD,qCAAwC;AAExC,mDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBpD,mDAKE;AAeK;;;;;EAYN;AAEM,yEAkBN;wBAtFuB,SAAS;oBAGb,cAAc"}

package/dist-tsc/spatial.js

@@ -454,7 +454,7 @@ export function normalizeCoordinateTransformations(coordinateTransformations, da
     // Reference: https://ngff.openmicroscopy.org/0.4/index.html#trafo-md
     let result = [];
     if (Array.isArray(coordinateTransformations)) {
-        result = coordinateTransformations.map((transform) => {
+        result = coordinateTransformations.flatMap((transform) => {
             if (transform.input && transform.output) {
                 // This is a new-style coordinate transformation.
                 // (As proposed in https://github.com/ome/ngff/pull/138)
@@ -474,6 +474,9 @@ export function normalizeCoordinateTransformations(coordinateTransformations, da
                 if (type === 'identity') {
                     return { type };
                 }
+                if (type === 'sequence') {
+                    return normalizeCoordinateTransformations(transform.transformations, datasets);
+                }
                 console.warn(`Coordinate transformation type "${type}" is not supported.`);
             }
             // Assume it was already an old-style (NGFF v0.4) coordinate transformation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/spatial-utils",
-  "version": "3.4.8",
+  "version": "3.4.10",
   "author": "Gehlenborg Lab",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -17,12 +17,12 @@
   ],
   "dependencies": {
     "lodash-es": "^4.17.21",
-    "zarrita": "0.4.0-next.10",
+    "zarrita": "0.4.0-next.16",
     "math.gl": "^3.5.6",
     "mathjs": "^9.2.0",
-    "@vitessce/gl": "3.4.8",
-    "@vitessce/utils": "3.4.8",
-    "@vitessce/zarr-utils": "3.4.8"
+    "@vitessce/gl": "3.4.10",
+    "@vitessce/utils": "3.4.10",
+    "@vitessce/zarr-utils": "3.4.10"
   },
   "scripts": {
     "bundle": "pnpm exec vite build -c ../../../scripts/vite.config.js",

package/src/spatial.js

@@ -512,7 +512,7 @@ export function normalizeCoordinateTransformations(coordinateTransformations, da
   let result = [];
 
   if (Array.isArray(coordinateTransformations)) {
-    result = coordinateTransformations.map((transform) => {
+    result = coordinateTransformations.flatMap((transform) => {
       if (transform.input && transform.output) {
         // This is a new-style coordinate transformation.
         // (As proposed in https://github.com/ome/ngff/pull/138)
@@ -532,6 +532,9 @@ export function normalizeCoordinateTransformations(coordinateTransformations, da
         if (type === 'identity') {
           return { type };
         }
+        if (type === 'sequence') {
+          return normalizeCoordinateTransformations(transform.transformations, datasets);
+        }
         console.warn(`Coordinate transformation type "${type}" is not supported.`);
       }
       // Assume it was already an old-style (NGFF v0.4) coordinate transformation.