@aics/vole-app 3.4.4 → 3.6.0

package/es/aics-image-viewer/state/deserialize.js

@@ -1,6 +1,6 @@
-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 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 _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 _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); }
@@ -11,34 +11,19 @@ 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 { ImageType, RenderMode, ViewMode } from "../shared/enums";
+import { clamp, identity } from "lodash";
 import { controlPointsToRamp, parseLutSetting } from "../shared/utils/controlPointsToLut";
 import { removeUndefinedProperties } from "../shared/utils/datatypes";
-import { clamp } from "../shared/utils/math";
-import { CameraTransformKeys, ViewerChannelSettingKeys, ViewerStateKeys } from "./types";
+import { CameraTransformKeys, ChannelStateSnapshotKeys, ImageType, ImageTypeSnapshot, RenderMode, RenderModeSnapshot, ViewerStateSnapshotKeys, ViewMode, ViewModeSnapshot } from "./types";
 var DEFAULT_CONTROL_POINT_COLOR = [255, 255, 255];
 var DEFAULT_CONTROL_POINT_COLOR_CODE = "1";
 var FLOAT_REGEX = /-?[0-9]*\.?[0-9]+/;
 
-/** Match colon-separated pairs of alphanumeric strings */
-var LUT_REGEX = /^-?[a-z0-9.]*:[ ]*-?[a-z0-9.]*$/;
-
 /**
- * Match colon-separated pairs of numeric strings, representing histogram bin
- * indices or intensity values.
+ * A valid lut specifier for `ViewerChannelSettings` is a float optionally prefixed with one of `v`, `p`, or `m`, or
+ * the string `autoij`.
  */
-var RAMP_REGEX = new RegExp("^".concat(FLOAT_REGEX.source, ":").concat(FLOAT_REGEX.source, "$"));
-
-/**
- * Match comma-separated triplet of numeric strings.
- */
-var SLICE_REGEX = new RegExp("^".concat(FLOAT_REGEX.source, ",").concat(FLOAT_REGEX.source, ",").concat(FLOAT_REGEX.source, "$"));
-
-/**
- * Matches a sequence of three comma-separated min:max number pairs, representing
- * the x, y, and z axes.
- */
-var REGION_REGEX = new RegExp("^(".concat(FLOAT_REGEX.source, ":").concat(FLOAT_REGEX.source, ")(,").concat(FLOAT_REGEX.source, ":").concat(FLOAT_REGEX.source, "){2}$"));
+var LUT_VALUE_REGEX = new RegExp("^([vpm]?".concat(FLOAT_REGEX.source, "|autoij)?$"));
 var HEX_COLOR_REGEX = new RegExp("(([0-9a-fA-F]{6})|".concat(DEFAULT_CONTROL_POINT_COLOR_CODE, ")"));
 
 /** Represents control points specified by bin indices. */
@@ -64,6 +49,147 @@ export var LEGACY_CONTROL_POINTS_REGEX = new RegExp("^".concat(CONTROL_POINT_REG
  */
 export var CONTROL_POINTS_REGEX = new RegExp("^".concat(CONTROL_POINT_REGEX.source, "(:").concat(CONTROL_POINT_REGEX.source, ")*$"));
 
+/** An array of exactly `N` `T`s. */
+// adapted from https://github.com/microsoft/TypeScript/pull/40002
+
+// MARK: Destringifiers
+
+/**
+ * Creates a function that parses a string into a list of exactly `length` items split by `delimiter`,
+ * with each item further parsed by `itemParser`; or returns `undefined` if parsing failed.
+ */
+var tupleParser = function tupleParser(length) {
+  var itemParser = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
+  var delimiter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ":";
+  return function (stringified) {
+    var split = stringified.split(delimiter);
+    if (split.length !== length) {
+      return undefined;
+    }
+    var result = [];
+    var _iterator = _createForOfIteratorHelper(split),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var value = _step.value;
+        var parsedValue = itemParser(value.trim());
+        if (parsedValue === undefined || Number.isNaN(parsedValue)) {
+          return undefined;
+        }
+        result.push(parsedValue);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return result;
+  };
+};
+function parseControlPointSnapshots(controlPoints) {
+  if (!(controlPoints && (CONTROL_POINTS_REGEX.test(controlPoints) || LEGACY_CONTROL_POINTS_REGEX.test(controlPoints)))) {
+    return undefined;
+  }
+
+  // Parse raw control point data from the string into an array of [x, opacity, color] triplets.
+  var controlPointStrings;
+  if (LEGACY_CONTROL_POINTS_REGEX.test(controlPoints)) {
+    // Legacy format uses commas to separate control points.
+    controlPointStrings = controlPoints.split(",").map(function (cp) {
+      return cp.split(":");
+    });
+  } else {
+    // New format is all colon-separated, where every three elements represent a control point.
+    controlPointStrings = controlPoints.split(":").reduce(function (acc, _val, i, array) {
+      if ((i + 1) % 3 === 0) {
+        acc.push([array[i - 2], array[i - 1], array[i]]);
+      }
+      return acc;
+    }, []);
+  }
+  var newControlPoints = controlPointStrings.map(function (cp) {
+    var _cp = _slicedToArray(cp, 3),
+      x = _cp[0],
+      opacity = _cp[1],
+      color = _cp[2];
+    return {
+      x: Number.parseFloat(x),
+      opacity: Number.parseFloat(opacity),
+      color: color
+    };
+  });
+  return newControlPoints;
+}
+var parseBoolean = function parseBoolean(value) {
+  return value === "1" ? true : value === "0" ? false : undefined;
+};
+export var enumParser = function enumParser(enumValues) {
+  var variants = Object.values(enumValues);
+  var variantsLowercase = Object.fromEntries(variants.map(function (v) {
+    return [v.toLowerCase(), v];
+  }));
+  return function (value) {
+    return typeof value === "string" ? variantsLowercase[value.toLowerCase()] : undefined;
+  };
+};
+var parseViewMode = enumParser(ViewModeSnapshot);
+var parseRenderMode = enumParser(RenderModeSnapshot);
+var parseImageType = enumParser(ImageTypeSnapshot);
+
+/**
+ * Helper function for parsing all keys of a stringified object back to their
+ * proper types.
+ *
+ * Accepts an object with string keys, and a map of parsers that convert the
+ * keys to their proper types, or return `undefined` when parsing fails.
+ */
+var destringify = function destringify(stringified, parsers) {
+  var result = {};
+  for (var _i = 0, _Object$keys = Object.keys(parsers); _i < _Object$keys.length; _i++) {
+    var k = _Object$keys[_i];
+    var key = k;
+    var parser = parsers[key];
+    var stringValue = stringified[key];
+    if (stringValue !== undefined) {
+      var parsed = parser(stringValue);
+      if (parsed !== undefined && !Number.isNaN(parsed)) {
+        result[key] = parsed;
+      }
+    }
+  }
+  return result;
+};
+
+/**
+ * Converts a `CameraStateStringified` into a `CameraStateSnapshot` by parsing each key from its stringified
+ * representation to its type in `CameraStateSnapshot`.
+ */
+export var destringifyCameraStateSnapshot = function destringifyCameraStateSnapshot(stringified) {
+  return destringify(stringified, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, CameraTransformKeys.Position, tupleParser(3, Number.parseFloat)), CameraTransformKeys.Target, tupleParser(3, Number.parseFloat)), CameraTransformKeys.Up, tupleParser(3, Number.parseFloat)), CameraTransformKeys.OrthoScale, Number.parseFloat), CameraTransformKeys.Fov, Number.parseFloat));
+};
+
+/**
+ * Converts a `ViewerStateStringified` into a `ViewerStateSnapshot` by parsing each key from its stringified
+ * representation to its type in `ViewerStateSnapshot`.
+ */
+export var destringifyViewerStateSnapshot = function destringifyViewerStateSnapshot(stringified) {
+  var _destringify2;
+  return destringify(stringified, (_destringify2 = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_destringify2, ViewerStateSnapshotKeys.View, parseViewMode), ViewerStateSnapshotKeys.Mode, parseRenderMode), ViewerStateSnapshotKeys.MaskOpacity, Number.parseFloat), ViewerStateSnapshotKeys.ImageType, parseImageType), ViewerStateSnapshotKeys.ShowAxes, parseBoolean), ViewerStateSnapshotKeys.ShowBoundingBox, parseBoolean), ViewerStateSnapshotKeys.BoundingBoxColor, identity), ViewerStateSnapshotKeys.BackgroundColor, identity), ViewerStateSnapshotKeys.Autorotate, parseBoolean), ViewerStateSnapshotKeys.Brightness, Number.parseFloat), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_destringify2, ViewerStateSnapshotKeys.Density, Number.parseFloat), ViewerStateSnapshotKeys.Levels, tupleParser(3, Number.parseFloat, ",")), ViewerStateSnapshotKeys.Interpolation, parseBoolean), ViewerStateSnapshotKeys.Region, tupleParser(3, tupleParser(2, Number.parseFloat), ",")), ViewerStateSnapshotKeys.Slice, tupleParser(3, Number.parseFloat, ",")), ViewerStateSnapshotKeys.Time, Number.parseInt), ViewerStateSnapshotKeys.Scene, Number.parseInt), ViewerStateSnapshotKeys.CameraState, function (cameraString) {
+    return destringifyCameraStateSnapshot(parseKeyValueList(cameraString));
+  }), ViewerStateSnapshotKeys.SingleChannelMode, parseBoolean), ViewerStateSnapshotKeys.SingleChannelIndex, Number.parseInt), _defineProperty(_defineProperty(_destringify2, ViewerStateSnapshotKeys.UseExactScaleLevel, parseBoolean), ViewerStateSnapshotKeys.ScaleLevelIndex, Number.parseInt)));
+};
+
+/**
+ * Converts a `ChannelStateStringified` into a `ChannelStateSnapshot` by parsing each key from its stringified
+ * representation to its type in `ChannelStateSnapshot`.
+ */
+export var destringifyChannelStateSnapshot = function destringifyChannelStateSnapshot(stringified) {
+  var _destringify3;
+  return destringify(stringified, (_destringify3 = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_destringify3, ChannelStateSnapshotKeys.Color, identity), ChannelStateSnapshotKeys.Colorize, parseBoolean), ChannelStateSnapshotKeys.ColorizeAlpha, Number.parseFloat), ChannelStateSnapshotKeys.IsosurfaceAlpha, Number.parseFloat), ChannelStateSnapshotKeys.Lut, tupleParser(2)), ChannelStateSnapshotKeys.ControlPoints, parseControlPointSnapshots), ChannelStateSnapshotKeys.ControlPointsLegacy, parseControlPointSnapshots), ChannelStateSnapshotKeys.Ramp, tupleParser(2, Number.parseFloat)), ChannelStateSnapshotKeys.RampLegacy, tupleParser(2, Number.parseFloat)), ChannelStateSnapshotKeys.ControlPointsEnabled, parseBoolean), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_destringify3, ChannelStateSnapshotKeys.VolumeEnabled, parseBoolean), ChannelStateSnapshotKeys.SurfaceEnabled, parseBoolean), ChannelStateSnapshotKeys.IsosurfaceValue, Number.parseFloat), ChannelStateSnapshotKeys.KeepRange, parseBoolean)));
+};
+
+// MARK: Parsing Helpers
+
 /**
  * Parse a string list of comma-separated key:value pairs into
  * a key-value object.
@@ -80,11 +206,11 @@ export function parseKeyValueList(data) {
   }
   var result = {};
   var keyValuePairs = data.split(",");
-  var _iterator = _createForOfIteratorHelper(keyValuePairs),
-    _step;
+  var _iterator2 = _createForOfIteratorHelper(keyValuePairs),
+    _step2;
   try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var pair = _step.value;
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var pair = _step2.value;
       var splitIndex = pair.indexOf(":");
       if (splitIndex === -1) {
         continue;
@@ -94,78 +220,14 @@ export function parseKeyValueList(data) {
       result[decodeURIComponent(key).trim()] = decodeURIComponent(value).trim();
     }
   } catch (err) {
-    _iterator.e(err);
+    _iterator2.e(err);
   } finally {
-    _iterator.f();
+    _iterator2.f();
   }
   return result;
 }
-
-/**
- * Parses a string to a float and clamps the result to the [min, max] range.
- * Returns `undefined` if the string is undefined or NaN.
- * @param value String to parse as a float. Will be parsed with `Number.parseFloat`.
- * @param min Minimum value, inclusive.
- * @param max Maximum value, inclusive.
- * @returns
- * - The parsed number, clamped to the [min, max] range.
- * - `undefined` if the string is undefined or NaN.
- */
-export function parseStringFloat(value, min, max) {
-  if (value === undefined) {
-    return undefined;
-  }
-  var number = Number.parseFloat(value);
-  return Number.isNaN(number) ? undefined : clamp(number, min, max);
-}
-
-/**
- * Parses a string to an integer and clamps the result to the [min, max] range.
- * @param value String to parse as a float. Assumes base 10, parses with `Number.parseInt(value, 10)`.
- * @param min Minimum value, inclusive.
- * @param max Maximum value, inclusive.
- * @returns
- * - The parsed number, clamped to the [min, max] range.
- * - `undefined` if the string is undefined or NaN.
- */
-export function parseStringInt(value, min, max) {
-  if (value === undefined) {
-    return undefined;
-  }
-  var number = Number.parseInt(value, 10);
-  if (Number.isNaN(number)) {
-    return undefined;
-  }
-  return clamp(number, min, max);
-}
-
-/**
- * Parses a string to an enum value; if the string is not in the enum, returns the default value.
- * @param value String to parse.
- * @param enumValues Enum. Cannot be a `const enum`, as these are removed at compile time.
- * @param defaultValue Default value to return if the string is not in the enum.
- * @returns A value from the enum or the default value. Note that the return type includes `undefined`
- * if the `defaultValue` is `undefined`.
- */
-export function parseStringEnum(value, enumValues) {
-  var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
-  if (value === undefined || !Object.values(enumValues).includes(value)) {
-    return defaultValue;
-  }
-  return value;
-}
-
-/**
- * Parses a string boolean value ("1" as true, "0" as false), and returns `undefined` if the value is `undefined`.
- */
-function parseStringBoolean(value) {
-  if (value === undefined) {
-    return undefined;
-  }
-  return value === "1";
-}
 export function parseHexColorAsColorArray(hexColor) {
-  if (!hexColor || !HEX_COLOR_STR_REGEX.test(hexColor)) {
+  if (typeof hexColor !== "string" || !HEX_COLOR_STR_REGEX.test(hexColor)) {
     return undefined;
   }
   // if (hexColor in COLOR_CODES) {
@@ -179,257 +241,267 @@ export function parseHexColorAsColorArray(hexColor) {
   var b = Number.parseInt(hexColor.slice(4, 6), 16);
   return [r, g, b];
 }
-function parseStringSlice(region) {
-  if (!region || !SLICE_REGEX.test(region)) {
+
+/** Verifies that `value` is a `number`; if it is, clamps it between `min` and `max`. */
+export var validateNumber = function validateNumber(value) {
+  var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -Infinity;
+  var max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Infinity;
+  return typeof value === "number" && !Number.isNaN(value) ? clamp(value, min, max) : undefined;
+};
+
+/** Verifies that `value` is a `number`; if it is, truncates it to an integer and clamps it between `min` and `max`. */
+export var validateInt = function validateInt(value) {
+  var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -Infinity;
+  var max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Infinity;
+  return typeof value === "number" && !Number.isNaN(value) ? clamp(Math.trunc(value), min, max) : undefined;
+};
+
+/** Verifies that a value is a `boolean`. */
+var validateBoolean = function validateBoolean(value) {
+  return typeof value === "boolean" ? value : undefined;
+};
+
+/** Verifies that `value` is a list of length `length` and that all its items are valid per `validator`. */
+var validateTuple = function validateTuple(value, length, validator) {
+  if (!Array.isArray(value) || value.length !== length) {
     return undefined;
   }
-  var _region$split$map = region.split(",").map(function (val) {
-      return parseStringFloat(val, 0, 1);
-    }),
-    _region$split$map2 = _slicedToArray(_region$split$map, 3),
-    x = _region$split$map2[0],
-    y = _region$split$map2[1],
-    z = _region$split$map2[2];
-  if (x === undefined || y === undefined || z === undefined) {
+  var result = [];
+  var _iterator3 = _createForOfIteratorHelper(value),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var v = _step3.value;
+      var validated = validator(v);
+      if (validated === undefined) {
+        return undefined;
+      }
+      result.push(validated);
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return result;
+};
+
+/**
+ * Verifies that `value` is a three-element array whose items are valid per `validator`;
+ * if it is, converts it to an object with the form `{ x, y, z }`
+ */
+var validateXYZ = function validateXYZ(value, validator) {
+  var tuple = validateTuple(value, 3, validator);
+  if (tuple === undefined) {
     return undefined;
   }
+  var _tuple = _slicedToArray(tuple, 3),
+    x = _tuple[0],
+    y = _tuple[1],
+    z = _tuple[2];
   return {
     x: x,
     y: y,
     z: z
   };
-}
+};
 
 /**
- * Parses an array of three numbers from a string.
- * @param stringArr The string to parse. Should be three numbers separated by a separator.
- * @param options Optional parameters for parsing:
- * - `min`: Minimum value for each number. Default is negative infinity.
- * - `max`: Maximum value for each number. Default is positive infinity.
- * - `separator`: Separator between numbers. Default is `,`.
- * @returns
- * - undefined if the string is undefined or could not be parsed.
- * - An array of three numbers, clamped to the [min, max] range.
+ * Verifies that `value` is a two-element array of numbers, clamps both numbers between `min` and `max`,
+ * then sorts the numbers.
  */
-function parseThreeNumberArray(stringArr, options) {
-  var _options$min, _options$max, _options$separator;
-  if (!stringArr) {
+var validateSortedPair = function validateSortedPair(value, min, max) {
+  var tuple = validateTuple(value, 2, function (number) {
+    return validateNumber(number, min, max);
+  });
+  if (tuple === undefined) {
     return undefined;
   }
-  var min = (_options$min = options === null || options === void 0 ? void 0 : options.min) !== null && _options$min !== void 0 ? _options$min : Number.NEGATIVE_INFINITY;
-  var max = (_options$max = options === null || options === void 0 ? void 0 : options.max) !== null && _options$max !== void 0 ? _options$max : Number.POSITIVE_INFINITY;
-  var separator = (_options$separator = options === null || options === void 0 ? void 0 : options.separator) !== null && _options$separator !== void 0 ? _options$separator : ",";
-  var _stringArr$split$map = stringArr.split(separator).map(function (val) {
-      return parseStringFloat(val, min, max);
-    }),
-    _stringArr$split$map2 = _slicedToArray(_stringArr$split$map, 3),
-    x = _stringArr$split$map2[0],
-    y = _stringArr$split$map2[1],
-    z = _stringArr$split$map2[2];
-  if (x === undefined || y === undefined || z === undefined) {
+  var _tuple2 = _slicedToArray(tuple, 2),
+    minVal = _tuple2[0],
+    maxVal = _tuple2[1];
+  return minVal > maxVal ? [maxVal, minVal] : [minVal, maxVal];
+};
+
+/** Verifies that `value` is an object with `string` keys. */
+var validateRecord = function validateRecord(value) {
+  if (_typeof(value) !== "object" || Array.isArray(value) || value === null) {
     return undefined;
   }
-  return [x, y, z];
-}
-function parseStringRegion(region) {
-  if (!region || !REGION_REGEX.test(region)) {
+  if (!Object.keys(value).every(function (key) {
+    return typeof key === "string";
+  })) {
     return undefined;
   }
-  var _region$split$map3 = region.split(",").map(function (axis) {
-      // each is a min/max pair
-      var _axis$split$map = axis.split(":").map(function (val) {
-          return parseStringFloat(val, 0, 1);
-        }),
-        _axis$split$map2 = _slicedToArray(_axis$split$map, 2),
-        min = _axis$split$map2[0],
-        max = _axis$split$map2[1];
-      if (min === undefined || max === undefined) {
-        return undefined;
-      }
-      // Ensure sorted order
-      return min < max ? [min, max] : [max, min];
-    }),
-    _region$split$map4 = _slicedToArray(_region$split$map3, 3),
-    x = _region$split$map4[0],
-    y = _region$split$map4[1],
-    z = _region$split$map4[2];
-  // Check for undefined values
-  if (x === undefined || y === undefined || z === undefined) {
+  return value;
+};
+
+/** Verifies that `value` is a valid lut specifier per `ViewerChannelSettings`. */
+var validateLutValue = function validateLutValue(value) {
+  if (typeof value === "number") {
+    return clamp(value, 0, 255);
+  }
+  if (typeof value !== "string") {
     return undefined;
   }
-  return {
-    x: x,
-    y: y,
-    z: z
+  var result = value.trim().toLowerCase();
+  if (LUT_VALUE_REGEX.test(result)) {
+    return result;
+  }
+  return undefined;
+};
+var enumSnapshotConverter = function enumSnapshotConverter(map) {
+  var entries = Object.entries(map);
+  var lowercaseMap = Object.fromEntries(entries.map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      s = _ref2[0],
+      e = _ref2[1];
+    return [s.toLowerCase(), e];
+  }));
+  return function (value) {
+    return typeof value === "string" ? lowercaseMap[value.toLowerCase()] : undefined;
   };
-}
-function parseCameraState(cameraSettings) {
-  if (!cameraSettings) {
+};
+var snapshotToViewMode = enumSnapshotConverter(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, ViewModeSnapshot.threeD, ViewMode.threeD), ViewModeSnapshot.xy, ViewMode.xy), ViewModeSnapshot.xz, ViewMode.xz), ViewModeSnapshot.yz, ViewMode.yz));
+var snapshotToRenderMode = enumSnapshotConverter(_defineProperty(_defineProperty(_defineProperty({}, RenderModeSnapshot.volumetric, RenderMode.volumetric), RenderModeSnapshot.maxProject, RenderMode.maxProject), RenderModeSnapshot.pathTrace, RenderMode.pathTrace));
+var snapshotToImageType = enumSnapshotConverter(_defineProperty(_defineProperty({}, ImageTypeSnapshot.segmentedCell, ImageType.segmentedCell), ImageTypeSnapshot.fullField, ImageType.fullField));
+
+// MARK: Parsers
+
+/** Parses a `CameraStateSnapshot` to a `CameraState`. */
+function snapshotToCameraState(snapshot) {
+  if (snapshot === undefined) {
     return undefined;
   }
-  var parsedCameraSettings = parseKeyValueList(cameraSettings);
   var result = {
-    position: parseThreeNumberArray(parsedCameraSettings[CameraTransformKeys.Position], {
-      separator: ":"
-    }),
-    target: parseThreeNumberArray(parsedCameraSettings[CameraTransformKeys.Target], {
-      separator: ":"
-    }),
-    up: parseThreeNumberArray(parsedCameraSettings[CameraTransformKeys.Up], {
-      separator: ":"
-    }),
+    position: validateTuple(snapshot[CameraTransformKeys.Position], 3, validateNumber),
+    target: validateTuple(snapshot[CameraTransformKeys.Target], 3, validateNumber),
+    up: validateTuple(snapshot[CameraTransformKeys.Up], 3, validateNumber),
     // Orthographic scales cannot be negative
-    orthoScale: parseStringFloat(parsedCameraSettings[CameraTransformKeys.OrthoScale], 0, Infinity),
-    fov: parseStringFloat(parsedCameraSettings[CameraTransformKeys.Fov], 0, 180)
+    orthoScale: validateNumber(snapshot[CameraTransformKeys.OrthoScale], 0),
+    fov: validateNumber(snapshot[CameraTransformKeys.Fov], 0, 180)
   };
   return removeUndefinedProperties(result);
 }
-export function deserializeViewerState(params) {
+
+/** Parses a `ViewerStateSnapshot` to a `ViewerState`. */
+export function snapshotToViewerState(snapshot) {
   var result = {
-    maskAlpha: parseStringInt(params[ViewerStateKeys.Mask], 0, 100),
-    imageType: parseStringEnum(params[ViewerStateKeys.Image], ImageType),
-    showAxes: parseStringBoolean(params[ViewerStateKeys.Axes]),
-    showBoundingBox: parseStringBoolean(params[ViewerStateKeys.BoundingBox]),
-    boundingBoxColor: parseHexColorAsColorArray(params[ViewerStateKeys.BoundingBoxColor]),
-    backgroundColor: parseHexColorAsColorArray(params[ViewerStateKeys.BackgroundColor]),
-    autorotate: parseStringBoolean(params[ViewerStateKeys.Autorotate]),
-    brightness: parseStringFloat(params[ViewerStateKeys.Brightness], 0, 100),
-    density: parseStringFloat(params[ViewerStateKeys.Density], 0, 100),
-    levels: parseThreeNumberArray(params[ViewerStateKeys.Levels], {
-      min: 0,
-      max: 255
+    viewMode: snapshotToViewMode(snapshot[ViewerStateSnapshotKeys.View]),
+    maskAlpha: validateNumber(snapshot[ViewerStateSnapshotKeys.MaskOpacity], 0, 100),
+    imageType: snapshotToImageType(snapshot[ViewerStateSnapshotKeys.ImageType]),
+    showAxes: validateBoolean(snapshot[ViewerStateSnapshotKeys.ShowAxes]),
+    showBoundingBox: validateBoolean(snapshot[ViewerStateSnapshotKeys.ShowBoundingBox]),
+    boundingBoxColor: parseHexColorAsColorArray(snapshot[ViewerStateSnapshotKeys.BoundingBoxColor]),
+    backgroundColor: parseHexColorAsColorArray(snapshot[ViewerStateSnapshotKeys.BackgroundColor]),
+    autorotate: validateBoolean(snapshot[ViewerStateSnapshotKeys.Autorotate]),
+    brightness: validateNumber(snapshot[ViewerStateSnapshotKeys.Brightness], 0, 100),
+    density: validateNumber(snapshot[ViewerStateSnapshotKeys.Density], 0, 100),
+    levels: validateTuple(snapshot[ViewerStateSnapshotKeys.Levels], 3, function (value) {
+      return validateNumber(value, 0, 255);
     }),
-    interpolationEnabled: parseStringBoolean(params[ViewerStateKeys.Interpolation]),
-    region: parseStringRegion(params[ViewerStateKeys.Region]),
-    slice: parseStringSlice(params[ViewerStateKeys.Slice]),
-    time: parseStringInt(params[ViewerStateKeys.Time], 0, Number.POSITIVE_INFINITY),
-    scene: parseStringInt(params[ViewerStateKeys.Scene], 0, Number.POSITIVE_INFINITY),
-    renderMode: parseStringEnum(params[ViewerStateKeys.Mode], RenderMode),
-    singleChannelMode: parseStringBoolean(params[ViewerStateKeys.SingleChannelMode]),
-    singleChannelIndex: parseStringInt(params[ViewerStateKeys.SingleChannelIndex], 0, Number.POSITIVE_INFINITY),
-    useExactScaleLevel: parseStringBoolean(params[ViewerStateKeys.UseExactScaleLevel]),
-    scaleLevelIndex: parseStringInt(params[ViewerStateKeys.ScaleLevelIndex], 0, Number.MAX_SAFE_INTEGER),
-    cameraState: parseCameraState(params[ViewerStateKeys.CameraState])
+    interpolationEnabled: validateBoolean(snapshot[ViewerStateSnapshotKeys.Interpolation]),
+    region: validateXYZ(snapshot[ViewerStateSnapshotKeys.Region], function (value) {
+      return validateSortedPair(value, 0, 1);
+    }),
+    slice: validateXYZ(snapshot[ViewerStateSnapshotKeys.Slice], function (value) {
+      return validateNumber(value, 0, 1);
+    }),
+    time: validateInt(snapshot[ViewerStateSnapshotKeys.Time], 0, Number.POSITIVE_INFINITY),
+    scene: validateInt(snapshot[ViewerStateSnapshotKeys.Scene], 0, Number.POSITIVE_INFINITY),
+    renderMode: snapshotToRenderMode(snapshot[ViewerStateSnapshotKeys.Mode]),
+    singleChannelMode: validateBoolean(snapshot[ViewerStateSnapshotKeys.SingleChannelMode]),
+    singleChannelIndex: validateInt(snapshot[ViewerStateSnapshotKeys.SingleChannelIndex], 0, Number.POSITIVE_INFINITY),
+    useExactScaleLevel: validateBoolean(snapshot[ViewerStateSnapshotKeys.UseExactScaleLevel]),
+    scaleLevelIndex: validateInt(snapshot[ViewerStateSnapshotKeys.ScaleLevelIndex], 0, Number.MAX_SAFE_INTEGER),
+    cameraState: snapshotToCameraState(validateRecord(snapshot[ViewerStateSnapshotKeys.CameraState]))
   };
-
-  // Handle viewmode, since they use different mappings
-  // TODO: Allow lowercase
-  if (params.view) {
-    var viewParamToViewMode = {
-      "3D": ViewMode.threeD,
-      Z: ViewMode.xy,
-      Y: ViewMode.xz,
-      X: ViewMode.yz
-    };
-    var allowedViews = Object.keys(viewParamToViewMode);
-    var view;
-    if (allowedViews.includes(params.view.toUpperCase())) {
-      view = params.view.toUpperCase();
-    } else {
-      view = "3D";
-    }
-    result.viewMode = viewParamToViewMode[view];
-  }
   return removeUndefinedProperties(result);
 }
-function parseControlPoints(controlPoints) {
-  if (!(controlPoints && (CONTROL_POINTS_REGEX.test(controlPoints) || LEGACY_CONTROL_POINTS_REGEX.test(controlPoints)))) {
-    return undefined;
-  }
 
-  // Parse raw control point data from the string into an array of [x, opacity, color] triplets.
-  var controlPointStrings;
-  if (LEGACY_CONTROL_POINTS_REGEX.test(controlPoints)) {
-    // Legacy format uses commas to separate control points.
-    controlPointStrings = controlPoints.split(",").map(function (cp) {
-      return cp.split(":");
-    });
-  } else {
-    // New format is all colon-separated, where every three elements represent a control point.
-    controlPointStrings = controlPoints.split(":").reduce(function (acc, _val, i, array) {
-      if ((i + 1) % 3 === 0) {
-        acc.push([array[i - 2], array[i - 1], array[i]]);
+/** Attempts to parse an array of `ControlPointSnapshot`s to an array of `ControlPoint`s. */
+function snapshotToControlPoints(controlPoints) {
+  var result = [];
+  var _iterator4 = _createForOfIteratorHelper(controlPoints),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var _parseHexColorAsColor;
+      var point = _step4.value;
+      var x = validateNumber(point.x);
+      var opacity = validateNumber(point.opacity, 0, 1);
+      var color = (_parseHexColorAsColor = parseHexColorAsColorArray(point.color)) !== null && _parseHexColorAsColor !== void 0 ? _parseHexColorAsColor : [].concat(DEFAULT_CONTROL_POINT_COLOR);
+      if (x === undefined || opacity === undefined || color === undefined) {
+        return undefined;
       }
-      return acc;
-    }, []);
+      result.push({
+        x: x,
+        opacity: opacity,
+        color: color
+      });
+    }
+    // Sort control points by x value
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
   }
-  var newControlPoints = controlPointStrings.map(function (cp) {
-    var _parseStringFloat, _parseStringFloat2, _parseHexColorAsColor;
-    var _cp = _slicedToArray(cp, 3),
-      x = _cp[0],
-      opacity = _cp[1],
-      color = _cp[2];
-    return {
-      x: (_parseStringFloat = parseStringFloat(x, -Infinity, Infinity)) !== null && _parseStringFloat !== void 0 ? _parseStringFloat : 0,
-      opacity: (_parseStringFloat2 = parseStringFloat(opacity, 0, 1)) !== null && _parseStringFloat2 !== void 0 ? _parseStringFloat2 : 1.0,
-      color: (_parseHexColorAsColor = parseHexColorAsColorArray(color)) !== null && _parseHexColorAsColor !== void 0 ? _parseHexColorAsColor : DEFAULT_CONTROL_POINT_COLOR
-    };
-  });
-  // Sort control points by x value
-  return newControlPoints.sort(function (a, b) {
+  return result.sort(function (a, b) {
     return a.x - b.x;
   });
 }
 
 /**
- * Parses a ViewerChannelSetting from a JSON object.
- * @param channelIndex Index of the channel, to be turned into a `match` value.
- * @param jsonState The serialized ViewerChannelSetting to parse, as an object.
- * @returns A ViewerChannelSetting object.
+ * Parses a `ChannelStateSnapshot` to a `ViewerChannelSetting`.
+ * @param channelId Either the index or the name of the channel, to be turned into a `match` value.
+ * @param jsonState The serialized `ViewerChannelSetting` to parse, as an object.
+ * @returns A `ViewerChannelSetting` object.
  */
-export function deserializeViewerChannelSetting(channelIndex, jsonState) {
+export function snapshotToViewerChannelSetting(channelId, jsonState) {
   // Missing/undefined fields should be handled downstream.
   var result = {
-    match: channelIndex,
-    enabled: parseStringBoolean(jsonState[ViewerChannelSettingKeys.VolumeEnabled]),
-    surfaceEnabled: parseStringBoolean(jsonState[ViewerChannelSettingKeys.SurfaceEnabled]),
-    isovalue: parseStringFloat(jsonState[ViewerChannelSettingKeys.IsosurfaceValue], -Infinity, Infinity),
-    keepIntensityRange: parseStringBoolean(jsonState[ViewerChannelSettingKeys.KeepRange]),
-    surfaceOpacity: parseStringFloat(jsonState[ViewerChannelSettingKeys.IsosurfaceAlpha], 0, 1),
-    colorizeEnabled: parseStringBoolean(jsonState[ViewerChannelSettingKeys.Colorize]),
-    colorizeAlpha: parseStringFloat(jsonState[ViewerChannelSettingKeys.ColorizeAlpha], 0, 1),
-    controlPointsEnabled: parseStringBoolean(jsonState[ViewerChannelSettingKeys.ControlPointsEnabled])
+    match: channelId,
+    enabled: validateBoolean(jsonState[ChannelStateSnapshotKeys.VolumeEnabled]),
+    surfaceEnabled: validateBoolean(jsonState[ChannelStateSnapshotKeys.SurfaceEnabled]),
+    isovalue: validateNumber(jsonState[ChannelStateSnapshotKeys.IsosurfaceValue], -Infinity, Infinity),
+    keepIntensityRange: validateBoolean(jsonState[ChannelStateSnapshotKeys.KeepRange]),
+    surfaceOpacity: validateNumber(jsonState[ChannelStateSnapshotKeys.IsosurfaceAlpha], 0, 1),
+    colorizeEnabled: validateBoolean(jsonState[ChannelStateSnapshotKeys.Colorize]),
+    colorizeAlpha: validateNumber(jsonState[ChannelStateSnapshotKeys.ColorizeAlpha], 0, 1),
+    controlPointsEnabled: validateBoolean(jsonState[ChannelStateSnapshotKeys.ControlPointsEnabled])
   };
-  if (jsonState[ViewerChannelSettingKeys.Color] && HEX_COLOR_STR_REGEX.test(jsonState.col)) {
-    result.color = jsonState[ViewerChannelSettingKeys.Color];
+  var color = jsonState[ChannelStateSnapshotKeys.Color];
+  if (typeof color === "string" && HEX_COLOR_STR_REGEX.test(color)) {
+    result.color = color;
   }
-  if (jsonState[ViewerChannelSettingKeys.Lut] && LUT_REGEX.test(jsonState.lut)) {
-    var _jsonState$ViewerChan = jsonState[ViewerChannelSettingKeys.Lut].split(":"),
-      _jsonState$ViewerChan2 = _slicedToArray(_jsonState$ViewerChan, 2),
-      min = _jsonState$ViewerChan2[0],
-      max = _jsonState$ViewerChan2[1];
+  var lut = validateTuple(jsonState[ChannelStateSnapshotKeys.Lut], 2, validateLutValue);
+  if (lut !== undefined) {
     result.intensity = _objectSpread(_objectSpread({}, result.intensity), {}, {
-      lut: [min.trim(), max.trim()]
+      lut: lut
     });
   }
-  if (jsonState[ViewerChannelSettingKeys.Ramp]) {
-    if (RAMP_REGEX.test(jsonState[ViewerChannelSettingKeys.Ramp])) {
-      var _jsonState$ViewerChan3 = jsonState[ViewerChannelSettingKeys.Ramp].split(":"),
-        _jsonState$ViewerChan4 = _slicedToArray(_jsonState$ViewerChan3, 2),
-        _min = _jsonState$ViewerChan4[0],
-        _max = _jsonState$ViewerChan4[1];
+  if (jsonState[ChannelStateSnapshotKeys.Ramp]) {
+    var ramp = validateSortedPair(jsonState[ChannelStateSnapshotKeys.Ramp]);
+    if (ramp !== undefined) {
       result.intensity = _objectSpread(_objectSpread({}, result.intensity), {}, {
-        ramp: [Number.parseFloat(_min), Number.parseFloat(_max)]
+        ramp: ramp
       });
     }
-  } else if (jsonState[ViewerChannelSettingKeys.RampLegacy]) {
-    if (RAMP_REGEX.test(jsonState[ViewerChannelSettingKeys.RampLegacy])) {
-      var _jsonState$ViewerChan5 = jsonState[ViewerChannelSettingKeys.RampLegacy].split(":"),
-        _jsonState$ViewerChan6 = _slicedToArray(_jsonState$ViewerChan5, 2),
-        _min2 = _jsonState$ViewerChan6[0],
-        _max2 = _jsonState$ViewerChan6[1];
-      result.ramp = [Number.parseFloat(_min2), Number.parseFloat(_max2)];
+  } else if (jsonState[ChannelStateSnapshotKeys.RampLegacy]) {
+    var _ramp = validateSortedPair(jsonState[ChannelStateSnapshotKeys.RampLegacy]);
+    if (_ramp !== undefined) {
+      result.ramp = _ramp;
     }
   }
-  if (jsonState[ViewerChannelSettingKeys.ControlPoints]) {
-    var parsedResult = parseControlPoints(jsonState[ViewerChannelSettingKeys.ControlPoints]);
+  if (Array.isArray(jsonState[ChannelStateSnapshotKeys.ControlPoints])) {
+    var parsedResult = snapshotToControlPoints(jsonState[ChannelStateSnapshotKeys.ControlPoints]);
     if (parsedResult) {
       result.intensity = _objectSpread(_objectSpread({}, result.intensity), {}, {
         controlPoints: parsedResult
       });
     }
-  } else if (jsonState[ViewerChannelSettingKeys.ControlPointsLegacy]) {
-    var _parsedResult = parseControlPoints(jsonState[ViewerChannelSettingKeys.ControlPointsLegacy]);
+  } else if (Array.isArray(jsonState[ChannelStateSnapshotKeys.ControlPointsLegacy])) {
+    var _parsedResult = snapshotToControlPoints(jsonState[ChannelStateSnapshotKeys.ControlPointsLegacy]);
     if (_parsedResult) {
       result.controlPoints = _parsedResult;
     }
@@ -438,10 +510,10 @@ export function deserializeViewerChannelSetting(channelIndex, jsonState) {
 }
 
 /**
- * Parses a `ViewerChannelStateParams` object into a partial `ChannelState`.
+ * Parses a `ChannelStateSnapshot` object into a partial `ChannelState`.
  *
- * This is used to convert raw URL params into internal channel state fields,
- * leaving absent or invalid values undefined.
+ * This is used to convert from serialized formats (URL params, JSON) into
+ * internal channel state fields, leaving absent or invalid values undefined.
  *
  * This function optionally accepts the target channel's `Histogram`. This
  * argument is required to parse the following params correctly:
@@ -455,68 +527,59 @@ export function deserializeViewerChannelSetting(channelIndex, jsonState) {
  * If `histogram` is left undefined, e.g. because the channel has not yet been
  * loaded, these params are ignored.
  */
-export function deserializeChannelState(jsonState, histogram) {
+export function snapshotToChannelState(jsonState, histogram) {
   var result = {
-    volumeEnabled: parseStringBoolean(jsonState[ViewerChannelSettingKeys.VolumeEnabled]),
-    isosurfaceEnabled: parseStringBoolean(jsonState[ViewerChannelSettingKeys.SurfaceEnabled]),
-    isovalue: parseStringFloat(jsonState[ViewerChannelSettingKeys.IsosurfaceValue], -Infinity, Infinity),
-    keepIntensityRange: parseStringBoolean(jsonState[ViewerChannelSettingKeys.KeepRange]),
-    opacity: parseStringFloat(jsonState[ViewerChannelSettingKeys.IsosurfaceAlpha], 0, 1),
-    colorizeEnabled: parseStringBoolean(jsonState[ViewerChannelSettingKeys.Colorize]),
-    colorizeAlpha: parseStringFloat(jsonState[ViewerChannelSettingKeys.ColorizeAlpha], 0, 1),
-    useControlPoints: parseStringBoolean(jsonState[ViewerChannelSettingKeys.ControlPointsEnabled]),
-    color: parseHexColorAsColorArray(jsonState[ViewerChannelSettingKeys.Color])
+    volumeEnabled: validateBoolean(jsonState[ChannelStateSnapshotKeys.VolumeEnabled]),
+    isosurfaceEnabled: validateBoolean(jsonState[ChannelStateSnapshotKeys.SurfaceEnabled]),
+    isovalue: validateNumber(jsonState[ChannelStateSnapshotKeys.IsosurfaceValue], -Infinity, Infinity),
+    keepIntensityRange: validateBoolean(jsonState[ChannelStateSnapshotKeys.KeepRange]),
+    opacity: validateNumber(jsonState[ChannelStateSnapshotKeys.IsosurfaceAlpha], 0, 1),
+    colorizeEnabled: validateBoolean(jsonState[ChannelStateSnapshotKeys.Colorize]),
+    colorizeAlpha: validateNumber(jsonState[ChannelStateSnapshotKeys.ColorizeAlpha], 0, 1),
+    useControlPoints: validateBoolean(jsonState[ChannelStateSnapshotKeys.ControlPointsEnabled]),
+    color: parseHexColorAsColorArray(jsonState[ChannelStateSnapshotKeys.Color])
   };
-  var lutSerialized = jsonState[ViewerChannelSettingKeys.Lut];
+  var lutRaw = validateTuple(jsonState[ChannelStateSnapshotKeys.Lut], 2, validateLutValue);
   var pointsFromLut = undefined;
-  if (histogram !== undefined && lutSerialized !== undefined && LUT_REGEX.test(lutSerialized)) {
-    var _lutSerialized$split = lutSerialized.split(":"),
-      _lutSerialized$split2 = _slicedToArray(_lutSerialized$split, 2),
-      min = _lutSerialized$split2[0],
-      max = _lutSerialized$split2[1];
-    var lut = parseLutSetting(histogram, [min.trim(), max.trim()]);
+  if (histogram !== undefined && lutRaw !== undefined) {
+    var lut = parseLutSetting(histogram, lutRaw);
     pointsFromLut = lut === null || lut === void 0 ? void 0 : lut.controlPoints.map(function (point) {
       return _objectSpread(_objectSpread({}, point), {}, {
         x: histogram.getValueFromBinIndex(point.x)
       });
     });
   }
-  if (jsonState[ViewerChannelSettingKeys.Ramp]) {
-    if (RAMP_REGEX.test(jsonState[ViewerChannelSettingKeys.Ramp])) {
-      var _jsonState$ViewerChan7 = jsonState[ViewerChannelSettingKeys.Ramp].split(":"),
-        _jsonState$ViewerChan8 = _slicedToArray(_jsonState$ViewerChan7, 2),
-        _min3 = _jsonState$ViewerChan8[0],
-        _max3 = _jsonState$ViewerChan8[1];
-      result.ramp = [Number.parseFloat(_min3), Number.parseFloat(_max3)];
+  if (jsonState[ChannelStateSnapshotKeys.Ramp]) {
+    var ramp = validateSortedPair(jsonState[ChannelStateSnapshotKeys.Ramp]);
+    if (ramp !== undefined) {
+      result.ramp = ramp;
     }
-  } else if (jsonState[ViewerChannelSettingKeys.RampLegacy]) {
-    if (histogram !== undefined) {
-      if (RAMP_REGEX.test(jsonState[ViewerChannelSettingKeys.RampLegacy])) {
-        var _jsonState$ViewerChan9 = jsonState[ViewerChannelSettingKeys.RampLegacy].split(":"),
-          _jsonState$ViewerChan10 = _slicedToArray(_jsonState$ViewerChan9, 2),
-          rawMin = _jsonState$ViewerChan10[0],
-          rawMax = _jsonState$ViewerChan10[1];
-        var _min4 = histogram.getValueFromBinIndex(Number.parseFloat(rawMin));
-        var _max4 = histogram.getValueFromBinIndex(Number.parseFloat(rawMax));
-        result.ramp = [_min4, _max4];
-      }
+  } else if (jsonState[ChannelStateSnapshotKeys.RampLegacy]) {
+    var _ramp2 = validateSortedPair(jsonState[ChannelStateSnapshotKeys.RampLegacy]);
+    if (histogram !== undefined && _ramp2 !== undefined) {
+      var _ramp3 = _slicedToArray(_ramp2, 2),
+        rawMin = _ramp3[0],
+        rawMax = _ramp3[1];
+      var min = histogram.getValueFromBinIndex(rawMin);
+      var max = histogram.getValueFromBinIndex(rawMax);
+      result.ramp = [min, max];
     }
   } else if (pointsFromLut !== undefined) {
     result.ramp = controlPointsToRamp(pointsFromLut);
   }
-  if (jsonState[ViewerChannelSettingKeys.ControlPoints]) {
-    var parsedResult = parseControlPoints(jsonState[ViewerChannelSettingKeys.ControlPoints]);
+  if (Array.isArray(jsonState[ChannelStateSnapshotKeys.ControlPoints])) {
+    var parsedResult = snapshotToControlPoints(jsonState[ChannelStateSnapshotKeys.ControlPoints]);
     if (parsedResult) {
       result.controlPoints = parsedResult;
     }
-  } else if (jsonState[ViewerChannelSettingKeys.ControlPointsLegacy]) {
+  } else if (Array.isArray(jsonState[ChannelStateSnapshotKeys.ControlPointsLegacy])) {
     if (histogram !== undefined) {
-      var _parsedResult2 = parseControlPoints(jsonState[ViewerChannelSettingKeys.ControlPointsLegacy]);
+      var _parsedResult2 = snapshotToControlPoints(jsonState[ChannelStateSnapshotKeys.ControlPointsLegacy]);
       if (_parsedResult2) {
-        result.controlPoints = _parsedResult2.map(function (_ref) {
-          var opacity = _ref.opacity,
-            color = _ref.color,
-            x = _ref.x;
+        result.controlPoints = _parsedResult2.map(function (_ref3) {
+          var opacity = _ref3.opacity,
+            color = _ref3.color,
+            x = _ref3.x;
           return {
             opacity: opacity,
             color: color,
@@ -529,4 +592,53 @@ export function deserializeChannelState(jsonState, histogram) {
     result.controlPoints = pointsFromLut;
   }
   return removeUndefinedProperties(result);
-}
+}
+
+/**
+ * Parses a stringified viewer state snapshot (`ViewerStateStringified`) to a
+ * `ViewerState`.
+ *
+ * This is equivalent to (and implemented by) calling
+ * `destringifyViewerStateSnapshot`, then `snapshotToViewerState`.
+ */
+export var stringSnapshotToViewerState = function stringSnapshotToViewerState(stringified) {
+  return snapshotToViewerState(destringifyViewerStateSnapshot(stringified));
+};
+
+/**
+ * Parses a stringified channel state snapshot (`ChannelStateStringified`) to a
+ * `ViewerChannelSetting`.
+ *
+ * This is equivalent to (and implemented by) calling
+ * `destringifyChannelStateSnapshot`, then `snapshotToViewerChannelSetting`.
+ *
+ * @param channelIndex Index of the channel, to be turned into a `match` value.
+ * @param jsonState The serialized `ViewerChannelSetting` to parse, as an object.
+ * @returns A `ViewerChannelSetting` object.
+ */
+export var stringSnapshotToViewerChannelSetting = function stringSnapshotToViewerChannelSetting(channelIndex, jsonState) {
+  return snapshotToViewerChannelSetting(channelIndex, destringifyChannelStateSnapshot(jsonState));
+};
+
+/**
+ * Parses a stringified channel state snapshot (`ChannelStateStringified`)
+ * into a partial `ChannelState`.
+ *
+ * This is equivalent to (and implemented by) calling
+ * `destringifyChannelStateSnapshot`, then `snapshotToChannelState`.
+ *
+ * This function optionally accepts the target channel's `Histogram`. This
+ * argument is required to parse the following params correctly:
+ *
+ * - `lut`, which contains instructions for how to set the channel's
+ *   intensities *relative to its intensity distribution*.
+ * - `rmp`, the legacy ramp parameter represented as histogram bin indices
+ * - `cps`, the legacy control points parameter where `x` values are
+ *   represented as histogram bin indices
+ *
+ * If `histogram` is left undefined, e.g. because the channel has not yet been
+ * loaded, these params are ignored.
+ */
+export var stringSnapshotToChannelState = function stringSnapshotToChannelState(jsonState, histogram) {
+  return snapshotToChannelState(destringifyChannelStateSnapshot(jsonState), histogram);
+};