@sjcrh/proteinpaint-client 2.184.0 → 2.185.0

package/dist/chunk-WQ3U6X4Q.js

@@ -0,0 +1,269 @@
+import {
+  Menu
+} from "./chunk-HYOEWQ5P.js";
+import {
+  pointer_default,
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+
+// dom/svgSeriesTips.js
+function getSeriesTip(line, rect, _tip = null) {
+  const tip = _tip || new Menu({ padding: "5px" });
+  line.style("display", "none");
+  const rectNode = rect.style("fill", "transparent").node();
+  function mouseOver(event) {
+    const m = pointer_default(event, rectNode);
+    const mx = m[0];
+    const xVal = +opts.xScale.invert(mx).toFixed(opts.decimals);
+    const x = opts.xScale(xVal);
+    line.style("display", "").attr("stroke", "#aaa").attr("stroke-dasharray", 4).attr("x1", x).attr("x2", x);
+    const seriesHtmls = [];
+    for (const series of opts.serieses) {
+      const data = series.data;
+      const data_x = data.map((d) => d.x);
+      if (xVal >= Math.min(...data_x) && xVal <= Math.max(...data_x)) {
+        const max = Math.max(...data_x.filter((x2) => x2 <= xVal));
+        const timepoint = data.find((d) => d.x == max);
+        if (timepoint) seriesHtmls.push(timepoint.html);
+      }
+    }
+    if (seriesHtmls.length) {
+      tip.show(event.clientX, event.clientY).d.html(`<span>${opts.xTitleLabel}: ${xVal}</span><br>` + seriesHtmls.map((d) => d).join(opts.separator));
+    } else {
+      tip.hide();
+    }
+  }
+  rect.on("mouseover", mouseOver).on("mousemove", mouseOver).on("mouseout", () => {
+    line.style("display", "none");
+    tip.hide();
+  });
+  const opts = {
+    separator: "<br>",
+    decimals: 1
+  };
+  return {
+    /*
+    			Will update the length of the vertical line
+    			and reassign optional data values
+    
+    			!!! MUST call api.update() before the expected mouseover event,
+    			so that the line will have the proper length and the mouse
+    			position could be computed with .xScale !!! 
+    
+    			_opts{}
+    			.xScale					required
+    										the d3-scale object that was used for the rect dimensions
+    										
+    			.xTitleLabel			required
+    										title of x-axis
+    										will be used as label of x-value in tooltip
+    
+    			.serieses[{data}] 		required
+    										array of series objects, assumed to be visibly rendered
+    							
+    				.data[{x, html}]	required
+    										array of data objects
+    										the series data that is currently rendered in the chart
+    					
+    					.x 				required, float
+    										the datapoint's actual, unscaled x value
+    					
+    					.html   		required, string
+    										the HTML to display in the tooltip if this datapoint's 
+    										x value matched the vertical line's position
+    
+    			.separator				optional, string
+    										the html to be used to join the series html strings when displayed in the tooltip
+    
+    			.decimals				optional, number
+    										number of decimal places of the datapoint's x-value
+    										will control the precision of the vertical line
+    		*/
+    update(_opts = {}) {
+      Object.assign(opts, _opts);
+      const x = rect.attr("x");
+      const y = rect.attr("y");
+      line.attr("x1", x).attr("x2", x).attr("y1", y).attr("y2", rect.attr("height") - y);
+    },
+    /*
+    	detroy to help minimize memory leaks
+    	from elements and event handlers not being garbage collected
+    	because of non-deactivated references
+    */
+    destroy() {
+      rect.on("mouseover", null).on("mousemove", null).on("mouseout", null);
+    }
+  };
+}
+
+// dom/renderAtRisk.js
+function renderAtRiskG({ g, s, chart, order, term2toColor, onSerieClick }) {
+  const bySeries = {};
+  const xTickValues = chart.xTickValues.filter((xTick) => xTick >= chart.xMin);
+  for (const series of chart.visibleSerieses) {
+    const counts = [];
+    let i = 0, d = series.data[0], prev = d, nCensored = 0;
+    for (const time of xTickValues) {
+      while (d && d.x < time) {
+        nCensored += d.ncensor;
+        prev = d;
+        i++;
+        d = series.data[i];
+      }
+      if (d && d.x === time) {
+        counts.push([time, d.nrisk, nCensored]);
+      } else {
+        counts.push([time, prev.nrisk - prev.nevent - prev.ncensor, nCensored]);
+      }
+    }
+    bySeries[series.seriesId] = counts;
+  }
+  const y = s.svgh - s.svgPadding.top - s.svgPadding.bottom + 60;
+  const seriesOrder = order || chart.serieses.map((s2) => s2.seriesId);
+  let data;
+  g.selectAll(".sjpp-atrisk-title").remove();
+  if (s.atRiskVisible) {
+    data = Object.keys(bySeries).sort((a, b) => seriesOrder.indexOf(a) - seriesOrder.indexOf(b));
+    const addYoffset = chart.serieses.length == 1 && !chart.serieses[0].seriesId;
+    const titleg = g.append("text").attr("class", "sjpp-atrisk-title").attr("transform", `translate(${s.atRiskLabelOffset}, ${addYoffset ? 2 * s.axisTitleFontSize : 0})`).attr("text-anchor", "end").attr("font-size", `${s.axisTitleFontSize - 4}px`).attr("cursor", chart.serieses.length == 1 ? "pointer" : "default").text("Number at risk").on("click", chart.serieses.length == 1 ? (e) => onSerieClick({ seriesId: "" }, e.clientX, e.clientY) : null);
+    if (term2toColor[""]) titleg.style("fill", s.defaultColor);
+    titleg.append("tspan").attr("x", 0).attr("y", s.axisTitleFontSize - 4).text("(# censored)");
+  } else {
+    data = [];
+  }
+  const sg = g.attr("transform", `translate(0,${y})`).selectAll(":scope > g").data(data, (seriesId) => seriesId);
+  sg.exit().remove();
+  sg.each(function(seriesId, i) {
+    const y2 = (i + 1) * (2 * s.axisTitleFontSize);
+    const g2 = select_default(this).attr("transform", `translate(0,${y2})`).attr("fill", term2toColor[""] ? s.defaultColor : term2toColor[seriesId].adjusted);
+    renderAtRiskTick(g2.select(":scope>g"), chart, xTickValues, s, seriesId, bySeries[seriesId]);
+  });
+  sg.enter().append("g").each(function(seriesId, i) {
+    const y2 = (i + 1) * (2 * s.axisTitleFontSize);
+    const g2 = select_default(this).attr("transform", `translate(0,${y2})`).attr("fill", term2toColor[""] ? s.defaultColor : term2toColor[seriesId].adjusted).on("click", (e) => onSerieClick({ seriesId }, e.clientX, e.clientY));
+    const sObj = chart.serieses.find((s2) => s2.seriesId === seriesId);
+    g2.append("text").attr("data-testid", "sjpp-atrisk-seriesId").attr("transform", `translate(${s.atRiskLabelOffset}, 0)`).attr("text-anchor", "end").attr("font-size", `${s.axisTitleFontSize - 4}px`).attr("cursor", "pointer").datum({ seriesId }).text(seriesId && seriesId != "*" ? sObj.seriesLabel || seriesId : "");
+    renderAtRiskTick(g2.append("g"), chart, xTickValues, s, seriesId, bySeries[seriesId]);
+  });
+}
+function renderAtRiskTick(g, chart, xTickValues, s, seriesId, series) {
+  const reversed = series.slice().reverse();
+  const data = xTickValues.map((tickVal) => {
+    if (tickVal === 0) return { seriesId, tickVal, atRisk: series[0][1], nCensored: series[0][2] };
+    const d = reversed.find((d2) => d2[0] <= tickVal);
+    return { seriesId, tickVal, atRisk: d[1], nCensored: d[2] };
+  });
+  const text = g.selectAll("text").data(data);
+  text.exit().remove();
+  text.attr("transform", (d) => `translate(${chart.xScale(d.tickVal)},0)`).attr("text-anchor", "middle").attr("font-size", `${s.axisTitleFontSize - 4}px`).attr("cursor", "pointer").each(renderAtRiskLabel);
+  text.enter().append("text").attr("transform", (d) => `translate(${chart.xScale(d.tickVal)},0)`).attr("text-anchor", "middle").attr("font-size", `${s.axisTitleFontSize - 4}px`).attr("cursor", "pointer").each(renderAtRiskLabel);
+  function renderAtRiskLabel(d) {
+    const tspans = select_default(this).selectAll("tspan").data([d.atRisk, `(${d.nCensored})`]);
+    tspans.exit().remove();
+    tspans.attr("y", (d2, i) => i === 0 ? 0 : i * (s.axisTitleFontSize - 4)).text((d2) => d2);
+    tspans.enter().append("tspan").attr("x", 0).attr("y", (d2, i) => i === 0 ? 0 : i * (s.axisTitleFontSize - 4)).text((d2) => d2);
+  }
+}
+
+// dom/renderPvalueTable.js
+function renderPvalues({
+  title,
+  titleTestid,
+  holder,
+  plot,
+  tests,
+  s,
+  bins,
+  tip,
+  setActiveMenu,
+  updateHiddenPvalues
+}) {
+  let fontSize;
+  if (s.axisTitleFontSize) {
+    fontSize = s.axisTitleFontSize - 2;
+  } else fontSize = 15;
+  const maxPvalsToShow = 10;
+  holder.selectAll("*").remove();
+  if (!plot) {
+    throw `plot type '${plot}' not recognized`;
+  }
+  holder.append("div").style("padding-bottom", "5px").style("font-size", fontSize + "px").style("font-weight", "bold").attr("data-testid", titleTestid || "sjpp-pvalueTable-title").text(title);
+  const tablediv = holder.append("div").style("border", "1px solid #ccc");
+  if (plot == "violin" && tests.pvalues.length > maxPvalsToShow || tests.length > maxPvalsToShow) {
+    tablediv.style("overflow", "auto").style("height", "220px");
+  }
+  const visibleTests = s.hiddenPvalues ? tests.filter((t) => !s.hiddenPvalues.find((p) => p.series1.id === t.series1.id && p.series2.id === t.series2.id)) : tests;
+  if (plot == "violin" ? visibleTests.pvalues.length : visibleTests.length) {
+    const binOrder = bins && bins.length > 0 ? bins.map((b) => b.label) : null;
+    if (binOrder) {
+      for (const test of visibleTests) {
+        const orderedSeries = [test.series1.id, test.series2.id].sort(
+          (a, b) => binOrder.indexOf(a) - binOrder.indexOf(b)
+        );
+        if (test.series2.id == orderedSeries[0]) {
+          test.series1_new = test.series2;
+          test.series2_new = test.series1;
+          test.series1 = test.series1_new;
+          test.series2 = test.series2_new;
+          delete test.series1_new;
+          delete test.series2_new;
+        }
+      }
+      visibleTests.sort(
+        (a, b) => binOrder.indexOf(a.series1.id) - binOrder.indexOf(b.series1.id) || binOrder.indexOf(a.series2.id) - binOrder.indexOf(b.series2.id)
+      );
+    }
+    const table = tablediv.append("table").style("width", "100%");
+    table.append("thead").append("tr").selectAll("td").data(["Group 1", "Group 2", "P-value"]).enter().append("td").style("padding", "1px 8px 1px 2px").style("color", "#555").style("position", "sticky").style("top", "0px").style("background", "white").style("font-size", fontSize + "px").text((column) => column);
+    const tbody = table.append("tbody");
+    const tr = tbody.selectAll("tr").data(plot == "violin" ? visibleTests.pvalues : visibleTests).enter().append("tr").attr("class", `pp-${plot}-chartLegends-pvalue`);
+    if (plot == "survival") {
+      tr.on("click", (event, t) => {
+        const hiddenPvalues = s.hiddenPvalues.slice();
+        hiddenPvalues.push(t);
+        updateHiddenPvalues(hiddenPvalues);
+      });
+    }
+    tr.selectAll("td").data((d) => [d.series1, d.series2, d.pvalue]).enter().append("td").attr("aria-label", plot ? "Click to hide a p-value" : "").style("color", plot == "violin" ? "black" : (d) => d.color).style("padding", "1px 8px 1px 2px").style("font-size", fontSize + "px").style("cursor", plot == "survival" ? "pointer" : "auto").text((d) => plot == "violin" ? d : d.text);
+    if (plot == "cuminc") {
+      if (visibleTests.find((test) => test.permutation)) {
+        holder.append("div").style("margin-top", "10px").style("font-size", fontSize - 2 + "px").text("*computed by permutation of Gray's test statistic");
+      }
+    }
+  }
+  if (plot == "survival") {
+    const hiddenTests = tests.filter(
+      (t) => s.hiddenPvalues.find((p) => p.series1.id === t.series1.id && p.series2.id === t.series2.id)
+    );
+    if (hiddenTests.length) {
+      holder.append("div").style("color", "#aaa").style("cursor", "pointer").html(`<span style='color:#aaa; font-weight:400'><span>Hidden tests (${hiddenTests.length})</span>`).on("click", (event) => {
+        tip.clear();
+        const divs = tip.d.append("div").selectAll("div").data(hiddenTests).enter().append("div").each(function(d) {
+          setActiveMenu(true);
+          const div = select_default(this);
+          div.append("input").attr("type", "checkbox").style("margin-right", "5px");
+          div.append("span").html(`${d.series1.id} vs ${d.series2.id}`);
+        });
+        tip.d.append("button").html("Show checked test(s)").on("click", () => {
+          const hiddenPvalues = [];
+          divs.filter(function() {
+            return !select_default(this.firstChild).property("checked");
+          }).each((d) => hiddenPvalues.push(d));
+          updateHiddenPvalues(hiddenPvalues);
+          tip.hide();
+        });
+        tip.show(event.clientX, event.clientY);
+      });
+    }
+    if (s.maxTimeToEvent && visibleTests.length) {
+      holder.append("div").style("margin-top", "10px").style("font-size", fontSize - 2 + "px").text((visibleTests.length > 1 ? "p-values are" : "p-value is") + " computed with all survival data");
+    }
+  }
+}
+
+export {
+  getSeriesTip,
+  renderAtRiskG,
+  renderPvalues
+};
+//# sourceMappingURL=chunk-WQ3U6X4Q.js.map

package/dist/chunk-X4NI4JLQ.js

@@ -0,0 +1,177 @@
+import {
+  decimalPlacesUntilFirstNonZero
+} from "./chunk-L4QG7XZE.js";
+import {
+  basis_default,
+  line_default
+} from "./chunk-KSGA62R2.js";
+import {
+  axisTop
+} from "./chunk-LOZEKOES.js";
+import {
+  linear
+} from "./chunk-OAWQ6LOO.js";
+import {
+  brushX
+} from "./chunk-KYBIQBXE.js";
+import {
+  rgb
+} from "./chunk-OMR2DT66.js";
+
+// dom/numericRangeInput.ts
+var NumericRangeInput = class {
+  constructor(holder, range, callback, opts) {
+    this.input = holder.append("input").attr("name", "rangeInput").attr("aria-label", "Leave blank for the allowed minimum value").style("width", opts?.width || "250px").style("margin", "3px 5px").on("change", () => {
+      try {
+        this.parseRange();
+      } catch (ex) {
+        alert(ex);
+        this.setRange();
+      }
+    });
+    this.setRange(range);
+    this.callback = callback;
+  }
+  getInput() {
+    return this.input;
+  }
+  parseRange() {
+    const str = this.input.node().value;
+    const new_range = parseRange(str);
+    if (this.range?.min != void 0) {
+      if (!new_range.startunbounded && this.range?.min > new_range.start) throw "Invalid start value < minimum allowed";
+      if (!new_range.stopunbounded && this.range?.min >= new_range.stop) throw "Invalid stop value >= minimum allowed";
+    }
+    if (this.range?.max != void 0) {
+      if (!new_range.stopunbounded && this.range?.max < new_range.stop) throw "Invalid stop value > maximum allowed";
+      if (!new_range.startunbounded && new_range.start >= this.range?.max)
+        throw "Invalid start value >= maximum allowed";
+    }
+    this.range = new_range;
+    this.callback(new_range);
+    return new_range;
+  }
+  getRange() {
+    return this.range;
+  }
+  setRange(range) {
+    if (!range) range = this.range;
+    else this.range = range;
+    if (!range) return;
+    const start = range.start != void 0 ? `${range.start} <=` : "";
+    const stop = range.stop != void 0 ? `<= ${range.stop}` : "";
+    this.input.node().value = range.value != void 0 ? ` x=${range.value} ` : `${start} x ${stop}`;
+  }
+};
+function parseRange(str) {
+  if (!str) throw "Empty range";
+  const tokens = str.replace(/\s/g, "").split("x");
+  let start, stop, startinclusive, stopinclusive, value;
+  if (tokens[0]) parseRangeToken(tokens[0]);
+  if (tokens[1]) parseRangeToken(tokens[1]);
+  if (value != void 0) return { value, label: `x = ${value}` };
+  const startunbounded = start === void 0;
+  const stopunbounded = stop === void 0;
+  if (!startunbounded && !stopunbounded && start > stop) throw "start must be lower than stop";
+  return { start, stop, value, startinclusive, stopinclusive, startunbounded, stopunbounded };
+  function parseRangeToken(rangeToken) {
+    const floatExpr = "[+-]?\\d+(\\.\\d+)?";
+    if (new RegExp(`^${floatExpr}<$`).test(rangeToken) || new RegExp(`^>${floatExpr}$`).test(rangeToken)) {
+      start = parseFloat(rangeToken.match(floatExpr));
+      startinclusive = false;
+    } else if (new RegExp(`^${floatExpr}<=$`).test(rangeToken) || new RegExp(`^>=${floatExpr}$`).test(rangeToken)) {
+      start = parseFloat(rangeToken.match(floatExpr));
+      startinclusive = true;
+    } else if (new RegExp(`^${floatExpr}>$`).test(rangeToken) || new RegExp(`^<${floatExpr}$`).test(rangeToken)) {
+      stop = parseFloat(rangeToken.match(floatExpr));
+      stopinclusive = false;
+    } else if (new RegExp(`^${floatExpr}>=$`).test(rangeToken) || new RegExp(`^<=${floatExpr}$`).test(rangeToken)) {
+      stop = parseFloat(rangeToken.match(floatExpr));
+      stopinclusive = true;
+    } else if (new RegExp(`^${floatExpr}=$`).test(rangeToken) || new RegExp(`^=${floatExpr}$`).test(rangeToken)) {
+      value = parseFloat(rangeToken.match(floatExpr));
+      stopinclusive = true;
+      startinclusive = true;
+    } else throw `Could not parse expression '${rangeToken}'`;
+  }
+}
+
+// dom/violinRenderer.js
+var violinRenderer = class {
+  constructor({
+    holder,
+    rd,
+    radius = 10,
+    width = 500,
+    height = 100,
+    shiftx = 20,
+    shifty = 20,
+    callback = null,
+    scaleFactor = 1
+  }) {
+    this.holder = holder;
+    this.rd = rd;
+    this.vd = rd.charts?.[""]?.plots?.[0];
+    if (!this.vd) throw "No density plot data to render.";
+    this.width = width;
+    this.height = height;
+    this.radius = radius;
+    this.callback = callback;
+    this.shiftx = shiftx;
+    this.shifty = shifty;
+    this.svg = holder.append("svg").attr("width", `${width + 50}px`).attr("height", `${height + 50}px`);
+    this.axisScale = linear().domain([rd.min, rd.max]).range([0, width]);
+    this.axisScaleUI = linear().domain([rd.min * scaleFactor, rd.max * scaleFactor]).range([0, width]);
+    this.wScale = linear().domain([this.vd.density.densityMax, this.vd.density.densityMin]).range([height * 0.45, 0]);
+  }
+  render() {
+    this.svg.selectAll("*").remove();
+    this.violinG = this.svg.append("g").attr("transform", `translate(${this.shiftx}, ${this.height / 2 + this.shifty})`);
+    this.brushG = this.svg.append("g").attr("transform", `translate(${this.shiftx}, ${this.shifty})`);
+    this.scaleG = this.svg.append("g").attr("transform", `translate(${this.shiftx}, ${this.shifty})`);
+    this.scaleG.call(axisTop(this.axisScaleUI).tickValues(this.axisScaleUI.ticks()));
+    this.renderArea(false);
+    this.renderArea(true);
+    if (this.vd.src) {
+      this.violinG.append("image").classed("sjpp-beans-img", true).attr("xlink:href", this.vd.src).attr("transform", `translate(0, -${this.radius / 2})`).attr("width", this.width);
+    }
+    if (this.callback)
+      this.svg.append("g").call(
+        brushX().extent([
+          [this.shiftx, this.shifty],
+          [this.width + this.shiftx, this.height + this.shifty]
+        ]).on("end", async (event) => {
+          const selection = event.selection;
+          if (!selection) return;
+          const range_start = this.axisScale.invert(selection[0] - this.shiftx);
+          const range_end = this.axisScale.invert(selection[1] - this.shiftx);
+          this.callback({ range_start, range_end });
+        })
+      );
+  }
+  renderArea(invert) {
+    if (this.vd.densityMax == 0) return;
+    const areaBuilder = line_default().curve(basis_default).x((d) => this.axisScale(d.x0)).y((d) => invert ? -this.wScale(d.density) : this.wScale(d.density));
+    const color = this.vd.color || "#dddddd";
+    this.violinG.append("path").style("fill", color).style("opacity", 0).attr("stroke", rgb(color).darker()).attr("stroke-width", 1).attr("stroke-linejoin", "round").style("opacity", "0.8").attr("d", areaBuilder(this.vd.density.bins));
+  }
+};
+
+// dom/niceNumLabels.ts
+function niceNumLabels(nums) {
+  const sorted = nums.sort((a, b) => a - b);
+  const abs = Math.abs(sorted[0] - sorted[sorted.length - 1]);
+  const zeroDecimalNum = decimalPlacesUntilFirstNonZero(abs);
+  const decimals2Show = abs >= 10 ? 0 : abs >= 1 ? 1 : zeroDecimalNum + 2;
+  return nums.map((num) => {
+    if (Math.abs(num) < 1 && decimals2Show == 0) return Number(num.toPrecision(1));
+    return Number(num.toFixed(decimals2Show));
+  });
+}
+
+export {
+  NumericRangeInput,
+  violinRenderer,
+  niceNumLabels
+};
+//# sourceMappingURL=chunk-X4NI4JLQ.js.map

package/dist/chunk-XKF4KMCB.js

@@ -0,0 +1,146 @@
+import {
+  NumericModes
+} from "./chunk-EGWVYY7K.js";
+
+// plots/proteomeAbundance.js
+function renderAssayAndCohortRadios({
+  holder,
+  assays,
+  selectedProteomeDetails,
+  onChange,
+  assayTitle = "Assay Type",
+  cohortTitle = "Cohort"
+}) {
+  const assayEntries = Object.entries(assays || {});
+  if (!assayEntries.length) {
+    holder.append("div").attr("class", "sja_sharp_border").style("padding", "8px").text("No proteome assays available.");
+    return {
+      getSelected: () => ({ assay: void 0, cohort: void 0 })
+    };
+  }
+  const initialProteomeDetails = selectedProteomeDetails || {};
+  const assayRadioName = `sjpp-proteome-assay-${Math.random().toString().slice(-6)}`;
+  const cohortRadioName = `sjpp-proteome-cohort-${Math.random().toString().slice(-6)}`;
+  let selectedAssay = assays[initialProteomeDetails.assay] ? initialProteomeDetails.assay : assayEntries[0][0];
+  let selectedCohort = initialProteomeDetails.cohort;
+  holder.append("div").style("margin", "3px 5px").style("padding", "3px 5px").style("font-weight", 600).text(assayTitle);
+  const assayListDiv = holder.append("div").style("margin-bottom", "10px");
+  holder.append("div").style("margin", "3px 5px").style("padding", "3px 5px").style("font-weight", 600).text(cohortTitle);
+  const cohortListDiv = holder.append("div").style("max-height", "300px").style("overflow-y", "auto").style("border", "1px solid #ddd").style("border-radius", "4px").style("padding", "5px");
+  for (const [assayKey] of assayEntries) {
+    const assayLabel = assayListDiv.append("label").attr("class", "sja_sharp_border").style("display", "block").style("cursor", "pointer").style("padding", "6px 8px").style("border-radius", "4px");
+    assayLabel.append("input").attr("type", "radio").attr("name", assayRadioName).attr("value", assayKey).property("checked", assayKey === selectedAssay).style("margin-right", "6px").on("change", () => {
+      selectedAssay = assayKey;
+      selectedCohort = void 0;
+      renderCohortOptions();
+      onChange?.({ assay: selectedAssay, cohort: selectedCohort });
+    });
+    assayLabel.append("span").text(assayKey);
+  }
+  renderCohortOptions();
+  onChange?.({ assay: selectedAssay, cohort: selectedCohort });
+  return {
+    getSelected: () => ({ assay: selectedAssay, cohort: selectedCohort })
+  };
+  function renderCohortOptions() {
+    cohortListDiv.selectAll("*").remove();
+    const cohorts = Object.keys(assays[selectedAssay]?.cohorts || {});
+    if (!cohorts.length) {
+      selectedCohort = void 0;
+      cohortListDiv.append("div").attr("class", "sja_sharp_border").style("padding", "8px").text("No cohorts available.");
+      return;
+    }
+    if (!selectedCohort || !assays[selectedAssay]?.cohorts?.[selectedCohort]) {
+      selectedCohort = cohorts.includes(initialProteomeDetails.cohort) ? initialProteomeDetails.cohort : cohorts[0];
+    }
+    for (const cohortKey of cohorts) {
+      const cohortLabel = cohortListDiv.append("label").attr("class", "sja_sharp_border").style("display", "block").style("cursor", "pointer").style("padding", "6px 8px").style("border-radius", "4px");
+      cohortLabel.append("input").attr("type", "radio").attr("name", cohortRadioName).attr("value", cohortKey).property("checked", cohortKey === selectedCohort).style("margin-right", "6px").on("change", () => {
+        selectedCohort = cohortKey;
+        onChange?.({ assay: selectedAssay, cohort: selectedCohort });
+      });
+      cohortLabel.append("span").text(cohortKey);
+    }
+  }
+}
+function makeChartBtnMenu(holder, chartsInstance) {
+  chartsInstance.dom.tip.clear();
+  const assays = chartsInstance.state.termdbConfig?.queries?.proteome?.assays || {};
+  const proteomeOverlayTerm = chartsInstance.state.termdbConfig?.queries?.proteome?.overlayTerm;
+  const menuDiv = holder.append("div");
+  let selectedProteomeDetails;
+  let launchOption;
+  const syncLaunchButtonState = () => {
+    if (!launchOption) return;
+    if (selectedProteomeDetails?.cohort) launchOption.style("opacity", 1).style("pointer-events", "auto");
+    else launchOption.style("opacity", 0.5).style("pointer-events", "none");
+  };
+  renderAssayAndCohortRadios({
+    holder: menuDiv,
+    assays,
+    onChange: (proteomeDetails) => {
+      selectedProteomeDetails = proteomeDetails;
+      syncLaunchButtonState();
+    }
+  });
+  launchOption = menuDiv.append("button").attr("class", "sjpp_apply_btn sja_filter_tag_btn sja_sharp_border").style("display", "block").style("margin", "10px auto 10px").text("Select Protein").on("click", () => {
+    if (!selectedProteomeDetails?.cohort) return;
+    const { assay, cohort } = selectedProteomeDetails;
+    const assayCohortTitle = `${assay}: ${cohort}`;
+    const chart = {
+      label: "Protein Abundance",
+      chartType: "proteomeAbundance",
+      usecase: {
+        target: "proteomeAbundance",
+        detail: "term",
+        proteomeDetails: { assay, cohort },
+        label: `Assay: ${assay}; Cohort: ${cohort}`
+      },
+      processSelection: (termlst) => termlst,
+      updateActionBySelectedTerms: (action, termlst) => {
+        action.config.assayCohortTitle = assayCohortTitle;
+        const { assay: assay2, cohort: cohort2 } = selectedProteomeDetails;
+        action.config.proteomeDetails = { assay: assay2, cohort: cohort2 };
+        const twlst = termlst.map((term) => {
+          const t = structuredClone(term);
+          t.proteomeDetails = { assay: assay2, cohort: cohort2 };
+          return { term: t, q: { mode: NumericModes.continuous } };
+        });
+        if (twlst.length == 1) {
+          action.config.chartType = "summary";
+          action.config.term = twlst[0];
+          if (proteomeOverlayTerm) action.config.term2 = { term: structuredClone(proteomeOverlayTerm), q: {} };
+          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 = "proteomeAbundance";
+        action.config.termgroups = [{ name: "Protein Abundance Cluster", lst: twlst, type: "hierCluster" }];
+      }
+    };
+    chartsInstance.dom.tip.clear();
+    chartsInstance.showTree_selectlst(chart);
+  });
+  syncLaunchButtonState();
+}
+function toTvslstFilter(filterConfig) {
+  if (filterConfig && Array.isArray(filterConfig) && filterConfig.length)
+    return {
+      type: "tvslst",
+      in: true,
+      join: filterConfig.length > 1 ? "and" : "",
+      lst: filterConfig.map((tvs) => ({ type: "tvs", tvs }))
+    };
+}
+
+export {
+  renderAssayAndCohortRadios,
+  makeChartBtnMenu,
+  toTvslstFilter
+};
+//# sourceMappingURL=chunk-XKF4KMCB.js.map