@haniffalab/cherita-react 1.2.0 → 1.3.0-dev.2025-05-29.ee7e9b72

package/dist/esm/context/DatasetContext.js

@@ -1,13 +1,20 @@
-import React, { useEffect, createContext, useContext, useReducer } from "react";
+const _excluded = ["dataset_url", "children"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _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 } from "react";
 import { createSyncStoragePersister } from "@tanstack/query-sync-storage-persister";
 import { QueryClient, QueryCache } from "@tanstack/react-query";
 import { PersistQueryClientProvider } from "@tanstack/react-query-persist-client";
 import _ from "lodash";
 import { FilterProvider } from "./FilterContext";
+import { SettingsProvider } from "./SettingsContext";
 import { ZarrDataProvider } from "./ZarrDataContext";
-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";
 export const DatasetContext = /*#__PURE__*/createContext(null);
-export const DatasetDispatchContext = /*#__PURE__*/createContext(null);
 const queryClient = new QueryClient({
   defaultOptions: {
     queries: {
@@ -38,7 +45,7 @@ const persistOptions = {
         state
       } = _ref;
       if (state.status === "success") {
-        return persistKeys.includes(queryKey?.[0]);
+        return persistKeys.includes(queryKey === null || queryKey === void 0 ? void 0 : queryKey[0]);
       }
       return false;
     }
@@ -46,93 +53,29 @@ const persistOptions = {
   // @TODO: add maxAge and buster (app and api version numbers as busters)
 };
 const initialDataset = {
+  url: null,
   varNamesCol: null,
-  selectedObs: null,
-  selectedObsm: null,
-  selectedVar: null,
-  selectedMultiObs: [],
-  selectedMultiVar: [],
-  colorEncoding: null,
-  labelObs: [],
-  varSets: [],
-  sliceBy: {
-    obs: false,
-    polygons: false
-  },
-  controls: {
-    colorScale: "Viridis",
-    valueRange: [0, 1],
-    range: [0, 1],
-    colorAxis: {
-      dmin: 0,
-      dmax: 1,
-      cmin: 0,
-      cmax: 1
-    },
-    scale: {
-      dotplot: DOTPLOT_SCALES.NONE,
-      matrixplot: MATRIXPLOT_SCALES.NONE,
-      violinplot: VIOLINPLOT_SCALES.WIDTH
-    },
-    meanOnlyExpressed: false,
-    expressionCutoff: 0.0
-  },
   diseaseDatasets: [],
-  selectedDisease: null,
-  varSort: {
-    var: {
-      sort: VAR_SORT.NONE,
-      sortOrder: VAR_SORT_ORDER.ASC
-    },
-    disease: {
-      sort: VAR_SORT.NONE,
-      sortOrder: VAR_SORT_ORDER.ASC
-    }
-  },
   obsGroups: null,
   imageUrl: null,
-  pseudospatial: {
-    maskSet: null,
-    maskValues: null,
-    categoricalMode: PSEUDOSPATIAL_CATEGORICAL_MODES.ACROSS.value
-  },
-  polygons: {}
-};
-const initializer = initialState => {
-  const localObj = (JSON.parse(localStorage.getItem(LOCAL_STORAGE_KEY)) || {})[initialState.url] || {};
-  const keys = _.keys(initialState);
-  const localValues = _.pick(localObj, keys);
-  return _.assign(initialState, localValues);
+  defaultSettings: {},
+  canOverrideSettings: true
 };
 export function DatasetProvider(_ref2) {
   let {
-    dataset_url,
-    children,
-    ...dataset_params
-  } = _ref2;
-  const [dataset, dispatch] = useReducer(datasetReducer, _.assign(initializer({
-    url: dataset_url,
-    ...initialDataset
-  }), dataset_params));
-  useEffect(() => {
-    try {
-      const localObj = JSON.parse(localStorage.getItem(LOCAL_STORAGE_KEY)) || {};
-      localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify({
-        ...localObj,
-        [dataset.url]: dataset
-      }));
-    } 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");
-      } else {
-        console.err(err);
-      }
-    }
-  }, [dataset]);
+      dataset_url,
+      children
+    } = _ref2,
+    dataset_params = _objectWithoutProperties(_ref2, _excluded);
+  const dataset = _.assign(initialDataset, _objectSpread({
+    url: dataset_url
+  }, dataset_params));
   return /*#__PURE__*/React.createElement(DatasetContext.Provider, {
     value: dataset
-  }, /*#__PURE__*/React.createElement(DatasetDispatchContext.Provider, {
-    value: dispatch
+  }, /*#__PURE__*/React.createElement(SettingsProvider, {
+    dataset_url: dataset.url,
+    defaultSettings: dataset.defaultSettings,
+    canOverrideSettings: dataset.canOverrideSettings
   }, /*#__PURE__*/React.createElement(PersistQueryClientProvider, {
     client: queryClient,
     persistOptions: persistOptions
@@ -140,432 +83,4 @@ export function DatasetProvider(_ref2) {
 }
 export function useDataset() {
   return useContext(DatasetContext);
-}
-export function useDatasetDispatch() {
-  return useContext(DatasetDispatchContext);
-}
-function datasetReducer(dataset, action) {
-  switch (action.type) {
-    case "select.obs":
-      {
-        return {
-          ...dataset,
-          selectedObs: action.obs,
-          controls: {
-            ...dataset.controls,
-            range: action.obs?.type === OBS_TYPES.CATEGORICAL ? [0, 1] : dataset.controls.range
-          },
-          colorEncoding: dataset.colorEncoding === COLOR_ENCODINGS.OBS && !action.obs ? null : dataset.colorEncoding,
-          sliceBy: {
-            ...dataset.sliceBy,
-            obs: action.obs ? dataset.sliceBy.obs : false
-          }
-        };
-      }
-    case "select.obsm":
-      {
-        return {
-          ...dataset,
-          selectedObsm: action.obsm
-        };
-      }
-    case "select.var":
-      {
-        return {
-          ...dataset,
-          selectedVar: action.var
-        };
-      }
-    case "select.multivar":
-      {
-        if (dataset.selectedMultiVar.find(i => action.var.isSet ? i.name === action.var.name : i.matrix_index === action.var.matrix_index)) {
-          return dataset;
-        } else {
-          return {
-            ...dataset,
-            selectedMultiVar: [...dataset.selectedMultiVar, action.var]
-          };
-        }
-      }
-    case "deselect.multivar":
-      {
-        return {
-          ...dataset,
-          selectedMultiVar: dataset.selectedMultiVar.filter(a => action.var.isSet ? a.name !== action.var.name : a.matrix_index !== action.var.matrix_index)
-        };
-      }
-    case "update.multivar":
-      {
-        return {
-          ...dataset,
-          selelectedMultiVar: dataset.selectedMultiVar.map(i => {
-            if (i.isSet) {
-              return action.vars.find(s => s.name === i.name);
-            }
-            return i;
-          })
-        };
-      }
-    case "set.colorEncoding":
-      {
-        return {
-          ...dataset,
-          colorEncoding: action.value
-        };
-      }
-    case "reset.multiVar":
-      {
-        return {
-          ...dataset,
-          selectedMultiVar: [],
-          colorEncoding: dataset.colorEncoding === COLOR_ENCODINGS.VAR ? null : dataset.colorEncoding
-        };
-      }
-    case "reset.var":
-      {
-        return {
-          ...dataset,
-          selectedVar: null,
-          colorEncoding: dataset.colorEncoding === COLOR_ENCODINGS.VAR ? null : dataset.colorEncoding
-        };
-      }
-    case "add.varSet":
-      {
-        return {
-          ...dataset,
-          varSets: [...dataset.varSets, action.varSet]
-        };
-      }
-    case "remove.varSet":
-      {
-        return {
-          ...dataset,
-          varSets: dataset.varSets.filter(a => a.name !== action.varSet.name)
-        };
-      }
-    case "reset.varSets":
-      {
-        return {
-          ...dataset,
-          varSets: []
-        };
-      }
-    case "add.varSet.var":
-      {
-        const varSet = dataset.varSets.find(s => s.name === action.varSet.name);
-        if (varSet.vars.find(v => _.isEqual(v, action.var))) {
-          return dataset;
-        } else {
-          return {
-            ...dataset,
-            varSets: dataset.varSets.map(s => {
-              if (s.name === varSet.name) {
-                return {
-                  ...s,
-                  vars: [...s.vars, action.var]
-                };
-              } else {
-                return s;
-              }
-            })
-          };
-        }
-      }
-    case "remove.varSet.var":
-      {
-        const varSet = dataset.varSets.find(s => s.name === action.varSet.name);
-        return {
-          ...dataset,
-          varSets: dataset.varSets.map(s => {
-            if (s.name === varSet.name) {
-              return {
-                ...s,
-                vars: s.vars.filter(v => v.name !== action.var.name)
-              };
-            } else {
-              return s;
-            }
-          })
-        };
-      }
-    case "select.disease":
-      {
-        return {
-          ...dataset,
-          selectedDisease: {
-            id: action.id,
-            name: action.name
-          }
-        };
-      }
-    case "reset.disease":
-      {
-        return {
-          ...dataset,
-          selectedDisease: null
-        };
-      }
-    case "set.controls.colorScale":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            colorScale: action.colorScale
-          }
-        };
-      }
-    case "set.controls.valueRange":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            valueRange: action.valueRange
-          }
-        };
-      }
-    case "set.controls.range":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            range: action.range
-          }
-        };
-      }
-    case "set.controls.colorAxis":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            colorAxis: action.colorAxis
-          }
-        };
-      }
-    case "set.controls.colorAxis.crange":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            colorAxis: {
-              ...dataset.controls.colorAxis,
-              cmin: action.cmin,
-              cmax: action.cmax
-            }
-          }
-        };
-      }
-    case "set.controls.colorAxis.cmin":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            colorAxis: {
-              ...dataset.controls.colorAxis,
-              cmin: action.cmin
-            }
-          }
-        };
-      }
-    case "set.controls.colorAxis.cmax":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            colorAxis: {
-              ...dataset.controls.colorAxis,
-              cmax: action.cmax
-            }
-          }
-        };
-      }
-    case "set.controls.scale":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            scale: {
-              ...dataset.controls.scale,
-              [action.plot]: action.scale
-            }
-          }
-        };
-      }
-    case "set.controls.meanOnlyExpressed":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            meanOnlyExpressed: action.meanOnlyExpressed
-          }
-        };
-      }
-    case "set.controls.expressionCutoff":
-      {
-        return {
-          ...dataset,
-          controls: {
-            ...dataset.controls,
-            expressionCutoff: action.expressionCutoff
-          }
-        };
-      }
-    case "toggle.slice.obs":
-      {
-        if (_.isEqual(dataset.selectedObs, action.obs)) {
-          return {
-            ...dataset,
-            sliceBy: {
-              ...dataset.sliceBy,
-              obs: !dataset.sliceBy.obs
-            }
-          };
-        } else {
-          return {
-            ...dataset,
-            selectedObs: action.obs,
-            sliceBy: {
-              ...dataset.sliceBy,
-              obs: true
-            }
-          };
-        }
-      }
-    case "toggle.slice.polygons":
-      {
-        return {
-          ...dataset,
-          sliceBy: {
-            ...dataset.sliceBy,
-            polygons: !dataset.sliceBy.polygons
-          }
-        };
-      }
-    case "disable.slice.polygons":
-      {
-        return {
-          ...dataset,
-          sliceBy: {
-            ...dataset.sliceBy,
-            polygons: false
-          }
-        };
-      }
-    case "add.label.obs":
-      {
-        if (dataset.labelObs.find(i => _.isEqual(i, action.obs))) {
-          return dataset;
-        } else {
-          return {
-            ...dataset,
-            labelObs: [...dataset.labelObs, action.obs]
-          };
-        }
-      }
-    case "remove.label.obs":
-      {
-        return {
-          ...dataset,
-          labelObs: dataset.labelObs.filter(a => a.name !== action.obsName)
-        };
-      }
-    case "reset.label.obs":
-      {
-        return {
-          ...dataset,
-          labelObs: []
-        };
-      }
-    case "set.varSort":
-      {
-        return {
-          ...dataset,
-          varSort: {
-            ...dataset.varSort,
-            [action.var]: {
-              sort: action.sort,
-              sortOrder: action.sortOrder
-            }
-          }
-        };
-      }
-    case "set.varSort.sort":
-      {
-        return {
-          ...dataset,
-          varSort: {
-            ...dataset.varSort,
-            [action.var]: {
-              ...dataset.varSort[action.var],
-              sort: action.sort
-            }
-          }
-        };
-      }
-    case "set.varSort.sortOrder":
-      {
-        return {
-          ...dataset,
-          varSort: {
-            ...dataset.varSort,
-            [action.var]: {
-              ...dataset.varSort[action.var],
-              sortOrder: action.sortOrder
-            }
-          }
-        };
-      }
-    case "set.polygons":
-      {
-        return {
-          ...dataset,
-          polygons: {
-            ...dataset.polygons,
-            [action.obsm]: action.polygons
-          }
-        };
-      }
-    case "set.pseudospatial.maskSet":
-      {
-        return {
-          ...dataset,
-          pseudospatial: {
-            ...dataset.pseudospatial,
-            maskSet: action.maskSet
-          }
-        };
-      }
-    case "set.pseudospatial.maskValues":
-      {
-        return {
-          ...dataset,
-          pseudospatial: {
-            ...dataset.pseudospatial,
-            maskValues: action.maskValues
-          }
-        };
-      }
-    case "set.pseudospatial.categoricalMode":
-      {
-        return {
-          ...dataset,
-          pseudospatial: {
-            ...dataset.pseudospatial,
-            categoricalMode: action.categoricalMode
-          }
-        };
-      }
-    default:
-      {
-        throw Error("Unknown action: " + action.type);
-      }
-  }
 }

package/dist/esm/context/FilterContext.js

@@ -1,3 +1,8 @@
+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 React, { useReducer, createContext, useContext } from "react";
 export const FilteredDataContext = /*#__PURE__*/createContext(null);
 export const FilteredDataDispatchContext = /*#__PURE__*/createContext(null);
@@ -12,9 +17,7 @@ export function FilterProvider(_ref) {
   let {
     children
   } = _ref;
-  const [filteredData, dispatch] = useReducer(filterReducer, {
-    ...initialFilterData
-  });
+  const [filteredData, dispatch] = useReducer(filterReducer, _objectSpread({}, initialFilterData));
   return /*#__PURE__*/React.createElement(FilteredDataContext.Provider, {
     value: filteredData
   }, /*#__PURE__*/React.createElement(FilteredDataDispatchContext.Provider, {
@@ -31,14 +34,13 @@ function filterReducer(filteredData, action) {
   switch (action.type) {
     case "set.obs.indices":
       {
-        return {
-          ...filteredData,
+        return _objectSpread(_objectSpread({}, filteredData), {}, {
           obsIndices: action.indices,
           valueMin: action.valueMin,
           valueMax: action.valueMax,
           slicedLength: action.slicedLength,
           isSliced: action.isSliced
-        };
+        });
       }
     default:
       {