@sjcrh/proteinpaint-client 2.225.0 → 2.226.0

package/dist/cellTypeBubbleHeatmap-DFRSPWAY.js

@@ -0,0 +1,274 @@
+import {
+  LegendCircleReference,
+  PlotBase,
+  addGeneSearchbox
+} from "./chunk-DPWSIN62.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KZ54E2FU.js";
+import {
+  Menu
+} from "./chunk-CNFTQSNE.js";
+import "./chunk-DOC3HBOV.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import {
+  dofetch3
+} from "./chunk-6V7ITU5F.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-KUOXZIH4.js";
+import "./chunk-T2W4JHWJ.js";
+import "./chunk-2N345NXD.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import {
+  linear,
+  sqrt
+} from "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/cellTypeBubbleHeatmap.ts
+var defaultConfig = { chartType: "cellTypeBubbleHeatmap" };
+var CELL_W = 84;
+var CELL_H = 60;
+var ROW_LABEL_W = 74;
+var GROUP_LABEL_H = 22;
+var GENO_LABEL_H = 40;
+var COL_LABEL_H = GROUP_LABEL_H + GENO_LABEL_H;
+var MIN_DOT_R = 8;
+var MAX_DOT_R = 22;
+var NEG_LOG_FDR_CAP = 10;
+var COLOR_NEG = "#762a83";
+var COLOR_ZERO = "#f7f7f7";
+var COLOR_POS = "#2166ac";
+var CellTypeBubbleHeatmap = class _CellTypeBubbleHeatmap extends PlotBase {
+  constructor(opts, api) {
+    super(opts, api);
+    this.currentIsoform = "";
+    this.type = _CellTypeBubbleHeatmap.type;
+  }
+  static {
+    this.type = "cellTypeBubbleHeatmap";
+  }
+  async init() {
+    const holder = this.opts.holder.append("div").style("padding", "10px");
+    this.dom = {
+      holder,
+      body: holder.append("div"),
+      tip: new Menu({ padding: "" }),
+      header: this.opts.header
+    };
+    if (this.dom.header) this.dom.header.html("Cell-type Bubble Heatmap");
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) throw `No plot with id='${this.id}' found`;
+    return { config };
+  }
+  async main() {
+    const gene = this.state.config?.gene;
+    if (!gene) throw new Error("cellTypeBubbleHeatmap: gene is missing");
+    if (this.dom.header) this.dom.header.text(`Cell-type Bubble Heatmap: ${gene}`);
+    const body = {
+      genome: this.app.opts.state.vocab.genome,
+      dslabel: this.app.opts.state.vocab.dslabel,
+      gene
+    };
+    const data = await dofetch3("termdb/cellTypeBubbleHeatmap", { body });
+    if (data.error) throw data.error;
+    this.data = data;
+    this.dom.body.selectAll("*").remove();
+    const isoformIds = Object.keys(data.isoforms);
+    if (isoformIds.length === 0) {
+      this.dom.body.append("div").style("padding", "20px").style("color", "#666").text(`No data found for gene "${gene}" in any cohort DAPfile.`);
+      return;
+    }
+    this.currentIsoform = isoformIds[0];
+    const isoBlock = this.dom.body.append("div").style("margin-bottom", "12px");
+    isoBlock.append("span").style("font-weight", "bold").text("Isoform: ");
+    if (isoformIds.length > 1) {
+      const sel = isoBlock.append("select").style("margin-left", "5px").style("padding", "3px 6px").on("change", () => {
+        this.currentIsoform = sel.node().value;
+        this.renderGrid();
+      });
+      sel.selectAll("option").data(isoformIds).enter().append("option").attr("value", (d) => d).text((d) => `${data.isoforms[d].gene_name} \u2014 ${d}`);
+    } else {
+      isoBlock.append("span").style("margin-left", "5px").text(`${data.isoforms[this.currentIsoform].gene_name} \u2014 ${this.currentIsoform}`);
+    }
+    this.gridHolder = this.dom.body.append("div");
+    this.renderGrid();
+  }
+  renderGrid() {
+    const data = this.data;
+    const selectedIsoform = this.currentIsoform;
+    const threshold = data.fdrThreshold;
+    this.gridHolder.selectAll("*").remove();
+    const container = this.gridHolder.append("div").style("display", "flex").style("gap", "24px").style("align-items", "flex-start").style("flex-wrap", "wrap");
+    const isoformData = data.isoforms[selectedIsoform];
+    if (!isoformData) return;
+    const columns = data.columns;
+    const rows = data.rows;
+    const nCols = columns.length;
+    const nRows = rows.length;
+    const negLogFdr = (fdr) => fdr > 0 ? Math.min(-Math.log10(fdr), NEG_LOG_FDR_CAP) : NEG_LOG_FDR_CAP;
+    const cellOf = (colKey, rowKey) => isoformData.data[colKey]?.[rowKey];
+    let maxAbs = 0;
+    const thresholdNegLog = negLogFdr(threshold);
+    let maxNegLog = thresholdNegLog;
+    for (const col of columns) {
+      for (const row of rows) {
+        const s = cellOf(col.key, row.key);
+        if (!s) continue;
+        const v = Math.abs(s.log2FC);
+        if (v > maxAbs) maxAbs = v;
+        const nl = negLogFdr(s.fdr);
+        if (nl > maxNegLog) maxNegLog = nl;
+      }
+    }
+    if (maxAbs === 0) maxAbs = 1;
+    if (maxNegLog <= thresholdNegLog) maxNegLog = thresholdNegLog + 1;
+    const colorScale = linear().domain([-maxAbs, 0, maxAbs]).range([COLOR_NEG, COLOR_ZERO, COLOR_POS]).clamp(true);
+    const sizeScale = sqrt().domain([thresholdNegLog, maxNegLog]).range([MIN_DOT_R, MAX_DOT_R]).clamp(true);
+    const gridW = ROW_LABEL_W + nCols * CELL_W + 20;
+    const gridH = COL_LABEL_H + nRows * CELL_H + 20;
+    const svg = container.append("svg").attr("width", gridW).attr("height", gridH).style("flex", "0 0 auto");
+    const grid = svg.append("g");
+    let c = 0;
+    while (c < nCols) {
+      const cellType = columns[c].cellType;
+      let end = c;
+      while (end + 1 < nCols && columns[end + 1].cellType === cellType) end++;
+      const xStart = ROW_LABEL_W + c * CELL_W;
+      const xEnd = ROW_LABEL_W + (end + 1) * CELL_W;
+      const xMid = (xStart + xEnd) / 2;
+      grid.append("text").attr("x", xMid).attr("y", GROUP_LABEL_H - 7).attr("text-anchor", "middle").attr("font-size", "13px").attr("font-weight", "bold").text(cellType);
+      grid.append("line").attr("x1", xStart + 4).attr("y1", GROUP_LABEL_H - 3).attr("x2", xEnd - 4).attr("y2", GROUP_LABEL_H - 3).attr("stroke", "#bbb").attr("stroke-width", 1);
+      c = end + 1;
+    }
+    for (let col = 0; col < nCols; col++) {
+      const cx = ROW_LABEL_W + col * CELL_W + CELL_W / 2;
+      grid.append("text").attr("x", cx).attr("y", COL_LABEL_H - 14).attr("text-anchor", "middle").attr("font-size", "12px").attr("font-weight", "600").text(columns[col].genotype);
+    }
+    for (let r = 0; r < nRows; r++) {
+      const cy = COL_LABEL_H + r * CELL_H + CELL_H / 2;
+      grid.append("text").attr("x", ROW_LABEL_W - 12).attr("y", cy).attr("text-anchor", "end").attr("dominant-baseline", "central").attr("font-size", "13px").attr("font-weight", "bold").text(rows[r].label);
+    }
+    for (let r = 0; r < nRows; r++) {
+      for (let col = 0; col < nCols; col++) {
+        const x0 = ROW_LABEL_W + col * CELL_W;
+        const y0 = COL_LABEL_H + r * CELL_H;
+        grid.append("rect").attr("x", x0).attr("y", y0).attr("width", CELL_W).attr("height", CELL_H).attr("fill", "none").attr("stroke", "#eee").attr("stroke-width", 1);
+        const s = cellOf(columns[col].key, rows[r].key);
+        if (!s) continue;
+        const cx = x0 + CELL_W / 2;
+        const cy = y0 + CELL_H / 2;
+        grid.append("circle").attr("cx", cx).attr("cy", cy).attr("r", sizeScale(negLogFdr(s.fdr))).attr("fill", colorScale(s.log2FC)).attr("stroke", "#888").attr("stroke-width", 0.8).style("opacity", s.significant ? 1 : 0.35).on(
+          "mouseover",
+          (event) => this.showCellTip(event, isoformData.gene_name, selectedIsoform, columns[col], rows[r], s)
+        ).on("mouseout", () => this.dom.tip.hide());
+      }
+    }
+    this.renderLegend(container, colorScale, maxAbs, threshold, maxNegLog);
+  }
+  fmtFdr(v) {
+    return v >= 1e-4 ? v.toFixed(4) : v.toExponential(2);
+  }
+  showCellTip(event, geneName, isoform, col, row, s) {
+    this.dom.tip.clear().show(event.clientX, event.clientY);
+    const t = this.dom.tip.d.append("div").style("padding", "8px").style("font-size", "13px");
+    t.append("div").style("font-weight", "bold").style("margin-bottom", "4px").text(`${geneName} \u2014 ${isoform}`);
+    t.append("div").text(`Cell type: ${col.cellType}`);
+    t.append("div").text(`Genotype: ${col.genotype}`);
+    t.append("div").text(`Timepoint: ${row.label}`);
+    t.append("div").text(`Protein: ${s.id}`);
+    t.append("div").text(`log\u2082FC: ${s.log2FC.toFixed(3)}`);
+    t.append("div").text(`FDR: ${this.fmtFdr(s.fdr)}${s.significant ? "" : " (n.s.)"}`);
+    t.append("div").style("color", "#666").style("margin-top", "4px").text("Color = log\u2082FC (blue up / purple down). Size = \u2212log\u2081\u2080 FDR.");
+  }
+  renderLegend(container, colorScale, maxAbs, threshold, maxNegLog) {
+    const legend = container.append("div").style("display", "flex").style("flex-direction", "column").style("gap", "16px").style("padding", "8px 0").style("min-width", "180px").style("max-width", "260px");
+    const colorBlock = legend.append("div");
+    colorBlock.append("div").style("font-weight", "bold").style("font-size", "13px").style("margin-bottom", "6px").text("log\u2082FC");
+    const cW = 22;
+    const cH = 130;
+    const cSvg = colorBlock.append("svg").attr("width", cW + 80).attr("height", cH + 16);
+    const gid = `ctbh-grad-${this.id}`;
+    const grad = cSvg.append("defs").append("linearGradient").attr("id", gid).attr("x1", "0").attr("y1", "0").attr("x2", "0").attr("y2", "1");
+    const steps = 10;
+    for (let i = 0; i <= steps; i++) {
+      const t = i / steps;
+      grad.append("stop").attr("offset", `${t * 100}%`).attr("stop-color", colorScale(maxAbs * (1 - 2 * t)));
+    }
+    cSvg.append("rect").attr("x", 0).attr("y", 8).attr("width", cW).attr("height", cH).style("fill", `url(#${gid})`).attr("stroke", "#999");
+    const cScale = linear().domain([maxAbs, -maxAbs]).range([8, cH + 8]);
+    for (const tick of [maxAbs, maxAbs / 2, 0, -maxAbs / 2, -maxAbs]) {
+      const y = cScale(tick);
+      cSvg.append("line").attr("x1", cW).attr("y1", y).attr("x2", cW + 5).attr("y2", y).attr("stroke", "#666");
+      cSvg.append("text").attr("x", cW + 8).attr("y", y).attr("dominant-baseline", "central").attr("font-size", "10px").text(`${tick > 0 ? "+" : ""}${tick.toFixed(2)}`);
+    }
+    colorBlock.append("div").style("font-size", "11px").style("color", "#666").style("margin-top", "2px").text("blue = up (+), purple = down (\u2212)");
+    const sizeBlock = legend.append("div");
+    sizeBlock.append("div").style("font-weight", "bold").style("font-size", "13px").style("margin-bottom", "6px").text("Dot size: significance (\u2212log\u2081\u2080 FDR)");
+    const sSvg = sizeBlock.append("svg");
+    const sG = sSvg.append("g");
+    new LegendCircleReference({
+      g: sG,
+      inputMin: 0,
+      inputMax: MAX_DOT_R * 2,
+      minRadius: MIN_DOT_R,
+      maxRadius: MAX_DOT_R,
+      minLabel: Number(Math.min(-Math.log10(threshold), NEG_LOG_FDR_CAP).toFixed(1)),
+      maxLabel: Number(maxNegLog.toFixed(1))
+    });
+    const sPad = 4;
+    const sBox = sG.node().getBBox();
+    sG.attr("transform", `translate(${sPad - sBox.x}, ${sPad - sBox.y})`);
+    sSvg.attr("width", Math.ceil(sBox.width + 2 * sPad)).attr("height", Math.ceil(sBox.height + 2 * sPad));
+    const notes = legend.append("div").style("font-size", "11px").style("color", "#666").style("line-height", "1.5").style("max-width", "240px").style("overflow-wrap", "break-word");
+    notes.append("div").text(
+      `Color = log\u2082FC (blue up, purple down). Dot size = significance, \u2212log\u2081\u2080 FDR; the smallest size marks the FDR < ${threshold} cutoff. Non-significant dots (FDR \u2265 ${threshold}) are faded.`
+    );
+    notes.append("div").style("margin-top", "4px").text("An empty cell means the cohort was not assayed (e.g. OPC has no 4m) or the protein was not detected.");
+  }
+};
+var componentInit = getCompInit(CellTypeBubbleHeatmap);
+async function getPlotConfig(opts) {
+  const config = structuredClone(defaultConfig);
+  if (!opts.gene) throw new Error("cellTypeBubbleHeatmap requires opts.gene");
+  return copyMerge(config, opts);
+}
+function makeChartBtnMenu(holder, chartsInstance) {
+  const row = holder.append("div").style("padding", "5px");
+  row.append("span").style("font-weight", "bold").text("Enter a gene name:");
+  const geneSearch = addGeneSearchbox({
+    row,
+    genome: chartsInstance.app.opts.genome,
+    tip: new Menu({ padding: "0px" }),
+    searchOnly: "gene",
+    callback: async () => {
+      if (!geneSearch.geneSymbol) throw new Error("A valid gene selection is required");
+      chartsInstance.dom.tip.hide();
+      chartsInstance.app.dispatch({
+        type: "plot_create",
+        config: {
+          chartType: "cellTypeBubbleHeatmap",
+          gene: geneSearch.geneSymbol
+        }
+      });
+    }
+  });
+}
+export {
+  componentInit,
+  getPlotConfig,
+  makeChartBtnMenu
+};
+//# sourceMappingURL=cellTypeBubbleHeatmap-DFRSPWAY.js.map

package/dist/chunk-37ZEGLVY.js

@@ -0,0 +1,267 @@
+import {
+  DATermTypes,
+  DMRCATE_DEFAULTS,
+  onDeltaBetaAxis,
+  withOthersGroup
+} from "./chunk-DPWSIN62.js";
+import {
+  dofetch3
+} from "./chunk-6V7ITU5F.js";
+import {
+  DMR_SCAN_ELEMENT_TYPE
+} from "./chunk-2N345NXD.js";
+import {
+  rgb
+} from "./chunk-Q5RDQNIT.js";
+
+// plots/volcano/colors.ts
+function getGroupColors(config) {
+  const groups = config?.samplelst?.groups;
+  const termValues = config?.tw?.term?.values;
+  const rawDown = termValues?.[groups?.[0]?.name]?.color || "red";
+  const rawUp = termValues?.[groups?.[1]?.name]?.color || "blue";
+  return {
+    controlColor: toHex(rawDown, "red"),
+    caseColor: toHex(rawUp, "blue")
+  };
+}
+function toHex(color, fallback) {
+  const c = rgb(color || fallback);
+  return c.displayable() ? c.formatHex() : rgb(fallback).formatHex();
+}
+
+// plots/volcano/model/VolcanoModel.ts
+var VolcanoModel = class {
+  /** TODO: This model is used in both the volcano and gsea.
+   * In the future, create base model in DA and use specific
+   * classes for the volcano and gsea. */
+  constructor(plot, termType) {
+    this.plot = plot;
+    this.app = plot.app;
+    this.termType = termType;
+  }
+  /** May use mapper instead as more termTypes are added */
+  async getData(config, settings) {
+    this.config = config;
+    this.settings = settings;
+    if (this.termType === DATermTypes.GENE_EXPRESSION) {
+      const body = await this.getGERequestBody();
+      const response = await dofetch3("termdb/DE", { body, signal: this.plot.api?.getAbortSignal() });
+      if (response && !response.error) {
+        response.daRequest = body;
+        this.setGroupSizes(response);
+      }
+      return response;
+    }
+    if (this.termType === DATermTypes.DNA_METHYLATION) {
+      const body = await this.getDMRequestBody();
+      const response = await dofetch3("termdb/diffMeth", { body, signal: this.plot.api?.getAbortSignal() });
+      if (response && !response.error) {
+        response.daRequest = body;
+        this.setGroupSizes(response);
+      }
+      return response;
+    }
+    if (this.termType === DATermTypes.JUNCTION) {
+      const body = await this.getDSRequestBody();
+      const response = await dofetch3("termdb/diffSplice", { body, signal: this.plot.api?.getAbortSignal() });
+      if (response && !response.error) {
+        response.daRequest = body;
+        this.setGroupSizes(response);
+      }
+      return response;
+    }
+    if (this.termType === DATermTypes.SINGLECELL_CELLTYPE) {
+      const body = await this.getSCCTRequestBody();
+      return await dofetch3("termdb/singlecellDEgenes", { body, signal: this.plot.api?.getAbortSignal() });
+    }
+    if (this.termType === DATermTypes.PROTEOME_DAP) {
+      const body = this.getDapRequestBody();
+      return await dofetch3("termdb/dapVolcano", { body, signal: this.plot.api?.getAbortSignal() });
+    }
+    if (this.termType === DATermTypes.SINGLECELL_GENE_EXPRESSION) {
+    }
+    throw new Error(`Volcano plot does not support route for termType='${this.termType}'`);
+  }
+  //Gene expression
+  async getGERequestBody() {
+    this.setOthersGroup(this.config.samplelst);
+    const state = this.app.getState();
+    const body = {
+      kind: "DE",
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      method: this.settings.method,
+      min_count: this.settings.minCount,
+      min_total_count: this.settings.minTotalCount,
+      samplelst: this.config.samplelst,
+      filter: state.termfilter.filter,
+      filter0: state.termfilter.filter0,
+      cpm_cutoff: this.settings.cpmCutoff,
+      volcanoRender: this.getVolcanoRender()
+    };
+    const pseudobulk = this.config.tw?.pseudobulk;
+    if (pseudobulk) body.pseudobulk = pseudobulk;
+    this.addConfounderTw(body);
+    return body;
+  }
+  //DNA methylation
+  async getDMRequestBody() {
+    this.setOthersGroup(this.config.samplelst);
+    const state = this.app.getState();
+    const body = {
+      kind: "DM",
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      samplelst: this.config.samplelst,
+      filter: state.termfilter.filter,
+      filter0: state.termfilter.filter0,
+      min_samples_per_group: this.settings.minSamplesPerGroup,
+      exclude_sex_chr: this.settings.excludeSexChr,
+      /* Omitted rather than sent as 'promoter' when it is the default, so a request
+      from a promoter-only dataset is byte-identical to what this client sent before
+      the element picker existed. The server resolves an absent element_type to
+      'promoter'. This does NOT preserve cache keys -- the key object gained the
+      field server-side, so every pre-existing dm/ entry is orphaned on deploy
+      regardless of what the client sends. */
+      ...this.settings.elementType && this.settings.elementType != "promoter" ? { element_type: this.settings.elementType } : {},
+      // the scan's own knobs; the server ignores them for any other element type
+      ...this.settings.elementType == DMR_SCAN_ELEMENT_TYPE ? {
+        scan: {
+          ...this.settings.scanChromosome ? { chromosome: this.settings.scanChromosome } : {},
+          backgroundCorrection: !!this.settings.backgroundCorrection,
+          // display only: the rows are rebuilt from the cached scan on every request
+          yAxis: this.settings.scanYAxis,
+          minCpgs: this.settings.minCpgs,
+          // display only, like yAxis: what the scan counts, not what it runs
+          minDeltaBeta: this.settings.deltaBetaCutoff,
+          profileBinBp: this.settings.profileBinBp,
+          // only when changed: an explicit default would orphan every cached scan
+          ...this.settings.lambda != DMRCATE_DEFAULTS.lambda ? { lambda: this.settings.lambda } : {},
+          ...this.settings.C != DMRCATE_DEFAULTS.C ? { C: this.settings.C } : {},
+          ...this.settings.fdrCutoff != DMRCATE_DEFAULTS.fdrCutoff ? { fdrCutoff: this.settings.fdrCutoff } : {}
+        }
+      } : {},
+      volcanoRender: this.getVolcanoRender()
+    };
+    if (this.settings.elementType != DMR_SCAN_ELEMENT_TYPE) this.addConfounderTw(body);
+    return body;
+  }
+  //Splicing
+  async getDSRequestBody() {
+    this.setOthersGroup(this.config.samplelst);
+    const state = this.app.getState();
+    const body = {
+      kind: "DS",
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      samplelst: this.config.samplelst,
+      filter: state.termfilter.filter,
+      filter0: state.termfilter.filter0,
+      method: this.settings.method,
+      /* leafcutter's own cluster filters, applied by the edgeR screen too so both engines
+      rank the same cluster set. Sent already scaled to cohort size by validateDSSettings --
+      as absolute counts they silently loosen as N grows. */
+      minSamplesPerIntron: this.settings.minSamplesPerIntron,
+      minSamplesPerGroup: this.settings.minSamplesPerGroup,
+      minCountsPerCluster: this.settings.minCountsPerCluster,
+      volcanoRender: this.getVolcanoRender()
+    };
+    this.addConfounderTw(body);
+    return body;
+  }
+  /** Parameters telling the server to run the `volcano` Rust renderer and return a
+   * volcano PNG + top-significant rows instead of the full dot list. */
+  getVolcanoRender() {
+    const dotRadius = Math.max(this.settings.width, this.settings.height) / 80;
+    const { caseColor, controlColor } = getGroupColors(this.config);
+    const useDeltaBeta = onDeltaBetaAxis(this.termType, this.settings);
+    const render = {
+      significanceThresholds: {
+        pValueCutoff: this.settings.pValue,
+        pValueType: this.settings.pValueType,
+        foldChangeCutoff: useDeltaBeta ? this.settings.deltaBetaCutoff : this.settings.foldChangeCutoff
+      },
+      ...useDeltaBeta ? { xField: "delta_beta" } : {},
+      // Tied to the delta-beta axis: the control that sets it is only offered for
+      // methylation, and centering a log2 fold-change axis is a different conversation.
+      /* Not on a scan, whose control is hidden but whose setting survives a switch from an element
+      class: the scan counts, Manhattan and track use raw Δβ, and a centered volcano would disagree. */
+      ...useDeltaBeta && this.settings.centerDeltaBeta && this.settings.elementType != DMR_SCAN_ELEMENT_TYPE ? { centerX: true } : {},
+      pixelWidth: this.settings.width,
+      pixelHeight: this.settings.height,
+      colorSignificant: toHex(this.settings.defaultSignColor, "red"),
+      colorSignificantUp: caseColor,
+      colorSignificantDown: controlColor,
+      colorNonsignificant: toHex(this.settings.defaultNonSignColor, "black"),
+      dotRadius,
+      maxInteractiveDots: this.settings.maxInteractiveDots,
+      // Render the PNG at device-pixel resolution so it stays sharp on
+      // retina screens. The server reports the plot extent in CSS-space,
+      // so SVG overlay coords are unaffected.
+      //
+      // Oversample by 2× so the PNG also stays sharp when the user
+      // *zooms in after* the initial render (the captured DPR is frozen
+      // at fetch time — bigger headroom = more tolerable post-render
+      // zoom before pixelation appears). The server clamp keeps the
+      // bitmap memory bounded.
+      devicePixelRatio: (typeof window !== "undefined" ? window.devicePixelRatio : 1) * 2
+    };
+    if (this.termType === DATermTypes.JUNCTION) {
+      render.xField = "delta_psi";
+      render.significanceThresholds.foldChangeCutoff = this.settings.deltaPsiCutoff;
+    }
+    return render;
+  }
+  //This is a workaround until the server can accept an arr of confounder tws
+  addConfounderTw(body) {
+    const confounders = this.config?.confounderTws;
+    if (confounders?.length) {
+      body.tw = this.config.confounderTws[0];
+      if (confounders.length > 1) body.tw2 = this.config.confounderTws[1];
+    }
+  }
+  //Single cell cell type
+  getSCCTRequestBody() {
+    const body = {
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      sample: this.config.sample,
+      termId: this.config.termId,
+      categoryName: this.config.categoryName,
+      volcanoRender: this.getVolcanoRender()
+    };
+    return body;
+  }
+  getDapRequestBody() {
+    const { organism, assay, cohort } = this.config.proteomeDetails;
+    return {
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      organism,
+      assay,
+      cohort,
+      volcanoRender: this.getVolcanoRender()
+    };
+  }
+  /** The "others" group arrives as a placeholder with {in: false}. Replace it with the group that
+   * it stands for: the filter of the app without the samples of the other group, which the server
+   * resolves. */
+  setOthersGroup(samplelst) {
+    samplelst.groups = withOthersGroup(samplelst.groups, this.app.getState().termfilter);
+  }
+  /** A group that the server resolved from a filter lists no sample here. Keep the number of its
+   * samples that the analysis ran on, where the group does not carry one, for getSampleNum(). */
+  setGroupSizes(response) {
+    for (const [i, g] of this.config.samplelst.groups.entries()) {
+      const n = response[`sample_size${i + 1}`];
+      if (!Array.isArray(g.values) && g.sampleCount === void 0 && Number.isFinite(n)) g.sampleCount = n;
+    }
+  }
+};
+
+export {
+  getGroupColors,
+  VolcanoModel
+};
+//# sourceMappingURL=chunk-37ZEGLVY.js.map