@haniffalab/cherita-react 1.4.1-dev.2025-08-13.6fc43290 → 1.4.1-dev.2025-08-13.8f63c242

package/dist/esm/context/SettingsContext.js

@@ -6,25 +6,26 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 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 _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
 function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-import React, { createContext, useContext, useEffect, useReducer } from "react";
+import React, { createContext, useContext, useEffect, useReducer, useRef } from "react";
 import _ from "lodash";
 import { COLOR_ENCODINGS, DOTPLOT_SCALES, LOCAL_STORAGE_KEY, MATRIXPLOT_SCALES, OBS_TYPES, PSEUDOSPATIAL_CATEGORICAL_MODES, VAR_SORT, VAR_SORT_ORDER, VIOLINPLOT_SCALES } from "../constants/constants";
+import { useResolver } from "../utils/Resolver";
 export const SettingsContext = /*#__PURE__*/createContext(null);
 export const SettingsDispatchContext = /*#__PURE__*/createContext(null);
-
-// @TODO: consider splitting constant values and dataset-resolved values
-// e.g. store only obs name in selectedObs, and resolved obs data (counts, values, etc.) elsewhere
-// e.g. store only var name in selectedVar, and resolved var data (index, matrix_index) elsewhere
-// would simplify passing and validating defaultSettings and localSettings
 const initialSettings = {
   selectedObs: null,
+  // { name: "obs_name", omit: ["obs_item"], bins: {} }
   selectedVar: null,
+  // { name: "var_name", isSet: false } or { name: "var_set_name", isSet: true, vars: [{ name: "var1" }, { name: "var2" }] }
   selectedObsm: null,
-  selectedMultiObs: [],
+  // "obsm_name" (e.g. "X_umap")
   selectedMultiVar: [],
-  colorEncoding: null,
+  // [{ name: "var_name", isSet: false }, { name: "var_set_name", isSet: true, vars: [{ name: "var1" }, { name: "var2" }] }]
   labelObs: [],
+  // [ "obs_name1", "obs_name2" ]
   vars: [],
+  // [{ name: "var_name", isSet: false }, { name: "var_set_name", isSet: true, vars: [{ name: "var1" }, { name: "var2" }] }]
+  colorEncoding: null,
   sliceBy: {
     obs: false,
     polygons: false
@@ -32,8 +33,8 @@ const initialSettings = {
   polygons: {},
   controls: {
     colorScale: "Viridis",
-    valueRange: [0, 1],
     range: [0, 1],
+    // normalized
     colorAxis: {
       dmin: 0,
       dmax: 1,
@@ -62,11 +63,19 @@ const initialSettings = {
     maskSet: null,
     maskValues: null,
     categoricalMode: PSEUDOSPATIAL_CATEGORICAL_MODES.ACROSS.value
+  },
+  // dataset resolved values
+  data: {
+    // store resolved obs and vars from selectedObs, selectedVar, selectedMultiVar, vars, labelObs
+    // keys to be removed when not in any selection
+    obs: {},
+    vars: {}
   }
 };
 
 // validate on initialization and reducer
 const validateSettings = settings => {
+  var _settings$selectedObs;
   // make sure selectedVar is in vars
   if (settings.selectedVar) {
     const inVars = _.some(settings.vars, v => v.name === settings.selectedVar.name);
@@ -99,6 +108,18 @@ const validateSettings = settings => {
       settings.colorEncoding = null;
     }
   }
+
+  // @TODO: validate pseudospatial settings
+
+  // Keep only obs in use (selectedObs, labelObs) in data.obs
+  const obsNames = _.uniq(_.compact([(_settings$selectedObs = settings.selectedObs) === null || _settings$selectedObs === void 0 ? void 0 : _settings$selectedObs.name, ...settings.labelObs]));
+  const intersectionObs = _.intersection(_.keys(settings.data.obs), obsNames);
+  settings.data.obs = _.pick(settings.data.obs, intersectionObs);
+
+  // Keep only vars in use (settings.vars) in data.vars
+  const varNames = _.flatMap(settings.vars, v => v.isSet ? _.map(v.vars, vv => vv.name) : v.name);
+  const intersectionVars = _.intersection(_.keys(settings.data.vars), varNames);
+  settings.data.vars = _.pick(settings.data.vars, intersectionVars);
   return settings;
 };
 const initializer = _ref => {
@@ -110,6 +131,9 @@ const initializer = _ref => {
   const mergedSettings = canOverrideSettings ? _.defaultsDeep({}, localSettings, defaultSettings, initialSettings) : _.defaultsDeep({}, defaultSettings, initialSettings);
   return validateSettings(mergedSettings);
 };
+const validate = settings => {
+  return settings ? validateSettings(settings) : null;
+};
 export function SettingsProvider(_ref2) {
   let {
     dataset_url,
@@ -129,21 +153,34 @@ export function SettingsProvider(_ref2) {
 
   // If the buster is not set or does not match the current package version,
   // reset localSettings to avoid stale data
-  if (!buster || buster !== "1.4.1-dev.2025-08-13.6fc43290") {
+  if (!buster || buster !== "1.4.1-dev.2025-08-13.8f63c242") {
     localSettings = {};
   }
-  const [settings, dispatch] = useReducer(settingsReducer, {
+  const initSettings = useRef(initializer({
     canOverrideSettings,
     defaultSettings,
     localSettings
-  }, initializer);
+  }));
+  const resolvedSettings = useResolver(initSettings.current);
+  const [settings, dispatch] = useReducer(settingsReducer, resolvedSettings, validate);
+  useEffect(() => {
+    // If resolvedSettings is null, do not update settings
+    if (resolvedSettings) {
+      const validatedSettings = validateSettings(resolvedSettings);
+      console.log("Initial settings:", validatedSettings);
+      dispatch({
+        type: "init",
+        settings: validatedSettings
+      });
+    }
+  }, [resolvedSettings]);
   useEffect(() => {
     if (canOverrideSettings) {
       try {
-        localStorage.setItem(DATASET_STORAGE_KEY, JSON.stringify(_objectSpread({
-          buster: "1.4.1-dev.2025-08-13.6fc43290" || "0.0.0",
+        localStorage.setItem(DATASET_STORAGE_KEY, JSON.stringify(_objectSpread(_objectSpread({
+          buster: "1.4.1-dev.2025-08-13.8f63c242" || "0.0.0",
           timestamp: Date.now()
-        }, settings)));
+        }, _.omit(settings, "data")), settings)));
       } catch (err) {
         if (err.code === 22 || err.code === 1014 || err.name === "QuotaExceededError" || err.name === "NS_ERROR_DOM_QUOTA_REACHED") {
           console.err("Browser storage quota exceeded");
@@ -157,7 +194,7 @@ export function SettingsProvider(_ref2) {
     value: settings
   }, /*#__PURE__*/React.createElement(SettingsDispatchContext.Provider, {
     value: dispatch
-  }, children));
+  }, settings && children));
 }
 export function useSettings() {
   return useContext(SettingsContext);
@@ -165,13 +202,70 @@ export function useSettings() {
 export function useSettingsDispatch() {
   return useContext(SettingsDispatchContext);
 }
+const OBS_DATA_KEYS = ["name", "type",
+// categorical and numerical
+"codes", "codesMap", "values", "n_values", "value_counts",
+// numerical
+"bins", "min", "max", "mean", "median", "n_unique"];
+const splitObs = obs => {
+  if (!obs) return {
+    settings: null,
+    data: {}
+  };
+  const settings = _.pick(obs, ["name", "omit", "bins"]);
+  const data = obs ? {
+    [obs.name]: _.pick(obs, OBS_DATA_KEYS)
+  } : {};
+  return {
+    settings,
+    data
+  };
+};
+const splitVar = v => {
+  if (!v) return {
+    settings: null,
+    data: {}
+  };
+  let settings, data;
+  if (v.isSet) {
+    settings = _objectSpread(_objectSpread({}, _.pick(v, ["name", "isSet"])), {}, {
+      vars: _.map(v.vars, vv => ({
+        name: vv.name
+      }))
+    });
+    data = _.fromPairs(_.map(v.vars, vv => [vv.name, _.pick(vv, ["name", "index", "matrix_index"])]));
+  } else {
+    settings = _.pick(v, ["name", "isSet"]);
+    data = {
+      [v.name]: _.pick(v, ["name", "index", "matrix_index"])
+    };
+  }
+  return {
+    settings,
+    data
+  };
+};
 function settingsReducer(settings, action) {
   switch (action.type) {
+    case "init":
+      {
+        return action.settings;
+      }
     case "select.obs":
       {
         var _action$obs;
-        return _objectSpread(_objectSpread({}, settings), {}, {
-          selectedObs: action.obs,
+        const {
+          settings: obsSettings,
+          data: obsData
+        } = splitObs(action.obs);
+        return _objectSpread(_objectSpread(_objectSpread({}, settings), action.obs ? {
+          selectedObs: obsSettings,
+          data: _objectSpread(_objectSpread({}, settings.data), {}, {
+            obs: _objectSpread(_objectSpread({}, settings.data.obs), obsData)
+          })
+        } : {
+          selectedObs: null
+        }), {}, {
           controls: _objectSpread(_objectSpread({}, settings.controls), {}, {
             range: ((_action$obs = action.obs) === null || _action$obs === void 0 ? void 0 : _action$obs.type) === OBS_TYPES.CATEGORICAL ? [0, 1] : settings.controls.range
           }),
@@ -189,8 +283,15 @@ function settingsReducer(settings, action) {
       }
     case "select.var":
       {
+        const {
+          settings: varSettings,
+          data: varData
+        } = splitVar(action.var);
         return validateSettings(_objectSpread(_objectSpread({}, settings), {}, {
-          selectedVar: action.var
+          selectedVar: varSettings,
+          data: _objectSpread(_objectSpread({}, settings.data), {}, {
+            vars: _objectSpread(_objectSpread({}, settings.data.vars), varData)
+          })
         }));
       }
     case "select.multivar":
@@ -199,8 +300,15 @@ function settingsReducer(settings, action) {
         if (inMultiVar) {
           return validateSettings(_objectSpread({}, settings));
         } else {
+          const {
+            settings: varSettings,
+            data: varData
+          } = splitVar(action.var);
           return validateSettings(_objectSpread(_objectSpread({}, settings), {}, {
-            selectedMultiVar: [...settings.selectedMultiVar, action.var]
+            selectedMultiVar: [...settings.selectedMultiVar, varSettings],
+            data: _objectSpread(_objectSpread({}, settings.data), {}, {
+              vars: _objectSpread(_objectSpread({}, settings.data.vars), varData)
+            })
           }));
         }
       }
@@ -218,8 +326,15 @@ function settingsReducer(settings, action) {
             selectedMultiVar: settings.selectedMultiVar.filter(v => v.name !== action.var.name)
           }));
         } else {
+          const {
+            settings: varSettings,
+            data: varData
+          } = splitVar(action.var);
           return validateSettings(_objectSpread(_objectSpread({}, settings), {}, {
-            selectedMultiVar: [...settings.selectedMultiVar, action.var]
+            selectedMultiVar: [...settings.selectedMultiVar, varSettings],
+            data: _objectSpread(_objectSpread({}, settings.data), {}, {
+              vars: _objectSpread(_objectSpread({}, settings.data.vars), varData)
+            })
           }));
         }
       }
@@ -254,8 +369,15 @@ function settingsReducer(settings, action) {
         if (settings.vars.find(v => v.name === action.var.name)) {
           return settings;
         } else {
+          const {
+            settings: varSettings,
+            data: varData
+          } = splitVar(action.var);
           return _objectSpread(_objectSpread({}, settings), {}, {
-            vars: [...settings.vars, action.var]
+            vars: [...settings.vars, varSettings],
+            data: _objectSpread(_objectSpread({}, settings.data), {}, {
+              vars: _objectSpread(_objectSpread({}, settings.data.vars), varData)
+            })
           });
         }
       }
@@ -280,7 +402,11 @@ function settingsReducer(settings, action) {
           return settings;
         } else {
           var _settings$selectedVar2;
-          const varSetVars = [...varSet.vars, action.var];
+          const {
+            settings: varSettings,
+            data: varData
+          } = splitVar(action.var);
+          const varSetVars = [...varSet.vars, varSettings];
           const vars = settings.vars.map(v => {
             if (v.name === varSet.name) {
               return _objectSpread(_objectSpread({}, v), {}, {
@@ -305,7 +431,10 @@ function settingsReducer(settings, action) {
           return validateSettings(_objectSpread(_objectSpread({}, settings), {}, {
             vars: vars,
             selectedVar: selectedVar,
-            selectedMultiVar: selectedMultiVar
+            selectedMultiVar: selectedMultiVar,
+            data: _objectSpread(_objectSpread({}, settings.data), {}, {
+              vars: _objectSpread(_objectSpread({}, settings.data.vars), varData)
+            })
           }));
         }
       }
@@ -369,14 +498,6 @@ function settingsReducer(settings, action) {
           })
         });
       }
-    case "set.controls.valueRange":
-      {
-        return _objectSpread(_objectSpread({}, settings), {}, {
-          controls: _objectSpread(_objectSpread({}, settings.controls), {}, {
-            valueRange: action.valueRange
-          })
-        });
-      }
     case "set.controls.range":
       {
         return _objectSpread(_objectSpread({}, settings), {}, {
@@ -452,15 +573,22 @@ function settingsReducer(settings, action) {
       }
     case "toggle.slice.obs":
       {
-        if (_.isEqual(settings.selectedObs, action.obs)) {
+        if (settings.selectedObs && settings.selectedObs.name === action.obs.name) {
           return _objectSpread(_objectSpread({}, settings), {}, {
             sliceBy: _objectSpread(_objectSpread({}, settings.sliceBy), {}, {
               obs: !settings.sliceBy.obs
             })
           });
         } else {
+          const {
+            settings: obsSettings,
+            data: obsData
+          } = splitObs(action.obs);
           return _objectSpread(_objectSpread({}, settings), {}, {
-            selectedObs: action.obs,
+            selectedObs: obsSettings,
+            data: _objectSpread(_objectSpread({}, settings.data), {}, {
+              obs: _objectSpread(_objectSpread({}, settings.data.obs), obsData)
+            }),
             sliceBy: _objectSpread(_objectSpread({}, settings.sliceBy), {}, {
               obs: true
             })
@@ -485,25 +613,32 @@ function settingsReducer(settings, action) {
       }
     case "add.label.obs":
       {
-        if (settings.labelObs.find(i => _.isEqual(i, action.obs))) {
+        if (_.includes(settings.labelObs, action.obs.name)) {
           return settings;
         } else {
+          const {
+            settings: obsSettings,
+            data: obsData
+          } = splitObs(action.obs);
           return _objectSpread(_objectSpread({}, settings), {}, {
-            labelObs: [...settings.labelObs, action.obs]
+            labelObs: [...settings.labelObs, obsSettings.name],
+            data: _objectSpread(_objectSpread({}, settings.data), {}, {
+              obs: _objectSpread(_objectSpread({}, settings.data.obs), obsData)
+            })
           });
         }
       }
     case "remove.label.obs":
       {
-        return _objectSpread(_objectSpread({}, settings), {}, {
-          labelObs: settings.labelObs.filter(a => a.name !== action.obsName)
-        });
+        return validateSettings(_objectSpread(_objectSpread({}, settings), {}, {
+          labelObs: settings.labelObs.filter(a => a !== action.obsName)
+        }));
       }
     case "reset.label.obs":
       {
-        return _objectSpread(_objectSpread({}, settings), {}, {
+        return validateSettings(_objectSpread(_objectSpread({}, settings), {}, {
           labelObs: []
-        });
+        }));
       }
     case "set.varSort":
       {

package/dist/esm/utils/Filter.js

@@ -1,6 +1,7 @@
 import { useEffect, useCallback, useMemo } from "react";
 import { booleanPointInPolygon, point } from "@turf/turf";
 import _ from "lodash";
+import { useSelectedObs } from "./Resolver";
 import { COLOR_ENCODINGS, OBS_TYPES } from "../constants/constants";
 import { useFilteredDataDispatch } from "../context/FilterContext";
 import { useSettings } from "../context/SettingsContext";
@@ -29,9 +30,14 @@ const isInValues = (omit, value) => {
   return !_.includes(omit, value);
 };
 export const useFilter = data => {
-  var _settings$selectedObs, _settings$selectedObs2, _settings$selectedObs3, _settings$selectedObs4, _settings$selectedObs7, _settings$selectedObs8;
+  var _selectedObs$omit, _selectedObs$bins2;
   const settings = useSettings();
   const filterDataDispatch = useFilteredDataDispatch();
+  const selectedObs = useSelectedObs();
+  const omitCodes = _.map((selectedObs === null || selectedObs === void 0 ? void 0 : selectedObs.omit) || [], o => {
+    var _selectedObs$codes;
+    return selectedObs === null || selectedObs === void 0 || (_selectedObs$codes = selectedObs.codes) === null || _selectedObs$codes === void 0 ? void 0 : _selectedObs$codes[o];
+  });
   const {
     obsmData,
     xData,
@@ -39,26 +45,25 @@ export const useFilter = data => {
     isPending,
     serverError
   } = data;
-  const isCategorical = ((_settings$selectedObs = settings.selectedObs) === null || _settings$selectedObs === void 0 ? void 0 : _settings$selectedObs.type) === OBS_TYPES.CATEGORICAL || ((_settings$selectedObs2 = settings.selectedObs) === null || _settings$selectedObs2 === void 0 ? void 0 : _settings$selectedObs2.type) === OBS_TYPES.BOOLEAN;
-  const isContinuous = ((_settings$selectedObs3 = settings.selectedObs) === null || _settings$selectedObs3 === void 0 ? void 0 : _settings$selectedObs3.type) === OBS_TYPES.CONTINUOUS;
-  const sliceByObs = settings.colorEncoding === COLOR_ENCODINGS.OBS && !!((_settings$selectedObs4 = settings.selectedObs) !== null && _settings$selectedObs4 !== void 0 && _settings$selectedObs4.omit.length) || settings.sliceBy.obs;
+  const isCategorical = (selectedObs === null || selectedObs === void 0 ? void 0 : selectedObs.type) === OBS_TYPES.CATEGORICAL || (selectedObs === null || selectedObs === void 0 ? void 0 : selectedObs.type) === OBS_TYPES.BOOLEAN;
+  const isContinuous = (selectedObs === null || selectedObs === void 0 ? void 0 : selectedObs.type) === OBS_TYPES.CONTINUOUS;
+  const sliceByObs = settings.colorEncoding === COLOR_ENCODINGS.OBS && !!(selectedObs !== null && selectedObs !== void 0 && (_selectedObs$omit = selectedObs.omit) !== null && _selectedObs$omit !== void 0 && _selectedObs$omit.length) || settings.sliceBy.obs;
   const isInObsSlice = useCallback((index, values) => {
     let inSlice = true;
     if (values && sliceByObs) {
       if (isCategorical) {
-        var _settings$selectedObs5;
-        inSlice &= isInValues((_settings$selectedObs5 = settings.selectedObs) === null || _settings$selectedObs5 === void 0 ? void 0 : _settings$selectedObs5.omit, values[index]);
+        inSlice &= isInValues(omitCodes, values[index]);
       } else if (isContinuous) {
         if (isNaN(values[index])) {
-          var _settings$selectedObs6;
-          inSlice &= isInValues((_settings$selectedObs6 = settings.selectedObs) === null || _settings$selectedObs6 === void 0 ? void 0 : _settings$selectedObs6.omit, -1);
+          inSlice &= isInValues(omitCodes, -1);
         } else {
-          inSlice &= isInBins(values[index], settings.selectedObs.bins.binEdges, _.without(settings.selectedObs.omit, -1));
+          var _selectedObs$bins;
+          inSlice &= isInBins(values[index], selectedObs === null || selectedObs === void 0 || (_selectedObs$bins = selectedObs.bins) === null || _selectedObs$bins === void 0 ? void 0 : _selectedObs$bins.binEdges, _.without(omitCodes, -1));
         }
       }
     }
     return inSlice;
-  }, [(_settings$selectedObs7 = settings.selectedObs) === null || _settings$selectedObs7 === void 0 || (_settings$selectedObs7 = _settings$selectedObs7.bins) === null || _settings$selectedObs7 === void 0 ? void 0 : _settings$selectedObs7.binEdges, (_settings$selectedObs8 = settings.selectedObs) === null || _settings$selectedObs8 === void 0 ? void 0 : _settings$selectedObs8.omit, isCategorical, isContinuous, sliceByObs]);
+  }, [sliceByObs, isCategorical, isContinuous, omitCodes, selectedObs === null || selectedObs === void 0 || (_selectedObs$bins2 = selectedObs.bins) === null || _selectedObs$bins2 === void 0 ? void 0 : _selectedObs$bins2.binEdges]);
   const isInPolygonsSlice = useCallback((index, positions) => {
     let inSlice = true;
     if (settings.sliceBy.polygons && positions) {

package/dist/esm/utils/Resolver.js

@@ -0,0 +1,176 @@
+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); }
+import { useState, useEffect, useMemo } from "react";
+import _ from "lodash";
+import { useFetch } from "./requests";
+import { useDataset } from "../context/DatasetContext";
+import { useSettings } from "../context/SettingsContext";
+const cleanSettings = settings => {
+  // Remove obs and vars from settings that are not in data
+
+  const selectedObs = settings.selectedObs && settings.data.obs[settings.selectedObs.name] ? settings.selectedObs : null;
+  const labelObs = _.filter(settings.labelObs, obsName => settings.data.obs[obsName]);
+  const selectedVar = settings.selectedVar && (settings.selectedVar.isSet ? _.every(settings.selectedVar.vars, vv => settings.data.vars[vv.name]) : settings.data.vars[settings.selectedVar.name]) ? settings.selectedVar : null;
+  const selectedMultiVar = _.filter(settings.selectedMultiVar, v => {
+    if (v.isSet) {
+      return _.every(v.vars, vv => settings.data.vars[vv.name]);
+    } else {
+      return settings.data.vars[v.name];
+    }
+  });
+  const vars = _.filter(settings.vars, v => {
+    if (v.isSet) {
+      return _.every(v.vars, vv => settings.data.vars[vv.name]);
+    } else {
+      return settings.data.vars[v.name];
+    }
+  });
+  return _objectSpread(_objectSpread({}, settings), {}, {
+    selectedObs: selectedObs,
+    labelObs: labelObs,
+    selectedVar: selectedVar,
+    selectedMultiVar: selectedMultiVar,
+    vars: vars
+  });
+};
+export const useResolver = initSettings => {
+  var _initSettings$selecte;
+  const dataset = useDataset();
+  const [data, setData] = useState({
+    obs: {},
+    vars: {}
+  });
+  const [resolvedObs, setResolvedObs] = useState(false);
+  const [resolvedVars, setResolvedVars] = useState(false);
+  const [resolvedSettings, setResolvedSettings] = useState(null);
+
+  // obs
+  // all obs should be in initSettings.selectedObs and initSettings.labelObs
+  const initObs = _.uniqBy(_.compact([initSettings.selectedObs, ..._.map(initSettings.labelObs, o => ({
+    name: o
+  }))]), "name");
+  const initObsNames = _.map(initObs, o => o.name);
+  const [obsParams] = useState({
+    url: dataset.url,
+    cols: initObsNames,
+    obsParams: _.fromPairs(_.map(initObs, o => [o.name, {
+      bins: o.bins || {}
+    }]))
+  });
+  const {
+    fetchedData: obsData,
+    isPending: obsDataPending,
+    serverError: obsDataError
+  } = useFetch("obs/cols", obsParams, {
+    enabled: !!initObsNames.length
+  });
+
+  // vars
+  // all vars should be in initSettings.vars from validation
+  const initVars = initSettings.vars;
+  const initVarsNames = _.flatMap(initVars, v => v.isSet ? _.map(v.vars, vv => vv.name) : v.name);
+  const [varParams] = useState({
+    url: dataset.url,
+    col: dataset.varNamesCol,
+    names: initVarsNames
+  });
+  const {
+    fetchedData: varData,
+    isPending: varDataPending,
+    serverError: varDataError
+  } = useFetch("var/cols/names", varParams, {
+    enabled: !!varParams.names.length
+  });
+  useEffect(() => {
+    if (!obsDataPending) {
+      if (obsDataError) {
+        console.error("Error fetching obs data:", obsDataError);
+        setResolvedObs(true);
+        return;
+      }
+      if (obsData) {
+        setData(d => _objectSpread(_objectSpread({}, d), {}, {
+          obs: _.fromPairs(_.map(obsData, o => [o.name, o]))
+        }));
+      }
+      setResolvedObs(true);
+    }
+  }, [obsData, obsDataError, obsDataPending, (_initSettings$selecte = initSettings.selectedObs) === null || _initSettings$selecte === void 0 ? void 0 : _initSettings$selecte.omit]);
+  useEffect(() => {
+    if (!varDataPending) {
+      if (varDataError) {
+        console.error("Error fetching var data:", varDataError);
+        setResolvedVars(true);
+        return;
+      }
+      if (varData) {
+        setData(d => _objectSpread(_objectSpread({}, d), {}, {
+          vars: _.fromPairs(_.map(varData, v => [v.name, v]))
+        }));
+      }
+      setResolvedVars(true);
+    }
+  }, [initSettings.vars, varData, varDataError, varDataPending]);
+  useEffect(() => {
+    if (resolvedObs && resolvedVars) {
+      const cleanedSettings = cleanSettings(_objectSpread(_objectSpread({}, initSettings), {}, {
+        data: data
+      }));
+      setResolvedSettings(cleanedSettings);
+    }
+  }, [data, initSettings, resolvedObs, resolvedVars, setResolvedSettings]);
+  return resolvedSettings;
+};
+export const useSelectedObs = () => {
+  const settings = useSettings();
+  return useMemo(() => {
+    return settings.selectedObs ? _objectSpread(_objectSpread({}, settings.selectedObs), settings.data.obs[settings.selectedObs.name]) : null;
+  }, [settings.data.obs, settings.selectedObs]);
+};
+export const useSelectedVar = () => {
+  const settings = useSettings();
+  return useMemo(() => {
+    if (settings.selectedVar) {
+      if (settings.selectedVar.isSet) {
+        return _objectSpread(_objectSpread({}, settings.selectedVar), {}, {
+          vars: settings.selectedVar.vars.map(v => _objectSpread({}, settings.data.vars[v.name]))
+        });
+      } else {
+        return _objectSpread(_objectSpread({}, settings.selectedVar), settings.data.vars[settings.selectedVar.name]);
+      }
+    } else {
+      return null;
+    }
+  }, [settings.data.vars, settings.selectedVar]);
+};
+export const useSelectedMultiVar = () => {
+  const settings = useSettings();
+  return useMemo(() => {
+    return _.map(settings.selectedMultiVar, v => {
+      if (v.isSet) {
+        return _objectSpread(_objectSpread({}, v), {}, {
+          vars: v.vars.map(vv => _objectSpread({}, settings.data.vars[vv.name]))
+        });
+      } else {
+        return _objectSpread(_objectSpread({}, v), settings.data.vars[v.name]);
+      }
+    });
+  }, [settings.data.vars, settings.selectedMultiVar]);
+};
+export const useSettingsVars = () => {
+  const settings = useSettings();
+  return useMemo(() => {
+    return _.map(settings.vars, v => {
+      if (v.isSet) {
+        return _objectSpread(_objectSpread({}, v), {}, {
+          vars: v.vars.map(vv => _objectSpread({}, settings.data.vars[vv.name]))
+        });
+      } else {
+        return _objectSpread(_objectSpread({}, v), settings.data.vars[v.name]);
+      }
+    });
+  }, [settings.data.vars, settings.vars]);
+};