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

package/dist/cjs/context/SettingsContext.js

@@ -10,6 +10,7 @@ exports.useSettingsDispatch = useSettingsDispatch;
 var _react = _interopRequireWildcard(require("react"));
 var _lodash = _interopRequireDefault(require("lodash"));
 var _constants = require("../constants/constants");
+var _Resolver = require("../utils/Resolver");
 const _excluded = ["buster", "timestamp"];
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
@@ -22,20 +23,20 @@ function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, 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; }
 const SettingsContext = exports.SettingsContext = /*#__PURE__*/(0, _react.createContext)(null);
 const SettingsDispatchContext = exports.SettingsDispatchContext = /*#__PURE__*/(0, _react.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
@@ -43,8 +44,8 @@ const initialSettings = {
   polygons: {},
   controls: {
     colorScale: "Viridis",
-    valueRange: [0, 1],
     range: [0, 1],
+    // normalized
     colorAxis: {
       dmin: 0,
       dmax: 1,
@@ -73,11 +74,19 @@ const initialSettings = {
     maskSet: null,
     maskValues: null,
     categoricalMode: _constants.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 = _lodash.default.some(settings.vars, v => v.name === settings.selectedVar.name);
@@ -110,6 +119,18 @@ const validateSettings = settings => {
       settings.colorEncoding = null;
     }
   }
+
+  // @TODO: validate pseudospatial settings
+
+  // Keep only obs in use (selectedObs, labelObs) in data.obs
+  const obsNames = _lodash.default.uniq(_lodash.default.compact([(_settings$selectedObs = settings.selectedObs) === null || _settings$selectedObs === void 0 ? void 0 : _settings$selectedObs.name, ...settings.labelObs]));
+  const intersectionObs = _lodash.default.intersection(_lodash.default.keys(settings.data.obs), obsNames);
+  settings.data.obs = _lodash.default.pick(settings.data.obs, intersectionObs);
+
+  // Keep only vars in use (settings.vars) in data.vars
+  const varNames = _lodash.default.flatMap(settings.vars, v => v.isSet ? _lodash.default.map(v.vars, vv => vv.name) : v.name);
+  const intersectionVars = _lodash.default.intersection(_lodash.default.keys(settings.data.vars), varNames);
+  settings.data.vars = _lodash.default.pick(settings.data.vars, intersectionVars);
   return settings;
 };
 const initializer = _ref => {
@@ -121,6 +142,9 @@ const initializer = _ref => {
   const mergedSettings = canOverrideSettings ? _lodash.default.defaultsDeep({}, localSettings, defaultSettings, initialSettings) : _lodash.default.defaultsDeep({}, defaultSettings, initialSettings);
   return validateSettings(mergedSettings);
 };
+const validate = settings => {
+  return settings ? validateSettings(settings) : null;
+};
 function SettingsProvider(_ref2) {
   let {
     dataset_url,
@@ -140,21 +164,34 @@ 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] = (0, _react.useReducer)(settingsReducer, {
+  const initSettings = (0, _react.useRef)(initializer({
     canOverrideSettings,
     defaultSettings,
     localSettings
-  }, initializer);
+  }));
+  const resolvedSettings = (0, _Resolver.useResolver)(initSettings.current);
+  const [settings, dispatch] = (0, _react.useReducer)(settingsReducer, resolvedSettings, validate);
+  (0, _react.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]);
   (0, _react.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)));
+        }, _lodash.default.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");
@@ -168,7 +205,7 @@ function SettingsProvider(_ref2) {
     value: settings
   }, /*#__PURE__*/_react.default.createElement(SettingsDispatchContext.Provider, {
     value: dispatch
-  }, children));
+  }, settings && children));
 }
 function useSettings() {
   return (0, _react.useContext)(SettingsContext);
@@ -176,13 +213,70 @@ function useSettings() {
 function useSettingsDispatch() {
   return (0, _react.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 = _lodash.default.pick(obs, ["name", "omit", "bins"]);
+  const data = obs ? {
+    [obs.name]: _lodash.default.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({}, _lodash.default.pick(v, ["name", "isSet"])), {}, {
+      vars: _lodash.default.map(v.vars, vv => ({
+        name: vv.name
+      }))
+    });
+    data = _lodash.default.fromPairs(_lodash.default.map(v.vars, vv => [vv.name, _lodash.default.pick(vv, ["name", "index", "matrix_index"])]));
+  } else {
+    settings = _lodash.default.pick(v, ["name", "isSet"]);
+    data = {
+      [v.name]: _lodash.default.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) === _constants.OBS_TYPES.CATEGORICAL ? [0, 1] : settings.controls.range
           }),
@@ -200,8 +294,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":
@@ -210,8 +311,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)
+            })
           }));
         }
       }
@@ -229,8 +337,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)
+            })
           }));
         }
       }
@@ -265,8 +380,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)
+            })
           });
         }
       }
@@ -291,7 +413,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), {}, {
@@ -316,7 +442,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)
+            })
           }));
         }
       }
@@ -380,14 +509,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), {}, {
@@ -463,15 +584,22 @@ function settingsReducer(settings, action) {
       }
     case "toggle.slice.obs":
       {
-        if (_lodash.default.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
             })
@@ -496,25 +624,32 @@ function settingsReducer(settings, action) {
       }
     case "add.label.obs":
       {
-        if (settings.labelObs.find(i => _lodash.default.isEqual(i, action.obs))) {
+        if (_lodash.default.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/cjs/utils/Filter.js

@@ -7,6 +7,7 @@ exports.useFilter = void 0;
 var _react = require("react");
 var _turf = require("@turf/turf");
 var _lodash = _interopRequireDefault(require("lodash"));
+var _Resolver = require("./Resolver");
 var _constants = require("../constants/constants");
 var _FilterContext = require("../context/FilterContext");
 var _SettingsContext = require("../context/SettingsContext");
@@ -36,9 +37,14 @@ const isInValues = (omit, value) => {
   return !_lodash.default.includes(omit, value);
 };
 const useFilter = data => {
-  var _settings$selectedObs, _settings$selectedObs2, _settings$selectedObs3, _settings$selectedObs4, _settings$selectedObs7, _settings$selectedObs8;
+  var _selectedObs$omit, _selectedObs$bins2;
   const settings = (0, _SettingsContext.useSettings)();
   const filterDataDispatch = (0, _FilterContext.useFilteredDataDispatch)();
+  const selectedObs = (0, _Resolver.useSelectedObs)();
+  const omitCodes = _lodash.default.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,
@@ -46,26 +52,25 @@ const useFilter = data => {
     isPending,
     serverError
   } = data;
-  const isCategorical = ((_settings$selectedObs = settings.selectedObs) === null || _settings$selectedObs === void 0 ? void 0 : _settings$selectedObs.type) === _constants.OBS_TYPES.CATEGORICAL || ((_settings$selectedObs2 = settings.selectedObs) === null || _settings$selectedObs2 === void 0 ? void 0 : _settings$selectedObs2.type) === _constants.OBS_TYPES.BOOLEAN;
-  const isContinuous = ((_settings$selectedObs3 = settings.selectedObs) === null || _settings$selectedObs3 === void 0 ? void 0 : _settings$selectedObs3.type) === _constants.OBS_TYPES.CONTINUOUS;
-  const sliceByObs = settings.colorEncoding === _constants.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) === _constants.OBS_TYPES.CATEGORICAL || (selectedObs === null || selectedObs === void 0 ? void 0 : selectedObs.type) === _constants.OBS_TYPES.BOOLEAN;
+  const isContinuous = (selectedObs === null || selectedObs === void 0 ? void 0 : selectedObs.type) === _constants.OBS_TYPES.CONTINUOUS;
+  const sliceByObs = settings.colorEncoding === _constants.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 = (0, _react.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, _lodash.default.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, _lodash.default.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 = (0, _react.useCallback)((index, positions) => {
     let inSlice = true;
     if (settings.sliceBy.polygons && positions) {

package/dist/cjs/utils/Resolver.js

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