@sjcrh/proteinpaint-client 2.204.0 → 2.205.0

package/dist/Regression-PSHH7ZXN.js

@@ -0,0 +1,1416 @@
+import {
+  appInit
+} from "./chunk-5AAAH4OZ.js";
+import "./chunk-IAE3KWN5.js";
+import {
+  getDefaultViolinSettings
+} from "./chunk-57NYHASA.js";
+import "./chunk-X46YA4CB.js";
+import "./chunk-SKMFMGCD.js";
+import {
+  mayRunSnplstTask
+} from "./chunk-7OYOC7XY.js";
+import {
+  RegressionResults
+} from "./chunk-6JBQLOJW.js";
+import {
+  PlotBase,
+  fillTermWrapper,
+  get$id,
+  getActiveCohortStr,
+  getCombinedTermFilter,
+  make_one_checkbox,
+  sayerror,
+  termsettingInit
+} from "./chunk-J7JDCNLU.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-N635HDJ4.js";
+import "./chunk-T46FA72N.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import {
+  get_bin_label
+} from "./chunk-JYOIO5UY.js";
+import "./chunk-YN5NY3D3.js";
+import {
+  dictionaryNumericTypes,
+  isDictionaryType,
+  isNumericTw,
+  numericTypes
+} from "./chunk-RN4BOWRH.js";
+import "./chunk-IK2BO37K.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-D6G64XPJ.js";
+import {
+  getValueConversionFactor
+} from "./chunk-W5J3LTYS.js";
+import "./chunk-YLJOZP4P.js";
+import "./chunk-HDTFYTEL.js";
+import "./chunk-FXQXCOII.js";
+import {
+  roundValue
+} from "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/regression/regression.inputs.values.table.ts
+var row_hover_bgcolor = "#fff6dc";
+var graytextcolor = "#555";
+var InputValuesTable = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.input = opts.input;
+    setRenderers(this);
+    this.setDOM(opts.holder);
+  }
+  main() {
+    try {
+      const term = this.input.term;
+      if (!term || !this.input.termStatus) {
+        this.dom.holder.style("display", "none");
+        this.dom.loading_div.style("display", "none");
+        return;
+      } else if (term) {
+        this.dom.holder.style("display", "block");
+        this.dom.loading_div.style("display", "block");
+        this.updateValueCount();
+        this.dom.loading_div.style("display", "none");
+        this.render();
+        return;
+      }
+    } catch (e) {
+      this.dom.loading_div.style("display", "none");
+      throw e;
+    }
+  }
+  updateValueCount() {
+    const i = this.input;
+    try {
+      if (i.pill && i.pill.validateQ) {
+        i.pill.validateQ({
+          term: i.term.term,
+          q: i.term.q,
+          sampleCounts: i.termStatus.sampleCounts
+        });
+      }
+    } catch (e) {
+      i.term.error = e;
+    }
+  }
+};
+function setRenderers(self) {
+  self.setDOM = (holder) => {
+    self.dom = {
+      holder: holder.style("margin", "10px").style("font-size", ".8em").style("text-align", "left").style("color", graytextcolor),
+      loading_div: holder.append("div").text("Loading..").style("display", "none"),
+      top_info_div: holder.append("div").style("padding-bottom", "5px"),
+      violin_div: holder.append("div").style("color", "black").style("padding-top", "5px"),
+      table_div: holder.append("table").style("margin", "5px 0px 15px 0px").style("border-collapse", "collapse").style("color", "black"),
+      bottom_info_div: holder.append("div"),
+      excluded_div: holder.append("table").style("display", "none").style("margin", "5px 10px").style("border-collapse", "collapse")
+    };
+  };
+  self.render = async () => {
+    const input = self.input;
+    renderTopInfo(input);
+    await renderValuesTable(input);
+    renderBottomInfo(input);
+    renderExcludedValues(input);
+  };
+  function renderTopInfo(input) {
+    if (input.termStatus.topInfoStatus?.length) {
+      self.dom.top_info_div.style("display", "block").html(input.termStatus.topInfoStatus.join("<br>"));
+    } else {
+      self.dom.top_info_div.style("display", "none");
+    }
+  }
+  async function renderValuesTable(input) {
+    if (input.term.q.mode == "continuous" || input.term.q.mode == "spline") {
+      self.dom.violin_div.style("display", "block");
+      self.dom.table_div.style("display", "none");
+      if (self.plotAppApi) {
+        const action = {
+          type: "app_refresh",
+          state: { termfilter: structuredClone(self.input.parent.state?.termfilter) },
+          subactions: [
+            {
+              type: "plot_edit",
+              id: self.violinApi.id,
+              config: {
+                term: input.term
+              }
+            }
+          ]
+        };
+        self.plotAppApi.dispatch(action);
+      } else {
+        const opts = {
+          holder: self.dom.violin_div,
+          vocabApi: self.input.parent.app.vocabApi,
+          state: {
+            vocab: {
+              genome: self.input.parent.app.vocabApi.genome,
+              dslabel: self.input.parent.app.vocabApi.dslabel
+            },
+            termfilter: structuredClone(self.input.parent.state?.termfilter),
+            plots: [
+              {
+                chartType: "violin",
+                term: input.term,
+                settings: {
+                  violin: getDefaultViolinSettings(null, {
+                    svgw: 350,
+                    axisHeight: 25,
+                    rightMargin: 10,
+                    datasymbol: "rug",
+                    radius: 8,
+                    plotThickness: 80
+                  })
+                }
+              }
+            ]
+          },
+          // global options for plotAppApi
+          // opts.violin will apply to all violin plots within the plotApp
+          // rx will pass options by component type, which are not tracked in state
+          // examples are callbacks, event listeners, etc
+          violin: {
+            mode: "minimal"
+          }
+        };
+        self.plotAppApi = await appInit(opts);
+        const plotId = self.plotAppApi.getState().plots[0].id;
+        self.violinApi = self.plotAppApi.getComponents(`plots.${plotId}`);
+      }
+    } else {
+      self.dom.violin_div.style("display", "none");
+      const data = input.termStatus.sampleCounts;
+      if (!data || !data.length) {
+        self.dom.table_div.style("display", "none");
+        return;
+      }
+      self.dom.table_div.style("display", "block").attr("data-testid", "sjpp-regression-barchart");
+      const l = self.input.orderedLabels;
+      const sortFxn = l && l.length ? (a, b) => l.indexOf(a.label) - l.indexOf(b.label) : (a, b) => b.samplecount - a.samplecount;
+      const tr_data = data.sort(sortFxn);
+      const maxCount = Math.max(...tr_data.map((v) => v.samplecount), 0);
+      tr_data.forEach((v) => v.bar_width_frac = Number((1 - (maxCount - v.samplecount) / maxCount).toFixed(4)));
+      self.dom.table_div.selectAll("tr").remove();
+      const trs = self.dom.table_div.selectAll("tr").data(tr_data, (b) => b.key);
+      trs.enter().append("tr").each(trEnter);
+    }
+  }
+  function renderBottomInfo(input) {
+    if (input.termStatus.bottomSummaryStatus) {
+      self.dom.bottom_info_div.style("display", "block").html(input.termStatus.bottomSummaryStatus);
+    } else {
+      self.dom.bottom_info_div.style("display", "none");
+    }
+  }
+  function renderExcludedValues(input) {
+    const data = input.termStatus.excludeCounts;
+    if (!data || !data.length) {
+      self.dom.excluded_div.style("display", "none");
+      return;
+    }
+    self.dom.excluded_div.style("display", "block").selectAll("tr").remove();
+    const trs = self.dom.excluded_div.selectAll("tr").data(data, (b) => b.key);
+    trs.enter().append("tr").each(trEnter);
+    self.dom.excluded_div.selectAll("td").style("color", graytextcolor);
+  }
+  function trEnter(item) {
+    const tr = select_default(this);
+    const input = this.parentNode.__data__;
+    const maxBarWidth = 150;
+    tr.style("text-align", "left").style("cursor", input.termStatus.allowToSelectRefGrp ? "pointer" : "default");
+    const tdSpacing = "1px 10px 1px 0px";
+    tr.append("td").style("padding", tdSpacing).style("text-align", "left").style("color", "black").text(item.samplecount !== void 0 ? "n=" + item.samplecount : "");
+    tr.append("td").style("padding", tdSpacing).style("text-align", "left").style("color", "black").text(item.label);
+    const bar_td = tr.append("td").style("padding", tdSpacing);
+    const barWidth = maxBarWidth * item.bar_width_frac;
+    bar_td.append("div").style("margin", tdSpacing).style("width", barWidth + "px").style("height", "15px").style("background-color", "#ddd");
+    addTrBehavior({ input, item, tr, rendered: false });
+  }
+  function addTrBehavior({ input, item, tr, rendered }) {
+    if (!item.bar_width_frac) return;
+    const t = input.term;
+    const hover_flag = input.termStatus.allowToSelectRefGrp;
+    let ref_text;
+    if (rendered) {
+      tr.style("background", "white");
+      ref_text = select_default(tr.node().lastChild).select("div").style("display", item.key === t.refGrp && hover_flag ? "inline-block" : "none").style("border", item.key === t.refGrp && hover_flag ? "1px solid #bbb" : "");
+    } else if (input.term.q.mode != "cutoff") {
+      const reference_td = tr.append("td").style("padding", "1px 5px").style("text-align", "left");
+      ref_text = reference_td.append("div").style("display", item.key === t.refGrp && hover_flag ? "inline-block" : "none").style("padding", "2px 10px").style("border", item.key === t.refGrp && hover_flag ? "1px solid #bbb" : "").style("border-radius", "10px").style("color", graytextcolor).style("font-size", ".7em").text("REFERENCE");
+      if (hover_flag) {
+        tr.on("mouseover", () => {
+          if (t.refGrp !== item.key) {
+            tr.style("background", row_hover_bgcolor);
+            ref_text.style("display", "inline-block").style("border", "").text("Set as reference");
+          } else tr.style("background", "white");
+        }).on("mouseout", () => {
+          tr.style("background", "white");
+          if (t.refGrp !== item.key) ref_text.style("display", "none");
+        }).on("click", () => {
+          t.refGrp = item.key;
+          ref_text.style("border", "1px solid #bbb").text("REFERENCE");
+          self.opts.callback(t);
+        });
+      }
+    }
+  }
+}
+
+// plots/regression/regression.inputs.term.ts
+var graytextcolor2 = "#555";
+var InputTerm = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.section = opts.section;
+    this.term = opts.term;
+    this.parent = opts.parent;
+    this.vocabApi = this.parent.parent.vocabApi;
+  }
+  async init(holder) {
+    const termRow = holder.append("div");
+    const pillDiv = termRow.append("span").style("display", "inline-block");
+    const interactionDiv = termRow.append("span").style("margin-left", "20px");
+    this.dom = {
+      holder,
+      termRow,
+      pillDiv,
+      interactionDiv,
+      err_div: holder.append("div").style("display", "none").style("padding", "5px").style("background-color", "rgba(255,100,100,0.2)"),
+      infoDiv: holder.append("div"),
+      tip: new Menu()
+    };
+    try {
+      const { app, config, state, disable_terms } = this.parent;
+      const arg = {
+        placeholder: this.section.selectPrompt,
+        placeholderIcon: this.section.placeholderIcon,
+        holder: this.dom.pillDiv,
+        vocabApi: this.vocabApi,
+        noTermPromptOptions: this.opts.noTermPromptOptions,
+        activeCohort: state.activeCohort,
+        debug: app.opts.debug,
+        menuOptions: this.getMenuOptions(),
+        usecase: { target: "regression", detail: this.section.configKey, regressionType: config.regressionType },
+        disable_terms,
+        abbrCutoff: 50,
+        genomeObj: this.parent.parent.genomeObj,
+        // required for snplocus
+        defaultQ4fillTW: get_defaultQ4fillTW(config.regressionType, this.section.configKey),
+        callback: (term) => {
+          this.parent.editConfig(this, term);
+        }
+      };
+      this.furbishTsConstructorArg(arg);
+      this.pill = await termsettingInit(arg);
+      if (this.section.configKey == "outcome") {
+        this.setQ = getQSetter4outcome(config.regressionType);
+      }
+      this.valuesTable = new InputValuesTable({
+        holder: this.dom.infoDiv,
+        input: this,
+        callback: (term) => {
+          this.parent.editConfig(this, term);
+        }
+      });
+    } catch (e) {
+      this.displayError([e]);
+    }
+  }
+  furbishTsConstructorArg(arg) {
+    const type = this.parent.config.regressionType;
+    if (this.section.configKey == "outcome") {
+      if (type == "logistic") {
+        arg.numericEditMenuVersion = ["binary"];
+        return;
+      }
+      if (type == "linear") {
+        arg.numericEditMenuVersion = ["continuous"];
+        return;
+      }
+      if (type == "cox") {
+        return;
+      }
+      throw "unknown regressionType";
+    }
+    if (this.section.configKey == "independent") {
+      arg.numericEditMenuVersion = ["continuous", "discrete", "spline"];
+      arg.geneVariantEditMenuOnlyGrp = true;
+      return;
+    }
+    throw "unknown section.configKey: " + this.section.configKey;
+  }
+  displayError(errors) {
+    this.hasError = true;
+    this.dom.err_div.selectAll("*").remove();
+    this.dom.err_div.style("display", "block").selectAll("div").data(Array.isArray(errors) ? errors : [errors]).enter().append("div").text((e) => e);
+    this.parent.handleError();
+    console.error(errors);
+  }
+  async main() {
+    const tw = this.term;
+    if (tw) {
+      delete tw.error;
+    }
+    this.dom.err_div.style("display", "none").text("");
+    this.hasError = false;
+    const errors = [];
+    try {
+      if (tw && this.setQ) {
+        const {
+          /*app,*/
+          state
+        } = this.parent;
+        await this.setQ[tw.term.type](tw, this.vocabApi, this.parent.parent.filter, state);
+      }
+      try {
+        await this.updateTerm();
+      } catch (e2) {
+        errors.push(e2);
+      }
+      await this.pill.main(this.getPillArgs());
+      this.renderInteractionPrompt();
+      await this.valuesTable.main();
+      if (tw && !tw.$id) tw.$id = await get$id(this.vocabApi.getTwMinCopy(tw));
+      const e = tw && tw.error || this.pill.error;
+      if (e) errors.push(e);
+      if (errors.length) throw errors;
+    } catch (errors2) {
+      this.displayError(errors2);
+    }
+  }
+  async updateTerm() {
+    const tw = this.term;
+    if (!tw) return;
+    if (!tw.q) throw ".term.q missing on this input";
+    if (!tw.q.mode && isDictionaryType(tw.term.type)) {
+      if (tw.term.type == "categorical" || tw.term.type == "condition" || tw.term.type == "survival" || tw.term.type == "samplelst")
+        tw.q.mode = "discrete";
+      else tw.q.mode = "continuous";
+    }
+    const body = tw.term.type == "snplst" || tw.term.type == "snplocus" ? { cacheid: tw.q.cacheid } : {};
+    const wait = this.dom.holder.append("div").style("padding", "5px").text("Loading...");
+    let data;
+    try {
+      data = await this.vocabApi.getTwCategories(tw, this.parent.parent.filter, body);
+      if (!data) throw `no data for term.id='${tw.term.id}'`;
+      if (data.error) throw data.error;
+    } finally {
+      wait.remove();
+    }
+    mayRunSnplstTask(tw, data);
+    this.termStatus = {
+      topInfoStatus: [],
+      bottomSummaryStatus: void 0,
+      sampleCounts: void 0,
+      excludeCounts: void 0,
+      allowToSelectRefGrp: false
+    };
+    if (tw.q.numOfSampleWithAnyValidGT) {
+      const invalid_snps_count = tw.term.snps.reduce((i, j) => i + (j.invalid ? 1 : 0), 0);
+      this.termStatus.topInfoStatus.push(
+        `${tw.q.numOfSampleWithAnyValidGT} samples with valid genotypes` + (invalid_snps_count > 0 ? ` ${invalid_snps_count} invalid SNP${invalid_snps_count > 1 ? "s" : ""}.` : "")
+      );
+    }
+    if ("geneticModel" in tw.q) {
+      this.termStatus.topInfoStatus.push(
+        "Genetic model: " + (tw.q.geneticModel == 0 ? "Additive" : tw.q.geneticModel == 1 ? "Dominant" : tw.q.geneticModel == 2 ? "Recessive" : "By genotype")
+      );
+    }
+    if (tw.q.restrictAncestry) {
+      this.termStatus.topInfoStatus.push("Analyzing " + tw.q.restrictAncestry.name);
+      if (tw.q.restrictAncestry.PCcount) {
+        this.termStatus.topInfoStatus.push(
+          `Adjusting for top ${tw.q.restrictAncestry.PCcount} ancestry principal components`
+        );
+      }
+    }
+    if (tw.term.reachedVariantLimit) {
+      this.termStatus.topInfoStatus.push(
+        `<span class=sja_mcdot style="background:#aaa;font-size:1em">
+				&nbsp;&#9888; Restricted to first ${tw.term.snps.length}
+				variants of this region.&nbsp;</span> Try zooming in.`
+      );
+    }
+    this.orderedLabels = data.orderedLabels;
+    if (data.lst) {
+      this.summarizeSample(tw, data.lst);
+      if (isNumericTw(tw)) {
+        if (tw.q.mode != "continuous" && tw.q.mode != "spline") {
+          this.termStatus.allowToSelectRefGrp = true;
+        }
+        if (tw.q.scale && tw.q.scale != 1) this.termStatus.topInfoStatus.push(`Scale: Per ${tw.q.scale}`);
+        if (tw.q.mode == "discrete") {
+          this.termStatus.topInfoStatus.push(`Discrete variable with ${this.termStatus?.sampleCounts?.length} bins`);
+        }
+        const vc = tw.term.valueConversion;
+        const isConverted = vc && (tw.q.mode == "continuous" || tw.q.mode == "spline");
+        if (isConverted) {
+          this.termStatus.topInfoStatus.push(`Analyzed by the unit of ${vc.toUnit}, converted from ${vc.fromUnit}`);
+        }
+        if (tw.q.mode == "spline") {
+          const f = getValueConversionFactor(tw.term);
+          this.termStatus.topInfoStatus.push(
+            `Cubic spline variable with ${tw.q.knots.length} knots: ${tw.q.knots.map((x) => Number(x.value) * f).sort((a, b) => a - b).map((v) => f == 1 ? v : roundValue(v, 2)).join(", ")}${isConverted ? ` ${vc.toUnit}s` : ""}`
+          );
+        }
+      } else if (tw.term.type == "categorical" || tw.term.type == "geneVariant" || tw.term.type == "samplelst") {
+        this.termStatus.allowToSelectRefGrp = true;
+      } else if (tw.term.type == "condition") {
+        if (this.section.configKey == "outcome" && this.parent.opts.regressionType == "logistic") {
+          this.termStatus.allowToSelectRefGrp = true;
+        }
+        if (this.section.configKey == "outcome" && this.parent.opts.regressionType == "cox") {
+          if (!["age", "time"].includes(tw.q.timeScale)) throw "invalid q.timeScale";
+          const tdb = this.vocabApi.termdbConfig;
+          this.termStatus.topInfoStatus.push(`Time axis: ${tw.q.timeScale == "time" ? tdb.timeUnit : "age"}`);
+          this.termStatus.topInfoStatus.push(
+            `<span style="padding-left: 10px;">-start: ${tw.q.timeScale == "time" ? " " : "age at "}entry into the cohort (i.e., ${tdb.cohortStartTimeMsg})</span>`
+          );
+          this.termStatus.topInfoStatus.push(
+            `<span style="padding-left: 10px;">-end: ${tw.q.timeScale == "time" ? " " : "age at "}event or censoring/death</span>`
+          );
+          const grades = Object.keys(tw.term.values).map(Number);
+          const maxgrade = Math.max(...grades);
+          this.termStatus.topInfoStatus.push(
+            `<div style="padding-top: 8px;">Event: first occurrence of grade ${tw.q.breaks[0] === maxgrade ? tw.q.breaks[0] : `${tw.q.breaks[0]}-${maxgrade}</div>`}`
+          );
+        }
+      }
+      this.maySet_refGrp(tw);
+      if (this.section.configKey == "outcome") {
+        if (this.parent.config.regressionType == "logistic") {
+          tw.nonRefGrp = getLogisticOutcomeNonref(tw);
+        } else if (this.parent.config.regressionType == "cox") {
+          tw.eventLabel = getCoxOutcomeEventLabel(tw);
+        }
+      }
+    }
+  }
+  summarizeSample(tw, datalst) {
+    const excluded_values = /* @__PURE__ */ new Set();
+    if (tw.term.values) {
+      for (const i in tw.term.values) {
+        if (tw.term.values[i].uncomputable) excluded_values.add(tw.term.values[i].label);
+      }
+    }
+    if (tw.q.mode == "cox") {
+      const toExclude = datalst.find((x) => x.key == -1);
+      if (toExclude) excluded_values.add(toExclude.label);
+    }
+    const sampleCounts = this.termStatus.sampleCounts = datalst.filter((v) => !excluded_values.has(v.label));
+    const excludeCounts = this.termStatus.excludeCounts = datalst.filter((v) => excluded_values.has(v.label));
+    const totalCount = { included: 0, excluded: 0, total: 0 };
+    sampleCounts.forEach((v) => totalCount.included += v.samplecount);
+    excludeCounts.forEach((v) => totalCount.excluded += v.samplecount);
+    totalCount.total = totalCount.included + totalCount.excluded;
+    if (tw.term.type == "condition" && totalCount.total) {
+      totalCount.excluded = totalCount.total - totalCount.included;
+    }
+    this.termStatus.bottomSummaryStatus = `${totalCount.included} samples included` + (totalCount.excluded ? `. ${totalCount.excluded} samples excluded:` : "");
+    if (tw && tw.q.mode !== "continuous" && sampleCounts.length < 2)
+      throw `there should be two or more discrete values with samples for variable='${tw.term.name}'`;
+  }
+  maySet_refGrp(tw) {
+    if (this.section.configKey == "outcome" && this.parent.config.regressionType == "cox") {
+      return;
+    }
+    if (tw.q.mode == "continuous") {
+      tw.refGrp = "NA";
+      return;
+    }
+    const sc = this.termStatus.sampleCounts;
+    if (!sc) throw new Error("termStatus.sampleCounts missing");
+    if (!("refGrp" in tw) || !sc.find((i) => i.key == tw.refGrp)) {
+      if (tw.term.type == "geneVariant") {
+        const wtGrp = getGeneVariantWildtypeGrp(tw, sc);
+        if (wtGrp) {
+          tw.refGrp = wtGrp;
+          return;
+        }
+      }
+      const o = this.orderedLabels;
+      if (o && o.length) sc.sort((a, b) => o.indexOf(a.key) - o.indexOf(b.key));
+      else sc.sort((a, b) => a.samplecount < b.samplecount ? 1 : -1);
+      tw.refGrp = sc[0].key;
+    }
+  }
+  /*
+  recomputed on every main() and not just at init(), since switching cohort can change whether the
+  outcome term is the only one this dataset offers
+  */
+  getMenuOptions() {
+    const { config, state } = this.parent;
+    if (this.section.configKey != "outcome") return "{edit,reuse,remove}";
+    return isLoneOutcome(config.regressionType, this.vocabApi.termdbConfig, state.activeCohort) ? "{edit,reuse}" : "{edit,reuse,replace}";
+  }
+  getPillArgs() {
+    const section = this.section;
+    const { config, state, disable_terms } = this.parent;
+    const args = Object.assign(
+      {
+        activeCohort: state.activeCohort,
+        disable_terms,
+        menuOptions: this.getMenuOptions(),
+        usecase: {
+          target: "regression",
+          detail: section.configKey,
+          regressionType: config.regressionType
+        }
+      },
+      this.term
+    );
+    args.filter = this.parent.parent.filter;
+    return args;
+  }
+  remove() {
+    this.dom.termRow.transition().duration(500).style("opacity", 0).remove();
+    for (const key in this.dom) {
+      delete this.dom[key];
+    }
+  }
+  renderInteractionPrompt() {
+    this.dom.interactionDiv.style("display", "none");
+    if (!this.term) return;
+    if (this.section.configKey != "independent") return;
+    if (this.term.q.mode == "spline") return;
+    if (this.vocabApi.termdbConfig.regression?.settings?.disableInteractions) return;
+    {
+      let count = 0;
+      for (const input of this.section.inputLst) {
+        if (input.term && input.term.q.mode != "spline") {
+          count++;
+        }
+      }
+      if (count < 2) return;
+    }
+    const n = this.term.interactions.length;
+    this.dom.interactionDiv.style("display", "inline").html(n == 0 ? "Add interactions" : `${n} interaction${n > 1 ? "s" : ""}`).style("padding", "5px").style("background-color", n == 0 ? "" : "#ececec").style("border-radius", n == 0 ? "" : "6px").style("color", n == 0 ? graytextcolor2 : "#000").style("font-size", n == 0 ? "0.8em" : "").style("cursor", "pointer").on("click", () => this.renderInteractionOptions());
+  }
+  renderInteractionOptions() {
+    const self = this;
+    this.dom.tip.clear().showunder(this.dom.interactionDiv.node());
+    if (this.parent.config.includeUnivariate) {
+      const label = this.parent.dom.univariateCheckboxDiv.select("label").text().trim();
+      this.dom.tip.d.append("div").text(`Cannot add interactions. Please uncheck the "${label}" checkbox.`);
+      return;
+    }
+    this.dom.tip.d.append("div").style("padding", "5px").style("font-size", "0.8em").style("color", graytextcolor2).html(`Selected variables will each form pairwise interaction with ${this.term.term.name}`);
+    this.dom.tip.d.append("div").selectAll("div").data(this.parent.config.independent.filter((tw) => tw && tw.$id != this.term.$id && tw.q.mode != "spline")).enter().append("div").style("margin", "5px").each(function(tw) {
+      const elem = select_default(this).append("label");
+      elem.append("input").attr("type", "checkbox").property("checked", self.term.interactions.includes(tw.$id));
+      elem.append("span").text(" " + tw.term.name);
+    });
+    this.dom.tip.d.append("button").text("Apply").style("margin", "5px").on("click", () => {
+      this.dom.tip.hide();
+      this.term.interactions = [];
+      this.dom.tip.d.selectAll("input").each(function(tw) {
+        if (select_default(this).property("checked")) self.term.interactions.push(tw.$id);
+      });
+      for (const tw of this.parent.config.independent) {
+        const interactions = new Set(tw.interactions);
+        if (this.term.interactions.includes(tw.$id)) interactions.add(this.term.$id);
+        else interactions.delete(this.term.$id);
+        tw.interactions = [...interactions];
+      }
+      this.parent.editConfig(this, this.term);
+    });
+  }
+};
+function getQSetter4outcome(regressionType) {
+  return {
+    integer: regressionType == "logistic" ? maySetTwoBins : setContMode,
+    float: regressionType == "logistic" ? maySetTwoBins : setContMode,
+    geneExpression: regressionType == "logistic" ? maySetTwoBins : setContMode,
+    //Added geneExpression, but still breaks, need to fix
+    categorical: maySetTwoGroups,
+    condition: setQ4tteOutcome,
+    survival: setQ4tteOutcome
+  };
+}
+async function maySetTwoBins(tw, vocabApi, _, state) {
+  if (tw.q.mode == "binary" && tw.q.lst && tw.q.lst.length == 2) {
+    tw.q.mode = "binary";
+    return;
+  }
+  const data = await vocabApi.getPercentile(tw.term, [50], state.termfilter);
+  if (data.error || !data.values.length || !Number.isFinite(data.values[0]))
+    throw "cannot get median value: " + (data.error || "no data");
+  const median = tw.term.type == "integer" ? Math.round(data.values[0]) : Number(data.values[0].toFixed(2));
+  tw.q = {
+    mode: "binary",
+    type: "custom-bin",
+    lst: [
+      {
+        startunbounded: true,
+        stopinclusive: true,
+        stop: median
+      },
+      {
+        stopunbounded: true,
+        startinclusive: false,
+        start: median
+      }
+    ]
+  };
+  tw.q.lst.forEach((bin) => {
+    bin.label = get_bin_label(bin, tw.q);
+  });
+  tw.refGrp = tw.q.lst[0].label;
+}
+function setQ4tteOutcome(tw, vocabApi, filter, state) {
+  if (state.config.regressionType == "logistic") {
+    if (!tw.refGrp) tw.refGrp = tw.q.groups[0].name;
+  }
+  if (state.config.regressionType == "cox") {
+    if (!tw.q.timeScale) tw.q.timeScale = "time";
+  }
+}
+async function maySetTwoGroups(tw, vocabApi, filter, state) {
+  const { term, q } = tw;
+  if (q.mode == "binary") {
+    if (q.type == "values" && Object.keys(term.values).length == 2) return;
+    if (q.type == "predefined-groupset") {
+      const idx = q.predefined_groupset_idx;
+      const t_gs2 = term.groupsetting;
+      if (t_gs2[idx] && Object.keys(t_gs2[idx]).length == 2) return;
+    }
+    if (q.type == "custom-groupset") {
+      const gs = q.customset;
+      if (gs.groups.filter((g) => !g.uncomputable).length == 2) return;
+    }
+  }
+  const data = await vocabApi.getCategories(term, filter);
+  if (data.error) throw "cannot get categories: " + data.error;
+  const category2samplecount = /* @__PURE__ */ new Map();
+  const computableCategories = [];
+  const uncomputableCategories = [];
+  for (const i of data.lst) {
+    category2samplecount.set(i.key, i.samplecount);
+    if (term.values && term.values[i.key] && term.values[i.key].uncomputable) uncomputableCategories.push(i.key);
+    else computableCategories.push(i.key);
+  }
+  if (computableCategories.length < 2) {
+    q.type = "values";
+    tw.error = "less than 2 categories/grades - cannot create separate groups";
+    return;
+  }
+  if (computableCategories.length == 2) {
+    q.type = "values";
+    return;
+  }
+  const t_gs = term.groupsetting;
+  if (q.customset && q.customset.groups && q.customset.groups.length == 2 && groupsetNoEmptyGroup(q.customset, category2samplecount)) {
+    q.type = "custom-groupset";
+    return;
+  }
+  if (t_gs && t_gs.lst) {
+    if (q.predefined_groupset_idx >= 0 && t_gs.lst[q.predefined_groupset_idx] && t_gs.lst[q.predefined_groupset_idx].groups.length == 2 && groupsetNoEmptyGroup(t_gs.lst[q.predefined_groupset_idx], category2samplecount)) {
+      q.type = "predefined-groupset";
+      return;
+    }
+    const i = t_gs.lst.findIndex((g) => g.groups.length == 2);
+    if (i != -1 && groupsetNoEmptyGroup(t_gs.lst[i], category2samplecount)) {
+      q.predefined_groupset_idx = i;
+      q.type = "predefined-groupset";
+      return;
+    }
+  }
+  const customset = {
+    activeCohort: state.activeCohort,
+    // creating 3 groups instead of 2 groups since current groupset UI expects first group to be excluded group
+    // TODO: refactor client/termsetting/handlers/qualitative.ts to not consider the first group (i.e. group.currentIdx === 0) as the excluded group, but rather to consider group.excluded=true as the excluded group
+    groups: [
+      {
+        name: "Excluded categories",
+        type: "values",
+        values: uncomputableCategories.map((v) => {
+          return { key: v };
+        })
+      },
+      {
+        name: "Group 1",
+        type: "values",
+        values: []
+      },
+      {
+        name: "Group 2",
+        type: "values",
+        values: []
+      }
+    ]
+  };
+  const group_i_cutoff = Math.round(computableCategories.length / 2);
+  for (const [i, v] of computableCategories.entries()) {
+    if (i < group_i_cutoff) customset.groups[1].values.push({ key: v });
+    else customset.groups[2].values.push({ key: v });
+  }
+  q.customset = customset;
+  q.type = "custom-groupset";
+}
+function setContMode(tw) {
+  tw.q.mode = "continuous";
+}
+function groupsetNoEmptyGroup(gs, c2s) {
+  for (const g of gs.groups) {
+    let total = 0;
+    if (g.type == "values") {
+      for (const i of g.values) total += c2s.get(i.key) || 0;
+      if (total == 0) return false;
+    }
+  }
+  return true;
+}
+function getGeneVariantWildtypeGrp(tw, sampleCounts) {
+  const groupset = tw.q.type == "predefined-groupset" ? tw.term.groupsetting?.lst?.[tw.q.predefined_groupset_idx] : tw.q.type == "custom-groupset" ? tw.q.customset : null;
+  if (!groupset?.groups) return;
+  for (const g of groupset.groups) {
+    if (g.type != "filter") continue;
+    const isWt = g.filter?.lst?.some((i) => i.tvs && (i.tvs.genotype == "wt" || i.tvs.cnvWT));
+    if (!isWt) continue;
+    if (sampleCounts.find((i) => i.key == g.name)) return g.name;
+  }
+}
+function getLogisticOutcomeNonref(outcome) {
+  if (outcome.term.type == "condition") {
+    for (const i of outcome.q.groups) {
+      if (i.name != outcome.refGrp) return i.name;
+    }
+    throw "nonref group not found for logistic outcome";
+  }
+  if (outcome.q.type == "predefined-groupset") {
+    if (!Number.isInteger(outcome.q.predefined_groupset_idx))
+      throw 'outcome.q.predefined_groupset_idx not integer when q.type is "predefined-groupset"';
+    if (!outcome.term.groupsetting) throw "outcome.term.groupsetting missing";
+    const grpset = outcome.term.groupsetting.lst[outcome.q.predefined_groupset_idx];
+    if (!grpset) throw "groupset not found by outcome.q.predefined_groupset_idx";
+    const nonrefgrp = grpset.groups.find((i) => i.name != outcome.refGrp);
+    if (!nonrefgrp) throw "non-ref group not found for predefined-groupset";
+    return nonrefgrp.name;
+  }
+  if (outcome.q.type == "custom-groupset") {
+    if (!outcome.q.customset) throw "outcome.q.customset missing";
+    const nonrefgrp = outcome.q.customset.groups.find((i) => i.name != outcome.refGrp);
+    if (!nonrefgrp) throw "non-ref group not found for custom-groupset";
+    return nonrefgrp.name;
+  }
+  if (outcome.q.type == "values") {
+    if (!outcome.term.values) throw "outcome.term.values{} missing";
+    for (const k in outcome.term.values) {
+      const v = outcome.term.values[k];
+      if (v.label != outcome.refGrp) return v.label;
+    }
+    throw "unknown nonref group from outcome.term.values";
+  }
+  if (outcome.q.type == "custom-bin") {
+    const nonrefbin = outcome.q.lst.find((i) => i.label != outcome.refGrp);
+    if (!nonrefbin) throw "non-ref bin is not found for custom-bin";
+    return nonrefbin.label;
+  }
+  if (outcome.q.type == "regular-bin") {
+    throw "do not know a way to find computed bin list for type=regular-bin";
+  }
+  throw "unknown outcome.q.type";
+}
+function getCoxOutcomeEventLabel(tw) {
+  let eventLabel;
+  if (!tw.term.values) throw "tw.term.values missing";
+  if (tw.term.type == "condition") {
+    const grades = Object.keys(tw.term.values).map((k) => {
+      const grade = Number(k);
+      if (!Number.isFinite(grade)) throw "grade is not a number";
+      return grade;
+    });
+    const startGrade = tw.q.breaks[0];
+    const endGrade = Math.max(...grades);
+    eventLabel = `Grades ${startGrade}-${endGrade}`;
+  } else if (tw.term.type == "survival") {
+    const exitCodes = Object.keys(tw.term.values).map((k) => {
+      const code = Number(k);
+      if (!Number.isFinite(code)) throw "exit code is not a number";
+      return code;
+    });
+    eventLabel = tw.term.values[Math.max(...exitCodes)].label;
+  } else {
+    throw "unexpected tw.term.type";
+  }
+  return eventLabel;
+}
+
+// plots/regression/regression.inputs.ts
+var allNonDictionaryTerms = [
+  {
+    termtype: "snplst",
+    //html: 'A list of SNPs <span style="font-size:.7em">All SNPs are analyzed in one model</span>'
+    html: "A list of variants"
+  },
+  {
+    termtype: "snplocus",
+    //html: 'Variants in a locus <span style="font-size:.7em">Variants are analyzed individually</span>'
+    html: "Variants in a locus"
+  },
+  {
+    termtype: "prs",
+    text: "Polygenic risk score"
+  }
+];
+var RegressionInputs = class {
+  constructor(opts) {
+    this.hasError = false;
+    this.disable_terms = [];
+    this.opts = opts;
+    this.app = opts.app;
+    this.parent = opts.parent;
+    setInteractivity(this);
+    setRenderers2(this);
+    this.createSectionConfigs();
+    this.initUI();
+  }
+  createSectionConfigs() {
+    this.outcome = {
+      /*** static configuration ***/
+      heading: "Outcome variable",
+      selectPrompt: this.opts.regressionType == "linear" ? "Select continuous outcome variable" : "Select outcome variable",
+      placeholderIcon: "+",
+      configKey: "outcome",
+      limit: 1,
+      usecase: { target: "regression", regressionType: this.opts.regressionType, detail: "outcome" },
+      /*** dynamic configuration ***/
+      inputLst: [],
+      /*** tracker for this section's DOM elements ***/
+      dom: {}
+    };
+    this.independent = {
+      /*** static configuration ***/
+      heading: "Independent variable(s)",
+      selectPrompt: "Add independent variable",
+      placeholderIcon: "+",
+      configKey: "independent",
+      limit: 10,
+      usecase: { target: "regression", regressionType: this.opts.regressionType, detail: "independent" },
+      /*** dynamic configuration ***/
+      inputLst: [],
+      /*** tracker for this section's DOM elements ***/
+      dom: {}
+    };
+    this.sections = [this.outcome, this.independent];
+  }
+  async main() {
+    try {
+      this.config = this.parent.config;
+      this.state = this.parent.state;
+      this.hasError = false;
+      this.setDisableTerms();
+      const updates = [];
+      for (const section of this.sections) {
+        await this.renderSection(section);
+        for (const input of section.inputLst) {
+          input.dom.holder.style("border-left", input.term ? "1px solid #bbb" : "");
+          updates.push(input.main());
+        }
+      }
+      await Promise.all(updates);
+      for (const section of this.sections) {
+        for (const input of section.inputLst) {
+          if (input.term && input.term.error || input.hasError) {
+            this.hasError = true;
+          }
+        }
+      }
+    } catch (e) {
+      this.hasError = true;
+      throw e;
+    }
+  }
+  setDisableTerms() {
+    this.disable_terms = [];
+    if (this.config.outcome && this.config.outcome.term) this.disable_terms.push(this.config.outcome.term);
+    if (this.config.independent) {
+      for (const vb of this.config.independent) {
+        this.disable_terms.push(vb.term);
+      }
+    }
+  }
+  handleError() {
+    this.hasError = true;
+    this.dom.submitBtn.property("disabled", true);
+  }
+  getNoTermPromptOptions(section) {
+    if (section.configKey != "independent") return;
+    const lst = [];
+    for (const i of structuredClone(allNonDictionaryTerms)) {
+      const item = i;
+      if (!this.state.allowedTermTypes.includes(item.termtype)) {
+        continue;
+      }
+      if (section.inputLst.find((i2) => i2.term && i2.term.term.type == item.termtype)) {
+        continue;
+      }
+      if (item.termtype == "snplocus") {
+        if (this.config.includeUnivariate) {
+          item.invalid = true;
+          const label = this.dom.univariateCheckboxDiv.select("label").text().trim();
+          item.invalidMsg = `Cannot add this variable. Please uncheck the "${label}" checkbox.`;
+        }
+      }
+      lst.push(item);
+    }
+    if (lst.length) {
+      lst.unshift({
+        isDictionary: true,
+        text: "Dictionary variable"
+      });
+    }
+    return lst;
+  }
+};
+function setRenderers2(self) {
+  self.initUI = () => {
+    const controls = self.opts.holder.append("div").style("display", "block");
+    self.dom = {
+      div: self.opts.holder,
+      //.style('margin', '10px 0px'),
+      controls,
+      body: controls.append("div"),
+      foot: controls.append("div").style("margin", "0px 20px").style("display", "flex").style("align-items", "center").style("gap", "20px")
+    };
+    self.dom.submitBtn = self.dom.foot.append("div").append("button").style("display", "none").style("padding", "5px 15px").style("border-radius", "15px").style("cursor", "pointer").text("Run analysis").on("click", self.submit);
+    self.dom.univariateCheckboxDiv = self.dom.foot.append("div").style("display", "none");
+    self.dom.univariateCheckbox = make_one_checkbox({
+      labeltext: "Include univariate results",
+      checked: false,
+      holder: self.dom.univariateCheckboxDiv,
+      callback: (checked) => {
+        const invalid = self.config.independent.find((v) => v.interactions.length || v.term.type == "snplocus");
+        if (invalid) {
+          self.dom.univariateCheckbox.property("checked", false);
+          const tip = new Menu();
+          tip.showunder(self.dom.univariateCheckboxDiv.node());
+          const msg = `Cannot include univariate results. Please remove ${invalid.interactions.length ? "all interactions" : `the "${invalid.term.name}" variable`}.`;
+          tip.d.append("div").text(msg);
+          return;
+        }
+        self.app.dispatch({
+          type: "plot_edit",
+          id: self.parent.id,
+          chartType: "regression",
+          config: {
+            hasUnsubmittedEdits: true,
+            includeUnivariate: checked
+          }
+        });
+      }
+    });
+    self.dom.submitMsgs = self.dom.foot.append("div").style("color", "#cc0000").style("font-style", "italic").style("font-size", "0.8em");
+    self.submitMsgs = {};
+    for (const section of self.sections) {
+      const div = self.dom.body.append("div");
+      self.addSection(section, div);
+    }
+  };
+  self.addSection = function(section, div) {
+    div.style("display", "none").style("margin", "3px 5px").style("padding", "3px 5px").attr("data-testid", section.configKey);
+    section.dom = {
+      holder: div,
+      headingDiv: div.append("div").style("margin", "3px 5px 20px 5px").style("font-size", "17px").style("color", "#555").text(section.heading),
+      inputsDiv: div.append("div")
+    };
+  };
+  self.renderSection = function(section) {
+    section.dom.holder.style("display", section.configKey == "outcome" || self.config.outcome ? "block" : "none");
+    syncInputsWithConfig(section);
+    const inputs = section.dom.inputsDiv.selectAll(":scope > div").data(section.inputLst, (input) => input.term && (input.term.term.id || input.term.term.name));
+    inputs.exit().each(removeInput);
+    inputs.enter().append("div").each(addInput);
+  };
+  function syncInputsWithConfig(section) {
+    const selected = self.config[section.configKey];
+    const selectedArray = Array.isArray(selected) ? selected : selected ? [selected] : [];
+    mayConvertInteractionIds(selectedArray, section);
+    for (const variable of selectedArray) {
+      if (section.configKey == "independent") {
+        if (!variable.interactions) variable.interactions = [];
+        for (const id of variable.interactions) {
+          const tw = selectedArray.find((i) => i.$id == id);
+          if (!tw) throw "interacting partner not found in independents: " + id;
+          if (!tw.interactions) tw.interactions = [];
+          if (!tw.interactions.includes(variable.$id)) tw.interactions.push(variable.$id);
+        }
+      }
+      const input = section.inputLst.find((input2) => input2.term?.$id == variable.$id);
+      if (!input) {
+        section.inputLst.push(
+          new InputTerm({
+            section,
+            term: variable,
+            parent: self
+          })
+        );
+      } else {
+        input.term = variable;
+      }
+    }
+    mayAddBlankInput(section, self);
+  }
+  function mayConvertInteractionIds(selectedArray, section) {
+    if (section.configKey != "independent") return;
+    const id2$id = /* @__PURE__ */ new Map();
+    for (const v of selectedArray) {
+      if (v.id) id2$id.set(v.id, v.$id);
+    }
+    for (const v of selectedArray) {
+      if (v.interactions?.length) {
+        for (const [i, id] of v.interactions.entries()) {
+          const $id = id2$id.get(id);
+          if ($id) v.interactions[i] = $id;
+        }
+      }
+    }
+  }
+  async function addInput(input) {
+    await input.init(
+      select_default(this).style("width", "fit-content").style("margin", "0px 15px 35px 25px").style("padding", "0px 5px")
+    );
+  }
+  function removeInput(input) {
+    input.remove();
+    for (const key in input.dom) {
+      delete input.dom[key];
+    }
+    const div = select_default(this);
+    div.transition().duration(500).style("opacity", 0).remove();
+  }
+  self.resetSubmitButton = () => {
+    self.dom.submitBtn.text("Run analysis").style("display", self.config.outcome && self.config.independent.length ? "block" : "none").property("disabled", self.hasError);
+  };
+  self.mayShowUnivariateCheckbox = () => {
+    if (!self.config.outcome || self.config.independent.length < 2) {
+      self.dom.univariateCheckboxDiv.style("display", "none");
+      return;
+    }
+    self.dom.univariateCheckboxDiv.style("display", "block");
+    self.dom.univariateCheckbox.property("checked", self.config.includeUnivariate);
+  };
+  self.mayShowSubmitMsgs = () => {
+    self.dom.submitMsgs.selectAll("div").data(Object.values(self.submitMsgs)).join("div").text((d) => d);
+  };
+}
+function setInteractivity(self) {
+  self.editConfig = async (input, variable) => {
+    if (!variable) {
+      const i = input.section.inputLst.findIndex((d) => d === input);
+      if (i == -1) throw `deleting an unknown input`;
+      input.section.inputLst.splice(i, 1);
+      if (input.term) {
+        for (const other of input.section.inputLst) {
+          if (!other.term || !other.term.interactions?.length) continue;
+          const i2 = other.term.interactions.indexOf(input.term.$id);
+          if (i2 != -1) other.term.interactions.splice(i2, 1);
+        }
+      }
+    } else {
+      const prevTerm = input.term;
+      if (prevTerm && variable.term.id === prevTerm.term.id) {
+        for (const k in prevTerm) {
+          if (!(k in variable)) variable[k] = prevTerm[k];
+        }
+      }
+      input.term = variable;
+      if (variable.q.mode == "spline" && variable.interactions) {
+        for (const other of input.section.inputLst) {
+          if (!other.term || !other.term.interactions) continue;
+          const i = other.term.interactions.indexOf(input.term.$id);
+          if (i != -1) other.term.interactions.splice(i, 1);
+        }
+        variable.interactions = [];
+      }
+    }
+    const selected = [];
+    for (const i of input.section.inputLst) {
+      if (i.term) selected.push(i.term);
+    }
+    const key = input.section.configKey;
+    const configValue = Array.isArray(self.config[key]) ? selected : selected[0];
+    self.app.dispatch({
+      type: "plot_edit",
+      id: self.parent.id,
+      chartType: "regression",
+      config: {
+        hasUnsubmittedEdits: true,
+        // replace config.outcome or config.independent
+        [key]: JSON.parse(JSON.stringify(configValue))
+      }
+    });
+  };
+  self.submit = () => {
+    self.dom.submitBtn.property("disabled", true);
+    if (self.hasError) {
+      alert("Please fix the input variable errors (highlighted in red background).");
+      return;
+    }
+    const config = JSON.parse(JSON.stringify(self.config));
+    config.hasUnsubmittedEdits = false;
+    self.app.dispatch({
+      type: "plot_edit",
+      id: self.parent.id,
+      chartType: "regression",
+      config
+    });
+  };
+}
+function mayAddBlankInput(section, self) {
+  if (section.inputLst.length >= section.limit) {
+    return;
+  }
+  const blankInput = section.inputLst.find((i) => !i.term);
+  if (blankInput) {
+    const noTermPromptOptions = self.getNoTermPromptOptions(section);
+    if (noTermPromptOptions) {
+      blankInput.pill.main({ noTermPromptOptions });
+    }
+    return;
+  }
+  section.inputLst.push(
+    new InputTerm({
+      section,
+      parent: self,
+      noTermPromptOptions: self.getNoTermPromptOptions(section)
+    })
+  );
+}
+
+// plots/regression/Regression.ts
+var Regression = class _Regression extends PlotBase {
+  static {
+    this.type = "regression";
+  }
+  constructor(opts, api) {
+    super(opts, api);
+    this.type = _Regression.type;
+    this.genomeObj = opts.app.opts.genome;
+  }
+  async init(appState) {
+    this.dom = {
+      header: this.opts.header,
+      // header is optional
+      errordiv: this.opts.holder.append("div"),
+      inputs: this.opts.holder.append("div").style("margin", "20px 10px"),
+      results: this.opts.holder.append("div").style("margin-left", "40px")
+    };
+    const config = appState.plots.find((p) => p.id === this.id);
+    this.inputs = new RegressionInputs({
+      app: this.app,
+      parent: this,
+      id: this.id,
+      holder: this.dom.inputs,
+      regressionType: config.regressionType
+    });
+    this.results = new RegressionResults({
+      app: this.app,
+      parent: this,
+      id: this.id,
+      holder: this.dom.results,
+      regressionType: config.regressionType
+    });
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) {
+      throw `No plot with id='${this.id}' found. Did you set this.id before this.api = getComponentApi(this)?`;
+    }
+    if (!config.regressionType) throw "regressionType is required";
+    const parentConfig = this.parentId && appState.plots.find((p) => p.id === this.parentId);
+    const termfilter = getCombinedTermFilter(appState, config.filter || parentConfig?.filter);
+    return {
+      vocab: appState.vocab,
+      formIsComplete: config.outcome && config.independent.length,
+      activeCohort: appState.activeCohort,
+      termfilter,
+      config,
+      allowedTermTypes: appState.termdbConfig.allowedTermTypes,
+      minTimeSinceDx: appState.termdbConfig.minTimeSinceDx
+    };
+  }
+  /* do not set reactsTo
+  so it reacts to all actions matching with the plot id (controlled by store method)
+  including filter/cohort change
+  */
+  async main() {
+    try {
+      this.config = JSON.parse(JSON.stringify(this.state.config));
+      this.mayUpdateSandboxHeader();
+      this.getFilter();
+      await this.inputs.main();
+      await this.results.main();
+      this.inputs.resetSubmitButton();
+      this.inputs.mayShowUnivariateCheckbox();
+      this.inputs.mayShowSubmitMsgs();
+    } catch (e) {
+      if (this.inputs.hasError) {
+        this.results.main();
+      }
+      sayerror(this.dom.errordiv, "Error: " + (e.error || e));
+      if (e.stack) console.log(e.stack);
+    }
+  }
+  mayUpdateSandboxHeader() {
+    if (!this.dom.header) return;
+    const o = this.config.outcome;
+    this.dom.header.html(
+      (o ? o.term.name : "") + '<span style="opacity:.6;font-size:.7em;margin-left:10px;">' + this.config.regressionType.toUpperCase() + " REGRESSION</span>"
+    );
+  }
+  getFilter() {
+    const filters = [];
+    if (this.state.termfilter?.filter) filters.push(this.state.termfilter.filter);
+    const tws = [this.config.outcome, ...this.config.independent];
+    const tws_restrictAncestry = tws.filter((tw) => tw?.q.restrictAncestry);
+    if (tws_restrictAncestry.length) {
+      if (tws_restrictAncestry.length > 1) {
+        const ancestries = new Set(tws_restrictAncestry.map((tw2) => tw2.q.restrictAncestry.name));
+        if (ancestries.size > 1) throw "samples cannot be restricted to more than 1 ancestry";
+      }
+      const tw = tws_restrictAncestry[0];
+      filters.push({ type: "tvs", tvs: tw.q.restrictAncestry.tvs });
+      this.inputs.submitMsgs.restrictAncestry = `Restricting analysis to samples of ${tw.q.restrictAncestry.name}`;
+    } else {
+      delete this.inputs.submitMsgs.restrictAncestry;
+    }
+    this.filter = { type: "tvslst", join: "and", lst: filters };
+  }
+};
+var regressionInit = getCompInit(Regression);
+var componentInit = regressionInit;
+var _ID_ = 1;
+async function getPlotConfig(opts, app, activeCohort) {
+  if (!opts.outcome) opts.outcome = mayGetLoneOutcome(opts.regressionType, app, activeCohort);
+  const id = "id" in opts ? opts.id : `_REGRESSION_${_ID_++}`;
+  const config = { id };
+  if (opts.outcome) {
+    await fillTermWrapper(opts.outcome, app.vocabApi, getDefaultQ4tw(opts.outcome, opts.regressionType, "outcome"));
+    config.outcome = opts.outcome;
+  }
+  if (opts.independent) {
+    if (!Array.isArray(opts.independent)) throw ".independent[] is not array";
+    for (const t of opts.independent) {
+      await fillTermWrapper(
+        t,
+        app.vocabApi,
+        t.q?.mode ? void 0 : getDefaultQ4tw(t, opts.regressionType, "independent")
+      );
+    }
+    config.independent = opts.independent;
+  } else {
+    config.independent = [];
+  }
+  return copyMerge(config, opts);
+}
+function mayGetLoneOutcome(regressionType, app, activeCohort) {
+  if (regressionType != "cox") return;
+  const byType = getLoneTermByType(app.vocabApi.termdbConfig, activeCohort);
+  const t1 = byType?.survival;
+  const t2 = byType?.condition;
+  if (t1 && t2) return;
+  if (t1) return { term: structuredClone(t1) };
+  if (t2) return { term: structuredClone(t2) };
+  return;
+}
+var coxOutcomeTypes = ["survival", "condition"];
+function getLoneTermByType(termdbConfig, activeCohort) {
+  if (!termdbConfig?.loneTermByType) return;
+  if (termdbConfig.selectCohort && !Number.isInteger(activeCohort)) return;
+  return termdbConfig.loneTermByType[getActiveCohortStr({ termdbConfig, activeCohort })];
+}
+function isLoneOutcome(regressionType, termdbConfig, activeCohort) {
+  if (regressionType != "cox") return false;
+  const byType = getLoneTermByType(termdbConfig, activeCohort);
+  if (!byType) return false;
+  const loneTypes = coxOutcomeTypes.filter((type) => byType[type]);
+  if (loneTypes.length != 1) return false;
+  const otherType = coxOutcomeTypes.find((type) => type != loneTypes[0]);
+  return !termdbConfig.allowedTermTypes?.includes(otherType);
+}
+function get_defaultQ4fillTW(regressionType, useCase = "") {
+  const defaultQ = {};
+  defaultQ["numeric"] = regressionType == "logistic" && useCase == "outcome" ? { mode: "binary" } : { mode: "discrete" };
+  for (const t of numericTypes) {
+    if (dictionaryNumericTypes.has(t)) continue;
+    defaultQ[t] = regressionType == "logistic" && useCase == "outcome" ? { mode: "binary" } : { mode: "discrete", type: "custom-bin", preferredBins: "median" };
+  }
+  defaultQ["categorical"] = regressionType == "logistic" && useCase == "outcome" ? { mode: "binary" } : { mode: "discrete" };
+  if (useCase == "outcome") {
+    if (regressionType == "cox") {
+      defaultQ.condition = { mode: "cox" };
+    }
+    if (regressionType == "logistic") {
+      defaultQ.condition = { mode: "binary" };
+    }
+  }
+  defaultQ["geneVariant"] = { type: "predefined-groupset" };
+  return defaultQ;
+}
+function getDefaultQ4tw(tw, regressionType, useCase) {
+  const defaultQ = get_defaultQ4fillTW(regressionType, useCase);
+  if (tw?.term?.type == "geneVariant" && tw.q?.type) delete defaultQ.geneVariant;
+  return defaultQ;
+}
+async function makeChartBtnMenu(holder, chartsInstance) {
+  const allMethods = [
+    { label: "Linear", type: "linear" },
+    { label: "Logistic", type: "logistic" },
+    { label: "Cox", type: "cox" }
+  ];
+  const useMethods = allMethods.filter((i) => chartsInstance.state.currentCohortChartTypes.includes(i.type));
+  if (useMethods.length == 0) return holder.append("div").text("Error: no methods available");
+  if (useMethods.length == 1) {
+    chartsInstance.dom.tip.hide();
+    chartsInstance.prepPlot({ config: await getPrepConfig(useMethods[0].type, chartsInstance) });
+    return;
+  }
+  for (const { label, type } of useMethods) {
+    holder.append("div").attr("class", "sja_menuoption sja_sharp_border").text(label).on("click", async () => {
+      chartsInstance.dom.tip.hide();
+      chartsInstance.prepPlot({ config: await getPrepConfig(type, chartsInstance) });
+    });
+  }
+}
+async function getPrepConfig(regressionType, chartsInstance) {
+  const config = { chartType: "regression", regressionType, independent: [] };
+  const { app, state } = chartsInstance;
+  const outcome = mayGetLoneOutcome(regressionType, app, state.activeCohort);
+  if (!outcome) return config;
+  try {
+    await fillTermWrapper(outcome, app.vocabApi, get_defaultQ4fillTW(regressionType, "outcome"));
+    config.outcome = outcome;
+  } catch (e) {
+    console.error(`cannot prefill ${regressionType} outcome with "${outcome.term.id}": ${e}`);
+  }
+  return config;
+}
+export {
+  componentInit,
+  getPlotConfig,
+  get_defaultQ4fillTW,
+  isLoneOutcome,
+  makeChartBtnMenu,
+  regressionInit
+};
+//# sourceMappingURL=Regression-PSHH7ZXN.js.map