@vitessce/spatial-utils 3.5.5 → 3.5.7

package/dist/{deflate-72995733.js → deflate-fb583d27.js}

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

package/dist/{index-ac1a35fe.js → index-6813c045.js}

@@ -9003,7 +9003,7 @@ function clone$6(obj) {
   Decimal2.floor = floor$1;
   Decimal2.hypot = hypot;
   Decimal2.ln = ln;
-  Decimal2.log = log$5;
+  Decimal2.log = log$6;
   Decimal2.log10 = log10;
   Decimal2.log2 = log2$1;
   Decimal2.max = max$2;
@@ -9068,7 +9068,7 @@ function isDecimalInstance(obj) {
 function ln(x2) {
   return new this(x2).ln();
 }
-function log$5(x2, y2) {
+function log$6(x2, y2) {
   return new this(x2).log(y2);
 }
 function log2$1(x2) {
@@ -19995,6 +19995,258 @@ var pluralizeExports = pluralize.exports;
 const plur = /* @__PURE__ */ getDefaultExportFromCjs(pluralizeExports);
 plur.addPluralRule("glomerulus", "glomeruli");
 plur.addPluralRule("interstitium", "interstitia");
+var loglevel = { exports: {} };
+(function(module2) {
+  (function(root2, definition) {
+    if (module2.exports) {
+      module2.exports = definition();
+    } else {
+      root2.log = definition();
+    }
+  })(commonjsGlobal, function() {
+    var noop2 = function() {
+    };
+    var undefinedType = "undefined";
+    var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
+    var logMethods = [
+      "trace",
+      "debug",
+      "info",
+      "warn",
+      "error"
+    ];
+    var _loggersByName = {};
+    var defaultLogger = null;
+    function bindMethod(obj, methodName) {
+      var method = obj[methodName];
+      if (typeof method.bind === "function") {
+        return method.bind(obj);
+      } else {
+        try {
+          return Function.prototype.bind.call(method, obj);
+        } catch (e2) {
+          return function() {
+            return Function.prototype.apply.apply(method, [obj, arguments]);
+          };
+        }
+      }
+    }
+    function traceForIE() {
+      if (console.log) {
+        if (console.log.apply) {
+          console.log.apply(console, arguments);
+        } else {
+          Function.prototype.apply.apply(console.log, [console, arguments]);
+        }
+      }
+      if (console.trace)
+        console.trace();
+    }
+    function realMethod(methodName) {
+      if (methodName === "debug") {
+        methodName = "log";
+      }
+      if (typeof console === undefinedType) {
+        return false;
+      } else if (methodName === "trace" && isIE) {
+        return traceForIE;
+      } else if (console[methodName] !== void 0) {
+        return bindMethod(console, methodName);
+      } else if (console.log !== void 0) {
+        return bindMethod(console, "log");
+      } else {
+        return noop2;
+      }
+    }
+    function replaceLoggingMethods() {
+      var level = this.getLevel();
+      for (var i2 = 0; i2 < logMethods.length; i2++) {
+        var methodName = logMethods[i2];
+        this[methodName] = i2 < level ? noop2 : this.methodFactory(methodName, level, this.name);
+      }
+      this.log = this.debug;
+      if (typeof console === undefinedType && level < this.levels.SILENT) {
+        return "No console available for logging";
+      }
+    }
+    function enableLoggingWhenConsoleArrives(methodName) {
+      return function() {
+        if (typeof console !== undefinedType) {
+          replaceLoggingMethods.call(this);
+          this[methodName].apply(this, arguments);
+        }
+      };
+    }
+    function defaultMethodFactory(methodName, _level, _loggerName) {
+      return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
+    }
+    function Logger(name2, factory2) {
+      var self2 = this;
+      var inheritedLevel;
+      var defaultLevel;
+      var userLevel;
+      var storageKey = "loglevel";
+      if (typeof name2 === "string") {
+        storageKey += ":" + name2;
+      } else if (typeof name2 === "symbol") {
+        storageKey = void 0;
+      }
+      function persistLevelIfPossible(levelNum) {
+        var levelName = (logMethods[levelNum] || "silent").toUpperCase();
+        if (typeof window === undefinedType || !storageKey)
+          return;
+        try {
+          window.localStorage[storageKey] = levelName;
+          return;
+        } catch (ignore) {
+        }
+        try {
+          window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
+        } catch (ignore) {
+        }
+      }
+      function getPersistedLevel() {
+        var storedLevel;
+        if (typeof window === undefinedType || !storageKey)
+          return;
+        try {
+          storedLevel = window.localStorage[storageKey];
+        } catch (ignore) {
+        }
+        if (typeof storedLevel === undefinedType) {
+          try {
+            var cookie = window.document.cookie;
+            var cookieName = encodeURIComponent(storageKey);
+            var location = cookie.indexOf(cookieName + "=");
+            if (location !== -1) {
+              storedLevel = /^([^;]+)/.exec(
+                cookie.slice(location + cookieName.length + 1)
+              )[1];
+            }
+          } catch (ignore) {
+          }
+        }
+        if (self2.levels[storedLevel] === void 0) {
+          storedLevel = void 0;
+        }
+        return storedLevel;
+      }
+      function clearPersistedLevel() {
+        if (typeof window === undefinedType || !storageKey)
+          return;
+        try {
+          window.localStorage.removeItem(storageKey);
+        } catch (ignore) {
+        }
+        try {
+          window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+        } catch (ignore) {
+        }
+      }
+      function normalizeLevel(input) {
+        var level = input;
+        if (typeof level === "string" && self2.levels[level.toUpperCase()] !== void 0) {
+          level = self2.levels[level.toUpperCase()];
+        }
+        if (typeof level === "number" && level >= 0 && level <= self2.levels.SILENT) {
+          return level;
+        } else {
+          throw new TypeError("log.setLevel() called with invalid level: " + input);
+        }
+      }
+      self2.name = name2;
+      self2.levels = {
+        "TRACE": 0,
+        "DEBUG": 1,
+        "INFO": 2,
+        "WARN": 3,
+        "ERROR": 4,
+        "SILENT": 5
+      };
+      self2.methodFactory = factory2 || defaultMethodFactory;
+      self2.getLevel = function() {
+        if (userLevel != null) {
+          return userLevel;
+        } else if (defaultLevel != null) {
+          return defaultLevel;
+        } else {
+          return inheritedLevel;
+        }
+      };
+      self2.setLevel = function(level, persist) {
+        userLevel = normalizeLevel(level);
+        if (persist !== false) {
+          persistLevelIfPossible(userLevel);
+        }
+        return replaceLoggingMethods.call(self2);
+      };
+      self2.setDefaultLevel = function(level) {
+        defaultLevel = normalizeLevel(level);
+        if (!getPersistedLevel()) {
+          self2.setLevel(level, false);
+        }
+      };
+      self2.resetLevel = function() {
+        userLevel = null;
+        clearPersistedLevel();
+        replaceLoggingMethods.call(self2);
+      };
+      self2.enableAll = function(persist) {
+        self2.setLevel(self2.levels.TRACE, persist);
+      };
+      self2.disableAll = function(persist) {
+        self2.setLevel(self2.levels.SILENT, persist);
+      };
+      self2.rebuild = function() {
+        if (defaultLogger !== self2) {
+          inheritedLevel = normalizeLevel(defaultLogger.getLevel());
+        }
+        replaceLoggingMethods.call(self2);
+        if (defaultLogger === self2) {
+          for (var childName in _loggersByName) {
+            _loggersByName[childName].rebuild();
+          }
+        }
+      };
+      inheritedLevel = normalizeLevel(
+        defaultLogger ? defaultLogger.getLevel() : "WARN"
+      );
+      var initialLevel = getPersistedLevel();
+      if (initialLevel != null) {
+        userLevel = normalizeLevel(initialLevel);
+      }
+      replaceLoggingMethods.call(self2);
+    }
+    defaultLogger = new Logger();
+    defaultLogger.getLogger = function getLogger(name2) {
+      if (typeof name2 !== "symbol" && typeof name2 !== "string" || name2 === "") {
+        throw new TypeError("You must supply a name when creating a logger.");
+      }
+      var logger = _loggersByName[name2];
+      if (!logger) {
+        logger = _loggersByName[name2] = new Logger(
+          name2,
+          defaultLogger.methodFactory
+        );
+      }
+      return logger;
+    };
+    var _log = typeof window !== undefinedType ? window.log : void 0;
+    defaultLogger.noConflict = function() {
+      if (typeof window !== undefinedType && window.log === defaultLogger) {
+        window.log = _log;
+      }
+      return defaultLogger;
+    };
+    defaultLogger.getLoggers = function getLoggers2() {
+      return _loggersByName;
+    };
+    defaultLogger["default"] = defaultLogger;
+    return defaultLogger;
+  });
+})(loglevel);
+var loglevelExports = loglevel.exports;
+const log$5 = /* @__PURE__ */ getDefaultExportFromCjs(loglevelExports);
 const VIEWER_PALETTE = [
   [0, 0, 255],
   [0, 255, 0],
@@ -119259,16 +119511,16 @@ function addDecoder(cases, importFn) {
   }
   cases.forEach((c) => registry$2.set(c, importFn));
 }
-addDecoder([void 0, 1], () => import("./raw-50921dfc.js").then((m) => m.default));
-addDecoder(5, () => import("./lzw-04aab5f2.js").then((m) => m.default));
+addDecoder([void 0, 1], () => import("./raw-f26a9f8d.js").then((m) => m.default));
+addDecoder(5, () => import("./lzw-5a827465.js").then((m) => m.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-defa9e7c.js").then((m) => m.default));
-addDecoder([8, 32946], () => import("./deflate-72995733.js").then((m) => m.default));
-addDecoder(32773, () => import("./packbits-3b8eecdb.js").then((m) => m.default));
-addDecoder(34887, () => import("./lerc-016c6bf9.js").then((m) => m.default));
-addDecoder(50001, () => import("./webimage-98d89993.js").then((m) => m.default));
+addDecoder(7, () => import("./jpeg-1cb04461.js").then((m) => m.default));
+addDecoder([8, 32946], () => import("./deflate-fb583d27.js").then((m) => m.default));
+addDecoder(32773, () => import("./packbits-9a095897.js").then((m) => m.default));
+addDecoder(34887, () => import("./lerc-36bff55b.js").then((m) => m.default));
+addDecoder(50001, () => import("./webimage-54f03dd3.js").then((m) => m.default));
 function decodeRowAcc(row, stride) {
   let length2 = row.length - stride;
   let offset = 0;
@@ -133193,10 +133445,10 @@ function multiSetsToTextureData(multiFeatureValues, multiMatrixObsIndex, setColo
   const valueTexHeight = Math.max(2, Math.ceil(totalValuesLength / texSize));
   const colorTexHeight = Math.max(2, Math.ceil(totalColorsLength / texSize));
   if (valueTexHeight > texSize) {
-    console.error("Error: length of concatenated quantitative feature values larger than maximum texture size");
+    log$5.error("Error: length of concatenated quantitative feature values larger than maximum texture size");
   }
   if (colorTexHeight > texSize) {
-    console.error("Error: length of concatenated quantitative feature values larger than maximum texture size");
+    log$5.error("Error: length of concatenated quantitative feature values larger than maximum texture size");
   }
   const totalData = new Uint8Array(texSize * valueTexHeight);
   const totalColors = new Uint8Array(texSize * colorTexHeight);
@@ -133994,7 +134246,7 @@ function normalizeCoordinateTransformations(coordinateTransformations, datasets)
         if (type2 === "sequence") {
           return normalizeCoordinateTransformations(transform2.transformations, datasets);
         }
-        console.warn(`Coordinate transformation type "${type2}" is not supported.`);
+        log$5.warn(`Coordinate transformation type "${type2}" is not supported.`);
       }
       return transform2;
     });

package/dist/index.js

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

package/dist/{jpeg-defa9e7c.js → jpeg-1cb04461.js}

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

package/dist/{lerc-016c6bf9.js → lerc-36bff55b.js}

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

package/dist/{lzw-04aab5f2.js → lzw-5a827465.js}

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

package/dist/{packbits-3b8eecdb.js → packbits-9a095897.js}

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

package/dist/{raw-50921dfc.js → raw-f26a9f8d.js}

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

package/dist/{webimage-98d89993.js → webimage-54f03dd3.js}

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

package/dist-tsc/spatial.js

@@ -3,6 +3,7 @@ import { Matrix4 } from 'math.gl';
 import { divide, compare, unit } from 'mathjs';
 import { VIEWER_PALETTE } from '@vitessce/utils';
 import { GLOBAL_LABELS, DEFAULT_RASTER_LAYER_PROPS } from '@vitessce/constants-internal';
+import { log } from '@vitessce/globals';
 import { getMultiSelectionStats } from './layer-controller.js';
 /**
  * Get a representative PixelSource from a loader object returned from
@@ -448,7 +449,7 @@ export function normalizeCoordinateTransformations(coordinateTransformations, da
                 if (type === 'sequence') {
                     return normalizeCoordinateTransformations(transform.transformations, datasets);
                 }
-                console.warn(`Coordinate transformation type "${type}" is not supported.`);
+                log.warn(`Coordinate transformation type "${type}" is not supported.`);
             }
             // Assume it was already an old-style (NGFF v0.4) coordinate transformation.
             return transform;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/spatial-utils",
-  "version": "3.5.5",
+  "version": "3.5.7",
   "author": "HIDIVE Lab at HMS",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -20,10 +20,11 @@
     "zarrita": "0.4.0-next.16",
     "math.gl": "^3.5.6",
     "mathjs": "^9.2.0",
-    "@vitessce/gl": "3.5.5",
-    "@vitessce/utils": "3.5.5",
-    "@vitessce/zarr-utils": "3.5.5",
-    "@vitessce/constants-internal": "3.5.5"
+    "@vitessce/gl": "3.5.7",
+    "@vitessce/utils": "3.5.7",
+    "@vitessce/constants-internal": "3.5.7",
+    "@vitessce/globals": "3.5.7",
+    "@vitessce/zarr-utils": "3.5.7"
   },
   "scripts": {
     "bundle": "pnpm exec vite build -c ../../../scripts/vite.config.js",

package/src/spatial.js

@@ -3,8 +3,8 @@ import { Matrix4 } from 'math.gl';
 import { divide, compare, unit } from 'mathjs';
 import { VIEWER_PALETTE } from '@vitessce/utils';
 import { GLOBAL_LABELS, DEFAULT_RASTER_LAYER_PROPS } from '@vitessce/constants-internal';
+import { log } from '@vitessce/globals';
 import { getMultiSelectionStats } from './layer-controller.js';
-
 /**
  * Get a representative PixelSource from a loader object returned from
  * the Vitessce imaging loaders
@@ -500,7 +500,7 @@ export function normalizeCoordinateTransformations(coordinateTransformations, da
         if (type === 'sequence') {
           return normalizeCoordinateTransformations(transform.transformations, datasets);
         }
-        console.warn(`Coordinate transformation type "${type}" is not supported.`);
+        log.warn(`Coordinate transformation type "${type}" is not supported.`);
       }
       // Assume it was already an old-style (NGFF v0.4) coordinate transformation.
       return transform;