@aics/vole-app 2.15.0 → 3.1.1

package/es/aics-image-viewer/shared/utils/controlPointsToLut.js

@@ -1,20 +1,30 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
 function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-import { Lut, remapControlPoints } from "@aics/vole-core";
+import { Lut } from "@aics/vole-core";
 import { LUT_MAX_PERCENTILE, LUT_MIN_PERCENTILE, TFEDITOR_DEFAULT_COLOR, TFEDITOR_MAX_BIN } from "../constants";
 import { findFirstChannelMatch } from "./viewerChannelSettings";
 
-// @param {Object[]} controlPoints - array of {x:number, opacity:number, color:string}
-// @return {Uint8Array} array of length 256*4 representing the rgba values of the gradient
-export function controlPointsToLut(controlPoints) {
+/**
+ * @param {Object[]} controlPoints - array of `{x:number, opacity:number,
+ * color:string}`, where `x` is a histogram bin index.
+ * @returns {Uint8Array} array of length 256*4 representing the rgba values of
+ * the gradient
+ */
+export function binIndexedControlPointsToLut(controlPoints) {
   var lut = new Lut().createFromControlPoints(controlPoints);
   return lut;
 }
@@ -77,19 +87,25 @@ function parseLutValue(value, histogram) {
  * ```
  */
 export function parseLutFromSettings(histogram, initSettings) {
+  var _initSettings$intensi, _initSettings$intensi2;
   // TODO: Consider minimizing the types/classes this function is interacting
   // with, since it is only using `initSettings.lut` and the returned Lut is a
   // wrapper around the control point array, e.g.
   // `parseControlPointsFromLutParam(histogram: Histogram, lutParam: [string,
   // string] | undefined): ControlPoint[] | undefined`
-  if (initSettings.lut === undefined || initSettings.lut.length !== 2) {
+
+  // There are two possible locations for the LUT settings, due to legacy
+  // reasons. `initSettings.lut` is deprecated in favor of
+  // `initSettings.intensity.lut`.
+  var settingsLut = (_initSettings$intensi = (_initSettings$intensi2 = initSettings.intensity) === null || _initSettings$intensi2 === void 0 ? void 0 : _initSettings$intensi2.lut) !== null && _initSettings$intensi !== void 0 ? _initSettings$intensi : initSettings.lut;
+  if (settingsLut === undefined || settingsLut.length !== 2) {
     return undefined;
   }
   var lutValues;
-  if (initSettings.lut[0] === "autoij" || initSettings.lut[1] === "autoij") {
+  if (settingsLut[0] === "autoij" || settingsLut[1] === "autoij") {
     lutValues = histogram.findAutoIJBins();
   } else {
-    lutValues = [parseLutValue(initSettings.lut[0], histogram), parseLutValue(initSettings.lut[1], histogram)];
+    lutValues = [parseLutValue(settingsLut[0], histogram), parseLutValue(settingsLut[1], histogram)];
   }
   if (!Number.isFinite(lutValues[0]) || !Number.isFinite(lutValues[1])) {
     return undefined;
@@ -128,7 +144,7 @@ export function parseLutFromSettings(histogram, initSettings) {
  * to the volume; otherwise, the ramp will be applied.
  */
 export function initializeLut(aimg, channelIndex, channelSettings) {
-  var _initSettings$control;
+  var _initSettings$intensi3, _initSettings$intensi4;
   var histogram = aimg.getHistogram(channelIndex);
   var defaultLut = getDefaultLut(histogram);
   var ramp = [];
@@ -137,15 +153,42 @@ export function initializeLut(aimg, channelIndex, channelSettings) {
   var name = aimg.channelNames[channelIndex];
   var initSettings = channelSettings && findFirstChannelMatch(name, channelIndex, channelSettings);
 
-  // Attempt to load a LUT from the settings, which will be used to initialize the control points and ramp
-  if (initSettings && initSettings.lut) {
+  // Attempt to load a LUT from the settings, which will be used as a fallback
+  // to initialize the control points and ramp.
+  if (initSettings) {
     var _parseLutFromSettings;
     lut = (_parseLutFromSettings = parseLutFromSettings(histogram, initSettings)) !== null && _parseLutFromSettings !== void 0 ? _parseLutFromSettings : defaultLut;
   }
-  // Initialize the control points + ramp using the LUT.
-  // Optionally, override the LUT's control points with the provided control points and/or ramp.
-  controlPoints = (_initSettings$control = initSettings === null || initSettings === void 0 ? void 0 : initSettings.controlPoints) !== null && _initSettings$control !== void 0 ? _initSettings$control : _toConsumableArray(lut.controlPoints);
-  ramp = initSettings !== null && initSettings !== void 0 && initSettings.ramp ? rampToControlPoints(initSettings.ramp) : _toConsumableArray(lut.controlPoints);
+
+  // Use raw intensity values for control points or ramp if provided in the
+  // settings. Otherwise, get default values from the LUT by remapping
+  // from histogram bin indices.
+  if (initSettings !== null && initSettings !== void 0 && (_initSettings$intensi3 = initSettings.intensity) !== null && _initSettings$intensi3 !== void 0 && _initSettings$intensi3.controlPoints) {
+    // Raw intensity values can be used directly.
+    controlPoints = initSettings.intensity.controlPoints;
+  } else {
+    var _initSettings$control;
+    // No provided value; use histogram to convert from bin index to raw
+    // intensity values.
+    var binIndexedControlPoints = (_initSettings$control = initSettings === null || initSettings === void 0 ? void 0 : initSettings.controlPoints) !== null && _initSettings$control !== void 0 ? _initSettings$control : _toConsumableArray(lut.controlPoints);
+    controlPoints = binIndexedControlPoints.map(function (cp) {
+      return _objectSpread(_objectSpread({}, cp), {}, {
+        x: histogram.getValueFromBinIndex(cp.x)
+      });
+    });
+  }
+
+  // Initialize the ramp
+  if (initSettings !== null && initSettings !== void 0 && (_initSettings$intensi4 = initSettings.intensity) !== null && _initSettings$intensi4 !== void 0 && _initSettings$intensi4.ramp) {
+    ramp = rampToControlPoints(initSettings.intensity.ramp);
+  } else {
+    var binIndexedRamp = initSettings !== null && initSettings !== void 0 && initSettings.ramp ? rampToControlPoints(initSettings.ramp) : _toConsumableArray(lut.controlPoints);
+    ramp = binIndexedRamp.map(function (cp) {
+      return _objectSpread(_objectSpread({}, cp), {}, {
+        x: histogram.getValueFromBinIndex(cp.x)
+      });
+    });
+  }
 
   // Apply whatever lut is currently visible
   var visibleLut;
@@ -198,14 +241,4 @@ export function rampToControlPoints(_ref) {
     opacity: 1,
     color: TFEDITOR_DEFAULT_COLOR
   }];
-}
-
-/** Remaps an array of control points from an old range (as a 2-tuple) to a new one (extracted from a `Channel`) */
-export function remapControlPointsForChannel(controlPoints, oldRange, _ref3) {
-  var rawMin = _ref3.rawMin,
-    rawMax = _ref3.rawMax;
-  if (oldRange === undefined) {
-    return controlPoints;
-  }
-  return remapControlPoints(controlPoints, oldRange[0], oldRange[1], rawMin, rawMax);
 }

package/es/aics-image-viewer/shared/utils/sceneStore.js

@@ -68,7 +68,8 @@ var SceneStore = /*#__PURE__*/function () {
   }, {
     key: "loadScene",
     value: function () {
-      var _loadScene = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(scene, image, loadSpec, onChannelLoaded) {
+      var _loadScene = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(scene, image, loadSpec, options) {
+        var _options$onCreateScen;
         var loader, spec;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
@@ -83,8 +84,9 @@ var SceneStore = /*#__PURE__*/function () {
               return loader.createImageInfo(spec);
             case 7:
               image.imageInfo.imageInfo = _context2.sent.imageInfo;
-              loader.loadVolumeData(image, spec, onChannelLoaded);
-            case 9:
+              options === null || options === void 0 || (_options$onCreateScen = options.onCreateScene) === null || _options$onCreateScen === void 0 || _options$onCreateScen.call(options, image, scene);
+              loader.loadVolumeData(image, spec, options === null || options === void 0 ? void 0 : options.onChannelLoaded);
+            case 10:
             case "end":
               return _context2.stop();
           }

package/es/aics-image-viewer/shared/utils/storage.js

@@ -0,0 +1,238 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { mapKeys, mapValues } from "lodash";
+var QUEUE_KEY = "GLOBAL_ENTRY_QUEUE";
+var StorageEntryType = /*#__PURE__*/function (StorageEntryType) {
+  StorageEntryType["Scenes"] = "scenes";
+  StorageEntryType["Meta"] = "meta";
+  return StorageEntryType;
+}(StorageEntryType || {});
+var MAX_ENTRIES = {
+  scenes: 25,
+  meta: 1000
+};
+var sanitizeStorageKey = function sanitizeStorageKey(key) {
+  return key.includes(",") ? encodeURIComponent(key) : key;
+};
+
+/** `window.localStorage.setItem`, but returns `false` on quota exceeded instead of erroring */
+function safeSetItem(key, value) {
+  try {
+    window.localStorage.setItem(key, value);
+    return true;
+  } catch (e) {
+    // `setItem` throws a `QuotaExceededError` when the browser won't let us put any more data in local storage
+    if (e instanceof DOMException && e.name === "QuotaExceededError") {
+      return false;
+    }
+    throw e;
+  }
+}
+
+/**
+ * Wrapper for `window.localStorage.setItem` that accepts a `queue` of evictable storage keys, and attempts to safely
+ * handle exceeding the storage quota by removing items off the back of the `queue` until space is available.
+ *
+ * Also, unlike `setItem`, this function can accept `value`s of type `string[]`. This allows `queue` to also be passed
+ * into `value`, so that it can be written to storage *after* picking up any evictions that are made during the write.
+ *
+ * Returns `false` if `value` could not fit into storage even after removing everything from `queue`, `true` otherwise.
+ */
+function setStorageItem(key, value, queue) {
+  var removedItems = [];
+  while (!safeSetItem(key, Array.isArray(value) ? value.join(",") : value)) {
+    // can't fit `value` in the store; remove something off the back of `queue` and try again
+    var evictKey = queue.shift();
+    if (evictKey === undefined) {
+      // nothing left to remove means `value` is larger than the entire store
+      // give up on inserting it and try to put everything we removed back
+      var _iterator = _createForOfIteratorHelper(removedItems),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            _key = _step$value[0],
+            _value = _step$value[1];
+          if (safeSetItem(_key, _value)) {
+            queue.unshift(_key);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return false;
+    }
+    var removedValue = window.localStorage.getItem(evictKey);
+    if (removedValue !== null) {
+      removedItems.push([evictKey, removedValue]);
+      window.localStorage.removeItem(evictKey);
+    }
+  }
+  return true;
+}
+var getStorageQueue = function getStorageQueue() {
+  var _window$localStorage$, _window$localStorage$2;
+  return (_window$localStorage$ = (_window$localStorage$2 = window.localStorage.getItem(QUEUE_KEY)) === null || _window$localStorage$2 === void 0 ? void 0 : _window$localStorage$2.split(",")) !== null && _window$localStorage$ !== void 0 ? _window$localStorage$ : [];
+};
+/** If this function returns `false`, something serious has gone wrong and using local storage is likely impossible. */
+var setStorageQueue = function setStorageQueue(queue) {
+  return setStorageItem(QUEUE_KEY, queue, queue);
+};
+
+/**
+ * Writes a bundle of `entries` to local storage, all with an optional `entryType` for categorizing the data.
+ *
+ * Entries written with this function are tracked like a least-recently-used cache, and evicted when either:
+ * - the size of local storage exceeds the browser's quota
+ * - the number of entries of type `entryType` exceeds the maximum for that type
+ *
+ * Returns `true` if all entries fit in storage, or `false` if some did not.
+ */
+function writeStorage(entries, entryType) {
+  var prevQueue = getStorageQueue();
+  var typePrefix = entryType ? "".concat(entryType, "@") : "";
+  var escapedEntries = mapKeys(entries, function (_, key) {
+    return sanitizeStorageKey(key);
+  });
+
+  // filter keys we're currently inserting out of the queue (to be re-inserted at the front)
+  var index = 0;
+  var thisTypeIndexes = [];
+  var queue = prevQueue.filter(function (k) {
+    if (k.startsWith(typePrefix)) {
+      if (k.slice(typePrefix.length) in escapedEntries) {
+        return false;
+      } else if (entryType !== undefined) {
+        // start saving the location of entries of this type, for enforcing the maximum entry count below
+        thisTypeIndexes.push(index);
+      }
+    }
+    index += 1;
+    return true;
+  });
+
+  // push new keys onto the end
+  for (var _i = 0, _Object$keys = Object.keys(escapedEntries); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    thisTypeIndexes.push(queue.length);
+    queue.push(typePrefix + key);
+  }
+
+  // enforce the maximum number of entries for this type (e.g. no more than 25 of type "scenes")
+  if (entryType !== undefined) {
+    var evictIndexes = thisTypeIndexes.slice(0, -MAX_ENTRIES[entryType]);
+    var _iterator2 = _createForOfIteratorHelper(evictIndexes.reverse()),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _index = _step2.value;
+        var _queue$splice = queue.splice(_index, 1),
+          _queue$splice2 = _slicedToArray(_queue$splice, 1),
+          evictKey = _queue$splice2[0];
+        window.localStorage.removeItem(evictKey);
+        delete escapedEntries[evictKey.slice(typePrefix.length)];
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+
+  // write the new entries
+  var entryList = Object.entries(escapedEntries);
+  var firstKey = entryList.length < 2 ? undefined : typePrefix + entryList[0][0];
+  var allEntriesFit = true;
+  for (var _i2 = 0, _Object$entries = Object.entries(escapedEntries); _i2 < _Object$entries.length; _i2++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i2], 2),
+      _key2 = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    var entryFits = setStorageItem(typePrefix + _key2, value, queue);
+    allEntriesFit = allEntriesFit && entryFits;
+  }
+
+  // TODO if the queue somehow doesn't fit, it's a much more serious problem than an individual entry.
+  //   Should that be communicated in the return type?
+  var queueFit = setStorageQueue(queue);
+  return allEntriesFit && queueFit && (firstKey === undefined || window.localStorage.getItem(firstKey) !== null);
+}
+
+/**
+ * Writes a bundle of metadata records keyed by image URL to local storage.
+ *
+ * Returns `true` if all records fit into local storage, or `false` if at least one did not.
+ */
+export function writeMetadata(meta) {
+  var stringMeta = mapValues(meta, function (metaVal) {
+    return JSON.stringify(metaVal);
+  });
+  return writeStorage(stringMeta, StorageEntryType.Meta);
+}
+
+/**
+ * Writes a scene `url` to local storage at the given `key`.
+ *
+ * Returns `false` if the entry did not fit in local storage, or `true` if it did.
+ */
+export function writeScenes(key, url) {
+  return writeStorage(_defineProperty({}, sanitizeStorageKey(key), url), StorageEntryType.Scenes);
+}
+export function readStoredMetadata(scenes) {
+  var skipCacheUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var keySet = new Set();
+  var result = scenes.map(function (scene) {
+    if (Array.isArray(scene)) {
+      // can't handle multi-source scenes (yet)
+      return undefined;
+    }
+    var globalKey = "".concat(StorageEntryType.Meta, "@").concat(sanitizeStorageKey(scene));
+    var meta = window.localStorage.getItem(globalKey);
+    if (meta === null) {
+      return undefined;
+    }
+    keySet.add(globalKey);
+    return JSON.parse(meta);
+  });
+  if (keySet.size > 0 && !skipCacheUpdate) {
+    var prevQueue = getStorageQueue();
+    var queue = prevQueue.filter(function (key) {
+      return !keySet.has(key);
+    });
+    queue.push.apply(queue, _toConsumableArray(keySet));
+    setStorageQueue(queue);
+  }
+  return result;
+}
+export function readStoredScenes(key) {
+  var skipCacheUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var globalKey = "".concat(StorageEntryType.Scenes, "@").concat(sanitizeStorageKey(key));
+  var result = window.localStorage.getItem(globalKey);
+  if (result === null) {
+    return undefined;
+  }
+  if (!skipCacheUpdate) {
+    var queue = getStorageQueue();
+    var entryIndex = queue.indexOf(globalKey);
+    if (entryIndex !== -1) {
+      queue.splice(entryIndex, 1);
+    }
+    queue.push(globalKey);
+    setStorageQueue(queue);
+  }
+  return result;
+}

package/es/aics-image-viewer/shared/utils/test/storage.test.js

@@ -0,0 +1,264 @@
+import { describe, expect, it } from "@jest/globals";
+import { readStoredMetadata, readStoredScenes, writeMetadata, writeScenes } from "../storage";
+var LONG_STRING = "This is a very long string, long enough that it dwarfs the size of other example data used in this test. Its purpose is to test how the functions in the \"storage\" module evict data from local storage when the quota for local storage size is exceeded. The local storage quota is set to five thousand in this test environment, which is much smaller than most browsers will provide. At one thousand two hundred and thirty-four characters, this string represents a little less than a quarter of the total size of local storage in this test environment. Therefore, the tests below can reliably predict that up to three objects containing this string in one of its properties will fit in local storage, and that inserting a fourth one will trigger an eviction. They can also predict that a single object containing four or more copies of this string will not be allowed in local storage at all. This is slightly imprecise because adding items to local storage using the functions tested in this module incurs some additional storage penalties for the storage key, the stringified JSON surrounding the value, and the key and value of the least-recently-used queue. The size of local storage in this test environment is set in jest.config.js.";
+var LARGE_ENTRY = {
+  data: LONG_STRING
+};
+describe("writeMetadata/readStoredMetadata", function () {
+  it("writes metadata records to local storage", function () {
+    writeMetadata({
+      foo: {
+        foo: "bar"
+      },
+      bar: {
+        bar: "foo"
+      }
+    });
+    expect(readStoredMetadata(["bar", "foo"])).toEqual([{
+      bar: "foo"
+    }, {
+      foo: "bar"
+    }]);
+  });
+  it("handles metadata keys that contain commas", function () {
+    writeMetadata({
+      "foo,bar": {
+        a: 1,
+        b: 2
+      },
+      baz: {
+        three: "eight"
+      },
+      "bar,foo": {
+        c: 3,
+        d: 4
+      }
+    });
+    expect(readStoredMetadata(["baz", "foo,bar"])).toEqual([{
+      three: "eight"
+    }, {
+      a: 1,
+      b: 2
+    }]);
+  });
+  it("overwrites duplicate entries", function () {
+    writeMetadata({
+      foo: {
+        numbers: [1, 2, 3]
+      }
+    });
+    writeMetadata({
+      foo: {
+        numbers: [4, 5, 6]
+      }
+    });
+    expect(readStoredMetadata(["foo"])).toEqual([{
+      numbers: [4, 5, 6]
+    }]);
+  });
+  it("evicts least-recently used entries when storage runs out", function () {
+    writeMetadata({
+      one: LARGE_ENTRY
+    });
+    writeMetadata({
+      two: LARGE_ENTRY,
+      three: LARGE_ENTRY
+    });
+    expect(readStoredMetadata(["one", "two", "three"])).toEqual([LARGE_ENTRY, LARGE_ENTRY, LARGE_ENTRY]);
+    writeMetadata({
+      four: LARGE_ENTRY
+    });
+    expect(readStoredMetadata(["one", "two", "three", "four"])).toEqual([undefined, LARGE_ENTRY, LARGE_ENTRY, LARGE_ENTRY]);
+  });
+  it("leaves storage unchanged when a single entry is too large to fit in storage", function () {
+    writeMetadata({
+      one: {
+        entrySize: "small"
+      },
+      two: {
+        bigness: "not_too_large"
+      }
+    });
+    writeMetadata({
+      three: {
+        favoriteNumber: 8
+      },
+      big: {
+        one: LONG_STRING,
+        two: LONG_STRING,
+        three: LONG_STRING,
+        four: LONG_STRING
+      }
+    });
+    expect(readStoredMetadata(["one", "two", "three", "big"])).toEqual([{
+      entrySize: "small"
+    }, {
+      bigness: "not_too_large"
+    }, {
+      favoriteNumber: 8
+    }, undefined]);
+  });
+  it("moves entries to the front of the queue when read", function () {
+    writeMetadata({
+      one: LARGE_ENTRY
+    });
+    writeMetadata({
+      two: LARGE_ENTRY,
+      three: LARGE_ENTRY
+    });
+    readStoredMetadata(["one"]);
+    writeMetadata({
+      four: LARGE_ENTRY,
+      five: LARGE_ENTRY
+    });
+    expect(readStoredMetadata(["one", "two", "three", "four", "five"])).toEqual([LARGE_ENTRY, undefined, undefined, LARGE_ENTRY, LARGE_ENTRY]);
+  });
+  it("moves entries to the front of the queue when overwritten", function () {
+    writeMetadata({
+      one: LARGE_ENTRY,
+      two: LARGE_ENTRY
+    });
+    writeMetadata({
+      three: LARGE_ENTRY,
+      one: LARGE_ENTRY
+    });
+    writeMetadata({
+      four: LARGE_ENTRY
+    });
+    expect(readStoredMetadata(["one", "two", "three", "four"])).toEqual([LARGE_ENTRY, undefined, LARGE_ENTRY, LARGE_ENTRY]);
+  });
+  it("returns `false` on an attempt to write more data than local storage can hold", function () {
+    var fits = writeMetadata({
+      one: LARGE_ENTRY,
+      two: LARGE_ENTRY,
+      three: LARGE_ENTRY
+    });
+    expect(fits).toBe(true);
+    var tooBig = writeMetadata({
+      big: {
+        one: LONG_STRING,
+        two: LONG_STRING,
+        four: LONG_STRING,
+        six: LONG_STRING
+      }
+    });
+    expect(tooBig).toBe(false);
+    var tooMany = writeMetadata({
+      one: LARGE_ENTRY,
+      two: LARGE_ENTRY,
+      three: LARGE_ENTRY,
+      four: LARGE_ENTRY
+    });
+    expect(tooMany).toBe(false);
+  });
+  it("returns `undefined` on an attempt to get an array key", function () {
+    writeMetadata({
+      one: {
+        digits: 1
+      },
+      "one,two": {
+        digits: 12
+      }
+    });
+    expect(readStoredMetadata(["one", "one,two", ["one", "two"]])).toEqual([{
+      digits: 1
+    }, {
+      digits: 12
+    }, undefined]);
+  });
+});
+describe("writeScenes/readStoredScenes", function () {
+  var EXAMPLE_URL = "https://example.com/image.zarr";
+  var EXAMPLE_URL_2 = "https://example.com/image2.zarr";
+  it("writes keyed URLs to local storage", function () {
+    writeScenes("foo", EXAMPLE_URL);
+    expect(readStoredScenes("foo")).toBe(EXAMPLE_URL);
+  });
+  it("handles keys that contain commas", function () {
+    writeScenes("foo,bar", EXAMPLE_URL);
+    expect(readStoredScenes("foo,bar")).toBe(EXAMPLE_URL);
+  });
+  it("overwrites duplicate entries", function () {
+    writeScenes("foo", EXAMPLE_URL);
+    writeScenes("foo", EXAMPLE_URL_2);
+    expect(readStoredScenes("foo")).toBe(EXAMPLE_URL_2);
+  });
+  it("evicts least-recently used entries when storage runs out", function () {
+    writeScenes("one", LONG_STRING);
+    writeScenes("two", LONG_STRING);
+    writeScenes("three", LONG_STRING);
+    writeScenes("four", LONG_STRING);
+    expect(readStoredScenes("one")).toBe(undefined);
+    expect(readStoredScenes("two")).toBe(LONG_STRING);
+    expect(readStoredScenes("three")).toBe(LONG_STRING);
+    expect(readStoredScenes("four")).toBe(LONG_STRING);
+  });
+  it("shares an eviction queue with metadata", function () {
+    writeMetadata({
+      one: LARGE_ENTRY
+    });
+    writeScenes("one", LONG_STRING);
+    writeMetadata({
+      two: LARGE_ENTRY
+    });
+    writeScenes("two", LONG_STRING);
+    expect(readStoredScenes("one")).toBe(LONG_STRING);
+    expect(readStoredMetadata(["one", "two"])).toEqual([undefined, LARGE_ENTRY]);
+    expect(readStoredScenes("two")).toBe(LONG_STRING);
+    writeMetadata({
+      three: LARGE_ENTRY
+    });
+    expect(readStoredMetadata(["one", "two", "three"])).toEqual([undefined, LARGE_ENTRY, LARGE_ENTRY]);
+    expect(readStoredScenes("one")).toBe(undefined);
+    expect(readStoredScenes("two")).toBe(LONG_STRING);
+  });
+  it("moves entries to the front of the queue when read", function () {
+    var LARGE_ENTRY = {
+      data: LONG_STRING
+    };
+    writeScenes("one", LONG_STRING);
+    writeMetadata({
+      one: LARGE_ENTRY
+    });
+    readStoredScenes("one");
+    writeMetadata({
+      two: LARGE_ENTRY,
+      three: LARGE_ENTRY
+    });
+    expect(readStoredScenes("one")).toBe(LONG_STRING);
+    expect(readStoredMetadata(["one", "two", "three"])).toEqual([undefined, LARGE_ENTRY, LARGE_ENTRY]);
+  });
+  it("moves entries to the front of the queue when overwritten", function () {
+    writeScenes("one", LONG_STRING);
+    writeMetadata({
+      two: LARGE_ENTRY
+    });
+    writeMetadata({
+      three: LARGE_ENTRY
+    });
+    writeScenes("one", LONG_STRING);
+    writeMetadata({
+      four: LARGE_ENTRY
+    });
+    expect(readStoredScenes("one")).toBe(LONG_STRING);
+    expect(readStoredMetadata(["two", "three", "four"])).toEqual([undefined, LARGE_ENTRY, LARGE_ENTRY]);
+  });
+  it("returns `false` on an attempt to write a longer scene url than local storage can hold", function () {
+    expect(writeScenes("fits", LONG_STRING)).toBe(true);
+    expect(writeScenes("does_not_fit", LONG_STRING + LONG_STRING + LONG_STRING + LONG_STRING)).toBe(false);
+  });
+  it("enforces a maximum number of scene entries", function () {
+    var MAX_ENTRIES = 25;
+    var EXTRA_ENTRIES = 5;
+    var entriesToInsert = MAX_ENTRIES + EXTRA_ENTRIES;
+    for (var i = 0; i < entriesToInsert; i++) {
+      writeScenes("scene".concat(i), EXAMPLE_URL);
+    }
+    for (var _i = 0; _i < EXTRA_ENTRIES; _i++) {
+      expect(readStoredScenes("scene".concat(_i))).toBe(undefined);
+    }
+    for (var _i2 = EXTRA_ENTRIES; _i2 < entriesToInsert; _i2++) {
+      expect(readStoredScenes("scene".concat(_i2))).toBe(EXAMPLE_URL);
+    }
+  });
+});