@vitessce/all 3.4.2 → 3.4.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,5 +1,5 @@
1
1
  import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
2
- import { aP as BaseDecoder } from "./index-0d08aaae.js";
2
+ import { aP as BaseDecoder } from "./index-7122d405.js";
3
3
  import "react";
4
4
  import "@vitessce/vit-s";
5
5
  import "react-dom";
@@ -1,6 +1,6 @@
1
1
  import React__default from "react";
2
2
  import ReactDOM__default from "react-dom";
3
- import { aS as commonjsGlobal, aT as objectAssign, g as getDefaultExportFromCjs, aU as earcut, aV as getAugmentedNamespace } from "./index-0d08aaae.js";
3
+ import { aS as commonjsGlobal, aT as objectAssign, g as getDefaultExportFromCjs, aU as earcut, aV as getAugmentedNamespace } from "./index-7122d405.js";
4
4
  function _mergeNamespaces(n, m) {
5
5
  for (var i = 0; i < m.length; i++) {
6
6
  const e = m[i];
@@ -39097,11 +39097,19 @@ var _fails = function(exec) {
39097
39097
  return true;
39098
39098
  }
39099
39099
  };
39100
- var _descriptors = !_fails(function() {
39101
- return Object.defineProperty({}, "a", { get: function() {
39102
- return 7;
39103
- } }).a != 7;
39104
- });
39100
+ var _descriptors;
39101
+ var hasRequired_descriptors;
39102
+ function require_descriptors() {
39103
+ if (hasRequired_descriptors)
39104
+ return _descriptors;
39105
+ hasRequired_descriptors = 1;
39106
+ _descriptors = !_fails(function() {
39107
+ return Object.defineProperty({}, "a", { get: function() {
39108
+ return 7;
39109
+ } }).a != 7;
39110
+ });
39111
+ return _descriptors;
39112
+ }
39105
39113
  var _domCreate;
39106
39114
  var hasRequired_domCreate;
39107
39115
  function require_domCreate() {
@@ -39116,11 +39124,19 @@ function require_domCreate() {
39116
39124
  };
39117
39125
  return _domCreate;
39118
39126
  }
39119
- var _ie8DomDefine = !_descriptors && !_fails(function() {
39120
- return Object.defineProperty(require_domCreate()("div"), "a", { get: function() {
39121
- return 7;
39122
- } }).a != 7;
39123
- });
39127
+ var _ie8DomDefine;
39128
+ var hasRequired_ie8DomDefine;
39129
+ function require_ie8DomDefine() {
39130
+ if (hasRequired_ie8DomDefine)
39131
+ return _ie8DomDefine;
39132
+ hasRequired_ie8DomDefine = 1;
39133
+ _ie8DomDefine = !require_descriptors() && !_fails(function() {
39134
+ return Object.defineProperty(require_domCreate()("div"), "a", { get: function() {
39135
+ return 7;
39136
+ } }).a != 7;
39137
+ });
39138
+ return _ie8DomDefine;
39139
+ }
39124
39140
  var isObject$i = _isObject;
39125
39141
  var _toPrimitive = function(it, S) {
39126
39142
  if (!isObject$i(it))
@@ -39134,25 +39150,32 @@ var _toPrimitive = function(it, S) {
39134
39150
  return val;
39135
39151
  throw TypeError("Can't convert object to primitive value");
39136
39152
  };
39137
- var anObject$3 = _anObject;
39138
- var IE8_DOM_DEFINE$1 = _ie8DomDefine;
39139
- var toPrimitive$2 = _toPrimitive;
39140
- var dP$3 = Object.defineProperty;
39141
- _objectDp.f = _descriptors ? Object.defineProperty : function defineProperty(O, P2, Attributes) {
39142
- anObject$3(O);
39143
- P2 = toPrimitive$2(P2, true);
39144
- anObject$3(Attributes);
39145
- if (IE8_DOM_DEFINE$1)
39146
- try {
39147
- return dP$3(O, P2, Attributes);
39148
- } catch (e3) {
39149
- }
39150
- if ("get" in Attributes || "set" in Attributes)
39151
- throw TypeError("Accessors not supported!");
39152
- if ("value" in Attributes)
39153
- O[P2] = Attributes.value;
39154
- return O;
39155
- };
39153
+ var hasRequired_objectDp;
39154
+ function require_objectDp() {
39155
+ if (hasRequired_objectDp)
39156
+ return _objectDp;
39157
+ hasRequired_objectDp = 1;
39158
+ var anObject2 = _anObject;
39159
+ var IE8_DOM_DEFINE2 = require_ie8DomDefine();
39160
+ var toPrimitive2 = _toPrimitive;
39161
+ var dP2 = Object.defineProperty;
39162
+ _objectDp.f = require_descriptors() ? Object.defineProperty : function defineProperty4(O, P2, Attributes) {
39163
+ anObject2(O);
39164
+ P2 = toPrimitive2(P2, true);
39165
+ anObject2(Attributes);
39166
+ if (IE8_DOM_DEFINE2)
39167
+ try {
39168
+ return dP2(O, P2, Attributes);
39169
+ } catch (e3) {
39170
+ }
39171
+ if ("get" in Attributes || "set" in Attributes)
39172
+ throw TypeError("Accessors not supported!");
39173
+ if ("value" in Attributes)
39174
+ O[P2] = Attributes.value;
39175
+ return O;
39176
+ };
39177
+ return _objectDp;
39178
+ }
39156
39179
  var _propertyDesc = function(bitmap, value2) {
39157
39180
  return {
39158
39181
  enumerable: !(bitmap & 1),
@@ -39161,9 +39184,9 @@ var _propertyDesc = function(bitmap, value2) {
39161
39184
  value: value2
39162
39185
  };
39163
39186
  };
39164
- var dP$2 = _objectDp;
39187
+ var dP$2 = require_objectDp();
39165
39188
  var createDesc$2 = _propertyDesc;
39166
- var _hide = _descriptors ? function(object2, key2, value2) {
39189
+ var _hide = require_descriptors() ? function(object2, key2, value2) {
39167
39190
  return dP$2.f(object2, key2, createDesc$2(1, value2));
39168
39191
  } : function(object2, key2, value2) {
39169
39192
  object2[key2] = value2;
@@ -39367,7 +39390,7 @@ function require_objectAssign() {
39367
39390
  if (hasRequired_objectAssign)
39368
39391
  return _objectAssign;
39369
39392
  hasRequired_objectAssign = 1;
39370
- var DESCRIPTORS2 = _descriptors;
39393
+ var DESCRIPTORS2 = require_descriptors();
39371
39394
  var getKeys2 = _objectKeys$1;
39372
39395
  var gOPS2 = _objectGops;
39373
39396
  var pIE2 = require_objectPie();
@@ -39427,9 +39450,9 @@ var _default$8 = _assign2.default || function(target2) {
39427
39450
  return target2;
39428
39451
  };
39429
39452
  var $export$4 = _export;
39430
- $export$4($export$4.S + $export$4.F * !_descriptors, "Object", { defineProperty: _objectDp.f });
39453
+ $export$4($export$4.S + $export$4.F * !require_descriptors(), "Object", { defineProperty: require_objectDp().f });
39431
39454
  var $Object$2 = _coreExports.Object;
39432
- var defineProperty$6 = function defineProperty2(it, key2, desc) {
39455
+ var defineProperty$6 = function defineProperty(it, key2, desc) {
39433
39456
  return $Object$2.defineProperty(it, key2, desc);
39434
39457
  };
39435
39458
  var defineProperty$5 = { "default": defineProperty$6, __esModule: true };
@@ -39497,10 +39520,10 @@ var _stringAt = function(TO_STRING) {
39497
39520
  };
39498
39521
  var _redefine = _hide;
39499
39522
  var _iterators = {};
39500
- var dP$1 = _objectDp;
39523
+ var dP$1 = require_objectDp();
39501
39524
  var anObject$2 = _anObject;
39502
39525
  var getKeys$1 = _objectKeys$1;
39503
- var _objectDps = _descriptors ? Object.defineProperties : function defineProperties(O, Properties) {
39526
+ var _objectDps = require_descriptors() ? Object.defineProperties : function defineProperties(O, Properties) {
39504
39527
  anObject$2(O);
39505
39528
  var keys4 = getKeys$1(Properties);
39506
39529
  var length2 = keys4.length;
@@ -39566,7 +39589,7 @@ var $exports = _wks.exports = function(name2) {
39566
39589
  };
39567
39590
  $exports.store = store;
39568
39591
  var _wksExports = _wks.exports;
39569
- var def$1 = _objectDp.f;
39592
+ var def$1 = require_objectDp().f;
39570
39593
  var has$8 = _has$1;
39571
39594
  var TAG = _wksExports("toStringTag");
39572
39595
  var _setToStringTag = function(it, tag2, stat) {
@@ -39733,7 +39756,7 @@ var _meta$3 = { exports: {} };
39733
39756
  var META$1 = _uid("meta");
39734
39757
  var isObject$h = _isObject;
39735
39758
  var has$6 = _has$1;
39736
- var setDesc = _objectDp.f;
39759
+ var setDesc = require_objectDp().f;
39737
39760
  var id$3 = 0;
39738
39761
  var isExtensible = Object.isExtensible || function() {
39739
39762
  return true;
@@ -39786,7 +39809,7 @@ var meta$6 = _meta$3.exports = {
39786
39809
  var _metaExports = _meta$3.exports;
39787
39810
  var core$1 = _coreExports;
39788
39811
  var wksExt$1 = _wksExt;
39789
- var defineProperty$4 = _objectDp.f;
39812
+ var defineProperty$4 = require_objectDp().f;
39790
39813
  var _wksDefine = function(name2) {
39791
39814
  var $Symbol2 = core$1.Symbol || (core$1.Symbol = {});
39792
39815
  if (name2.charAt(0) != "_" && !(name2 in $Symbol2))
@@ -39840,9 +39863,9 @@ var createDesc$1 = _propertyDesc;
39840
39863
  var toIObject$1 = _toIobject;
39841
39864
  var toPrimitive$1 = _toPrimitive;
39842
39865
  var has$5 = _has$1;
39843
- var IE8_DOM_DEFINE = _ie8DomDefine;
39866
+ var IE8_DOM_DEFINE = require_ie8DomDefine();
39844
39867
  var gOPD$4 = Object.getOwnPropertyDescriptor;
39845
- _objectGopd.f = _descriptors ? gOPD$4 : function getOwnPropertyDescriptor2(O, P2) {
39868
+ _objectGopd.f = require_descriptors() ? gOPD$4 : function getOwnPropertyDescriptor2(O, P2) {
39846
39869
  O = toIObject$1(O);
39847
39870
  P2 = toPrimitive$1(P2, true);
39848
39871
  if (IE8_DOM_DEFINE)
@@ -39855,7 +39878,7 @@ _objectGopd.f = _descriptors ? gOPD$4 : function getOwnPropertyDescriptor2(O, P2
39855
39878
  };
39856
39879
  var global$2 = _globalExports;
39857
39880
  var has$4 = _has$1;
39858
- var DESCRIPTORS = _descriptors;
39881
+ var DESCRIPTORS = require_descriptors();
39859
39882
  var $export$2 = _export;
39860
39883
  var redefine = _redefine;
39861
39884
  var META = _metaExports.KEY;
@@ -39878,7 +39901,7 @@ var _create$1 = _objectCreate;
39878
39901
  var gOPNExt = _objectGopnExt;
39879
39902
  var $GOPD = _objectGopd;
39880
39903
  var $GOPS = _objectGops;
39881
- var $DP = _objectDp;
39904
+ var $DP = require_objectDp();
39882
39905
  var $keys = _objectKeys$1;
39883
39906
  var gOPD$3 = $GOPD.f;
39884
39907
  var dP = $DP.f;
@@ -39921,7 +39944,7 @@ var isSymbol$6 = USE_NATIVE && typeof $Symbol$1.iterator == "symbol" ? function(
39921
39944
  } : function(it) {
39922
39945
  return it instanceof $Symbol$1;
39923
39946
  };
39924
- var $defineProperty$1 = function defineProperty3(it, key2, D2) {
39947
+ var $defineProperty$1 = function defineProperty2(it, key2, D2) {
39925
39948
  if (it === ObjectProto)
39926
39949
  $defineProperty$1(OPSymbols, key2, D2);
39927
39950
  anObject(it);
@@ -45463,7 +45486,7 @@ function _regeneratorRuntime$1() {
45463
45486
  _regeneratorRuntime$1 = function _regeneratorRuntime2() {
45464
45487
  return exports2;
45465
45488
  };
45466
- var exports2 = {}, Op2 = Object.prototype, hasOwn2 = Op2.hasOwnProperty, defineProperty5 = Object.defineProperty || function(obj, key2, desc) {
45489
+ var exports2 = {}, Op2 = Object.prototype, hasOwn2 = Op2.hasOwnProperty, defineProperty4 = Object.defineProperty || function(obj, key2, desc) {
45467
45490
  obj[key2] = desc.value;
45468
45491
  }, $Symbol2 = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol2 = $Symbol2.iterator || "@@iterator", asyncIteratorSymbol2 = $Symbol2.asyncIterator || "@@asyncIterator", toStringTagSymbol2 = $Symbol2.toStringTag || "@@toStringTag";
45469
45492
  function define2(obj, key2, value2) {
@@ -45483,7 +45506,7 @@ function _regeneratorRuntime$1() {
45483
45506
  }
45484
45507
  function wrap2(innerFn, outerFn, self2, tryLocsList) {
45485
45508
  var protoGenerator = outerFn && outerFn.prototype instanceof Generator2 ? outerFn : Generator2, generator = Object.create(protoGenerator.prototype), context2 = new Context2(tryLocsList || []);
45486
- return defineProperty5(generator, "_invoke", {
45509
+ return defineProperty4(generator, "_invoke", {
45487
45510
  value: makeInvokeMethod2(innerFn, self2, context2)
45488
45511
  }), generator;
45489
45512
  }
@@ -45540,7 +45563,7 @@ function _regeneratorRuntime$1() {
45540
45563
  reject(record.arg);
45541
45564
  }
45542
45565
  var previousPromise;
45543
- defineProperty5(this, "_invoke", {
45566
+ defineProperty4(this, "_invoke", {
45544
45567
  value: function value2(method2, arg) {
45545
45568
  function callInvokeWithMethodAndArg() {
45546
45569
  return new PromiseImpl(function(resolve2, reject) {
@@ -45645,10 +45668,10 @@ function _regeneratorRuntime$1() {
45645
45668
  done: true
45646
45669
  };
45647
45670
  }
45648
- return GeneratorFunction2.prototype = GeneratorFunctionPrototype2, defineProperty5(Gp2, "constructor", {
45671
+ return GeneratorFunction2.prototype = GeneratorFunctionPrototype2, defineProperty4(Gp2, "constructor", {
45649
45672
  value: GeneratorFunctionPrototype2,
45650
45673
  configurable: true
45651
- }), defineProperty5(GeneratorFunctionPrototype2, "constructor", {
45674
+ }), defineProperty4(GeneratorFunctionPrototype2, "constructor", {
45652
45675
  value: GeneratorFunction2,
45653
45676
  configurable: true
45654
45677
  }), GeneratorFunction2.displayName = define2(GeneratorFunctionPrototype2, toStringTagSymbol2, "GeneratorFunction"), exports2.isGeneratorFunction = function(genFun) {
@@ -156421,16 +156444,16 @@ async function getDecoder(fileDirectory) {
156421
156444
  const Decoder = await importFn();
156422
156445
  return new Decoder(fileDirectory);
156423
156446
  }
156424
- addDecoder([void 0, 1], () => import("./raw-0c2d8506.js").then((m2) => m2.default));
156425
- addDecoder(5, () => import("./lzw-f0c0faa6.js").then((m2) => m2.default));
156447
+ addDecoder([void 0, 1], () => import("./raw-dcf27768.js").then((m2) => m2.default));
156448
+ addDecoder(5, () => import("./lzw-2c621078.js").then((m2) => m2.default));
156426
156449
  addDecoder(6, () => {
156427
156450
  throw new Error("old style JPEG compression is not supported.");
156428
156451
  });
156429
- addDecoder(7, () => import("./jpeg-9f88d9a1.js").then((m2) => m2.default));
156430
- addDecoder([8, 32946], () => import("./deflate-05e36353.js").then((m2) => m2.default));
156431
- addDecoder(32773, () => import("./packbits-d0fa0169.js").then((m2) => m2.default));
156432
- addDecoder(34887, () => import("./lerc-d1028c67.js").then((m2) => m2.default));
156433
- addDecoder(50001, () => import("./webimage-3234790c.js").then((m2) => m2.default));
156452
+ addDecoder(7, () => import("./jpeg-39c27c9a.js").then((m2) => m2.default));
156453
+ addDecoder([8, 32946], () => import("./deflate-36ad815c.js").then((m2) => m2.default));
156454
+ addDecoder(32773, () => import("./packbits-9707f081.js").then((m2) => m2.default));
156455
+ addDecoder(34887, () => import("./lerc-6d84361f.js").then((m2) => m2.default));
156456
+ addDecoder(50001, () => import("./webimage-39250891.js").then((m2) => m2.default));
156434
156457
  function copyNewSize(array2, width2, height2, samplesPerPixel = 1) {
156435
156458
  return new (Object.getPrototypeOf(array2)).constructor(width2 * height2 * samplesPerPixel);
156436
156459
  }
@@ -178512,7 +178535,8 @@ function Legend(props) {
178512
178535
  g2.append("text").attr("text-anchor", "start").attr("dominant-baseline", "hanging").attr("x", 0).attr("y", y2).text(levelZeroName).style("font-size", "9px").style("fill", foregroundColor);
178513
178536
  y2 += titleHeight;
178514
178537
  setPaths.forEach((setPath) => {
178515
- const setColor = obsSetColor.find((d) => isEqual$4(d.path, setPath)).color;
178538
+ var _a3;
178539
+ const setColor = ((_a3 = obsSetColor == null ? void 0 : obsSetColor.find((d) => isEqual$4(d.path, setPath))) == null ? void 0 : _a3.color) || getDefaultColor(theme);
178516
178540
  g2.append("rect").attr("x", 0).attr("y", y2).attr("width", rectHeight).attr("height", rectHeight).attr("fill", `rgb(${setColor[0]},${setColor[1]},${setColor[2]})`);
178517
178541
  g2.append("text").attr("text-anchor", "start").attr("dominant-baseline", "hanging").attr("x", rectHeight + rectMarginX).attr("y", y2).text(setPath.at(-1)).style("font-size", "9px").style("fill", foregroundColor);
178518
178542
  y2 += rectHeight + rectMarginY;
@@ -178547,7 +178571,8 @@ function Legend(props) {
178547
178571
  spatialChannelColor,
178548
178572
  obsSetColor,
178549
178573
  obsSetSelection,
178550
- isSetColor
178574
+ isSetColor,
178575
+ theme
178551
178576
  ]);
178552
178577
  return jsxRuntimeExports.jsx("div", { className: clsx(classes.legend, {
178553
178578
  [classes.legendRelative]: positionRelative,
@@ -199567,7 +199592,7 @@ class ErrorBoundary extends React__default.Component {
199567
199592
  }
199568
199593
  }
199569
199594
  const LazySpatialThree = React__default.lazy(async () => {
199570
- const { SpatialWrapper: SpatialWrapper2 } = await import("./index-d7d5e603.js");
199595
+ const { SpatialWrapper: SpatialWrapper2 } = await import("./index-7c6ff616.js");
199571
199596
  return { default: SpatialWrapper2 };
199572
199597
  });
199573
199598
  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 }) }) }) }));
@@ -200024,26 +200049,18 @@ function SpatialSubscriber(props) {
200024
200049
  var _a3;
200025
200050
  return (_a3 = obsSegmentationsLocationsData == null ? void 0 : obsSegmentationsLocationsData[layerScope]) == null ? void 0 : _a3[channelScope];
200026
200051
  })).length > 0;
200027
- const onEntitySelected = useCallback((obsId) => {
200028
- const obsIdsToSelect = [obsId];
200029
- const layerScope = segmentationLayerScopes[0];
200030
- if (layerScope !== void 0 && segmentationChannelScopesByLayer[layerScope][0] !== void 0) {
200031
- const channelScope = segmentationChannelScopesByLayer[layerScope][0];
200032
- const { additionalObsSets: firstChannelAdditionalObsSets, obsSetColor: firstChannelObsSetColor } = segmentationChannelCoordination[0][layerScope][channelScope];
200033
- const { setObsSetColor: firstChannelSetObsSetColor, setAdditionalObsSets: firstChannelSetAdditionalObsSets, setObsColorEncoding: firstChannelSetObsColorEncoding, setObsSetSelection: firstChannelSetObsSetSelection } = segmentationChannelCoordination[1][layerScope][channelScope];
200034
- setObsSelection(obsIdsToSelect, firstChannelAdditionalObsSets, firstChannelObsSetColor, firstChannelSetObsSetSelection, firstChannelSetAdditionalObsSets, firstChannelSetObsSetColor, firstChannelSetObsColorEncoding);
200035
- } else {
200036
- setObsSelection(obsIdsToSelect, additionalObsSets, obsSetColor, setObsSetSelection, setAdditionalObsSets, setObsSetColor, setObsColorEncoding);
200052
+ const onEntitySelected = (obsId, layerScope, channelScope) => {
200053
+ if (layerScope && channelScope) {
200054
+ const channelCoordinationValues = segmentationChannelCoordination[0][layerScope][channelScope];
200055
+ const channelCoordinationSetters = segmentationChannelCoordination[1][layerScope][channelScope];
200056
+ if (channelCoordinationValues && channelCoordinationSetters) {
200057
+ const { additionalObsSets: channelAdditionalObsSets, obsSetColor: channelObsSetColor } = channelCoordinationValues;
200058
+ const { setObsSetColor: setChannelObsSetColor, setAdditionalObsSets: setChannelAdditionalObsSets, setObsColorEncoding: setChannelObsColorEncoding, setObsSetSelection: setChannelObsSetSelection } = channelCoordinationSetters;
200059
+ const obsIdsToSelect = [obsId];
200060
+ setObsSelection(obsIdsToSelect, channelAdditionalObsSets, channelObsSetColor, setChannelObsSetSelection, setChannelAdditionalObsSets, setChannelObsSetColor, setChannelObsColorEncoding);
200061
+ }
200037
200062
  }
200038
- }, [
200039
- additionalObsSets,
200040
- obsSetColor,
200041
- setObsSetSelection,
200042
- setAdditionalObsSets,
200043
- setObsSetColor,
200044
- setObsColorEncoding
200045
- // TODO: more dependencies?
200046
- ]);
200063
+ };
200047
200064
  return jsxRuntimeExports.jsxs(TitleInfo, { title: title2, info: subtitle, isSpatial: true, urls: urls2, theme, closeButtonVisible, downloadButtonVisible, removeGridComponent, isReady, children: [shouldUseThree ? jsxRuntimeExports.jsx(SpatialThreeAdapter, {
200048
200065
  ref: threeRef,
200049
200066
  uuid,
@@ -200071,8 +200088,7 @@ function SpatialSubscriber(props) {
200071
200088
  spatialRenderingMode,
200072
200089
  updateViewInfo: setComponentViewInfo,
200073
200090
  delegateHover,
200074
- // TODO: do not make this glom-specific. need to generalize
200075
- onGlomSelected: onEntitySelected,
200091
+ onEntitySelected,
200076
200092
  // Points
200077
200093
  obsPoints: obsPointsData,
200078
200094
  pointLayerScopes,
@@ -201384,11 +201400,11 @@ function requireInherits() {
201384
201400
  })(inherits$1);
201385
201401
  return inherits$1.exports;
201386
201402
  }
201387
- var defineProperty4 = { exports: {} };
201403
+ var defineProperty3 = { exports: {} };
201388
201404
  var hasRequiredDefineProperty;
201389
201405
  function requireDefineProperty() {
201390
201406
  if (hasRequiredDefineProperty)
201391
- return defineProperty4.exports;
201407
+ return defineProperty3.exports;
201392
201408
  hasRequiredDefineProperty = 1;
201393
201409
  (function(module2) {
201394
201410
  function _defineProperty3(obj, key2, value2) {
@@ -201405,8 +201421,8 @@ function requireDefineProperty() {
201405
201421
  return obj;
201406
201422
  }
201407
201423
  module2.exports = _defineProperty3, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
201408
- })(defineProperty4);
201409
- return defineProperty4.exports;
201424
+ })(defineProperty3);
201425
+ return defineProperty3.exports;
201410
201426
  }
201411
201427
  var detectElementResize = {};
201412
201428
  var hasRequiredDetectElementResize;
@@ -208624,7 +208640,7 @@ const HIGLASS_BUNDLE_VERSION = "1.11.13";
208624
208640
  const HIGLASS_CSS_URL = `https://unpkg.com/${HIGLASS_PKG_NAME}@${HIGLASS_BUNDLE_VERSION}/dist/hglib.css`;
208625
208641
  register({ dataFetcher: ZarrMultivecDataFetcher_default, config: ZarrMultivecDataFetcher_default.config }, { pluginType: "dataFetcher" });
208626
208642
  const LazyHiGlassComponent = React__default.lazy(async () => {
208627
- const { HiGlassComponent } = await import("./hglib-2bedd252.js").then((n3) => n3.h);
208643
+ const { HiGlassComponent } = await import("./hglib-afa0c597.js").then((n3) => n3.h);
208628
208644
  return { default: HiGlassComponent };
208629
208645
  });
208630
208646
  const HG_SIZE = 800;
@@ -266643,7 +266659,7 @@ function FeatureBarPlot(props) {
266643
266659
  (_c2 = (_b2 = (_a3 = additionalCellSets == null ? void 0 : additionalCellSets.tree) == null ? void 0 : _a3[0]) == null ? void 0 : _b2.children) == null ? void 0 : _c2.forEach((child) => {
266644
266660
  if (child.name === selectedElement) {
266645
266661
  child.set.forEach(([obsId]) => {
266646
- const info2 = { name: "", id: "", color: [] };
266662
+ const info2 = { name: "", id: "", color: [255, 255, 255] };
266647
266663
  info2.name = selectedElement;
266648
266664
  info2.id = obsId;
266649
266665
  cellSetColor.forEach((color2) => {
@@ -303881,7 +303897,7 @@ const baseCoordinationTypes = [
303881
303897
  new PluginCoordinationType(CoordinationType$1.IMAGE_CHANNEL, null, z.string().nullable()),
303882
303898
  new PluginCoordinationType(CoordinationType$1.SEGMENTATION_LAYER, null, z.string().nullable()),
303883
303899
  new PluginCoordinationType(CoordinationType$1.SEGMENTATION_CHANNEL, null, z.string().nullable()),
303884
- new PluginCoordinationType(CoordinationType$1.SPATIAL_TARGET_C, null, z.number().nullable()),
303900
+ new PluginCoordinationType(CoordinationType$1.SPATIAL_TARGET_C, null, z.number().or(z.string()).nullable()),
303885
303901
  new PluginCoordinationType(CoordinationType$1.SPATIAL_TARGET_Z, null, z.number().nullable()),
303886
303902
  new PluginCoordinationType(CoordinationType$1.SPATIAL_TARGET_T, null, z.number().nullable()),
303887
303903
  new PluginCoordinationType(CoordinationType$1.SPATIAL_LAYER_VISIBLE, true, z.boolean()),
@@ -1,4 +1,4 @@
1
- import { g as getDefaultExportFromCjs, R as Raycaster, O as OrthographicCamera, P as PerspectiveCamera, S as Scene, a as PCFSoftShadowMap, N as NoToneMapping, A as ACESFilmicToneMapping, V as Vector2, b as Vector3, L as Layers, T as Texture, c as RGBAFormat, U as UnsignedByteType, W as WebGLRenderer, C as Camera, B as BasicShadowMap, d as PCFShadowMap, e as VSMShadowMap, f as BufferGeometry, M as Material, h as Color, i as Clock, _ as _extends, j as THREE, G as Group, k as Matrix4, l as TrianglesDrawMode, m as TriangleFanDrawMode, n as TriangleStripDrawMode, o as REVISION, p as Loader, q as LoaderUtils, F as FileLoader, r as SpotLight, s as PointLight, D as DirectionalLight, t as MeshBasicMaterial, u as MeshPhysicalMaterial, I as InstancedMesh, v as Object3D, w as TextureLoader, x as ImageBitmapLoader, y as BufferAttribute, z as InterleavedBuffer, E as LinearFilter, H as LinearMipmapLinearFilter, J as RepeatWrapping, K as PointsMaterial, Q as LineBasicMaterial, X as MeshStandardMaterial, Y as DoubleSide, Z as PropertyBinding, $ as SkinnedMesh, a0 as Mesh, a1 as LineSegments, a2 as Line$1, a3 as LineLoop, a4 as Points, a5 as MathUtils, a6 as Skeleton, a7 as InterpolateLinear, a8 as AnimationClip, a9 as Bone, aa as Quaternion, ab as NearestFilter, ac as NearestMipmapNearestFilter, ad as LinearMipmapNearestFilter, ae as NearestMipmapLinearFilter, af as ClampToEdgeWrapping, ag as MirroredRepeatWrapping, ah as InterpolateDiscrete, ai as FrontSide, aj as InterleavedBufferAttribute, ak as VectorKeyframeTrack, al as QuaternionKeyframeTrack, am as NumberKeyframeTrack, an as Box3, ao as Sphere, ap as Interpolant, aq as SphereGeometry, ar as Ray$1, as as Plane, at as EventDispatcher, au as MOUSE, av as TOUCH, aw as Spherical, ax as InstancedBufferGeometry, ay as Float32BufferAttribute, az as InstancedInterleavedBuffer, aA as WireframeGeometry, aB as ShaderMaterial, aC as UniformsUtils, aD as UniformsLib, aE as Vector4, aF as Line3, 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-0d08aaae.js";
1
+ import { g as getDefaultExportFromCjs, R as Raycaster, O as OrthographicCamera, P as PerspectiveCamera, S as Scene, a as PCFSoftShadowMap, N as NoToneMapping, A as ACESFilmicToneMapping, V as Vector2, b as Vector3, L as Layers, T as Texture, c as RGBAFormat, U as UnsignedByteType, W as WebGLRenderer, C as Camera, B as BasicShadowMap, d as PCFShadowMap, e as VSMShadowMap, f as BufferGeometry, M as Material, h as Color, i as Clock, _ as _extends, j as THREE, G as Group, k as Matrix4, l as TrianglesDrawMode, m as TriangleFanDrawMode, n as TriangleStripDrawMode, o as REVISION, p as Loader, q as LoaderUtils, F as FileLoader, r as SpotLight, s as PointLight, D as DirectionalLight, t as MeshBasicMaterial, u as MeshPhysicalMaterial, I as InstancedMesh, v as Object3D, w as TextureLoader, x as ImageBitmapLoader, y as BufferAttribute, z as InterleavedBuffer, E as LinearFilter, H as LinearMipmapLinearFilter, J as RepeatWrapping, K as PointsMaterial, Q as LineBasicMaterial, X as MeshStandardMaterial, Y as DoubleSide, Z as PropertyBinding, $ as SkinnedMesh, a0 as Mesh, a1 as LineSegments, a2 as Line$1, a3 as LineLoop, a4 as Points, a5 as MathUtils, a6 as Skeleton, a7 as InterpolateLinear, a8 as AnimationClip, a9 as Bone, aa as Quaternion, ab as NearestFilter, ac as NearestMipmapNearestFilter, ad as LinearMipmapNearestFilter, ae as NearestMipmapLinearFilter, af as ClampToEdgeWrapping, ag as MirroredRepeatWrapping, ah as InterpolateDiscrete, ai as FrontSide, aj as InterleavedBufferAttribute, ak as VectorKeyframeTrack, al as QuaternionKeyframeTrack, am as NumberKeyframeTrack, an as Box3, ao as Sphere, ap as Interpolant, aq as SphereGeometry, ar as Ray$1, as as Plane, at as EventDispatcher, au as MOUSE, av as TOUCH, aw as Spherical, ax as InstancedBufferGeometry, ay as Float32BufferAttribute, az as InstancedInterleavedBuffer, aA as WireframeGeometry, aB as ShaderMaterial, aC as UniformsUtils, aD as UniformsLib, aE as Vector4, aF as Line3, 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-7122d405.js";
2
2
  import * as React from "react";
3
3
  import React__default, { useReducer, useRef, useDebugValue, useEffect, useLayoutEffect, useState, useMemo, forwardRef } from "react";
4
4
  import "@vitessce/vit-s";
@@ -23800,7 +23800,7 @@ const Text = /* @__PURE__ */ React.forwardRef(({
23800
23800
  const {
23801
23801
  Text: TextMeshImpl,
23802
23802
  preloadFont
23803
- } = suspend(async () => import("./troika-three-text.esm-f60fc675.js"), []);
23803
+ } = suspend(async () => import("./troika-three-text.esm-465ad5ce.js"), []);
23804
23804
  const invalidate2 = useThree(({
23805
23805
  invalidate: invalidate3
23806
23806
  }) => invalidate3);
@@ -27381,7 +27381,7 @@ function MeasureLine(props) {
27381
27381
  })] });
27382
27382
  }
27383
27383
  function GeometryAndMesh(props) {
27384
- const { segmentationGroup, segmentationSettings, segmentationSceneScale, renderingSettings, materialRef, highlightGlom, setObsHighlight } = props;
27384
+ const { segmentationGroup, segmentationSettings, segmentationSceneScale, renderingSettings, materialRef, highlightEntity, setObsHighlight } = props;
27385
27385
  const model = useRef();
27386
27386
  const distanceRef = useRef();
27387
27387
  const rayGrabGroup = useRef();
@@ -27514,7 +27514,7 @@ function GeometryAndMesh(props) {
27514
27514
  2e-3 * renderingSettings.meshScale[2]
27515
27515
  ], ref: materialRef, children: [jsxRuntimeExports.jsx("boxGeometry", { args: renderingSettings.geometrySize }), jsxRuntimeExports.jsx("shaderMaterial", { customProgramCacheKey: () => "1", side: FrontSide, uniforms: renderingSettings.uniforms, needsUpdate: true, transparent: true, vertexShader: renderingSettings.shader.vertexShader, fragmentShader: renderingSettings.shader.fragmentShader })] }) }) : null] }), jsxRuntimeExports.jsx("group", { name: "currentLine", ref: distanceRef, children: showLine ? jsxRuntimeExports.jsx(MeasureLine, { currentLine, scale: 1 / 2e-3 * 0.4 }) : null }), jsxRuntimeExports.jsx("group", { name: "lines", children: lines.map((object) => jsxRuntimeExports.jsx(MeasureLine, { currentLine: object, scale: 1 / 2e-3 * 0.4 })) })] }) : jsxRuntimeExports.jsxs("group", { children: [jsxRuntimeExports.jsxs("group", { children: [(segmentationGroup == null ? void 0 : segmentationGroup.visible) ? jsxRuntimeExports.jsxs("group", { children: [jsxRuntimeExports.jsx("hemisphereLight", { skyColor: 8421504, groundColor: 6316128 }), jsxRuntimeExports.jsx("directionalLight", { color: 16777215, position: [0, -800, 0] }), jsxRuntimeExports.jsx("directionalLight", { color: 16777215, position: [0, 800, 0] }), jsxRuntimeExports.jsx(Bvh, { firstHitOnly: true, children: jsxRuntimeExports.jsx("primitive", { ref: model, object: segmentationGroup, position: [0, 0, 0], onClick: (e) => {
27516
27516
  if (e.object.parent.userData.name === "finalPass") {
27517
- highlightGlom(e.object.name);
27517
+ highlightEntity(e.object.name, e.object.userData.layerScope, e.object.userData.channelScope);
27518
27518
  }
27519
27519
  }, onPointerOver: (e) => {
27520
27520
  setObsHighlight(e.object.name);
@@ -28464,7 +28464,7 @@ function SpatialThree(props) {
28464
28464
  obsSets: []
28465
28465
  });
28466
28466
  const { images, layerScope, channelsVisible, allChannels, channelTargetC, resolution, data, colors, contrastLimits, is3dMode, renderingMode, layerTransparency, xSlice, ySlice, zSlice } = useVolumeSettings(props, volumeSettings, setVolumeSettings, dataReady, setDataReady);
28467
- const { obsSegmentations, onGlomSelected, segmentationLayerCoordination, segmentationChannelCoordination, segmentationChannelScopesByLayer } = props;
28467
+ const { obsSegmentations, onEntitySelected, segmentationLayerCoordination, segmentationChannelCoordination, segmentationChannelScopesByLayer } = props;
28468
28468
  let setObsHighlightFct = () => {
28469
28469
  };
28470
28470
  const setsSave = [];
@@ -28479,7 +28479,7 @@ function SpatialThree(props) {
28479
28479
  sets.tree[0].children.forEach((child) => {
28480
28480
  if (child.name === selectedElement) {
28481
28481
  child.set.forEach(([obsId]) => {
28482
- const info = { name: "", id: "", color: [] };
28482
+ const info = { name: "", id: "", color: [255, 255, 255] };
28483
28483
  info.name = selectedElement;
28484
28484
  info.id = obsId;
28485
28485
  segmentationObsSetLayerProps.obsSetColor.forEach((color) => {
@@ -28517,6 +28517,7 @@ function SpatialThree(props) {
28517
28517
  }
28518
28518
  childElement.name = name;
28519
28519
  childElement.userData.name = name;
28520
+ childElement.userData.layerScope = layerScope;
28520
28521
  childElement.material.transparent = true;
28521
28522
  childElement.material.writeDepthTexture = true;
28522
28523
  childElement.material.depthTest = true;
@@ -28610,6 +28611,7 @@ function SpatialThree(props) {
28610
28611
  }
28611
28612
  }
28612
28613
  segmentationGroup.children[finalGroupIndex].children.forEach((child, childIndex) => {
28614
+ var _a3;
28613
28615
  let { color } = segmentationSettings;
28614
28616
  const id = child.userData.name;
28615
28617
  segmentationSettings.obsSets.forEach((obsSet) => {
@@ -28620,13 +28622,15 @@ function SpatialThree(props) {
28620
28622
  if (segmentationChannelScopesByLayer[layerScope].length > 1) {
28621
28623
  segmentationChannelScopesByLayer[layerScope].forEach((channelScope) => {
28622
28624
  const channelSet = segmentationChannelCoordination[0][layerScope][channelScope];
28623
- if (channelSet.obsType === id) {
28625
+ if (channelSet.spatialTargetC === id) {
28624
28626
  child.material.color.r = channelSet.spatialChannelColor[0] / 255;
28625
28627
  child.material.color.g = channelSet.spatialChannelColor[1] / 255;
28626
28628
  child.material.color.b = channelSet.spatialChannelColor[2] / 255;
28627
28629
  child.material.opacity = channelSet.spatialChannelOpacity;
28628
28630
  child.visible = channelSet.spatialChannelVisible;
28629
28631
  child.material.needsUpdate = true;
28632
+ child.userData.layerScope = layerScope;
28633
+ child.userData.channelScope = channelScope;
28630
28634
  segmentationGroup.children[firstGroupIndex].children[childIndex].material.needsUpdate = true;
28631
28635
  }
28632
28636
  });
@@ -28637,6 +28641,9 @@ function SpatialThree(props) {
28637
28641
  child.material.opacity = segmentationSettings.opacity;
28638
28642
  child.material.visible = segmentationSettings.visible;
28639
28643
  child.material.needsUpdate = true;
28644
+ child.userData.layerScope = layerScope;
28645
+ const firstChannelScope = (_a3 = Object.keys(segmentationChannelCoordination[0][layerScope])) == null ? void 0 : _a3[0];
28646
+ child.userData.channelScope = firstChannelScope;
28640
28647
  }
28641
28648
  });
28642
28649
  }
@@ -28752,7 +28759,7 @@ function SpatialThree(props) {
28752
28759
  segmentationSceneScale,
28753
28760
  renderingSettings,
28754
28761
  materialRef,
28755
- highlightGlom: onGlomSelected,
28762
+ highlightEntity: onEntitySelected,
28756
28763
  setObsHighlight: setObsHighlightFct
28757
28764
  };
28758
28765
  return jsxRuntimeExports.jsxs("group", { children: [jsxRuntimeExports.jsx(Controllers, {}), jsxRuntimeExports.jsx(Hands, {}), jsxRuntimeExports.jsx(HandBbox, {}), jsxRuntimeExports.jsx(HandDecorate, {}), jsxRuntimeExports.jsx(GeometryAndMesh, { ...geometryAndMeshProps }), jsxRuntimeExports.jsx(OrbitControls2, { ref: orbitRef, enableDamping: false, dampingFactor: 0, zoomDampingFactor: 0, smoothZoom: false })] });
package/dist/index.js CHANGED
@@ -1,4 +1,4 @@
1
- import { b3, b1, b4, b2, b0, b5 } from "./index-0d08aaae.js";
1
+ import { b3, b1, b4, b2, b0, b5 } from "./index-7122d405.js";
2
2
  import { useCoordination } from "@vitessce/vit-s";
3
3
  import "react";
4
4
  import "react-dom";
@@ -1,4 +1,4 @@
1
- import { aP as BaseDecoder } from "./index-0d08aaae.js";
1
+ import { aP as BaseDecoder } from "./index-7122d405.js";
2
2
  import "react";
3
3
  import "@vitessce/vit-s";
4
4
  import "react-dom";
@@ -1,5 +1,5 @@
1
1
  import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
2
- import { g as getDefaultExportFromCjs, aP as BaseDecoder, aQ as LercParameters, aR as LercAddCompression } from "./index-0d08aaae.js";
2
+ import { g as getDefaultExportFromCjs, aP as BaseDecoder, aQ as LercParameters, aR as LercAddCompression } from "./index-7122d405.js";
3
3
  import "react";
4
4
  import "@vitessce/vit-s";
5
5
  import "react-dom";
@@ -1,4 +1,4 @@
1
- import { aP as BaseDecoder } from "./index-0d08aaae.js";
1
+ import { aP as BaseDecoder } from "./index-7122d405.js";
2
2
  import "react";
3
3
  import "@vitessce/vit-s";
4
4
  import "react-dom";
@@ -1,4 +1,4 @@
1
- import { aP as BaseDecoder } from "./index-0d08aaae.js";
1
+ import { aP as BaseDecoder } from "./index-7122d405.js";
2
2
  import "react";
3
3
  import "@vitessce/vit-s";
4
4
  import "react-dom";
@@ -1,4 +1,4 @@
1
- import { aP as BaseDecoder } from "./index-0d08aaae.js";
1
+ import { aP as BaseDecoder } from "./index-7122d405.js";
2
2
  import "react";
3
3
  import "@vitessce/vit-s";
4
4
  import "react-dom";
@@ -1,4 +1,4 @@
1
- import { aC as UniformsUtils, aW as MeshDepthMaterial, aX as RGBADepthPacking, aY as MeshDistanceMaterial, aZ as ShaderChunk, T as Texture, E as LinearFilter, ax as InstancedBufferGeometry, ao as Sphere, an as Box3, aH as BackSide, Y as DoubleSide, a_ as InstancedBufferAttribute, V as Vector2, aE as Vector4, h as Color, aJ as Matrix3, a0 as Mesh, ai as FrontSide, a$ as PlaneGeometry, f as BufferGeometry, ay as Float32BufferAttribute, t as MeshBasicMaterial, k as Matrix4, b as Vector3 } from "./index-0d08aaae.js";
1
+ import { aC as UniformsUtils, aW as MeshDepthMaterial, aX as RGBADepthPacking, aY as MeshDistanceMaterial, aZ as ShaderChunk, T as Texture, E as LinearFilter, ax as InstancedBufferGeometry, ao as Sphere, an as Box3, aH as BackSide, Y as DoubleSide, a_ as InstancedBufferAttribute, V as Vector2, aE as Vector4, h as Color, aJ as Matrix3, a0 as Mesh, ai as FrontSide, a$ as PlaneGeometry, f as BufferGeometry, ay as Float32BufferAttribute, t as MeshBasicMaterial, k as Matrix4, b as Vector3 } from "./index-7122d405.js";
2
2
  import "react";
3
3
  import "@vitessce/vit-s";
4
4
  import "react-dom";
@@ -1,4 +1,4 @@
1
- import { aP as BaseDecoder } from "./index-0d08aaae.js";
1
+ import { aP as BaseDecoder } from "./index-7122d405.js";
2
2
  import "react";
3
3
  import "@vitessce/vit-s";
4
4
  import "react-dom";
@@ -1073,5 +1073,5 @@ export declare const baseCoordinationTypes: (PluginCoordinationType<z.ZodNullabl
1073
1073
  color?: number[] | undefined;
1074
1074
  })[];
1075
1075
  })[];
1076
- }>>> | PluginCoordinationType<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>> | PluginCoordinationType<z.ZodNullable<z.ZodEnum<["BlackIsZero", "RGB"]>>> | PluginCoordinationType<z.ZodNullable<z.ZodEnum<["2D", "3D"]>>> | PluginCoordinationType<z.ZodEnum<["maximumIntensityProjection", "additive"]>> | PluginCoordinationType<z.ZodEnum<["vertical", "horizontal"]>>)[];
1076
+ }>>> | PluginCoordinationType<z.ZodNullable<z.ZodUnion<[z.ZodNumber, z.ZodString]>>> | PluginCoordinationType<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>> | PluginCoordinationType<z.ZodNullable<z.ZodEnum<["BlackIsZero", "RGB"]>>> | PluginCoordinationType<z.ZodNullable<z.ZodEnum<["2D", "3D"]>>> | PluginCoordinationType<z.ZodEnum<["maximumIntensityProjection", "additive"]>> | PluginCoordinationType<z.ZodEnum<["vertical", "horizontal"]>>)[];
1077
1077
  //# sourceMappingURL=base-plugins.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"base-plugins.d.ts","sourceRoot":"","sources":["../src/base-plugins.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,CAAC,EA4CF,MAAM,mBAAmB,CAAC;AAmI3B,eAAO,MAAM,aAAa,kBAkBzB,CAAC;AAEF,eAAO,MAAM,aAAa,wDAqEzB,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgB9B,CAAC;AAIF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4WAqLjC,CAAC"}
1
+ {"version":3,"file":"base-plugins.d.ts","sourceRoot":"","sources":["../src/base-plugins.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,CAAC,EA4CF,MAAM,mBAAmB,CAAC;AAmI3B,eAAO,MAAM,aAAa,kBAkBzB,CAAC;AAEF,eAAO,MAAM,aAAa,wDAqEzB,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgB9B,CAAC;AAIF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4bAqLjC,CAAC"}
@@ -235,7 +235,7 @@ export const baseCoordinationTypes = [
235
235
  new PluginCoordinationType(CoordinationType.IMAGE_CHANNEL, null, z.string().nullable()),
236
236
  new PluginCoordinationType(CoordinationType.SEGMENTATION_LAYER, null, z.string().nullable()),
237
237
  new PluginCoordinationType(CoordinationType.SEGMENTATION_CHANNEL, null, z.string().nullable()),
238
- new PluginCoordinationType(CoordinationType.SPATIAL_TARGET_C, null, z.number().nullable()),
238
+ new PluginCoordinationType(CoordinationType.SPATIAL_TARGET_C, null, z.number().or(z.string()).nullable()),
239
239
  new PluginCoordinationType(CoordinationType.SPATIAL_TARGET_Z, null, z.number().nullable()),
240
240
  new PluginCoordinationType(CoordinationType.SPATIAL_TARGET_T, null, z.number().nullable()),
241
241
  new PluginCoordinationType(CoordinationType.SPATIAL_LAYER_VISIBLE, true, z.boolean()),
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@vitessce/all",
3
- "version": "3.4.2",
3
+ "version": "3.4.4",
4
4
  "author": "Gehlenborg Lab",
5
5
  "homepage": "http://vitessce.io",
6
6
  "repository": {
@@ -18,29 +18,29 @@
18
18
  "dependencies": {
19
19
  "@material-ui/core": "~4.12.3",
20
20
  "zod": "^3.21.4",
21
- "@vitessce/constants-internal": "3.4.2",
22
- "@vitessce/csv": "3.4.2",
23
- "@vitessce/description": "3.4.2",
24
- "@vitessce/feature-list": "3.4.2",
25
- "@vitessce/genomic-profiles": "3.4.2",
26
- "@vitessce/glb": "3.4.2",
27
- "@vitessce/heatmap": "3.4.2",
28
- "@vitessce/json": "3.4.2",
29
- "@vitessce/layer-controller": "3.4.2",
30
- "@vitessce/layer-controller-beta": "3.4.2",
31
- "@vitessce/obs-sets-manager": "3.4.2",
32
- "@vitessce/ome-tiff": "3.4.2",
33
- "@vitessce/plugins": "3.4.2",
34
- "@vitessce/scatterplot-embedding": "3.4.2",
35
- "@vitessce/schemas": "3.4.2",
36
- "@vitessce/spatial-beta": "3.4.2",
37
- "@vitessce/spatial": "3.4.2",
38
- "@vitessce/statistical-plots": "3.4.2",
39
- "@vitessce/scatterplot-gating": "3.4.2",
40
- "@vitessce/status": "3.4.2",
41
- "@vitessce/vit-s": "3.4.2",
42
- "@vitessce/zarr": "3.4.2",
43
- "@vitessce/spatial-three": "3.4.2"
21
+ "@vitessce/constants-internal": "3.4.4",
22
+ "@vitessce/csv": "3.4.4",
23
+ "@vitessce/description": "3.4.4",
24
+ "@vitessce/feature-list": "3.4.4",
25
+ "@vitessce/genomic-profiles": "3.4.4",
26
+ "@vitessce/heatmap": "3.4.4",
27
+ "@vitessce/layer-controller": "3.4.4",
28
+ "@vitessce/glb": "3.4.4",
29
+ "@vitessce/json": "3.4.4",
30
+ "@vitessce/layer-controller-beta": "3.4.4",
31
+ "@vitessce/obs-sets-manager": "3.4.4",
32
+ "@vitessce/ome-tiff": "3.4.4",
33
+ "@vitessce/plugins": "3.4.4",
34
+ "@vitessce/scatterplot-embedding": "3.4.4",
35
+ "@vitessce/scatterplot-gating": "3.4.4",
36
+ "@vitessce/spatial": "3.4.4",
37
+ "@vitessce/spatial-beta": "3.4.4",
38
+ "@vitessce/schemas": "3.4.4",
39
+ "@vitessce/statistical-plots": "3.4.4",
40
+ "@vitessce/status": "3.4.4",
41
+ "@vitessce/vit-s": "3.4.4",
42
+ "@vitessce/zarr": "3.4.4",
43
+ "@vitessce/spatial-three": "3.4.4"
44
44
  },
45
45
  "devDependencies": {
46
46
  "@types/react": "^18.0.28",
@@ -450,7 +450,7 @@ export const baseCoordinationTypes = [
450
450
  new PluginCoordinationType(CoordinationType.IMAGE_CHANNEL, null, z.string().nullable()),
451
451
  new PluginCoordinationType(CoordinationType.SEGMENTATION_LAYER, null, z.string().nullable()),
452
452
  new PluginCoordinationType(CoordinationType.SEGMENTATION_CHANNEL, null, z.string().nullable()),
453
- new PluginCoordinationType(CoordinationType.SPATIAL_TARGET_C, null, z.number().nullable()),
453
+ new PluginCoordinationType(CoordinationType.SPATIAL_TARGET_C, null, z.number().or(z.string()).nullable()),
454
454
  new PluginCoordinationType(CoordinationType.SPATIAL_TARGET_Z, null, z.number().nullable()),
455
455
  new PluginCoordinationType(CoordinationType.SPATIAL_TARGET_T, null, z.number().nullable()),
456
456
  new PluginCoordinationType(CoordinationType.SPATIAL_LAYER_VISIBLE, true, z.boolean()),