@sjcrh/proteinpaint-client 2.223.0 → 2.224.1

package/dist/chunk-Z6LQ3URB.js

@@ -0,0 +1,14 @@
+// src/block.lazyload.js
+var Block;
+async function blocklazyload(arg) {
+  if (!Block) {
+    const b = await import("./block-IS3WJCNW.js");
+    Block = b.Block;
+  }
+  return new Block(arg);
+}
+
+export {
+  blocklazyload
+};
+//# sourceMappingURL=chunk-Z6LQ3URB.js.map

package/dist/chunk-ZESHWW2R.js

@@ -0,0 +1,54 @@
+import {
+  addGeneSearchbox
+} from "./chunk-3YQYWX4M.js";
+import {
+  Menu
+} from "./chunk-CNFTQSNE.js";
+
+// termdb/handlers/snp.ts
+var SearchHandler = class {
+  init(opts) {
+    this.callback = opts.callback;
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: opts.genomeObj,
+      row: opts.holder,
+      searchOnly: "snp",
+      allowVariant: true,
+      callback: () => this.selectSnp(geneSearch)
+    });
+  }
+  async selectSnp(geneSearch) {
+    const { chr, ref, alt, fromWhat } = geneSearch;
+    if (!chr || !ref || !alt || !fromWhat) throw "missing chr, ref, alt, or fromWhat of snp";
+    let start, stop;
+    if (!geneSearch.start && !geneSearch.stop) {
+      if (geneSearch.pos) {
+        start = geneSearch.pos - 1;
+        stop = geneSearch.pos;
+      } else {
+        throw "missing coordinate of snp";
+      }
+    } else {
+      start = geneSearch.start;
+      stop = geneSearch.stop;
+    }
+    const term = {
+      id: fromWhat,
+      chr,
+      start,
+      stop,
+      name: fromWhat,
+      ref,
+      alt: typeof alt == "string" ? [alt] : alt,
+      // is string if input to geneSearch was in variant or hgvs format // TODO: update genesearch.ts to parse alternative alleles from any input format into arrays
+      type: "snp"
+    };
+    this.callback(term);
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-ZESHWW2R.js.map

package/dist/chunk-ZK4JKSUK.js

@@ -0,0 +1,56 @@
+import {
+  sayerror
+} from "./chunk-3YQYWX4M.js";
+import {
+  TermTypeGroups
+} from "./chunk-WJLRU5OF.js";
+
+// termdb/handlers/singleCellCellType.ts
+var SearchHandler = class {
+  async init(opts) {
+    this.validateOpts(opts);
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    const scctTerms = opts.app.vocabApi.termdbConfig?.termType2terms?.[TermTypeGroups.SINGLECELL_CELLTYPE];
+    if (!scctTerms?.length) {
+      sayerror(
+        holder,
+        `termType2terms[${TermTypeGroups.SINGLECELL_CELLTYPE}]:[] is required in termdbConfig for singleCellCellType handler`
+      );
+      return;
+    }
+    const usecaseConfig = opts.usecase?.specialCase?.config;
+    const plots = usecaseConfig?.sample?.plots;
+    const isMeta = usecaseConfig?.sample?.isMetaResult;
+    const filtered = plots ? scctTerms.filter((t) => plots.includes(t.plot)) : usecaseConfig?.name ? scctTerms.filter((t) => t.plot === usecaseConfig.name) : scctTerms;
+    const getLabel = (t) => isMeta || plots?.length == 1 ? t.name : `${t.name} (${t.plot})`;
+    const filteredTerms = new Set(
+      plots || !usecaseConfig?.name ? filtered.map((t) => ({ ...t, label: getLabel(t) })) : filtered
+    );
+    for (const t of Array.from(filteredTerms)) {
+      holder.append("div").classed("termdiv", true).style("padding", "0px 5px").append("div").classed("termlabel sja_filter_tag_btn sja_tree_click_term ts_pill", true).style("display", "inline-block").style("padding", "5px 8px").style("margin", "1px 0px").style("border-radius", "6px").text(t.label || t.name).on("click", () => {
+        const term = this.makeTerm(t, usecaseConfig);
+        this.callback(term);
+      });
+    }
+  }
+  makeTerm(_term, usecaseConfig) {
+    const term = { ..._term };
+    if (!term.sample && usecaseConfig?.sample) term.sample = usecaseConfig.sample;
+    return term;
+  }
+  validateOpts(opts) {
+    if (opts.callback == null) throw new Error("callback is required");
+    if (opts.app == null) throw new Error("app is required");
+    if (opts.holder == null) throw new Error("holder is required");
+    if (opts.usecase == null) throw new Error("usecase is required");
+    if (!opts.app.vocabApi.termdbConfig?.termType2terms)
+      throw new Error("termType2terms is required in termdbConfig for singleCellCellType handler");
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-ZK4JKSUK.js.map

package/dist/chunk-ZV7LZY67.js

@@ -0,0 +1,550 @@
+import {
+  rehydrateFilter
+} from "./chunk-FE5TCBIT.js";
+import {
+  findParent,
+  getFilter,
+  getFilterItemByTag,
+  getGvQLabel,
+  getSamplelstTW,
+  isCustomizedGvQ
+} from "./chunk-3YQYWX4M.js";
+import {
+  importPlot
+} from "./chunk-R3RD3VEX.js";
+import {
+  CustomError
+} from "./chunk-W5J3LTYS.js";
+import {
+  forEachGvTw,
+  getGvQCacheKey,
+  gvQCacheKeyPrefix,
+  trimGvQForCache
+} from "./chunk-JHLF2ZC2.js";
+import {
+  StoreApi,
+  StoreBase,
+  deepEqual
+} from "./chunk-HBNB5TRH.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-ZV7LZY67.js.map