@sjcrh/proteinpaint-client 2.206.0 → 2.207.0

package/dist/chunk-7WWTWWB7.js

@@ -0,0 +1,158 @@
+import {
+  NumericDensity
+} from "./chunk-F4DM3WS4.js";
+import {
+  Tabs
+} from "./chunk-NQDF3U2C.js";
+import {
+  HandlerBase
+} from "./chunk-KV4W2ACA.js";
+
+// termsetting/handlers/NumericHandler.ts
+var NumericHandler = class extends HandlerBase {
+  constructor(opts) {
+    super(opts);
+    this.tabs = [];
+    this.handlerByMode = {};
+    this.dom = {};
+    this.opts = opts;
+    this.termsetting = opts.termsetting;
+    this.tw = opts.termsetting.tw;
+    this.tabs = this.setTabData();
+    this.density = new NumericDensity(opts);
+  }
+  getPillStatus() {
+    this.tw = this.termsetting.tw;
+    return this.tw.getStatus(this.termsetting.usecase, this.termsetting.data);
+  }
+  setTabData() {
+    const self = this.termsetting;
+    const tabs = [];
+    const callback = async (event, tabData) => {
+      if (event) event.stopPropagation();
+      try {
+        await this.setEditHandler(tabData);
+        await this.editHandler.showEditMenu(tabData.contentHolder);
+      } catch (e) {
+        this.dom.errdiv.style("display", "").text(e);
+      }
+    };
+    const numTabs = self.opts.numericEditMenuVersion.length;
+    if (self.opts.numericEditMenuVersion.includes("continuous")) {
+      tabs.push({
+        mode: "continuous",
+        label: self.term.type == "survival" ? "Time to Event" : "Continuous",
+        callback,
+        active: this.tw.q.mode === "continuous" || numTabs === 1
+      });
+    }
+    if (self.opts.numericEditMenuVersion.includes("discrete")) {
+      tabs.push({
+        mode: "discrete",
+        label: self.term.type == "survival" ? "Exit code" : "Discrete",
+        callback,
+        active: this.tw.q.mode === "discrete" || numTabs === 1
+      });
+    }
+    if (self.opts.numericEditMenuVersion.includes("spline")) {
+      tabs.push({
+        mode: "spline",
+        label: "Cubic spline",
+        callback,
+        active: this.tw.q.mode === "spline" || numTabs === 1
+      });
+    }
+    if (self.opts.numericEditMenuVersion.includes("binary")) {
+      tabs.push({
+        mode: "binary",
+        label: "Binary",
+        callback,
+        active: this.tw.q.mode === "binary" || numTabs === 1
+      });
+    }
+    return tabs;
+  }
+  async setEditHandler(tabData) {
+    if (!this.handlerByMode[tabData.mode]) {
+      switch (tabData.mode) {
+        case "continuous": {
+          const { NumContEditor } = await import("./NumContEditor-FSHA32UV.js");
+          this.handlerByMode.continuous = new NumContEditor(this.opts, this);
+          break;
+        }
+        case "discrete": {
+          const { NumDiscreteEditor } = await import("./NumDiscreteEditor-K4AZ6UQF.js");
+          this.handlerByMode.discrete = new NumDiscreteEditor(this.opts, this);
+          break;
+        }
+        case "binary": {
+          const { NumBinaryEditor } = await import("./NumBinaryEditor-V3YCDNRR.js");
+          this.handlerByMode.binary = new NumBinaryEditor(this.opts, this);
+          break;
+        }
+        case "spline": {
+          const { NumSplineEditor } = await import("./NumSplineEditor-ZLB5MWYK.js");
+          this.handlerByMode.spline = new NumSplineEditor(this.opts, this);
+          break;
+        }
+        default:
+          throw `unexpected numeric tabData.mode='${tabData.mode}'`;
+          break;
+      }
+    }
+    this.editHandler = this.handlerByMode[tabData.mode];
+  }
+  async showEditMenu(div) {
+    try {
+      this.showLoading(div);
+      this.dom.errdiv = div.append("div").attr("class", "sja_errorbar").style("display", "none");
+      this.tw = this.termsetting.tw;
+      const self = this.tw;
+      for (const t of this.tabs) {
+        t.active = this.tabs.length === 1 || self.q.mode == t.mode || t.mode == "continuous" && !self.q.mode;
+      }
+      this.density_data = await this.density.setData();
+      await this.setEditHandler(this.tabs.find((t) => t.active));
+      this.dom.editDiv = div.append("div").attr("data-testid", "sjpp-num-ts-edit-div");
+      this.dom.btnDiv = div.append("div").style("margin", "0px 0px 5px 5px");
+      this.renderButtons(this.dom.btnDiv);
+      if (this.tabs.length > 1) {
+        this.dom.topBar = this.dom.editDiv.append("div").style("padding", "10px");
+        this.dom.topBar.append("span").html("Use as ");
+        new Tabs({
+          holder: this.dom.topBar.append("div").style("display", "inline-block"),
+          contentHolder: this.dom.editDiv.append("div"),
+          noTopContentStyle: true,
+          tabs: this.tabs
+        }).main();
+      } else {
+        await this.editHandler.showEditMenu(this.dom.editDiv);
+      }
+      this.dom.loadingDiv.style("display", "none");
+    } catch (e) {
+      this.hideLoading();
+      this.dom.errdiv.style("display", "").text(typeof e == "object" ? e.message || e.error || e : e);
+    }
+  }
+  renderButtons(btnDiv) {
+    btnDiv.append("button").style("margin", "5px").attr("data-testId", "sjpp_numeric_edit_apply").html("Apply").on("click", () => {
+      this.termsetting.q = this.editHandler.getEditedQ();
+      this.termsetting.dom.tip.hide();
+      this.termsetting.api.runCallback();
+    });
+    btnDiv.append("button").style("margin", "5px").attr("data-testId", "sjpp_numeric_edit_reset").html("Reset").on("click", () => {
+      this.editHandler.undoEdits();
+    });
+  }
+  destroy() {
+    for (const s of Object.values(this.dom)) {
+      if (typeof s.remove == "function") s.remove();
+    }
+    this.density.destroy();
+  }
+};
+
+export {
+  NumericHandler
+};
+//# sourceMappingURL=chunk-7WWTWWB7.js.map

package/dist/chunk-AEHBMP7F.js

@@ -0,0 +1,550 @@
+import {
+  rehydrateFilter
+} from "./chunk-SKMFMGCD.js";
+import {
+  findParent,
+  getFilter,
+  getFilterItemByTag,
+  getGvQLabel,
+  getSamplelstTW,
+  isCustomizedGvQ
+} from "./chunk-NQDF3U2C.js";
+import {
+  importPlot
+} from "./chunk-CCYVGZGI.js";
+import {
+  forEachGvTw,
+  getGvQCacheKey,
+  gvQCacheKeyPrefix,
+  trimGvQForCache
+} from "./chunk-HZ3TCGBK.js";
+import {
+  StoreApi,
+  StoreBase,
+  deepEqual
+} from "./chunk-WINIL2KN.js";
+import {
+  CustomError
+} from "./chunk-W5J3LTYS.js";
+
+// mass/store.ts
+var idPrefix = "_MASS_AUTOID_" + Math.random().toString().slice(-6);
+var id = 0;
+var usedPlotIds = /* @__PURE__ */ new Set();
+function getId() {
+  return idPrefix + "_" + id++;
+}
+var navHeaderModes = /* @__PURE__ */ new Set([
+  "with_tabs",
+  // default, shows tabs cohort/charts/filter etc
+  "hidden",
+  // no header
+  "search_only",
+  // ?
+  "hide_search",
+  // ?
+  "with_cohortHtmlSelect",
+  // only show cohort toggle as <select>
+  "only_buttons"
+]);
+var defaultState = {
+  nav: {
+    header_mode: "with_tabs",
+    activeTab: 0
+    // -1 for no active tab and all closed
+  },
+  // will be ignored if there is no dataset termdb.selectCohort
+  // or value will be set to match a filter node that has been tagged
+  // as 'cohortfilter' in state.termfilter.filter
+  activeCohort: 0,
+  search: { isVisible: true },
+  plots: [],
+  termfilter: {
+    filter: {
+      type: "tvslst",
+      in: true,
+      join: "",
+      lst: []
+    }
+  },
+  reuse: {
+    /* settings a user has built for a geneVariant term, keyed by gene(s) and most recent
+    		first, so that a term built later for the same gene can offer them, see remember_gvq().
+    		Filled as a side effect of building one, unlike the removed Reuse menu that required the
+    		user to save a setting by hand before it could be reused, and seeded from the settings
+    		the opened plots already carry, see seedGvQCache().
+    
+    		Has to stay a plain object, since state.reuse is serialized into saved sessions, while
+    		it is keyed by gene names a url or an embedder can supply. Both the reads and the writes
+    		below are therefore plain property access on a key that getGvQCacheKey() has prefixed
+    		out of the namespace of Object.prototype -- see there for what an unprefixed '__proto__'
+    		would do to a reopened session, and withMigratedGvQCache() for the incoming states that
+    		have to be normalized before they are merged. */
+    gvQByGene: {}
+  },
+  groups: [],
+  // element: {name=str, filter={}}, to show in Groups tab
+  customTerms: [],
+  // element: {name=str, term={}}, able to attach more attr to object if needed
+  autoSave: true
+};
+var maxGvQPerGene = 5;
+var maxGvQGenes = 30;
+function withMigratedGvQCache(state) {
+  const cache = state?.reuse?.gvQByGene;
+  if (!cache || typeof cache != "object" || Array.isArray(cache)) return state;
+  const migrated = {};
+  for (const key of Object.getOwnPropertyNames(cache)) {
+    const lst = Object.getOwnPropertyDescriptor(cache, key)?.value;
+    if (!Array.isArray(lst)) continue;
+    const migratedKey = key.startsWith(gvQCacheKeyPrefix) ? key : gvQCacheKeyPrefix + key;
+    delete migrated[migratedKey];
+    migrated[migratedKey] = lst.slice(0, maxGvQPerGene);
+  }
+  const keys = Object.keys(migrated);
+  for (const key of keys.slice(0, keys.length - maxGvQGenes)) delete migrated[key];
+  return { ...state, reuse: { ...state.reuse, gvQByGene: migrated } };
+}
+var MassStore = class extends StoreBase {
+  constructor(opts, api) {
+    super(opts);
+    // expected class-specific props
+    this.defaultState = defaultState;
+    this.plotAdjusters = /* @__PURE__ */ new WeakMap();
+    this.app = opts.app;
+    this.api = api;
+    this.type = "store";
+    let savedState = {};
+    try {
+      const key = window.navigator.webdriver && window["SJPP_E2E_STORAGE_STATES_KEY"];
+      const savedStateStr = key && window.localStorage.getItem("SJPP_E2E_STORAGE_STATES") || "{}";
+      savedState = JSON.parse(savedStateStr)[key]?.state || {};
+    } catch (_) {
+      savedState = {};
+    }
+    this.state = this.copyMerge(
+      this.toJson(defaultState),
+      withMigratedGvQCache(opts.state),
+      withMigratedGvQCache(savedState)
+    );
+    this.prevGeneratedId = 0;
+  }
+  static {
+    this.type = "store";
+  }
+  validateOpts(opts) {
+    const s = opts.state;
+    if (s.vocab.dslabel) {
+      if (!s.vocab.genome) throw ".state[.vocab].genome missing";
+    } else {
+      if (!Array.isArray(s.vocab.terms)) throw "vocab.terms must be an array of objects";
+    }
+    return opts;
+  }
+  validateState() {
+    if (!navHeaderModes.has(this.state.nav.header_mode)) throw "invalid state.nav.header_mode";
+  }
+  async init() {
+    try {
+      this.state.termdbConfig = await this.app.vocabApi.getTermdbConfig();
+      await this.setTermfilter();
+      await this.rehydrateGroups();
+      await this.app.vocabApi.main({
+        termfilter: JSON.parse(JSON.stringify(this.state.termfilter)),
+        termdbConfig: this.state.termdbConfig
+      });
+      const invalidPlots = [];
+      for (const [i, savedPlot] of this.state.plots.entries()) {
+        let plot;
+        try {
+          const _ = await importPlot(savedPlot.chartType);
+          plot = await _.getPlotConfig(savedPlot, this.app, this.state.activeCohort);
+        } catch (e) {
+          this.app.printError(e);
+          console.error(`getPlotConfig() failed: ${e}`);
+        }
+        if (!plot) {
+          invalidPlots.push(i);
+          continue;
+        }
+        this.state.plots[i] = plot;
+        if (!("id" in plot)) plot.id = `_AUTOID_${id++}_${i}`;
+        if (plot.mayAdjustConfig) {
+          plot.mayAdjustConfig(plot);
+          this.plotAdjusters.set(plot, plot.mayAdjustConfig);
+          delete plot.mayAdjustConfig;
+        }
+      }
+      if (invalidPlots.length) {
+        for (const i of invalidPlots) {
+          this.state.plots.splice(i, 1);
+        }
+      }
+      this.seedGvQCache();
+    } catch (e) {
+      console.log("store.init() error", e);
+      throw e;
+    }
+  }
+  /*
+  	Remember the geneVariant settings that the plots this app opened with already carry, so
+  	that one supplied by a url, by an embedder, or by a session saved before these were
+  	remembered can be offered for a term built later, the same as one built by hand here.
+  	Without this, only the Apply button of the edit menu fills the cache, see remember_gvq().
+  
+  	Appended rather than unshifted, and skipped when already remembered, since a setting that
+  	merely arrived in the opened state has no recency to claim over what a recovered session
+  	carries in state.reuse: the entries a user built stay in front, and the seeded ones follow
+  	in the order the plots list them.
+  
+  	Neither cap evicts here for the same reason -- a remembered setting is never dropped to
+  	make room for a seeded one.
+  	*/
+  seedGvQCache() {
+    const cache = this.state.reuse.gvQByGene;
+    forEachGvTw(this.state.plots, ({ term, q }) => {
+      if (!isCustomizedGvQ(q)) return;
+      const key = getGvQCacheKey(term);
+      if (!key) return;
+      if (!cache[key]) {
+        if (Object.keys(cache).length >= maxGvQGenes) return;
+        cache[key] = [];
+      }
+      const lst = cache[key];
+      if (lst.length >= maxGvQPerGene) return;
+      const trimmed = trimGvQForCache(q);
+      if (lst.some((entry) => deepEqual(entry.q, trimmed))) return;
+      lst.push({ label: getGvQLabel(term, q), q: trimmed });
+    });
+  }
+  setId(item) {
+    item.$id = this.prevGeneratedId++;
+    if (item.$lst) {
+      for (const subitem of item.$lst) {
+        this.setId(subitem);
+      }
+    }
+  }
+  async setTermfilter() {
+    let filterUiRoot = getFilterItemByTag(this.state.termfilter.filter, "filterUiRoot");
+    if (!filterUiRoot) {
+      this.state.termfilter.filter.tag = "filterUiRoot";
+      filterUiRoot = this.state.termfilter.filter;
+    }
+    await Promise.all(rehydrateFilter(this.state.termfilter.filter, this.app.vocabApi));
+    if (!this.state.termdbConfig.selectCohort) {
+      this.state.activeCohort = -1;
+      if (this.state.activeTab === 0) this.state.activeTab = 1;
+      if (this.state.nav.header_mode === "with_cohortHtmlSelect") {
+        console.warn(`no termdbConfig.selectCohort to use for nav.header_mode = 'with_cohortHtmlSelect'`);
+        this.state.nav.header_mode = "search_only";
+      }
+    } else {
+      let cohortFilter = getFilterItemByTag(this.state.termfilter.filter, "cohortFilter");
+      if (!cohortFilter) {
+        cohortFilter = {
+          tag: "cohortFilter",
+          type: "tvs",
+          tvs: {
+            term: JSON.parse(JSON.stringify(this.state.termdbConfig.selectCohort.term)),
+            values: this.state.activeCohort == -1 ? [] : this.state.termdbConfig.selectCohort.values[this.state.activeCohort].keys.map((key) => {
+              return { key, label: key };
+            })
+          }
+        };
+        this.state.termfilter.filter = {
+          type: "tvslst",
+          in: true,
+          join: "and",
+          lst: [cohortFilter, filterUiRoot]
+        };
+      } else {
+        const sorter = (a, b) => a < b ? -1 : 1;
+        cohortFilter.tvs.values.sort((a, b) => a.key < b.key ? -1 : 1);
+        const keysStr = JSON.stringify(cohortFilter.tvs.values.map((v) => v.key).sort(sorter));
+        const i = this.state.termdbConfig.selectCohort.values.findIndex(
+          (v) => keysStr == JSON.stringify(v.keys.sort(sorter))
+        );
+        if (this.state.activeCohort !== -1 && this.state.activeCohort !== 0 && i !== this.state.activeCohort) {
+          console.log("Warning: cohortFilter will override the state.activeCohort due to mismatch");
+        }
+        this.state.activeCohort = i;
+      }
+    }
+  }
+  async rehydrateGroups() {
+    const lst = [];
+    for (const g of this.state.groups) {
+      lst.push(...rehydrateFilter(g.filter, this.app.vocabApi));
+    }
+    await Promise.all(lst);
+  }
+};
+MassStore.prototype.actions = {
+  // Type '{ app_refresh(this: MassStore, action?: {}): Promise<void>; tab_set(action: any): void; cohort_set(action: any): void; plot_prep(action: any): Promise<void>; ... 13 more ...; delete_group({ name }: { ...; }): void; }' is not assignable to type '(action: { [prop: string]: any; type: string; }) => void | Promise<void>'.
+  // Object literal may only specify known properties, and 'app_refresh' does not exist in type '(action: { [prop: string]: any; type: string; }) => void | Promise<void>'.
+  async app_refresh(action) {
+    this.state = this.copyMerge(this.toJson(this.state), withMigratedGvQCache(action.state || {}));
+    const subactionPlotIds = /* @__PURE__ */ new Set();
+    const promises = [];
+    if (action.subactions) {
+      for (const a of action.subactions) {
+        promises.push(this.actions[a.type].call(this, a));
+        if (a.type.startsWith("plot_")) subactionPlotIds.add(a.id);
+      }
+    }
+    await Promise.all(promises);
+    for (const plot of this.state.plots) {
+      const mayAdjustConfig = this.plotAdjusters.get(plot);
+      if (mayAdjustConfig && !subactionPlotIds.has(plot.id)) {
+        mayAdjustConfig(plot, action.config);
+      }
+    }
+  },
+  tab_set(action) {
+    this.state.nav.activeTab = action.activeTab;
+  },
+  cohort_set(action) {
+    this.state.activeCohort = action.activeCohort;
+    const cohort = this.state.termdbConfig.selectCohort.values[action.activeCohort];
+    const cohortFilter = getFilterItemByTag(this.state.termfilter.filter, "cohortFilter");
+    if (!cohortFilter) throw `No item tagged with 'cohortFilter'`;
+    cohortFilter.tvs.values = cohort.keys.map((key) => {
+      return { key, label: key };
+    });
+  },
+  // dispatch "plot_prep" action to produce a 'initiating' UI of this plot, for user to fill in additional details to launch the plot
+  // example: table, scatterplot which requires user to select two terms
+  async plot_prep(action) {
+    if (usedPlotIds.has(action.id)) delete action.id;
+    const plot = {
+      // rx.getComponents() relies on parsing dot-separated key names that breaks if a key has a dot,
+      // the plot.id value should be assumed to be auto-generated and to not have any non-rx usage expectations
+      id: "id" in action && !action.id.includes(".") ? action.id : getId()
+    };
+    usedPlotIds.add(plot.id);
+    if (!action.config) throw ".config{} missing for plot_prep";
+    if (action.config.chartType && Object.keys(action.config).length == 1) {
+      const _ = await importPlot(action.config.chartType);
+      const config = await _.getPlotConfig(action.config, this.app, this.state.activeCohort);
+      action.config = Object.assign(config, action.config);
+    }
+    Object.assign(plot, action.config);
+    this.state.plots.push(plot);
+  },
+  async plot_create(action) {
+    if (usedPlotIds.has(action.id)) delete action.id;
+    const _ = await importPlot(action.config.chartType);
+    const plot = await _.getPlotConfig(action.config, this.app, this.state.activeCohort);
+    if (!("id" in action) || action.id.includes(".")) action.id = getId();
+    plot.id = action.id;
+    usedPlotIds.add(plot.id);
+    if (plot.mayAdjustConfig) {
+      plot.mayAdjustConfig(plot);
+      this.plotAdjusters.set(plot, plot.mayAdjustConfig);
+      delete plot.mayAdjustConfig;
+    }
+    this.state.plots.push(plot);
+    if (plot.sections) {
+      for (const section of plot.sections) {
+        for (const p of section.plots) {
+          p.parentId = plot.id;
+          if (!p.id) p.id = getId();
+          const _2 = await importPlot(p.chartType);
+          const config = await _2.getPlotConfig(p, this.app, this.state.activeCohort);
+          this.state.plots.push(config);
+        }
+      }
+    }
+  },
+  plot_edit(action) {
+    const plot = this.state.plots.find((p) => p.id === action.id);
+    if (!plot) {
+      throw new CustomError(`missing plot config for id='${action.id}' in store.plot_edit()`, {
+        name: "MISSING_PLOT_CONFIG",
+        level: "warn"
+      });
+    }
+    this.copyMerge(plot, action.config, action.opts ? action.opts : {});
+    const mayAdjustConfig = this.plotAdjusters.get(plot);
+    if (mayAdjustConfig) mayAdjustConfig(plot, action.config);
+    if (action.config && "cutoff" in action.config) {
+      plot.cutoff = action.config.cutoff;
+    } else {
+      delete plot.cutoff;
+    }
+    if (!action.parentId && plot.parentId) action.parentId = plot.parentId;
+  },
+  plot_delete(action) {
+    const i = this.state.plots.findIndex((p) => p.id === action.id);
+    if (i !== -1) {
+      this.state.plots.splice(i, 1);
+      const plot = this.state.plots[i];
+      if (!action.parentId && plot?.parentId) action.parentId = plot.parentId;
+    }
+  },
+  plot_nestedEdits(action) {
+    const plot = this.state.plots.find((p) => p.id === action.id);
+    if (!plot) {
+      throw new CustomError(`missing plot config for id='${action.id}' in store.plot_edit_nested`, {
+        name: "MISSING_PLOT_CONFIG",
+        level: "warn"
+      });
+    }
+    for (const edit of action.edits) {
+      const lastKey = edit.nestedKeys.pop();
+      const obj = edit.nestedKeys.reduce((obj2, key) => obj2[key], plot);
+      obj[lastKey] = edit.value;
+    }
+    if (!action.parentId && plot.parentId) action.parentId = plot.parentId;
+  },
+  /*
+  	Remember a geneVariant setting that the user built, keyed by gene, so that a term built
+  	later for the same gene can offer it instead of making the user rebuild the same grouping.
+  
+  	Dispatched from the Apply button of the geneVariant edit menu, which is the only place
+  	that builds a custom groupset for such a term -- every other mention of 'custom-groupset'
+  	in client/plots/ reads one. See makeEditMenu() in client/termsetting/handlers/geneVariant.ts
+  	and rememberGvQ() in client/termdb/Vocab.js.
+  
+  	A setting the user returns to moves back to the front of its gene rather than being stored
+  	twice, so each list reads as most recent first. The settings that arrive already built, in
+  	the plots of an opened state, are seeded behind these by seedGvQCache().
+  
+  	Keyed by gene and never shared across genes: the tvs of a custom groupset filter by the dt
+  	terms of that gene, so a BCR-ABL1 fusion grouping is meaningless on another gene.
+  	*/
+  remember_gvq({ term, q }) {
+    if (!isCustomizedGvQ(q)) return;
+    const key = getGvQCacheKey(term);
+    if (!key) return;
+    const cache = this.state.reuse.gvQByGene;
+    const trimmed = trimGvQForCache(q);
+    const lst = cache[key] || [];
+    const i = lst.findIndex((entry) => deepEqual(entry.q, trimmed));
+    if (i != -1) lst.splice(i, 1);
+    lst.unshift({ label: getGvQLabel(term, q), q: trimmed });
+    if (lst.length > maxGvQPerGene) lst.length = maxGvQPerGene;
+    delete cache[key];
+    cache[key] = lst;
+    const keys = Object.keys(cache);
+    if (keys.length > maxGvQGenes) delete cache[keys[0]];
+  },
+  // TODO: delete this action? does not seem to be used
+  async plot_splice(action) {
+    for (const a of action.subactions) {
+      await this.actions[a.type].call(this, a);
+    }
+  },
+  filter_replace(action) {
+    if ("filter0" in action) {
+      this.state.termfilter.filter0 = action.filter0;
+      return;
+    }
+    const replacementFilter = action.filter ? action.filter : { type: "tvslst", join: "", in: 1, lst: [] };
+    if (!action.filter.tag) {
+      this.state.termfilter.filter = replacementFilter;
+    } else {
+      const filter = getFilterItemByTag(this.state.termfilter.filter, action.filter.tag);
+      if (!filter) throw `cannot replace missing filter with tag '${action.filter.tag}'`;
+      const parent = findParent(this.state.termfilter.filter, filter.$id);
+      if (parent == filter) {
+        this.state.termfilter.filter = replacementFilter;
+      } else {
+        const i = parent.lst.indexOf(filter);
+        parent.lst[i] = replacementFilter;
+      }
+    }
+    if (this.app.opts.app?.onFilterChange) this.app.opts.app.onFilterChange(this.state.plots);
+  },
+  add_customTerm(action) {
+    const i = action.obj.id ? this.state.customTerms.findIndex((term) => term.id === action.obj.id) : -1;
+    if (i === -1) this.state.customTerms.push(action.obj);
+    else this.state.customTerms[i] = action.obj;
+  },
+  delete_customTerm({ id: id2, name }) {
+    const i = this.state.customTerms.findIndex((term) => id2 ? term.id === id2 : term.name == name);
+    if (i != -1) this.state.customTerms.splice(i, 1);
+  },
+  add_group(action) {
+    if (this.state.nav.header_mode != "hidden") {
+      const group = action.obj;
+      const name = `Group ${this.state.groups.length + 1}`;
+      const samplelstTW = getSamplelstTW([group]);
+      const appGroup = {
+        name,
+        filter: getFilter(samplelstTW),
+        plotId: group.plotId
+      };
+      this.state.groups.push(appGroup);
+      this.state.nav.activeTab = 1;
+    } else if ("plotId" in action.obj) {
+      const plot = this.state.plots.find((p) => p.id == action.obj.plotId);
+      if (plot.groups) {
+        action.obj.index = plot.groups.length;
+        action.obj.name = `Group ${plot.groups.length + 1}`;
+        plot.groups.push(action.obj);
+      }
+    }
+  },
+  rename_group(action) {
+    const index = action.index;
+    const newName = action.newName;
+    if (this.state.nav.header_mode != "hidden") {
+      this.state.groups[index].name = newName;
+    } else {
+      for (const plot of this.state.plots) {
+        if (plot?.groups) {
+          plot.groups[index].name = newName;
+        }
+      }
+    }
+  },
+  change_color_group(action) {
+    const index = action.index;
+    const newColor = action.newColor;
+    if (this.state.nav.header_mode != "hidden") {
+      this.state.groups[index].color = newColor;
+    } else {
+      for (const plot of this.state.plots) {
+        if (plot?.groups) {
+          plot.groups[index].color = newColor;
+        }
+      }
+    }
+  },
+  delete_group({ name }) {
+    if (this.state.nav.header_mode != "hidden") {
+      const i = this.state.groups.findIndex((i2) => i2.name == name);
+      if (i != -1) this.state.groups.splice(i, 1);
+    } else {
+      for (const plot of this.state.plots) {
+        if (plot?.groups) {
+          const j = plot.groups.findIndex((j2) => j2.name == name);
+          if (j != -1) plot.groups.splice(j, 1);
+        }
+      }
+    }
+  }
+};
+var storeInit = StoreApi.getInitFxn(MassStore);
+
+// mass/skipPrevActionAbort.ts
+var globalStateKeys = ["termfilter", "activeCohort", "plots"];
+var isGlobalActionType = (type) => type.startsWith("filter") || type.startsWith("cohort");
+function skipPrevActionAbort(action) {
+  if (!action) return false;
+  if (isGlobalActionType(action.type)) return false;
+  if (action.type == "app_refresh") {
+    if (action.subactions?.find((a) => isGlobalActionType(a.type))) return false;
+    if (action.state) return !globalStateKeys.find((key) => key in action.state);
+    return Boolean(action.subactions);
+  }
+  return true;
+}
+
+export {
+  storeInit,
+  skipPrevActionAbort
+};
+//# sourceMappingURL=chunk-AEHBMP7F.js.map