@sjcrh/proteinpaint-client 2.204.0 → 2.205.0

package/dist/chunk-S5UN4VIQ.js

@@ -0,0 +1,272 @@
+import {
+  fillbar,
+  make_table_2col
+} from "./chunk-J7JDCNLU.js";
+
+// src/block.mds.expressionstat.js
+var color_noinfo = "#858585";
+function init_config(cfg) {
+  if (!cfg.datatype) cfg.datatype = "FPKM";
+  if (!cfg.itemcolor) cfg.itemcolor = "green";
+  if (!cfg.ase) cfg.ase = {};
+  if (cfg.ase.qvalue == void 0) cfg.ase.qvalue = 0.05;
+  if (cfg.ase.meandelta_monoallelic == void 0) cfg.ase.meandelta_monoallelic = 0.3;
+  if (cfg.ase.asemarkernumber_biallelic == void 0) cfg.ase.asemarkernumber_biallelic = 0;
+  if (!cfg.ase.color_noinfo) cfg.ase.color_noinfo = color_noinfo;
+  if (!cfg.ase.color_uncertain) cfg.ase.color_uncertain = "#A8E0B5";
+  if (!cfg.ase.color_biallelic) cfg.ase.color_biallelic = "#40859C";
+  if (!cfg.ase.color_monoallelic) cfg.ase.color_monoallelic = "#d95f02";
+  if (!cfg.outlier) cfg.outlier = {};
+  if (cfg.outlier.pvalue_cutoff == void 0) cfg.outlier.pvalue_cutoff = 0.05;
+  if (cfg.outlier.rank_asehigh_cutoff == void 0) cfg.outlier.rank_asehigh_cutoff = 0.1;
+  if (!cfg.outlier.color_outlier) cfg.outlier.color_outlier = "#FF8875";
+  if (!cfg.outlier.color_outlier_asehigh) cfg.outlier.color_outlier_asehigh = "blue";
+}
+function measure(v, cfg) {
+  if (!cfg) return;
+  v.estat = {};
+  if (v.ase && cfg.ase) {
+    const qvalue = v.ase.qvalue || v.ase.geometricmean;
+    if (qvalue == void 0) {
+      v.estat.ase_noinfo = true;
+    } else if (qvalue <= cfg.ase.qvalue) {
+      if (v.ase.mean_delta >= cfg.ase.meandelta_monoallelic) {
+        v.estat.ase_monoallelic = true;
+      } else {
+        v.estat.ase_uncertain = true;
+      }
+    } else {
+      if (v.ase.ase_markers == cfg.ase.asemarkernumber_biallelic) {
+        v.estat.ase_biallelic = true;
+      } else {
+        v.estat.ase_uncertain = true;
+      }
+    }
+  } else {
+    v.estat.ase_noinfo = true;
+  }
+  if (v.outlier && cfg.outlier) {
+    if (v.outlier.test_whitelist) {
+      if (v.outlier.test_whitelist.pvalue <= cfg.outlier.pvalue_cutoff) {
+        v.estat.outlier = true;
+      } else {
+        if (v.estat.ase_monoallelic) {
+          if (Number.isInteger(v.outlier.test_whitelist.rank) && Number.isInteger(v.outlier.test_whitelist.size) && v.outlier.test_whitelist.rank / v.outlier.test_whitelist.size <= cfg.outlier.rank_asehigh_cutoff) {
+            v.estat.outlier_asehigh = true;
+            v.outlier.test_whitelist.asehigh = true;
+          }
+        }
+      }
+    } else if (v.outlier.test_biallelic) {
+      if (v.outlier.test_biallelic.pvalue <= cfg.outlier.pvalue_cutoff) {
+        v.estat.outlier = true;
+      } else {
+        if (v.estat.ase_monoallelic) {
+          if (Number.isInteger(v.outlier.test_biallelic.rank) && Number.isInteger(v.outlier.test_biallelic.size) && v.outlier.test_biallelic.rank / v.outlier.test_biallelic.size <= cfg.outlier.rank_asehigh_cutoff) {
+            v.estat.outlier_asehigh = true;
+            v.outlier.test_biallelic.asehigh = true;
+          }
+        }
+      }
+    } else if (v.outlier.test_entirecohort) {
+      if (v.outlier.test_entirecohort.pvalue <= cfg.outlier.pvalue_cutoff) {
+        v.estat.outlier = true;
+      } else {
+        if (v.estat.ase_monoallelic) {
+          if (Number.isInteger(v.outlier.test_entirecohort.rank) && Number.isInteger(v.outlier.test_entirecohort.size) && v.outlier.test_entirecohort.rank / v.outlier.test_entirecohort.size <= cfg.outlier.rank_asehigh_cutoff) {
+            v.estat.outlier_asehigh = true;
+            v.outlier.test_entirecohort.asehigh = true;
+          }
+        }
+      }
+    }
+  }
+}
+function showsingleitem_table(v, cfg, table) {
+  if (!v.estat) return;
+  if (cfg.no_ase) return;
+  if (v.ase) {
+    const tr = table.append("tr");
+    tr.append("td").attr("colspan", 2).style("background", ase_color(v, cfg)).style("color", "white").html(
+      (v.estat.ase_monoallelic ? "Mono-allelic" : v.estat.ase_biallelic ? "Bi-allelic" : "ASE uncertain") + "<br>(allele-specific expression)"
+    );
+    const lst = [
+      {
+        k: "#SNPs heterozygous in DNA",
+        v: v.ase.markers
+      },
+      {
+        k: "#SNPs showing ASE in RNA",
+        v: v.ase.ase_markers
+      },
+      {
+        k: "Mean delta of ASE SNPs",
+        v: v.ase.mean_delta
+      }
+    ];
+    if (v.ase.qvalue) {
+      lst.push({
+        k: "Q-value",
+        v: v.ase.qvalue
+      });
+    } else if (v.ase.geometricmean) {
+      lst.push({
+        k: "Geometric mean of binomial P-values of ASE SNPs",
+        v: v.ase.geometricmean
+      });
+    }
+    const td = tr.append("td");
+    make_table_2col(td, lst);
+  } else {
+    const tr = table.append("tr");
+    tr.append("td").attr("colspan", 3).style("background", cfg.ase.color_noinfo).style("color", "white").text("No info on allele-specific expression");
+  }
+  if (v.snps && v.snps.length > 0) {
+    const hetsnp = v.snps.filter((i) => i.dnacount && i.dnacount.ishet);
+    if (hetsnp.length > 0) {
+      const lst = [];
+      for (const m of hetsnp) {
+        lst.push(
+          "<tr><td>" + m.chr + ":" + (m.pos + 1) + " " + m.ref + ">" + m.alt + "</td><td>" + fillbar(null, { f: m.dnacount.f }) + " " + m.dnacount.ref + "/" + m.dnacount.alt + "</td><td>" + (m.rnacount.nocoverage ? '<span style="font-size:.8em;opacity:.5">No coverage</span>' : fillbar(null, { f: m.rnacount.f }) + " " + m.rnacount.ref + "/" + m.rnacount.alt) + "</td><td>" + (m.rnacount.pvalue || "-") + "</td></tr>"
+        );
+      }
+      table.append("tr").append("td").attr("colspan", 3).html(
+        '<table style="margin-top:10px;border:solid 1px #ededed;border-spacing:5px;"><tr style="opacity:.5"><td>SNP</td><td>DNA</td><td>RNA</td><td>Binomial test P-value</td></tr>' + lst.join("") + "</table>"
+      );
+    }
+  }
+  if (v.outlier) {
+    if (v.outlier.test_whitelist) {
+      const tr = table.append("tr");
+      tr.append("td").attr("colspan", 2).text("Outlier (white list)");
+      const lst = [];
+      for (const k in v.outlier.test_whitelist) {
+        lst.push({ k, v: v.outlier.test_whitelist[k] });
+      }
+      const td = tr.append("td");
+      make_table_2col(td, lst);
+      if (v.outlier.test_whitelist.asehigh) {
+        td.append("div").style("background", cfg.outlier.color_outlier_asehigh).style("padding", "2px 10px").style("color", "white").text("ASE high");
+      }
+    }
+    if (v.outlier.test_biallelic) {
+      const tr = table.append("tr");
+      tr.append("td").attr("colspan", 2).text("Outlier (biallelic)");
+      const lst = [];
+      for (const k in v.outlier.test_biallelic) {
+        lst.push({ k, v: v.outlier.test_biallelic[k] });
+      }
+      const td = tr.append("td");
+      make_table_2col(td, lst);
+      if (v.outlier.test_biallelic.asehigh) {
+        td.append("div").style("background", cfg.outlier.color_outlier_asehigh).style("padding", "2px 10px").style("color", "white").text("ASE high");
+      }
+    }
+    if (v.outlier.test_entirecohort) {
+      const tr = table.append("tr");
+      tr.append("td").attr("colspan", 2).text("Outlier (all samples)");
+      const lst = [];
+      for (const k in v.outlier.test_entirecohort) {
+        lst.push({ k, v: v.outlier.test_entirecohort[k] });
+      }
+      const td = tr.append("td");
+      make_table_2col(td, lst);
+      if (v.outlier.test_entirecohort.asehigh) {
+        td.append("div").style("background", cfg.outlier.color_outlier_asehigh).style("padding", "2px 10px").style("color", "white").text("ASE high");
+      }
+    }
+  }
+}
+function ase_color(v, cfg) {
+  if (cfg.no_ase) return color_noinfo;
+  if (!cfg.ase) return color_noinfo;
+  if (!v.estat) return cfg.ase.color_noinfo;
+  if (v.estat.ase_monoallelic) return cfg.ase.color_monoallelic;
+  if (v.estat.ase_biallelic) return cfg.ase.color_biallelic;
+  if (v.estat.ase_uncertain) return cfg.ase.color_uncertain;
+  return cfg.ase.color_noinfo;
+}
+function ui_config(holder, cfg, tk, call) {
+  const indent = 30;
+  {
+    const row = holder.append("div").style("margin-bottom", "5px");
+    row.append("span").html("If " + (tk.checkrnabam ? "p-value geometric mean" : "Q-VALUE") + " &le;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", cfg.ase.qvalue).on("keyup", (event) => {
+      if (event.code != "Enter" && event.code != "NumpadEnter") return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0) {
+        return;
+      }
+      if (cfg.ase.qvalue == v) {
+        return;
+      }
+      cfg.ase.qvalue = v;
+      call();
+    });
+    row.append("span").html("&nbsp;:");
+  }
+  {
+    const row = holder.append("div").style("margin", "0px 5px 5px " + indent + "px");
+    row.append("span").html("If MEAN_DELTA &ge;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", cfg.ase.meandelta_monoallelic).on("keyup", (event) => {
+      if (event.code != "Enter" && event.code != "NumpadEnter") return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0) {
+        return;
+      }
+      if (cfg.ase.meandelta_monoallelic == v) {
+        return;
+      }
+      cfg.ase.meandelta_monoallelic = v;
+      call();
+    });
+    row.append("span").html("&nbsp;:&nbsp;");
+  }
+  holder.append("div").style("margin", "0px 5px 5px " + indent * 2 + "px").html(
+    'Is <span style="background:' + cfg.ase.color_monoallelic + ';padding:1px 5px;color:white;">mono-allelic expression</span>'
+  );
+  holder.append("div").style("margin", "0px 5px 5px " + indent + "px").html("Else:");
+  holder.append("div").style("margin", "0px 5px 5px " + indent * 2 + "px").html(
+    'Is <span style="background:' + cfg.ase.color_uncertain + ';padding:1px 5px;color:white;">ASE uncertain</span>'
+  );
+  holder.append("div").style("margin", "0px 5px 5px 0px").html("Else:");
+  {
+    const row = holder.append("div").style("margin", "0px 5px 5px " + indent + "px");
+    row.append("span").html("If number of ASE markers &le;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", cfg.ase.asemarkernumber_biallelic).on("keyup", (event) => {
+      if (event.code != "Enter" && event.code != "NumpadEnter") return;
+      let v = Number.parseInt(event.target.value);
+      if (v < 0) {
+        return;
+      }
+      if (cfg.ase.asemarkernumber_biallelic == v) {
+        return;
+      }
+      cfg.ase.asemarkernumber_biallelic = v;
+      call();
+    });
+    row.append("span").html("&nbsp;:&nbsp;");
+  }
+  holder.append("div").style("margin", "0px 5px 5px " + indent * 2 + "px").html(
+    'Is <span style="background:' + cfg.ase.color_biallelic + ';padding:1px 5px;color:white;">bi-allelic expression</span>'
+  );
+  holder.append("div").style("margin", "0px 5px 5px " + indent + "px").html("Else:");
+  holder.append("div").style("margin", "0px 5px 5px " + indent * 2 + "px").html(
+    'Is <span style="background:' + cfg.ase.color_uncertain + ';padding:1px 5px;color:white;">ASE uncertain</span>'
+  );
+  holder.append("div").style("margin", "10px").append("button").text("Default ASE parameters").on("click", () => {
+    cfg.ase.qvalue = 0.05;
+    cfg.ase.meandelta_monoallelic = 0.3;
+    cfg.ase.asemarkernumber_biallelic = 0;
+    call();
+  });
+}
+
+export {
+  init_config,
+  measure,
+  showsingleitem_table,
+  ase_color,
+  ui_config
+};
+//# sourceMappingURL=chunk-S5UN4VIQ.js.map

package/dist/chunk-SDMNZJ7X.js

@@ -0,0 +1,50 @@
+import {
+  addGeneSearchbox,
+  getSCGEunit
+} from "./chunk-J7JDCNLU.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import {
+  SINGLECELL_GENE_EXPRESSION
+} from "./chunk-IK2BO37K.js";
+
+// termdb/handlers/singleCellGeneExpression.ts
+var SearchHandler = class {
+  init(opts) {
+    this.validateOpts(opts);
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: opts.genomeObj,
+      row: holder,
+      searchOnly: "gene",
+      callback: () => this.selectGene(geneSearch.geneSymbol, opts.usecase?.specialCase?.config?.sample)
+    });
+  }
+  /**TODO: scge tw handler will validate that a sample is included. Need to resolve issue
+   * with sample info not included.*/
+  async selectGene(gene, sample) {
+    if (!gene) throw new Error("No gene selected");
+    const unit = getSCGEunit(this.app.vocabApi);
+    const name = `${gene} ${unit}`;
+    this.callback({ gene, name, type: SINGLECELL_GENE_EXPRESSION, sample });
+  }
+  validateOpts(opts) {
+    if (opts.callback == null) throw new Error("callback is required");
+    if (opts.app == null) throw new Error("app is required");
+    if (opts.holder == null) throw new Error("holder is required");
+    if (opts.genomeObj == null) throw new Error("genomeObj is required");
+    if (opts.usecase == null) throw new Error("usecase is required");
+    if (!opts.usecase?.specialCase?.config?.sample) {
+      throw new Error("usecase.specialCase.config.sample is required for singleCellGeneExpression handler");
+    }
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-SDMNZJ7X.js.map

package/dist/chunk-SWZAHJYP.js

@@ -0,0 +1,170 @@
+import {
+  getEmptyCell,
+  maySetEmptyCell,
+  setCellProps
+} from "./chunk-IB4NE4SI.js";
+import {
+  TermTypeGroups
+} from "./chunk-IK2BO37K.js";
+import {
+  __export
+} from "./chunk-HS5PO5ZQ.js";
+
+// plots/matrix/matrix.serieses.js
+var matrix_serieses_exports = {};
+__export(matrix_serieses_exports, {
+  getSerieses: () => getSerieses
+});
+function getSerieses(data) {
+  const s = this.settings.matrix;
+  const serieses = [];
+  const { colw, dx, dy, xMin, xMax } = this.dimensions;
+  const dvt = this.config.divideBy || {};
+  const divideByTermId = "id" in dvt ? dvt.id : dvt.name;
+  const legendGroups = {};
+  this.colorScaleByTermId = {};
+  for (const t of this.termOrder) {
+    const $id = t.tw.$id;
+    const termid = "id" in t.tw.term ? t.tw.term.id : t.tw.term.name;
+    const isDivideByTerm = termid === divideByTermId;
+    const emptyGridCells = [];
+    const cellht = t.grp.type == "hierCluster" ? s.clusterRowh : dy;
+    const htAdjust = t.grp.type == "hierCluster" ? 0 : t.totalHtAdjustments;
+    const y = s.transpose ? 0 : t.totalIndex * cellht + t.visibleGrpIndex * s.rowgspace + htAdjust;
+    const twSpecificSettings = this.config.settings.matrix.twSpecificSettings;
+    const hoverY0 = (twSpecificSettings[$id]?.contBarGap || 0) + y;
+    const series = {
+      t,
+      tw: t.tw,
+      cells: [],
+      y,
+      hoverY0,
+      hoverY1: hoverY0 + (twSpecificSettings[$id]?.contBarH || cellht)
+    };
+    for (const so of this.unfilteredSampleOrder) {
+      const { totalIndex, grpIndex, row } = so;
+      series.x = !s.transpose ? 0 : t.totalIndex * dx + t.visibleGrpIndex * s.colgspace;
+      const anno = row[$id];
+      const cellTemplate = {
+        s: so,
+        sample: row.sample,
+        tw: t.tw,
+        term: t.tw.term,
+        termid,
+        $id,
+        totalIndex,
+        grpIndex,
+        row,
+        t,
+        seriesY: y
+      };
+      if (!anno) {
+        if (!so.grp.isExcluded && (s.useCanvas || so.grp)) {
+          const cell = getEmptyCell(cellTemplate, s, this.dimensions);
+          series.cells.push(cell);
+        }
+        continue;
+      }
+      const key = anno.key;
+      const values = anno.filteredValues || anno.values || [anno.value];
+      const numRects = s.cellEncoding == "oncoprint" ? 1 : values.length;
+      const height = !s.transpose ? s.rowh / numRects : colw;
+      const width = !s.transpose ? colw : colw / values.length;
+      const siblingCells = [];
+      if (!anno || !anno.renderedValues?.length) {
+        if (!so.grp.isExcluded && (s.useCanvas || so.grp)) {
+          const cell = getEmptyCell(cellTemplate, s, this.dimensions);
+          series.cells.push(cell);
+        }
+        continue;
+      }
+      for (const [i, value] of values.entries()) {
+        const cell = Object.assign({ key, siblingCells }, cellTemplate);
+        cell.valueIndex = i;
+        let legend;
+        if (typeof t.tw.setCellProps == "function") {
+          legend = t.tw.setCellProps(cell, anno, value, s, t, this, width, height, dx, dy, i);
+        } else {
+          const cellProps = t.grp.type == "hierCluster" ? setCellProps["hierCluster"] : t.tw.term.type == "samplelst" ? setCellProps["categorical"] : setCellProps[t.tw.term.type];
+          legend = cellProps(cell, t.tw, anno, value, s, t, this, width, height, dx, dy, i);
+        }
+        if (!s.useCanvas && (cell.x + cell.width < xMin || cell.x - cell.width > xMax)) continue;
+        if (legend) {
+          for (const l of [legendGroups, so.grp.legendGroups]) {
+            if (!l) continue;
+            if (!l[legend.group]) {
+              l[legend.group] = {
+                ref: legend.ref,
+                values: {},
+                order: legend.order,
+                $id,
+                origin: legend.entry.origin
+              };
+              if (legend.entry.dt) l[legend.group].dt = [legend.entry.dt];
+            }
+            const lg = l[legend.group];
+            if (lg.dt && !lg.dt.includes(legend.entry.dt)) lg.dt.push(legend.entry.dt);
+            const legendK = legend.entry.origin ? legend.entry.origin + legend.value : legend.value;
+            if (!lg.values[legendK]) {
+              lg.values[legendK] = JSON.parse(JSON.stringify(legend.entry));
+              if (legend.entry.scale) lg.values[legendK].scale = legend.entry.scale;
+            }
+            if (!lg.values[legendK].samples) lg.values[legendK].samples = /* @__PURE__ */ new Set();
+            if (t.tw.term.name === TermTypeGroups.MUTATION_SIGNATURE) {
+              if (value?.value > 0) lg.values[legendK].samples.add(row.sample);
+            } else lg.values[legendK].samples.add(row.sample);
+            if (isDivideByTerm) {
+              lg.values[legend.value].isExcluded = so.grp.isExcluded;
+            }
+          }
+        }
+        if (!so.grp.isExcluded) {
+          if (anno.renderedValues.includes(value)) series.cells.push(cell);
+          siblingCells.push(cell);
+        }
+      }
+      if (s.showGrid == "rect" && !so.grp.isExcluded) {
+        const cell = t.grp.type == "hierCluster" ? getEmptyCell(cellTemplate, s, this.dimensions) : maySetEmptyCell[t.tw.term.type]?.(siblingCells, cellTemplate, s, this.dimensions, this);
+        if (cell) emptyGridCells.push(cell);
+      }
+    }
+    if (emptyGridCells.length) series.cells.unshift(...emptyGridCells);
+    if (series.cells.length) serieses.push(series);
+  }
+  addAllHiddenLegendGroups(legendGroups, this);
+  this.legendData = this.getLegendData(legendGroups, data.refs, this);
+  for (const grp of this.sampleGroups) {
+    grp.legendData = this.getLegendData(grp.legendGroups, data.refs, this);
+  }
+  return serieses;
+}
+function addAllHiddenLegendGroups(legendGroups, self) {
+  for (const valueFilter of self.config.legendValueFilter.lst) {
+    if (valueFilter.tvs.term.type == "categorical" && !legendGroups[valueFilter.tvs.term.$id]) {
+      legendGroups[valueFilter.tvs.term.$id] = {
+        ref: {},
+        values: {},
+        $id: valueFilter.tvs.term.$id
+      };
+    } else if (valueFilter.tvs.term.type == "geneVariant" && !legendGroups[valueFilter.legendGrpName]) {
+      legendGroups[valueFilter.legendGrpName] = {
+        ref: {},
+        values: {},
+        dt: [valueFilter.tvs.values[0].dt],
+        origin: valueFilter.tvs.values[0].origin
+      };
+    } else if ((valueFilter.tvs.term.type == "integer" || valueFilter.tvs.term.type == "float") && !legendGroups[valueFilter.tvs.term.$id]) {
+      legendGroups[valueFilter.tvs.term.$id] = {
+        ref: {},
+        values: {},
+        $id: valueFilter.tvs.term.$id
+      };
+    }
+  }
+}
+
+export {
+  getSerieses,
+  matrix_serieses_exports
+};
+//# sourceMappingURL=chunk-SWZAHJYP.js.map