@sjcrh/proteinpaint-client 2.208.0 → 2.210.0

package/dist/cellTypeBubbleHeatmap-VOHLI4P7.js

@@ -0,0 +1,278 @@
+import {
+  LegendCircleReference,
+  PlotBase,
+  addGeneSearchbox
+} from "./chunk-55FABQU2.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-UXD6G6G4.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import "./chunk-3FEP6B5T.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import {
+  dofetch3
+} from "./chunk-VA57CUC7.js";
+import "./chunk-BK6UDL7F.js";
+import "./chunk-KIAMLQ7S.js";
+import "./chunk-SB36AUG7.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import {
+  linear,
+  sqrt
+} from "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.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-VOHLI4P7.js.map

package/dist/chunk-26N3B2JO.js

@@ -0,0 +1,194 @@
+import {
+  sample_match_termvaluesetting
+} from "./chunk-3FEP6B5T.js";
+import {
+  isDictionaryType
+} from "./chunk-KIAMLQ7S.js";
+import {
+  __export
+} from "./chunk-HS5PO5ZQ.js";
+
+// plots/matrix/matrix.data.js
+var matrix_data_exports = {};
+__export(matrix_data_exports, {
+  applyLegendValueFilter: () => applyLegendValueFilter,
+  getMatrixRequestOpts: () => getMatrixRequestOpts,
+  mayRequireToken: () => mayRequireToken,
+  setData: () => setData
+});
+function mayRequireToken(tokenMessage = "") {
+  const message = tokenMessage || this.state.tokenVerificationMessage;
+  if (!message && this.state.hasVerifiedToken) {
+    this.dom.errdiv.style("display", "none").html();
+    this.dom.controls.style("display", this.opts.controls ? "inline-block" : "");
+    this.dom.svg.style("display", "");
+    return false;
+  } else {
+    this.dom.errdiv.style("display", "").html(message || "Requires login");
+    this.dom.controls.style("display", "none");
+    this.dom.svg.style("display", "none");
+    return true;
+  }
+}
+function getMatrixRequestOpts(state, config) {
+  const terms = [];
+  const termgroups = this.chartType == "hierCluster" ? config.termgroups.filter((grp) => grp.type != "hierCluster") : config.termgroups;
+  for (const grp of termgroups) {
+    terms.push(...getNormalizedTwLstCopy(grp.lst));
+  }
+  if (config.divideBy) terms.push(normalizeTwForRequest(structuredClone(config.divideBy)));
+  const opts = {
+    terms,
+    filter: state.filter,
+    filter0: state.filter0,
+    maxGenes: state.config.settings.matrix.maxGenes,
+    /*********** quick fix
+    when the flag is true, set artificially large number to ensure all genes are sent in one query
+    this avoids changing getAnnotatedSampleData()
+    additional non-matrix app that calls getAnnotatedSampleData will NEED THE SAME FIX
+    */
+    termsPerRequest: this.app.vocabApi.termdbConfig.queries?.snvindel?.byisoform?.processTwsInOneQuery ? 1e3 : 1
+  };
+  if (this.chartType == "hierCluster") {
+    opts.isHierCluster = 1;
+  }
+  return opts;
+}
+function getNormalizedTwLstCopy(twlst) {
+  const lst = [];
+  for (const tw of twlst) {
+    if (tw.type && tw.constructor.name != "Object") lst.push(tw);
+    else lst.push(normalizeTwForRequest(tw));
+  }
+  lst.forEach(normalizeTwForRequest);
+  lst.sort(sortTwLst);
+  return lst;
+}
+function normalizeTwForRequest(_tw) {
+  const tw = structuredClone(_tw);
+  if (!tw?.term) return;
+  delete tw.term.category2samplecount;
+  if (isDictionaryType(tw.term.type) && tw.term.type !== "samplelst") delete tw.term.values;
+  return tw;
+}
+function sortTwLst(twa, twb) {
+  const a = twa?.$id || twa.term?.id || twa?.term?.name;
+  const b = twb?.$id || twb.term?.id || twb?.term?.name;
+  return a < b ? -1 : 1;
+}
+async function setData(_data) {
+  const opts = this.currRequestOpts?.matrix || this.getMatrixRequestOpts(this.state, this.config);
+  this.numTerms = opts.terms.length;
+  opts.loadingDiv = this.chartType != "hierCluster" && this.dom.loadingDiv;
+  opts.signal = this.api.getAbortSignal();
+  const data = await this.app.vocabApi.getAnnotatedSampleData(opts, _data);
+  this.data = data;
+  this.origData = structuredClone(this.data);
+  this.sampleIdMap = {};
+  for (const d of this.data.lst) {
+    this.sampleIdMap[d.sample] = d._ref_.label;
+  }
+}
+function applyLegendValueFilter() {
+  const self = this;
+  if (!self.config.legendValueFilter.lst.length && !self.config.legendGrpFilter.lst.length) return;
+  for (const grpFilter of self.config.legendGrpFilter.lst) {
+    if (grpFilter.dt) {
+      const filteredOutCats = /* @__PURE__ */ new Set();
+      for (const oneSampleData of self.origData.lst) {
+        for (const annoForOneTerm of Object.values(oneSampleData)) {
+          if (annoForOneTerm.values) {
+            const newValues = [];
+            for (const v of annoForOneTerm.values) {
+              if (!(grpFilter.dt.includes(v.dt) && (!grpFilter.origin || v.origin == grpFilter.origin))) {
+                newValues.push(v);
+              } else {
+                filteredOutCats.add(v.class);
+              }
+            }
+            annoForOneTerm.values = newValues;
+          }
+        }
+      }
+      grpFilter.filteredOutCats = [...filteredOutCats];
+      for (const oneSampleData of Object.values(self.origData.samples)) {
+        for (const annoForOneTerm of Object.values(oneSampleData)) {
+          if (annoForOneTerm.values)
+            annoForOneTerm.values = annoForOneTerm.values.filter(
+              (v) => !(grpFilter.dt.includes(v.dt) && (!grpFilter.origin || v.origin == grpFilter.origin))
+            );
+        }
+      }
+    }
+  }
+  const geneVariant$ids = Object.values(self.data.refs.byTermId).filter((v) => v.term?.type == "geneVariant").map((v) => v.$id);
+  const data = { samples: {}, lst: [], refs: self.data.refs };
+  const onlyHardFilter = structuredClone(self.config.legendValueFilter);
+  onlyHardFilter.lst = onlyHardFilter.lst.filter(
+    (l) => !l.tvs.legendFilterType || l.tvs.legendFilterType !== "geneVariant_soft"
+  );
+  for (const row of self.origData.lst) {
+    const include = sample_match_termvaluesetting(row, onlyHardFilter, geneVariant$ids);
+    if (include || self.chartType == "hierCluster") {
+      data.samples[row.sample] = row;
+      data.lst.push(row);
+    }
+  }
+  for (const valFilter of self.config.legendValueFilter.lst) {
+    if (valFilter.tvs.legendFilterType !== "geneVariant_soft") continue;
+    const tvsV = valFilter.tvs.values[0];
+    const filteredOutCats = /* @__PURE__ */ new Set();
+    for (const oneSampleData of data.lst) {
+      for (const annoForOneTerm of Object.values(oneSampleData)) {
+        if (annoForOneTerm.values) {
+          const newValues = [];
+          for (const v of annoForOneTerm.values) {
+            if (!(v.dt == tvsV.dt && (!tvsV.origin || v.origin == tvsV.origin) && tvsV.mclasslst.includes(v.class))) {
+              newValues.push(v);
+            } else {
+              filteredOutCats.add(v.class);
+            }
+          }
+          annoForOneTerm.values = newValues;
+        }
+      }
+    }
+    valFilter.filteredOutCats = [...filteredOutCats];
+    for (const oneSampleData of Object.values(data.samples)) {
+      for (const annoForOneTerm of Object.values(oneSampleData)) {
+        if (annoForOneTerm.values)
+          annoForOneTerm.values = annoForOneTerm.values.filter(
+            (v) => !(v.dt == tvsV.dt && (!tvsV.origin || v.origin == tvsV.origin) && tvsV.mclasslst.includes(v.class))
+          );
+      }
+    }
+  }
+  if (self.chartType !== "hierCluster" && geneVariant$ids.length && self.app.vocabApi.termdbConfig?.matrix?.removeEmptySamples)
+    remove_empty_sample(data, geneVariant$ids);
+  self.data = data;
+}
+function remove_empty_sample(data) {
+  for (const oneSampleData of data.lst) {
+    let removeSample = true;
+    for (const [key, annoForOneTerm] of Object.entries(oneSampleData)) {
+      if (!annoForOneTerm.values) continue;
+      const annoType = data.refs.byTermId[key].term.type;
+      if (annoType != "geneVariant") continue;
+      if (annoForOneTerm.values.length) removeSample = false;
+    }
+    if (removeSample) {
+      data.lst = data.lst.filter((dl) => dl.sample !== oneSampleData.sample);
+      delete data.samples[parseInt(oneSampleData.sample)];
+    }
+  }
+  return data;
+}
+
+export {
+  mayRequireToken,
+  getMatrixRequestOpts,
+  setData,
+  applyLegendValueFilter,
+  matrix_data_exports
+};
+//# sourceMappingURL=chunk-26N3B2JO.js.map