@sjcrh/proteinpaint-client 2.166.0 → 2.167.1

package/dist/chunk-LMELY5Z2.js

@@ -0,0 +1,1412 @@
+import {
+  importPlot
+} from "./chunk-J7IU77CA.js";
+import {
+  maxGESampleCutoff,
+  maxSampleCutoff
+} from "./chunk-BTYCW3D5.js";
+import {
+  GeneExpChartMenu,
+  GeneSetEditUI,
+  appInit,
+  fillTermWrapper,
+  filterInit,
+  filterJoin,
+  filterPromptInit,
+  get$id,
+  getFilterItemByTag,
+  getNormalRoot,
+  make_radios,
+  negateFilter,
+  renderTable,
+  sayerror,
+  table2col
+} from "./chunk-W5EG334J.js";
+import {
+  dofetch3
+} from "./chunk-MK7RRJTX.js";
+import {
+  NumericModes,
+  TermTypes,
+  isNumericTerm,
+  termType2label
+} from "./chunk-DKI7YOTJ.js";
+import {
+  getColors
+} from "./chunk-6VQ4C735.js";
+import {
+  Menu
+} from "./chunk-TGZA4ETW.js";
+import {
+  getCompInit
+} from "./chunk-DDOM4XYV.js";
+import {
+  rgb
+} from "./chunk-OMR2DT66.js";
+
+// mass/charts.js
+var MassCharts = class {
+  constructor(opts = {}) {
+    this.type = "charts";
+    setRenderers(this);
+  }
+  async init(appState) {
+    this.dom = {
+      holder: this.opts.holder,
+      tip: new Menu({ padding: "0px" }),
+      tooltip: new Menu({ padding: "4px" })
+    };
+    this.makeButtons(appState);
+  }
+  // TODO later add reactsTo() to react to filter change
+  getState(appState) {
+    const state = {
+      vocab: appState.vocab,
+      // TODO delete it as vocabApi should be used instead
+      activeCohort: appState.activeCohort,
+      termfilter: appState.termfilter,
+      currentCohortChartTypes: getCurrentCohortChartTypes(appState),
+      termdbConfig: appState.termdbConfig
+    };
+    if (appState?.termfilter?.filter) {
+      state.filter = getNormalRoot(appState.termfilter.filter);
+    }
+    return state;
+  }
+  main() {
+    this.dom.btns.style("display", (d) => this.state.currentCohortChartTypes.includes(d.chartType) ? "" : "none");
+  }
+  getBtnLabel_dict(state) {
+    return state.termdbConfig.queries ? "Data Variables" : "Data Dictionary";
+  }
+  getBtnLabel_regression(state) {
+    const lst = getCurrentCohortChartTypes(state);
+    if (!lst.includes("regression")) return "";
+    const ms = [];
+    if (lst.includes("linear")) ms.push("linear");
+    if (lst.includes("logistic")) ms.push("logistic");
+    if (lst.includes("cox")) ms.push("cox");
+    if (ms.length > 1) return "Regression Analysis";
+    return `${ms[0] == "linear" ? "Linear" : ms[0] == "cox" ? "Cox" : "Logistic"} Regression`;
+  }
+  getBtnLabel_sampleScatter(state) {
+    const lst = getCurrentCohortChartTypes(state);
+    if (state.termdbConfig.scatterplots?.length == 1 && !lst.includes("dynamicScatter")) {
+      return state.termdbConfig.scatterplots[0].name;
+    }
+    return "Sample Scatter";
+  }
+  getBtnLabel_report(state) {
+    return state.termdbConfig.plotConfigByCohort?.default?.report?.name || "Report";
+  }
+  getBtnLabel_summarizeMutationTerm(state, phrase) {
+    if (!state.termdbConfig.queries) return "Not supported!";
+    const t = [];
+    if (state.termdbConfig.queries.snvindel) t.push("Mutation");
+    if (state.termdbConfig.queries.cnv) t.push("CNV");
+    if (state.termdbConfig.queries.svfusion) t.push("Fusion");
+    return `${t.length > 2 ? "Alterations" : t.join("/")} vs ${phrase}`;
+  }
+};
+var chartsInit = getCompInit(MassCharts);
+function getActiveCohortStr(appState) {
+  if (appState?.termdbConfig?.selectCohort?.values) {
+    if (!Number.isInteger(appState.activeCohort)) throw "appState.activeCohort is not integer array index";
+    const activeCohortObject = appState.termdbConfig.selectCohort.values[appState.activeCohort];
+    if (!activeCohortObject) throw "appState.activeCohort array index out of bound";
+    return [...activeCohortObject.keys].sort().join(",");
+  }
+  return "";
+}
+function getCurrentCohortChartTypes(appState) {
+  const activeCohortStr = getActiveCohortStr(appState);
+  const chartTypesByCohort = structuredClone(appState.termdbConfig?.supportedChartTypes || {});
+  return chartTypesByCohort[activeCohortStr] || ["summary"];
+}
+function getChartTypeList(self, state) {
+  const buttons = [
+    ////////////////////// PROFILE PLOTS START //////////////////////
+    {
+      label: "Polar",
+      chartType: "profilePolar",
+      clickTo: self.prepPlot,
+      config: { chartType: "profilePolar" }
+    },
+    {
+      label: "Barchart",
+      clickTo: self.prepPlot,
+      chartType: "profileBarchart",
+      config: { chartType: "profileBarchart" }
+    },
+    {
+      label: "Facility Radar",
+      chartType: "profileRadarFacility",
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "Radar",
+      chartType: "profileRadar",
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "Templates",
+      chartType: "profileForms",
+      clickTo: self.showTree_select1term,
+      usecase: { target: "profileForms", detail: "tw" },
+      config: { chartType: "profileForms" }
+    },
+    ////////////////////// PROFILE PLOTS END //////////////////////
+    //       rest are general plots applicable to all ds
+    {
+      label: self.getBtnLabel_dict(state),
+      clickTo: self.prepPlot,
+      chartType: "dictionary",
+      config: {
+        chartType: "dictionary"
+      }
+    },
+    {
+      // currently only used by gdc, so hardcoding correlation input label
+      // may allow for other labels if used by other datasets
+      label: "Correlation Input",
+      clickTo: self.prepPlot,
+      chartType: "summaryInput",
+      config: {
+        chartType: "summaryInput"
+      }
+    },
+    {
+      label: self.getBtnLabel_report(state),
+      chartType: "report",
+      clickTo: self.plotCreate,
+      config: { chartType: "report" }
+    },
+    {
+      label: "Sample View",
+      clickTo: self.prepPlot,
+      chartType: "sampleView",
+      config: {
+        chartType: "sampleView"
+      }
+    },
+    {
+      label: self.getBtnLabel_sampleScatter(state),
+      chartType: "sampleScatter",
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "Run Chart",
+      chartType: "runChart",
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "Frequency Chart",
+      chartType: "frequencyChart",
+      clickTo: self.showTree_select1term,
+      usecase: { target: "frequencyChart", detail: "term" }
+    },
+    {
+      label: "Cumulative Incidence",
+      chartType: "cuminc",
+      clickTo: self.showTree_select1term,
+      usecase: { target: "cuminc", detail: "term" }
+    },
+    {
+      label: "Survival",
+      chartType: "survival",
+      clickTo: self.showTree_select1term,
+      usecase: { target: "survival", detail: "term" }
+    },
+    {
+      label: self.getBtnLabel_regression(state),
+      chartType: "regression",
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "Sample Matrix",
+      chartType: "matrix",
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "Genome Browser",
+      chartType: "genomeBrowser",
+      clickTo: self.loadChartSpecificMenu
+    },
+    // Commenting out this button since DE does not work without specifying two groups
+    //{
+    //	label: 'Differential Expression',
+    //	chartType: 'DEanalysis',
+    //	clickTo: self.loadChartSpecificMenu
+    //},
+    {
+      label: "Data Download",
+      clickTo: self.prepPlot,
+      chartType: "dataDownload",
+      config: {
+        chartType: "dataDownload",
+        terms: []
+      }
+    },
+    {
+      label: "Facet Table",
+      clickTo: self.loadChartSpecificMenu,
+      chartType: "facet",
+      config: {
+        chartType: "facet"
+      }
+    },
+    {
+      label: "Brain Imaging",
+      clickTo: self.loadChartSpecificMenu,
+      chartType: "brainImaging",
+      config: {
+        chartType: "brainImaging"
+      }
+    },
+    {
+      label: "Chat",
+      clickTo: self.loadChartSpecificMenu,
+      chartType: "chat",
+      config: {
+        chartType: "chat"
+      }
+    },
+    {
+      label: "Single Cell Plot",
+      clickTo: self.prepPlot,
+      chartType: "singleCellPlot",
+      config: {
+        chartType: "singleCellPlot"
+      }
+    },
+    {
+      //This chart may be later on extended to support other gene expression data types
+      label: "Gene Expression",
+      chartType: "geneExpression",
+      clickTo: self.showGenesetEditUI,
+      usecase: { target: "geneExpression" }
+    },
+    {
+      label: "Metabolite Intensity",
+      chartType: "metaboliteIntensity",
+      clickTo: self.showTree_selectlst,
+      usecase: { target: "metaboliteIntensity", detail: "term" },
+      updateActionBySelectedTerms: (action, termlst) => {
+        const twlst = termlst.map((term) => ({
+          term: structuredClone(term),
+          q: { mode: NumericModes.continuous }
+        }));
+        if (twlst.length == 1) {
+          action.config.chartType = "summary";
+          action.config.term = twlst[0];
+          return;
+        }
+        if (twlst.length == 2) {
+          action.config.chartType = "summary";
+          action.config.term = twlst[0];
+          action.config.term2 = twlst[1];
+          return;
+        }
+        action.config.chartType = "hierCluster";
+        action.config.dataType = TermTypes.METABOLITE_INTENSITY;
+        action.config.termgroups = [{ name: "Metabolite Intensity Cluster", lst: twlst, type: "hierCluster" }];
+      }
+    },
+    {
+      label: state.termdbConfig.numericDictTermCluster?.appName || "Numeric Dictionary Term cluster",
+      chartType: "numericDictTermCluster",
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "Mutation Signature",
+      chartType: "mutationSignature",
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "Correlation Volcano",
+      chartType: "correlationVolcano",
+      usecase: { target: "correlationVolcano", detail: "numeric" },
+      clickTo: self.showTree_select1term
+    },
+    {
+      label: "GRIN2",
+      chartType: "grin2",
+      config: { chartType: "grin2" },
+      clickTo: self.prepPlot
+    },
+    {
+      label: self.getBtnLabel_summarizeMutationTerm(state, "Disease Type"),
+      chartType: "summarizeMutationDiagnosis",
+      // type names of other similar charts should all begin with `summarize` to indcate they are based on summary plot
+      usecase: { target: "summarizeMutationDiagnosis" },
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: self.getBtnLabel_summarizeMutationTerm(state, "Survival"),
+      chartType: "summarizeMutationSurvival",
+      usecase: { target: "summarizeMutationSurvival" },
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "CNV vs GeneExp",
+      // this is limited to cnv, and could be generalized to include snvindel/fusion
+      chartType: "summarizeCnvGeneexp",
+      usecase: { target: "summarizeCnvGeneexp" },
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "GeneExp vs Survival",
+      chartType: "summarizeGeneexpSurvival",
+      usecase: { target: "summarizeGeneexpSurvival" },
+      clickTo: self.loadChartSpecificMenu
+    },
+    {
+      label: "Alpha Genome",
+      chartType: "alphaGenome",
+      usecase: { target: "alphaGenome" },
+      clickTo: self.prepPlot,
+      config: { chartType: "alphaGenome" }
+    }
+  ];
+  for (const field in state?.termdbConfig.renamedChartTypes || []) {
+    const btn = buttons.find((b) => b.chartType === field);
+    if (btn) {
+      btn.label = state.termdbConfig.renamedChartTypes[field];
+    }
+  }
+  return buttons;
+}
+function setRenderers(self) {
+  self.makeButtons = function(state) {
+    const chartTypeList = getChartTypeList(self, state);
+    self.dom.btns = self.dom.holder.selectAll("button").data(chartTypeList).enter().append("button").style("margin", "10px").style("padding", "10px 15px").style("border-radius", "20px").style("border-color", "#ededed").html((d) => d.label).on("click", function(event, chart) {
+      self.dom.tip.clear().showunder(this);
+      chart.clickTo(chart);
+    }).on("mouseover", (e, d) => {
+      if (d.tooltip) self.dom.tooltip.clear().showunder(e.target).d.text(d.tooltip);
+    }).on("mouseleave", (e, d) => {
+      if (d.tooltip) self.dom.tooltip.hide();
+    });
+  };
+  self.showTree_select1term = async (chart) => {
+    if (chart.usecase.label) {
+      self.dom.tip.d.append("div").style("margin", "3px 5px").style("padding", "3px 5px").style("font-weight", 600).html(chart.usecase.label);
+    }
+    const action = {
+      type: "plot_create",
+      id: getId(),
+      config: { chartType: chart.chartType, activeCohort: self.state.activeCohort }
+    };
+    if (chart.parentId) action.parentId = chart.parentId;
+    const termdb = await import("./app-6SKETLMT.js");
+    termdb.appInit({
+      vocabApi: self.app.vocabApi,
+      holder: self.dom.tip.d.append("div"),
+      state: {
+        activeCohort: self.state.activeCohort,
+        nav: {
+          header_mode: "search_only"
+        },
+        tree: { usecase: chart.usecase }
+      },
+      tree: {
+        click_term: (term) => {
+          const tw = term.term ? term : { term };
+          action.config[chart.usecase.detail] = tw;
+          self.dom.tip.hide();
+          self.app.dispatch(action);
+        }
+      }
+    });
+  };
+  self.showGenesetEditUI = async (chart) => {
+    const app = self.app;
+    const additionalItems = [];
+    if (app.vocabApi.termdbConfig?.queries?.rnaseqGeneCount) {
+      additionalItems.push(
+        {
+          //Section heading
+          text: "Differential Gene Expression Analysis"
+        },
+        {
+          /** TODO: In the future, may replace these instructions
+           * with DA button that is in development. */
+          label: "View Instructions",
+          isSubmenu: true,
+          callback: (holder) => {
+            const message = `For Differential Gene Expression Analysis, please follow steps:
+		<ol>
+		<li>Navigate to the <span style="opacity:.5">GROUPS</span> tab at the top, and create two groups.</li>
+		<li>Create a new variable from the two groups and click on the new variable button.</li>
+		<li>Select <span class=sja_menuoption style="font-size:.8em">Differential Gene Expression Analysis</span> from the menu options and run the analysis.</li>
+		</ol>`;
+            holder.append("div").style("padding", "10px").html(message);
+          }
+        }
+      );
+    }
+    new GeneExpChartMenu(app, self.dom.tip, additionalItems);
+  };
+  self.showTree_selectlst = async (chart) => {
+    if (chart.usecase?.label) {
+      self.dom.tip.d.append("div").style("margin", "3px 5px").style("padding", "3px 5px").style("font-weight", 600).html(chart.usecase.label);
+    }
+    const action = {
+      type: "plot_create",
+      id: getId(),
+      config: { chartType: chart.chartType }
+      // NOTE if chartType is intermediary, action will be updated on term selection
+    };
+    const termdb = await import("./app-6SKETLMT.js");
+    self.dom.submenu = self.dom.tip.d.append("div");
+    termdb.appInit({
+      holder: self.dom.submenu,
+      vocabApi: self.app.vocabApi,
+      state: {
+        activeCohort: self.state.activeCohort,
+        nav: {
+          header_mode: "search_only"
+        },
+        tree: { usecase: chart.usecase }
+      },
+      tree: {
+        submit_lst: (termlst) => {
+          const data = chart.processSelection ? chart.processSelection(termlst) : termlst;
+          action.config[chart.usecase.detail] = data;
+          if (chart.updateActionBySelectedTerms) chart.updateActionBySelectedTerms(action, termlst);
+          self.dom.tip.hide();
+          self.app.dispatch(action);
+        }
+      }
+    });
+  };
+  self.loadChartSpecificMenu = async (chart) => {
+    self.dom.tip.clear();
+    const _ = await importPlot(chart.chartType);
+    _.makeChartBtnMenu(self.dom.tip.d, self, chart.chartType);
+  };
+  self.prepPlot = function(chart) {
+    self.dom.tip.hide();
+    const action = { type: "plot_prep", config: chart.config, id: getId() };
+    self.app.dispatch(action);
+  };
+  self.plotCreate = function(chart) {
+    self.dom.tip.hide();
+    const action = { type: "plot_create", config: chart.config, id: getId() };
+    self.app.dispatch(action);
+  };
+}
+var idPrefix = "_CHART_AUTOID_";
+var id = Date.now();
+function getId() {
+  return idPrefix + id++;
+}
+
+// mass/groups.js
+var colorScale = getColors(5);
+var MassGroups = class {
+  constructor(opts = {}) {
+    this.type = "groups";
+    this.selectedGroupsIdx = /* @__PURE__ */ new Set();
+  }
+  async init() {
+    this.dom = {
+      holder: this.opts.holder.append("div").style("margin", "10px")
+    };
+    initUI(this);
+    this.tip = new Menu({ padding: "0px" });
+    this.tip2 = new Menu({ padding: "0px", offsetX: 250, offsetY: -34, parent_menu: this.tip.d.node() });
+    this.tip3 = new Menu({ padding: "0px" });
+  }
+  getState(appState) {
+    const state = {
+      termfilter: appState.termfilter,
+      groups: rebaseGroupFilter(appState),
+      customTerms: appState.customTerms,
+      currentCohortChartTypes: getCurrentCohortChartTypes(appState),
+      matrixplots: this.app.vocabApi.termdbConfig.matrixplots
+    };
+    return state;
+  }
+  async main() {
+    await updateUI(this);
+  }
+  //////////////// rest are app-specific logic
+  getMassFilter() {
+    if (!this.state.termfilter.filter || this.state.termfilter.filter.lst.length == 0) {
+      return { type: "tvslst", in: true, join: "", lst: [] };
+    }
+    const f = getNormalRoot(structuredClone(this.state.termfilter.filter));
+    return f;
+  }
+  async groups2samplelst(groups) {
+    const samplelstGroups = [];
+    const processedSamples = /* @__PURE__ */ new Set(), overlap = [];
+    for (const g of groups) {
+      const samples = await this.app.vocabApi.getFilteredSampleList(
+        filterJoin([g.filter, this.state.termfilter.filter])
+      );
+      const items = [];
+      for (const sample of samples) {
+        const item = { sampleId: sample.id };
+        if ("name" in sample) {
+          item.sample = sample.name;
+        }
+        if (!processedSamples.has(sample.id)) items.push(item);
+        else {
+          for (const pg of samplelstGroups) {
+            const i = pg.items.findIndex((i2) => i2.sampleId === sample.id);
+            if (i !== -1) overlap.push(...pg.items.splice(i, 1));
+          }
+        }
+        processedSamples.add(item.sampleId);
+      }
+      if (items.length) samplelstGroups.push({ name: g.name, items, color: g.color });
+    }
+    if (overlap.length) {
+      const ok = confirm(
+        'Overlap detected: 1 or more samples belong to >1 groups. A new group will be created for these "overlap" samples.'
+      );
+      if (!ok) return;
+      samplelstGroups.push({ name: "Group overlap", items: overlap });
+    }
+    if (groups.length == 1) {
+      const samples = await this.app.vocabApi.getFilteredSampleList(
+        filterJoin([negateFilter(groups[0].filter), this.state.termfilter.filter])
+      );
+      if (!samples.length) throw "0 samples for the other group";
+      const items = [];
+      for (const sample of samples) {
+        const item = { sampleId: sample.id };
+        if ("name" in sample) {
+          item.sample = sample.name;
+        }
+        items.push(item);
+      }
+      samplelstGroups.push({ name: "Not in " + groups[0].name, items, color: "#ccc" });
+    }
+    return getSamplelstTW2(samplelstGroups);
+  }
+  updateLaunchButton() {
+    this.dom.newTermSpan.style("display", "none");
+    this.dom.noGroupSelected.style("display", "none");
+    if (this.state.groups.length == 0) return;
+    if (this.state.groups.length == 1) {
+      this.dom.newTermSpan.style("display", "");
+      this.dom.launchButton.text(`Create variable using "${this.state.groups[0].name}"`);
+      this.dom.newTermNameInput.property("value", this.state.groups[0].name + " vs others");
+      return;
+    }
+    const lst = [...this.selectedGroupsIdx];
+    if (lst.length == 0) {
+      this.dom.noGroupSelected.style("display", "");
+      return;
+    }
+    this.dom.newTermSpan.style("display", "");
+    if (lst.length == 1) {
+      this.dom.launchButton.text(`Create  variable using "${this.state.groups[lst[0]]?.name}"`);
+      this.dom.newTermNameInput.property("value", this.state.groups[lst[0]].name + " vs others");
+      return;
+    }
+    this.dom.launchButton.text(`Create variable using ${lst.length} groups`);
+    this.dom.newTermNameInput.property("value", lst.map((i) => this.state.groups[i].name).join(" vs "));
+  }
+  displayCustomTerms() {
+    this.dom.customTermDiv.selectAll("*").remove();
+    if (this.state.customTerms.length == 0) {
+      this.dom.customTermDiv.append("div").text("No custom variables. Use above controls to create new ones. Custom variables are added to dictionary.").style("font-size", ".8em");
+      return;
+    }
+    this.dom.customTermDiv.append("div").style("margin-bottom", "10px").style("font-size", ".8em").text("Following custom variables are available in all charts where variables are used. Click one to delete.");
+    for (const { name, tw } of this.state.customTerms) {
+      const div = this.dom.customTermDiv.append("div");
+      div.text(name).attr("class", "sja_filter_tag_btn").style("padding", "3px 6px").style("border-radius", "6px").style("margin-right", "5px").on("click", (event) => {
+        const deleteCallback = () => this.app.vocabApi.deleteCustomTerm(name);
+        this.showGroupsMenu(event, tw, deleteCallback);
+      });
+    }
+  }
+  newId() {
+    this.lastId = get$id();
+    return this.lastId;
+  }
+  showGroupsMenu(event, tw, deleteCallback) {
+    const samplelstTW = structuredClone(tw);
+    this.tip.clear().showunder(event.target);
+    const menuDiv = this.tip.d.append("div");
+    const id2 = this?.lastId;
+    const groupsInfo = menuDiv.append("div");
+    const table = table2col({ holder: groupsInfo });
+    table.table.style("scale", 0.9).style("margin-left", "0px");
+    for (const [grpKey, grp] of Object.entries(tw.term.values)) {
+      const colorSquare = grp.color ? `<span style="display:inline-block; width:12px; height:12px; background-color:${grp.color}" ></span>` : `<span style="display:inline-block; width:11px; height:11px; background-color:${"#fff"}; border: 0.1px solid black" ></span>`;
+      const [c1, c2] = table.addRow();
+      c1.html(`${colorSquare} ${grp.label}`);
+      c2.html(`${grp.othersGroupSampleNum || grp.list.length} samples`);
+    }
+    if (this.state.currentCohortChartTypes.includes("DA") && samplelstTW.q.groups.length == 2)
+      addDiffAnalysisPlotMenuItem(menuDiv, this, samplelstTW);
+    addSummarizeOptions(menuDiv, this, samplelstTW, id2);
+    mayAddHierClusterPlotMenuItem("geneExpression", menuDiv, "Gene expression", this.tip2, samplelstTW, id2, this, true);
+    mayAddMatrixMenuItems(menuDiv, "Matrix", this.tip2, samplelstTW, id2, this, this.state, true, () => this.newId);
+    mayAddSamplescatterOption(menuDiv, this, samplelstTW);
+    mayAddGenomebrowserOption(menuDiv, this, samplelstTW);
+    menuDiv.append("div").attr("class", "sja_menuoption sja_sharp_border").text("Delete variable").on("click", (event2) => {
+      deleteCallback();
+      this.tip.hide();
+    });
+  }
+};
+var groupsInit = getCompInit(MassGroups);
+function addSummarizeOptions(menuDiv, self, samplelstTW, id2) {
+  const d = menuDiv.append("div").attr("class", "sja_menuoption sja_sharp_border").text("Summarize");
+  d.on("click", async () => {
+    showTree(
+      d,
+      (term) => {
+        const tw = { term };
+        if (isNumericTerm(term)) tw.q = { mode: "continuous" };
+        openSummaryPlot(tw, samplelstTW, self.app, id2, () => self.newId);
+      },
+      self.app,
+      self.tip2
+    );
+  });
+  d.insert("div").html("\u203A").style("float", "right");
+  if (self.state.currentCohortChartTypes.includes("survival"))
+    addPlotMenuItem("survival", menuDiv, "Compare survival", self.tip2, samplelstTW, id2, self, true);
+  if (self.state.currentCohortChartTypes.includes("cuminc"))
+    addPlotMenuItem("cuminc", menuDiv, "Compare cumulative incidence", self.tip2, samplelstTW, id2, self, true);
+}
+function mayAddGenomebrowserOption(menuDiv, self, samplelstTW) {
+  if (!self.state.currentCohortChartTypes.includes("genomeBrowser")) return;
+  if (!self.app.vocabApi.termdbConfig.queries?.snvindel) return;
+  if (self.app.vocabApi.termdbConfig.queries.snvindel.details) return;
+  if (samplelstTW.q.groups.length != 2) return;
+  menuDiv.append("div").attr("class", "sja_menuoption sja_sharp_border").text("Compare mutations").on("click", () => {
+    self.tip.hide();
+    self.tip2.hide();
+    self.tip3.hide();
+    const [f1, f2] = makeFiltersFromTwoSampleGroups(samplelstTW);
+    const config = {
+      chartType: "genomeBrowser",
+      snvindel: { shown: true, filter: f1 },
+      // code filter in 1st tk
+      subMds3Tks: [{ filterObj: f2 }]
+      // code filter in 2nd tk
+    };
+    self.app.dispatch({
+      type: "plot_create",
+      config
+    });
+  });
+}
+function makeFiltersFromTwoSampleGroups(tw) {
+  const [g1, g2] = tw.q.groups;
+  if (!g1 || !g2) throw "not 2 groups in tw.q.groups[]";
+  return [
+    {
+      in: g1.in,
+      join: "",
+      type: "tvslst",
+      lst: [
+        {
+          type: "tvs",
+          tvs: {
+            term: {
+              name: g1.name,
+              type: "samplelst",
+              values: {
+                [g1.name]: {
+                  key: g1.name,
+                  label: g1.name,
+                  list: g1.values
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    {
+      in: g2.in,
+      join: "",
+      type: "tvslst",
+      lst: [
+        {
+          type: "tvs",
+          tvs: {
+            term: {
+              name: g2.name,
+              type: "samplelst",
+              values: {
+                [g2.name]: {
+                  key: g2.name,
+                  label: g2.name,
+                  list: g2.values
+                }
+              }
+            }
+          }
+        }
+      ]
+    }
+  ];
+}
+function mayAddSamplescatterOption(menuDiv, self, samplelstTW) {
+  if (!self.app.vocabApi.termdbConfig.scatterplots) return;
+  for (const plot of self.app.vocabApi.termdbConfig.scatterplots) {
+    if (plot.colorTW)
+      menuDiv.append("div").attr("class", "sja_menuoption sja_sharp_border").text(`Overlay on ${plot.name}`).on("click", () => {
+        self.tip2.hide();
+        let config = {
+          chartType: "sampleScatter",
+          name: plot.name
+        };
+        if (plot.sampleCategory)
+          config.sampleCategory = {
+            tw: structuredClone(plot.sampleCategory.tw),
+            order: plot.sampleCategory.order,
+            defaultValue: plot.sampleCategory.defaultValue
+          };
+        if (plot.sampleType) config.sampleType = plot.sampleType;
+        config.colorTW = structuredClone(samplelstTW);
+        if (plot.settings) config.settings = structuredClone(plot.settings);
+        self.app.dispatch({
+          type: "plot_create",
+          config
+        });
+        self.tip.hide();
+      });
+  }
+}
+function addDiffAnalysisPlotMenuItem(div, self, samplelstTW) {
+  if (self.app.vocabApi.termdbConfig.queries?.rnaseqGeneCount) {
+    const itemDiv = div.append("div").attr("class", "sja_menuoption sja_sharp_border").text(`Differential ${termType2label(TermTypes.GENE_EXPRESSION)} Analysis`).on("click", async (e) => {
+      const groups = [];
+      for (const group of samplelstTW.q.groups) {
+        if (group.values && group.values.length > 0) {
+          groups.push(group);
+        } else {
+          throw "group does not contain samples for differential analysis";
+        }
+      }
+      const body = {
+        genome: self.app.vocabApi.vocab.genome,
+        dslabel: self.app.vocabApi.vocab.dslabel,
+        samplelst: { groups },
+        filter: self.state.termfilter.filter,
+        filter0: self.state.termfilter.filter0,
+        preAnalysis: true
+      };
+      const preAnalysisData = await dofetch3("termdb/DE", { body });
+      const tip = self.tip2;
+      if (!preAnalysisData?.data) {
+        tip.clear().showunderoffset(itemDiv.node());
+        sayerror(tip.d.append("div"), "Error retrieving pre-analysis data");
+        throw new Error("no data returned from pre-analysis request");
+      }
+      const numControl = preAnalysisData.data[samplelstTW.q.groups[0].name];
+      const numCase = preAnalysisData.data[samplelstTW.q.groups[1].name];
+      if (numControl + numCase > maxSampleCutoff) {
+        if (preAnalysisData.data.alert)
+          preAnalysisData.data.alert += ` | Sample size ${numControl + numCase} exceeds max sample size of ${maxSampleCutoff}. Please reduce sample size.`;
+        else
+          preAnalysisData.data.alert = `Sample size ${numControl + numCase} exceeds max sample size of ${maxSampleCutoff}. Please reduce sample size.`;
+      }
+      tip.clear().showunderoffset(itemDiv.node());
+      const menuDiv = tip.d.append("div");
+      const table = table2col({ holder: menuDiv });
+      table.table.style("margin-left", "5px").style("padding", "5px 10px");
+      {
+        const controlGColor = samplelstTW.term.values[samplelstTW.q.groups[0].name].color;
+        const colorSquareCtrl = controlGColor ? `<span style="display:inline-block; width:12px; height:12px; background-color:${controlGColor}" ></span>` : `<span style="display:inline-block; width:11px; height:11px; background-color:${"#fff"}; border: 0.1px solid black" ></span>`;
+        const [c1, c2] = table.addRow();
+        c1.html(
+          `<span style="font-size:.8em;font-weight:bold">CONTROL</span> ${colorSquareCtrl} ${samplelstTW.q.groups[0].name}`
+        );
+        c2.html(`${numControl} samples`);
+      }
+      {
+        const caseGColor = samplelstTW.term.values[samplelstTW.q.groups[1].name].color;
+        const colorSquareCase = caseGColor ? `<span style="display:inline-block; width:12px; height:12px; background-color:${caseGColor}" ></span>` : `<span style="display:inline-block; width:11px; height:11px; background-color:${"#fff"}; border: 0.1px solid black" ></span>`;
+        const [c1, c2] = table.addRow();
+        c1.html(
+          `<span style="font-size:.8em;font-weight:bold">CASE</span> ${colorSquareCase} ${samplelstTW.q.groups[1].name}`
+        );
+        c2.html(`${numCase} samples`);
+      }
+      const alertDiv = menuDiv.append("div");
+      if (preAnalysisData.data.alert) {
+        sayerror(alertDiv, preAnalysisData.data.alert);
+      }
+      const sample_size_limit = 8;
+      if (!preAnalysisData.data.alert) {
+        const options = numControl + numCase >= maxGESampleCutoff ? [{ label: "Wilcoxon", value: "wilcoxon" }] : numControl <= sample_size_limit && numCase <= sample_size_limit ? [
+          { label: "edgeR", value: "edgeR" },
+          { label: "Limma", value: "limma" }
+        ] : [
+          { label: "edgeR", value: "edgeR" },
+          { label: "Wilcoxon", value: "wilcoxon" },
+          { label: "Limma", value: "limma" }
+        ];
+        const launchDEDiv = menuDiv.append("div").style("margin", "8px 5px").style("padding", "5px 10px");
+        const radioRow = launchDEDiv.append("tr");
+        let selectedMethod = options[0].value;
+        radioRow.append("td").html("Method").attr("aria-label", "DE Method").attr("class", "sja-termdb-config-row-label").style("padding", "5px");
+        const cell = radioRow.append("td");
+        const radioBtnDiv = cell.append("div");
+        make_radios({
+          holder: radioBtnDiv,
+          inputName: `de-method-${Date.now()}`,
+          options: options.map((o, i) => ({
+            ...o,
+            title: `${o.label} method`,
+            checked: i === 0
+            // preselect first option
+          })),
+          styles: {
+            display: "inline-block",
+            padding: "0 12px 0 0"
+          },
+          callback: (v) => selectedMethod = v
+        });
+        launchDEDiv.append("button").style("border", "none").style("border-radius", "20px").style("padding", "10px 15px").text(`Run Differential ${termType2label(TermTypes.GENE_EXPRESSION)} Analysis`).on("click", async () => {
+          const config = {
+            chartType: "differentialAnalysis",
+            state: self.state,
+            samplelst: { groups },
+            termType: TermTypes.GENE_EXPRESSION,
+            tw: samplelstTW,
+            settings: { volcano: { method: selectedMethod } }
+          };
+          tip.hide();
+          self.tip.hide();
+          self.app.dispatch({
+            type: "plot_create",
+            config
+          });
+        });
+      }
+    });
+  }
+  if (self.app.vocabApi.termdbConfig.allowedTermTypes?.includes(TermTypes.METABOLITE_INTENSITY)) {
+    div.append("div").text("DA should support metabolite");
+  }
+  div.append("div").html(
+    `<span style="font-size:.8em;font-weight:bold">CASE</span> ${samplelstTW.q.groups[1].name}
+		&nbsp;
+		<span style="font-size:.8em;font-weight:bold">CONTROL</span> ${samplelstTW.q.groups[0].name}`
+  ).style("font-size", "0.8em").style("opacity", 0.8).style("padding", "3px 3px 3px 10px");
+}
+function initUI(self) {
+  self.dom.filterTableDiv = self.dom.holder.append("div").style("margin-bottom", "10px");
+  const btnRow = self.dom.holder.append("div");
+  self.dom.addNewGroupBtnHolder = btnRow.append("span").style("margin-right", "20px");
+  self.dom.newTermSpan = btnRow.append("span");
+  self.dom.newTermSpan.append("span").style("padding-left", "15px").text("Add variable:");
+  self.dom.newTermNameInput = self.dom.newTermSpan.append("input").attr("type", "text");
+  self.dom.launchButton = self.dom.newTermSpan.append("span").attr("class", "sja_menuoption").on("click", () => clickLaunchBtn(self));
+  self.dom.noGroupSelected = btnRow.append("span").text("No groups selected").style("opacity", 0.5);
+  self.dom.customTermDiv = self.dom.holder.append("div").style("margin", "20px").style("border-left", "solid 1px black").style("padding", "10px");
+}
+async function updateUI(self) {
+  if (!self.filterPrompt) {
+    self.filterPrompt = await filterPromptInit({
+      holder: self.dom.addNewGroupBtnHolder,
+      vocabApi: self.app.vocabApi,
+      emptyLabel: "Add group",
+      termdbConfig: self.app.vocabApi.termdbConfig,
+      callback: (f) => {
+        addNewGroup(self.app, f, self.state.groups);
+      },
+      debug: self.opts.debug
+    });
+  }
+  self.filterPrompt.main(self.getMassFilter());
+  const groups = structuredClone(self.state.groups);
+  if (!groups.length) {
+    self.updateLaunchButton();
+    self.dom.filterTableDiv.style("display", "none");
+    self.displayCustomTerms();
+    return;
+  }
+  self.dom.filterTableDiv.style("display", "").selectAll("*").remove();
+  const tableArg = {
+    div: self.dom.filterTableDiv,
+    columns: [
+      {},
+      // blank column to add delete buttons
+      {
+        label: "NAME",
+        editCallback: async (i, cell) => {
+          const newName = cell.value;
+          const index = self.state.groups.findIndex((group) => group.name == newName);
+          if (index != -1) {
+            alert(`Group named ${newName} already exists`);
+            updateUI(self);
+          } else
+            await self.app.dispatch({
+              type: "rename_group",
+              index: i,
+              newName: cell.value
+            });
+        }
+      },
+      {
+        label: "COLOR",
+        editCallback: async (i, cell) => {
+          await self.app.dispatch({
+            type: "change_color_group",
+            index: i,
+            newColor: cell.color
+          });
+        }
+      },
+      { label: "#SAMPLE" },
+      { label: "FILTER" }
+    ],
+    rows: [],
+    striped: false,
+    // no alternating row bg color so delete button appears more visible
+    showLines: false
+  };
+  for (const g of groups) {
+    tableArg.rows.push([
+      {},
+      // blank cell to add delete button
+      { value: g.name },
+      // to allow click to show <input>
+      { color: g.color },
+      { value: "Loading..." },
+      // sample count is lazily retrieved to not to hold up table rendering
+      {}
+      // blank cell to show filter ui
+    ]);
+  }
+  self.selectedGroupsIdx.clear();
+  if (groups.length == 1) {
+    self.selectedGroupsIdx.add(0);
+  } else {
+    tableArg.noButtonCallback = (i, node) => {
+      if (node.checked) self.selectedGroupsIdx.add(i);
+      else self.selectedGroupsIdx.delete(i);
+      self.updateLaunchButton();
+    };
+    tableArg.selectedRows = [];
+    for (let i = 0; i < groups.length; i++) {
+      tableArg.selectedRows.push(i);
+      self.selectedGroupsIdx.add(i);
+    }
+  }
+  renderTable(tableArg);
+  for (const [i, row] of tableArg.rows.entries()) {
+    row[0].__td.append("div").attr("class", "sja_menuoption").style("padding", "1px 6px").html("&times;").on("click", () => {
+      const group2 = groups[i];
+      self.app.vocabApi.deleteGroup(group2.name);
+    });
+    const group = groups[i];
+    filterInit({
+      holder: row[4].__td,
+      vocabApi: self.app.vocabApi,
+      termdbConfig: self.app.vocabApi.termdbConfig,
+      callback: (f) => {
+        if (!f || f.lst.length == 0) {
+          const i2 = groups.findIndex((g) => g.name == group.name);
+          groups.splice(i2, 1);
+        } else {
+          group.filter = f;
+        }
+        self.app.dispatch({
+          type: "app_refresh",
+          state: { groups }
+        });
+      }
+    }).main(group.filter);
+    self.app.vocabApi.getFilteredSampleCount(groups[i].filter).then((n) => row[3].__td.text(n));
+  }
+  self.updateLaunchButton();
+  self.displayCustomTerms();
+}
+async function clickLaunchBtn(self) {
+  const groups = [];
+  for (const i of self.selectedGroupsIdx) {
+    const g = self.state.groups[i];
+    if (g) groups.push(g);
+  }
+  if (groups.length == 0) throw "No groups, should not happen";
+  const name = self.dom.newTermNameInput.property("value");
+  const tw = await self.groups2samplelst(groups);
+  if (!tw) return;
+  tw.term.name = name;
+  self.app.vocabApi.addCustomTerm({ name, tw });
+  self.dom.newTermSpan.style("display", "none");
+}
+function rebaseGroupFilter(s) {
+  if (!s.termfilter?.filter || s.termfilter.filter.lst.length == 0) {
+    return s.groups;
+  }
+  const groups = [];
+  for (const g of s.groups) {
+    const f = getNormalRoot(structuredClone(s.termfilter.filter));
+    const f2 = getFilterItemByTag(g.filter, "filterUiRoot");
+    if (!f2) {
+      groups.push(g);
+      continue;
+    }
+    f.lst.push(f2);
+    f.join = f.lst.length > 1 ? "and" : "";
+    const g2 = {
+      name: g.name,
+      filter: f,
+      color: g.color
+    };
+    groups.push(g2);
+  }
+  return groups;
+}
+async function openPlot(chartType, term, term2, app, id2, newId) {
+  let config = {
+    chartType,
+    term,
+    term2
+  };
+  if (id2) config.insertBefore = id2;
+  if (newId) config.id = newId();
+  await app.dispatch({
+    type: "plot_create",
+    config
+  });
+}
+async function openSummaryPlot(tw, samplelstTW, app, id2, newId) {
+  const config = {
+    chartType: "summary",
+    childType: tw.q?.mode == "continuous" ? "violin" : "barchart",
+    term: tw,
+    term2: samplelstTW
+  };
+  if (id2) config.insertBefore = id2;
+  if (newId) config.id = newId();
+  await app.dispatch({
+    type: "plot_create",
+    config
+  });
+}
+async function showTree(div, callback, app, tip, treeState = { tree: { usecase: { target: "default", detail: "term" } } }) {
+  const activeCohort = app.getState().activeCohort;
+  const state = { activeCohort, ...treeState };
+  tip.clear().showunderoffset(div.node());
+  appInit({
+    holder: tip.d,
+    vocabApi: app.vocabApi,
+    state,
+    tree: {
+      click_term: (term) => {
+        callback(term);
+        tip.hide();
+        if (tip.dnode.parent_menu) tip.dnode.parent_menu.style.display = "none";
+      }
+    }
+  });
+}
+function addPlotMenuItem(chartType, div, text, tip, samplelstTW, id2, parent, openOnTop = false) {
+  const d = div.append("div").attr("class", "sja_menuoption sja_sharp_border").text(text).on("click", (e) => {
+    const state = { tree: { usecase: { target: chartType, detail: "term" } } };
+    if (chartType == "survival") state.nav = { header_mode: "hide_search" };
+    showTree(
+      d,
+      (term) => {
+        openPlot(chartType, term, samplelstTW, parent.app, id2, openOnTop ? () => parent.newId : null);
+      },
+      parent.app,
+      tip,
+      state
+    );
+  });
+  d.insert("div").html("\u203A").style("float", "right");
+}
+function mayAddHierClusterPlotMenuItem(chartType, div, text, tip, samplelstTW, id2, parent, openOnTop = false) {
+  if (!parent.state.currentCohortChartTypes.includes("geneExpression")) return;
+  const itemDiv = div.append("div").attr("class", "sja_menuoption sja_sharp_border").text(text).on("click", () => {
+    tip.clear().showunderoffset(itemDiv.node());
+    new GeneSetEditUI({
+      holder: tip.d,
+      genome: parent.app.opts.genome,
+      geneList: [],
+      vocabApi: parent.app.vocabApi,
+      mode: TermTypes.GENE_EXPRESSION,
+      callback: async ({ geneList, groupName }) => {
+        const group = { name: groupName, lst: [], type: "hierCluster" };
+        const lst = group.lst.filter((tw) => tw.term.type != "geneExpression");
+        const tws = await Promise.all(
+          geneList.map(async (d) => {
+            const gene = d.symbol || d.gene;
+            const unit = parent.app.vocabApi.termdbConfig.queries.geneExpression?.unit || "Gene Expression";
+            const name = `${gene} ${unit}`;
+            const term = { gene, name, type: "geneExpression" };
+            let tw = group.lst.find((tw2) => tw2.term.name == d.symbol || tw2.term.name == d.gene);
+            if (!tw) {
+              tw = { term, q: {} };
+            }
+            return tw;
+          })
+        );
+        tip.hide();
+        if (tip.dnode.parent_menu) tip.dnode.parent_menu.style.display = "none";
+        if (tws.length == 1) {
+          const tw = tws[0];
+          parent.app.dispatch({
+            type: "plot_create",
+            config: {
+              chartType: "summary",
+              term: tw,
+              term2: samplelstTW
+            }
+          });
+          return;
+        }
+        if (tws.length == 2) {
+          const tw = tws[0];
+          const tw2 = tws[1];
+          parent.app.dispatch({
+            type: "plot_create",
+            config: {
+              chartType: "summary",
+              term: tw,
+              term2: tw2,
+              colorTW: samplelstTW
+            }
+          });
+          return;
+        }
+        group.lst = [...lst, ...tws];
+        parent.app.dispatch({
+          type: "plot_create",
+          config: {
+            chartType: "hierCluster",
+            termgroups: [group],
+            dataType: TermTypes.GENE_EXPRESSION,
+            divideBy: samplelstTW,
+            settings: { hierCluster: { yDendrogramHeight: 0, clusterSamples: false } }
+          }
+        });
+      }
+    });
+  });
+  itemDiv.insert("div").html("\u203A").style("float", "right");
+}
+function mayAddMatrixMenuItems(div, text, tip, samplelstTW, id2, parent, state, openOnTop = false, newId) {
+  if (!state.currentCohortChartTypes.includes("matrix")) return;
+  const preBuiltMatrix = state.matrixplots;
+  const hasSnvIndel = parent.app.vocabApi.termdbConfig?.queries?.snvindel;
+  if (!preBuiltMatrix && !hasSnvIndel) return;
+  const itemDiv = div.append("div").attr("class", "sja_menuoption sja_sharp_border").text(text).on("click", () => {
+    tip.clear().showunderoffset(itemDiv.node());
+    if (preBuiltMatrix) {
+      const preBuiltMatrixDiv = tip.d.append("div");
+      for (const plot of preBuiltMatrix) {
+        preBuiltMatrixDiv.append("button").style("margin", "10px").style("padding", "10px 15px").style("border-radius", "20px").style("border-color", "#ededed").style("display", "inline-block").text("Divide " + plot.name).on("click", async () => {
+          const config = await parent.app.vocabApi.getMatrixByName(plot.name);
+          config.divideBy = samplelstTW;
+          config.insertBefore = id2;
+          config.settings.matrix.colw = 0;
+          if (newId) config.id = newId();
+          parent.app.dispatch({
+            type: "plot_create",
+            config
+          });
+          tip.hide();
+          tip.dnode.parent_menu.style.display = "none";
+        });
+      }
+    }
+    if (hasSnvIndel) {
+      const newMatrixDiv = tip.d.append("div");
+      new GeneSetEditUI({
+        holder: newMatrixDiv,
+        genome: parent.app.opts.genome,
+        geneList: [],
+        mode: TermTypes.GENE_VARIANT,
+        vocabApi: parent.app.vocabApi,
+        callback: async ({ geneList, groupName }) => {
+          tip.hide();
+          tip.dnode.parent_menu.style.display = "none";
+          const group = { name: groupName, lst: [] };
+          const lst = group.lst.filter((tw) => tw.term.type != "geneVariant");
+          const tws = await Promise.all(
+            geneList.map(async (d) => {
+              const term = {
+                gene: d.symbol || d.gene,
+                name: d.symbol || d.gene,
+                type: "geneVariant"
+              };
+              let tw = group.lst.find((tw2) => tw2.term.name == d.symbol || tw2.term.name == d.gene);
+              if (!tw) {
+                tw = { term };
+                await fillTermWrapper(tw, parent.app.vocabApi);
+              } else if (!tw.$id) {
+                tw.$id = await get$id(parent.app.vocabApi.getTwMinCopy({ term }));
+              }
+              return tw;
+            })
+          );
+          group.lst = [...lst, ...tws];
+          parent.app.dispatch({
+            type: "plot_create",
+            config: {
+              chartType: "matrix",
+              termgroups: [group],
+              dataType: TermTypes.GENE_VARIANT,
+              divideBy: samplelstTW
+            }
+          });
+        }
+      });
+    }
+  });
+  itemDiv.insert("div").html("\u203A").style("float", "right");
+}
+function addNewGroup(app, filter, groups) {
+  groups = JSON.parse(JSON.stringify(groups));
+  let name = "New group";
+  let i = 0;
+  while (1) {
+    const name2 = name + (i == 0 ? "" : " " + i);
+    if (!groups.find((g) => g.name == name2)) break;
+    i++;
+  }
+  name = name + (i == 0 ? "" : " " + i);
+  const newGroup = {
+    name,
+    filter,
+    color: rgb(colorScale(groups.length)).formatHex()
+  };
+  groups.push(newGroup);
+  app.dispatch({
+    type: "app_refresh",
+    state: { groups }
+  });
+}
+function getSamplelstTWFromIds(ids) {
+  if (!ids) throw "getSamplelstTWFromIds: ids is empty";
+  if (!Array.isArray(ids)) throw "getSamplelstTWFromIds: ids must be an array";
+  const name = "group";
+  const values = ids.map((id2) => {
+    return { sampleId: id2 };
+  });
+  const qgroup = {
+    name,
+    in: true,
+    values
+  };
+  const tw = {
+    isAtomic: true,
+    term: { name, type: "samplelst", values: { [name]: { key: name, list: values } } },
+    q: {
+      groups: [qgroup]
+    }
+  };
+  return tw;
+}
+function getSamplelstFilter(ids) {
+  const tw = getSamplelstTWFromIds(ids);
+  const filter = getFilter(tw);
+  return filter;
+}
+function getFilter(samplelstTW) {
+  let i = 0;
+  let noEdit = true;
+  for (const field in samplelstTW.term.values) {
+    const values = samplelstTW.q.groups[i].values;
+    samplelstTW.term.values[field].list = values;
+    if (values[0] && "sample" in values[0]) noEdit = false;
+    i++;
+  }
+  const filter = {
+    type: "tvslst",
+    in: true,
+    join: "",
+    lst: [
+      {
+        type: "tvs",
+        tvs: { term: samplelstTW.term },
+        noEdit
+      }
+    ]
+  };
+  return filter;
+}
+function getSamplelstTW2(groups) {
+  const values = {};
+  const qgroups = [];
+  for (const group of groups) {
+    const samples = getGroupSamples(group);
+    const qgroup = {
+      name: group.name,
+      in: true,
+      values: samples
+    };
+    qgroups.push(qgroup);
+    values[group.name] = { key: group.name, label: group.name, color: group.color, list: samples };
+  }
+  return {
+    isAtomic: true,
+    term: { name: "groups", type: "samplelst", values },
+    q: { groups: qgroups }
+  };
+}
+function getSamplelstTW(groups, name = groups.length == 1 ? "group" : "groups", notIn = true) {
+  const values = {};
+  const qgroups = [];
+  let samples;
+  for (const group of groups) {
+    samples = getGroupSamples(group);
+    const qgroup = {
+      name: group.name,
+      in: true,
+      values: samples
+    };
+    qgroups.push(qgroup);
+    values[group.name] = { key: group.name, label: group.name, color: group.color, list: samples };
+  }
+  if (groups.length == 1 && notIn) {
+    const name2 = "Not in " + groups[0].name;
+    values[name2] = { key: name2, label: name2, color: "#aaa", list: samples, in: false };
+    qgroups.push({
+      name: name2,
+      in: false,
+      values: samples
+    });
+  }
+  const tw = {
+    isAtomic: true,
+    term: { name, type: "samplelst", values },
+    q: { groups: qgroups }
+  };
+  return tw;
+}
+function getGroupSamples(group) {
+  const values = [];
+  for (const item of group.items) {
+    const value = { sampleId: item.sampleId };
+    if ("sample" in item) {
+      value.sample = item.sample;
+    }
+    values.push(value);
+  }
+  return values;
+}
+
+export {
+  chartsInit,
+  getCurrentCohortChartTypes,
+  groupsInit,
+  rebaseGroupFilter,
+  openPlot,
+  openSummaryPlot,
+  addNewGroup,
+  getSamplelstFilter,
+  getFilter,
+  getSamplelstTW
+};
+//# sourceMappingURL=chunk-LMELY5Z2.js.map